Base class for Entity animation controllers. More...

Inherited by G3D::Entity::EntityTrack, and G3D::Entity::SplineTrack.

Classes
class	VariableTable
	For "with" expressions. More...

Public Member Functions
virtual CFrame	computeFrame (SimTime time) const =0
	More...

Static Public Member Functions
static shared_ptr< Track >	create (Entity entity, Scene scene, const Any &a)
	Creates any of the subclasses described/nested within a. More...

Static Protected Member Functions
static shared_ptr< Track >	create (Entity entity, Scene scene, const Any &a, const VariableTable &table)

template<class T , class ... ArgTypes>
static shared_ptr< T >	createShared (ArgTypes &&... args)
	Like std::make_shared, but works for protected constructors. More...

Detailed Description

Base class for Entity animation controllers.

This is not intended as a general or extensible simulation mechanism. Override Entity::onSimulation for complex animation needs.

Note that Lights and Cameras can be attached to other Entitys that have complex onSimulation without subclassing the Light or Camera if desired.

See also: Manipulator, Entity::onSimulation, Spline

Member Function Documentation

◆ computeFrame()

virtual CFrame G3D::Entity::Track::computeFrame ( SimTime time ) const

pure virtual

Parameters

time	Absolute simulation time

Implemented in G3D::Entity::EntityTrack, and G3D::Entity::SplineTrack.

◆ create() [1/2]

static shared_ptr<Track> G3D::Entity::Track::create	(	Entity *	entity,
		Scene *	scene,
		const Any &	a,
		const VariableTable &	table
	)

staticprotected

◆ create() [2/2]

static shared_ptr<Track> G3D::Entity::Track::create	(	Entity *	entity,
		Scene *	scene,
		const Any &	a
	)

static

Creates any of the subclasses described/nested within a.

Grammar:

ctrl := 
   "Point3(...)" |
   "CFrame..." |
   "Matrix3..." |
   "PhysicsFrameSpline { ... }" |
   "timeShift( splineTrack or orbitTrack, deltaTime)" |

   // Use the current position of this entity; creates a depends-on relationship.
   // optional cframe is equivalent to the common idiom "transform(entity(...), cframe)"
   "entity(\"entityname\" [, cframe:<CFrame>])" |   

   // use a * b
   "transform( a:<ctrl>, b:<ctrl> )" |

   // attach to <ctrl> by a spring; creates a depends-on relationship...reserved for future use
   "follow( <ctrl>, ? )" |  

   // Rotate to base to look at target's origin
   "lookAt( base:<ctrl>, target:<ctrl> [, up:<Vector3>] )" |

   // Strip the rotation from one track and the translation from another
   "combine(rot:<ctrl>, trans:<ctrl>)" |

   // Rotate around Y axis, facing forward on the track (use combine or transform to alter, use radius 0 to spin in place)
   "orbit(radius, period)" | 

   // name to be bound by a WITH expression
   "<id>" |

   // Bind the ids to controllers (in the previous variable environment), and then evaluate another one
   "with({ [<id> = <ctrl>]* }, <ctrl> )"

Example:

    VisibleEntity {
       ...
       controller = 
          with({
                target = entity("mothership");
                spline = PhysicsFrameSpline { .... };
               },

               // Lead the target by looking ahead of it in object space
               lookAt(spline, transform(target, Matrix4::translation(0, 0, -3)), Vector3::unitY())
           );
    }

Parameters

entity Needed to create dependencies in the scene

◆ createShared()

template<class T , class ... ArgTypes>

static shared_ptr<T> G3D::ReferenceCountedObject::createShared ( ArgTypes &&... args )

inlinestaticprotectedinherited

Like std::make_shared, but works for protected constructors.

Call as createShared<myclass>.

Classes

Public Member Functions