CUGL 2.3 Cornell University Game Library
Searching...
No Matches
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< EasingBezieralloc ()

static std::shared_ptr< EasingBezieralloc (EasingFunction::Type type)

static std::shared_ptr< EasingBezieralloc (float x1, float y1, float x2, float y2)

static std::shared_ptr< EasingBezieralloc (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.

## ◆ 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

## ◆ 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

 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

## ◆ _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 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: