cugl::EasingBezier Class Reference

#include <CUEasingBezier.h>

Inheritance diagram for cugl::EasingBezier:

Public Member Functions
	EasingBezier ()
	~EasingBezier ()
void	dispose ()
bool	init ()
bool	init (EasingFunction::Type type)
bool	init (float x1, float y1, float x2, float y2)
bool	init (const Vec2 p1, const Vec2 p2)
float	evaluate (float t)
std::function< float(float)>	getEvaluator ()

Static Public Member Functions
static std::shared_ptr< EasingBezier >	alloc ()
static std::shared_ptr< EasingBezier >	alloc (EasingFunction::Type type)
static std::shared_ptr< EasingBezier >	alloc (float x1, float y1, float x2, float y2)
static std::shared_ptr< EasingBezier >	alloc (const Vec2 p1, const Vec2 p2)

Protected Member Functions
void	solveQuadraticEquation (float a, float b, float c)
void	solveCubicEquation (float a, float b, float c, float d)

Protected Attributes
Vec2	_c1
Vec2	_c2
Vec2	_c3
std::vector< float >	_rootset

Detailed Description

This class represents a bexier curve that implements an easing function.

The object itself stores the bezier curve, which cannot be manipulated after creation (for thread safety). The bezier curve is defined as a cubic polynomial that maps a paramter t onto the xy plane.

The method getEvaluator() returns a function pointer that can be used to interpolate the function over time (e.g. for tweening support). The function retains a shared pointer to the object, so the object reference can be safely discarded after getting the function pointer.

Constructor & Destructor Documentation

EasingBezier()

cugl::EasingBezier::EasingBezier

(

)

Creates an uninitialized easing function.

NEVER USE A CONSTRUCTOR WITH NEW. If you want to allocate an object on the heap, use one of the static constructors instead.

~EasingBezier()

cugl::EasingBezier::~EasingBezier ( )

inline

Deletes this easing function, disposing all resources

Member Function Documentation

alloc() [1/4]

static std::shared_ptr< EasingBezier > cugl::EasingBezier::alloc ( )

inlinestatic

Returns a newly allocated linear easing function

Returns

a newly allocated linear easing function

alloc() [2/4]

static std::shared_ptr< EasingBezier > cugl::EasingBezier::alloc ( const Vec2  p1, const Vec2  p2  )

inlinestatic

Returns a newly allocated easing function eith the given control points.

Any cubic bezier can be defined by a two control points in the plane, which define the tanget lines of the two endpoints. These are often manifested as handles in programs like Adobe Illustrator.

Parameters

p1	The first handle.
p2	The second handle.

Returns

a newly allocated easing function eith the given control points.

alloc() [3/4]

static std::shared_ptr< EasingBezier > cugl::EasingBezier::alloc ( EasingFunction::Type  type )

inlinestatic

Returns a newly allocated easing function of the given type.

Bezier easing functions can duplicate every easing function in EasingFunction except for the bounce and elastic functions.

Parameters

type	The easing function type

Returns

a newly allocated easing function of the given type.

alloc() [4/4]

static std::shared_ptr< EasingBezier > cugl::EasingBezier::alloc ( float  x1, float  y1, float  x2, float  y2  )

inlinestatic

Returns a newly allocated easing function eith the given control points.

Any cubic bezier can be defined by a two control points in the plane, which define the tanget lines of the two endpoints. These are often manifested as handles in programs like Adobe Illustrator.

Parameters

x1	The x-coordinate of the first handle.
y1	The y-coordinate of the first handle.
x2	The x-coordinate of the second handle.
y2	The y-coordinate of the second handle.

Returns

a newly allocated easing function eith the given control points.

dispose()

void cugl::EasingBezier::dispose

(

)

Disposes all of the resources used by this easing function.

A disposed function can be safely reinitialized.

evaluate()

float cugl::EasingBezier::evaluate

(

float

t

)

Returns the value of the easing function at t.

The easing function is only well-defined when 0 <= t <= 1.

Returns

the value of the easing function at t.

getEvaluator()

std::function< float(float)> cugl::EasingBezier::getEvaluator

(

)

Returns a pointer to the function represented by this object.

The function retains a shared pointer to the object, so the object reference can be safely discarded after getting the function pointer.

Returns

a pointer to the function represented by this object.

init() [1/4]

bool cugl::EasingBezier::init ( )

inline

Initializes a linear easing function

Returns

true if initialization was successful.

init() [2/4]

bool cugl::EasingBezier::init ( const Vec2  p1, const Vec2  p2  )

inline

Initializes an easing function eith the given control points.

Any cubic bezier can be defined by a two control points in the plane, which define the tanget lines of the two endpoints. These are often manifested as handles in programs like Adobe Illustrator.

Parameters

p1	The first handle.
p2	The second handle.

Returns

true if initialization was successful.

init() [3/4]

bool cugl::EasingBezier::init

(

EasingFunction::Type

type

)

Initializes an easing function of the given type.

Bezier easing functions can duplicate every easing function in EasingFunction except for the bounce and elastic functions.

Parameters

type	The easing function type

Returns

true if initialization was successful.

init() [4/4]

bool cugl::EasingBezier::init	(	float	x1,
		float	y1,
		float	x2,
		float	y2
	)

Initializes an easing function eith the given control points.

Any cubic bezier can be defined by a two control points in the plane, which define the tanget lines of the two endpoints. These are often manifested as handles in programs like Adobe Illustrator.

Parameters

x1	The x-coordinate of the first handle.
y1	The y-coordinate of the first handle.
x2	The x-coordinate of the second handle.
y2	The y-coordinate of the second handle.

Returns

true if initialization was successful.

solveCubicEquation()

void cugl::EasingBezier::solveCubicEquation ( float  a, float  b, float  c, float  d  )

protected

Stores the roots of a x^3 + b x^2 + c x + d into the rootset.

This is a helper function for computing the root set from the bezier polynomial.

Parameters

a	The 3rd degree coefficient
b	The 2nd degree coefficient
c	The linear coefficient
d	The constant factor

solveQuadraticEquation()

void cugl::EasingBezier::solveQuadraticEquation ( float  a, float  b, float  c  )

protected

Stores the roots of a x^2 + b x + c into the rootset.

This is a helper function for computing the root set from the bezier polynomial.

Parameters

a	The 2nd degree coefficient
b	The linear coefficient
c	The constant factor

Member Data Documentation

_c1

Vec2 cugl::EasingBezier::_c1

protected

The C1 coefficient

_c2

Vec2 cugl::EasingBezier::_c2

protected

The C2 coefficient

_c3

Vec2 cugl::EasingBezier::_c3

protected

The C3 coefficient

_rootset

std::vector<float> cugl::EasingBezier::_rootset

protected

The rootset of the polynomial x-component (cached for efficiency).

---

The documentation for this class was generated from the following file:

• cugl/include/cugl/math/CUEasingBezier.h