Crystal Space 2.0.0: 4.15.1.2 List of animation nodes

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

#### 4.15.1.2 List of animation nodes

Here is the extensive list of the animation nodes that are shipped within Crystal Space.

You can find an example of loading of these animation nodes from a Crystal Space library file in `‘CS/data/krystal/anims_idle.cslib’`.

#### Raw animation

These are the objects `CS::Animation::iSkeletonAnimationNode` and `CS::Animation::iSkeletonAnimationNodeFactory`.

This animation node allows the storage and playback of raw animation data. In this sense, they are probably the most used animation nodes since they are the main way to store pre-defined animations.

The key frames of the animations are defined with a time stamp and some key values for the orientation and position of the bones of the skeleton. When playing back the animation, the data will be interpolated between the available key frames.

The node can be configured to be played cyclically or not.

The animations stored in this node are usually defined by an artist. They can also be loaded from motion captured data using the dedicated tool.

#### Finite State Machine

These are the objects `CS::Animation::iSkeletonFSMNode` and `CS::Animation::iSkeletonFSMNodeFactory`.

This animation node allows to control the animation of the skeleton by navigating into the states of a Finite State Machine (FSM). This node is useful e.g. to drive the locomotion and the actions of a character.

Each state of the FSM corresponds to an animation child node that will be played while the FSM is in that state. A crossfade and a transition sub-node can also be defined between the states of the FSM, they will be used when the FSM is switched between the two states, allowing for a smooth transition between two states.

Automatic transitions can also be defined, they will be followed automatically at the end of the current playing state if no other state has been asked by the user to switch to.

An example of Finite State Machine being used to drive the locomotion of a character can be found in CEL, within the `‘pcactormove’` property class.

#### Blending node

These are the objects `CS::Animation::iSkeletonBlendNode` and `CS::Animation::iSkeletonBlendNodeFactory`.

This node will blend together any number of child nodes. Each child node can receive a different weight in order to parameterize their influence.

#### Random node

These are the objects `CS::Animation::iSkeletonRandomNode` and `CS::Animation::iSkeletonRandomNodeFactory`.

This node will play randomly one of its child node, allowing for more varied animations.

#### Priority

These are the objects `CS::Animation::iSkeletonPriorityNode` and `CS::Animation::iSkeletonPriorityNodeFactory`.

This node blends its child nodes according to their priority. It is useful e.g. to add a secondary motion on top of a base animation while preserving most of the base animation.

#### LookAt

These are the objects `CS::Animation::iSkeletonLookAtNode` and `CS::Animation::iSkeletonLookAtNodeFactory`.

This node aligns automatically some bone with a user-defined target. It is useful e.g. to breathe life into a character by generating an active interaction from the character.

#### Speed

These are the objects `CS::Animation::iSkeletonSpeedNode` and `CS::Animation::iSkeletonSpeedNodeFactory`.

This node takes as child nodes the animations of the mesh moving at different speed, e.g. idle, walking, running, sprinting, and combines these animations to achieve any desired custom speed.

#### Ragdoll

These are the objects `CS::Animation::iSkeletonRagdollNode` and `CS::Animation::iSkeletonRagdollNodeFactory`.

This node allows the interaction between the Animesh mesh and the physical simulation, allowing to either control the animation of the mesh through physical simulation, and to hit and collide with the other objects of the simulation.

On demand, this node can create automatically the rigid bodies and joints for the bones of the skeleton of the Animesh, these rigid bodies will collide and interact with the physical environment.

The bones can be set in dynamic state e.g. to have a character falling realistically in a stairwell, or in kinematic state in order for the mesh to interact with the environment while being animated by the classical animation method. This allows for example to attach to the mesh some external objects or clothes that will be physically animated while colliding with the character (i.e. its bones in kinematic state).

Both states can also be combined to achieve effects such as the main body of the avatar classically animated, and sub-trees such as hair, clothes or accessories animated by the physical simulation.

In order to use a ragdoll animation node, you must first define a body skeleton (see section Animesh Mesh Object), that will define the colliders and physical properties that the ragdoll node must use for all bones of the skeleton. Once done, you must also define in the body skeleton some body chains that will allow you to designate the set of bones that you want to manipulate within the ragdoll node.

Whenever you change the dynamic state of some of the body chains, the ragdoll node will create and update automatically the rigid bodies and joints of the skeleton. You can use the ragdoll node to access those physical objects and manipulate them externally.

#### Inverse Kinematics

These are the objects `CS::Animation::iSkeletonIKNode` and `CS::Animation::iSkeletonIKNodeFactory`.

This node generates an animation that places a bone end effector at a specific position and orientation. It allows e.g. a character to grab an object regardless of the relative position of the character and the object.

There are two different implementation of this node:

- Using the Cyclic Coordinate Descent algorithm (object `CS::Animation::iSkeletonIKCCDNodeFactory`). This method is quite robust, but has some high computation costs.
- Using the physical simulation (object `CS::Animation::iSkeletonIKPhysicalNodeFactory`). This method has the advantage of being able to react realistically to collisions on the path of the arm to the effector, the drawback is that the physical simulation may behave strangely if the motion of the target of the effector is not manipulated wisely.

In order to use Inverse Kinematics animation nodes, you must first define a body skeleton and some body chains within it. The body chains will be used to designate the set of bones that will be manipulated by the IK animation node (e.g. the arms). For the animation node based on the physical simulation, you must also use a ragdoll animation node in combination, therefore a definition for all colliders and joints of the body chains.

#### Retarget

These are the objects `CS::Animation::iSkeletonRetargetNode` and `CS::Animation::iSkeletonRetargetNodeFactory`.

This node allows to retarget (or redirect) an animation that was defined for one skeleton to another skeleton. It is useful for example to re-use animations or to input motion captured data into your Animesh. However, the two skeletons must still have a similar topology and limb proportions, otherwise the results won't look good.

#### Debug

These are the objects `CS::Animation::iSkeletonDebugNode` and `CS::Animation::iSkeletonDebugNodeFactory`.

This node currently simply allows to display the state of part or the whole skeleton. It is useful if you want to visualize either the skeleton of your mesh or the actual effects of the animations and animation nodes that you have defined.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated using texi2html 1.76.