The animation is the base structure to allow Object and Scene to manage Action, Sequence and ActionController. Each of theses two resource have an internal Animation structure attached to them that allows you to control either statically or dynamically animations playback.

At runtime each animation elements that tagged as running is then handled by the Animator (Anm). that will process evaluate and update all queued structures of an animation that have been set to playback.

Static Variables

Name	Description
`type`	The type of the underlying resource the animation belongs to (either an Object or a Scene).
Declaration unsigned int type In case the `type` is an Object the value will be an ObjectType else if will be set to the AssetType `kScene`.
`action_count`	The number of actions available within the Animation structure.
Declaration unsigned short action_count
`sequence_count`	The total amount of Sequence the Animation structure contains.
Declaration unsigned short sequence_count
`actioncontroller_count`	How many ActionController are connected to the current Animation.
Declaration unsigned char actioncontroller_count
`scene`	The Scene reference pointer where the Animation is attached.
Declaration Scene *scene Note Only available if the `type` is `kScene`; instead `nil`.
`object`	The underlying Object the current Animation structure belongs to.
Declaration Object *object Note Only available if the `type` is an ObjectType; instead `nil`.

Functions

Name	Description
`AddAction`	Add a new Action to the animation structure.
Declaration Action AddAction( const char name ) Return Value On success return a new Action.
`GetAction`	Retrieve a specific Action by its name.
Declaration Action GetAction( const char name ) Return Value If found return the Action specified by the `name` parameter; else return `nil`.
`GetActionAt`	Retrieve an Action based on its index.
Declaration Action GetActionAt( unsigned short index ) Return Value* On success return the Action at the specified `index`; else return `nil`.
`GetActionIndex`	Get the index of a specific Action.
Declaration int GetActionIndex( const Action action ) Parameters* `action`: An existing Action that belongs to the source animation. Return Value If found return the action index; else return `-1`.
`RemoveAction`	Remove a specific action from an animation.
Declaration bool RemoveAction( Action action ) Parameters* `action`: An existing action that belongs to the animation action list. Return Value `true` if the function have actually remove something; else return `false`.
`RemoveActionAt`	Remove an action based on its index.
Declaration bool RemoveActionAt( int index ) Parameters `index`: Specify the action index to remove from the action list. Return Value `true` if the function have actually remove something; else return `false`.
`SwapActions`	Swap two actions based on their index.
Declaration bool SwapActions( unsigned short index0, unsigned short index1 ) Parameters `index0`: The first action index. `index1`: The second action index. Return Value `true` if both index are valid and the actions have been swapped; else return `false`.
`AddActionController`	Create a new ActionController.
Declaration ActionController AddActionController( const char name ) Parameters `name`: A name to identify the new ActionController. Return Value The newly created ActionController.
`GetActionController`	Retrieve a specific ActionController using its name as key.
Declaration ActionController GetActionController( const char name ) Parameters `name`: The name of the ActionController you want to retrieve. Return Value If found; the function will return the ActionController, else `nil`.
`GetActionControllerAt`	Return the ActionController located at the specified index in the actioncontroller list.
Declaration ActionController GetActionControllerAt( unsigned short index ) Parameters* `index`: Specify the index of the ActionController you want to retrieve. Return Value On success return the ActionController; else return `nil` if the index is out of bounds.
`GetActionControllerIndex`	Return the index of an ActionController.
Declaration int GetActionControllerIndex( const ActionController actioncontroller ) Parameters* `actioncontroller`: The ActionController you wish to get the index for. Return Value If the `actioncontroller` provided exists in the Animation ActionController array its index will be returned; else `-1`.
`RemoveActionController`	Remove a specific ActionController.
Declaration bool RemoveActionController( ActionController actioncontroller ) Parameters* `actioncontroller`: The ActionController you want to remove. Return Value `true` on success; else return `false` if the ActionController reference was not found inside the actioncontroller list.
`RemoveActionControllerAt`	Remove an ActionController by index.
Declaration bool RemoveActionControllerAt( int index ) Parameters `index`: The index of the ActionController you wish to delete. Return Value `true` if the index provided was valid; else return `false`.
`SwapActionControllers`	Swap two existing actioncontrollers based on their index.
Declaration bool SwapActionControllers( unsigned char index0, unsigned char index1 ) Parameters `index0`: The first actioncontroller index. `index1`: The second actioncontroller index. Return Value `true` if both actioncontrollers specificed are swapped; else return `false` if the indexes provided are either equal or out of bounds.
`AddSequence`	Create a new Sequence.
Declaration Sequence AddSequence( const char name ) Parameters `name`: Specify a name to identify the new sequence. Return Value A new Sequence.
`GetSequence`	Retrieve a specific Sequence by its name.
Declaration Sequence GetSequence( const char name ) Parameters `name`: The name of the sequence you want to retrieve. Return Value The Sequence pointer else `nil`.
`GetSequenceAt`	Get an existing Sequence located at the index position received in parameter.
Declaration Sequence GetSequenceAt( unsigned short index ) Parameters* `index`: Specify the index of the sequence you want to retrieve. Return Value A valid Sequence pointer; else `nil`.
`GetSequenceIndex`	Get the index of an existing Sequence.
Declaration int GetSequenceIndex( const Sequence sequence ) Parameters* `sequence`: A valide sequence pointer. Return Value The index of the Sequence provided in parameters if it exists; else return `-1`.
`SetSequenceIndex`	Move an existing Sequence to a different position.
Declaration bool SetSequenceIndex( Sequence sequence, const unsigned char index ) Parameters* `sequence`: A valid sequence that is present in the list. `index`: Specify the list index to place the sequence. Return Value `true` if the sequence have been moved successfully; else return `false`.
`RemoveSequence`	Remove an existing Sequence maintained by the current Animation.
Declaration bool RemoveSequence( Sequence sequence ) Parameters* `sequence`: The sequence to remove. Return Value `true` if the sequence received in parameter have been deleted; else return `false`.
`RemoveSequenceAt`	Remove a sequence using its index.
Declaration bool RemoveSequenceAt( int index ) Parameters `index`: The index of the sequence you wish to remove. Return Value `true` if the sequence have been removed successfully; else return `false`.
`SwapSequences`	Exchange the order of two sequences.
Declaration bool SwapSequences( unsigned char index0, unsigned char index1 ) Parameters `index0`: The first sequence index. `index1`: The second sequence index. Return Value `true` if the exchange occur; else return `false` if both indexes are the same or if one or both are out of bounds.
`ActionsUpdate`	Manually update all the actions associated with the current Animation.
Declaration void ActionsUpdate( void )
`ActionControllersUpdate`	Force all actioncontrollers to be updated.
Declaration void ActionControllersUpdate( void )
`SequencesUpdate`	Tell the system to update all sequences contained in the Animation.
Declaration void SequencesUpdate( void )