Before you start storing actions and working in the animation mixer, you must understand how your model is animated. That's what this section is about: how you animate determines which command you should use to store the animation in an action source. For example, constraints, path-animated objects, and custom parameters all have specific issues related to how actions are stored.
When you create an action source, you can store the transformations (scaling, rotation, translation), marked parameters, keyable parameters, animated parameters, or character key sets of selected objects.
If you have multiple objects selected in different models (including submodels), only the objects in the same model as the first object you selected will have their animation stored in a source. This is because only one model can be evaluated at a time.
As well, you cannot animation for parameters that are at the application level but are not part of a model of the Scene_Root node. This includes partition or image clip properties.
You should always put objects in a model before you save action sources for them. However, what happens if you already created an action source for an animated object before putting it into a model? Easy! You create the model with the animated object in it, then copy the action sources from the Scene_Root's Mixer to the new model's Mixer — see Copying Action Sources between Models.
All commands for storing (creating) actions are in the Actions
Store menu on the Animate toolbar. When you're ready to store an action, see the process in Creating Action Sources for using these commands.
There are different types of storage available for the animation that you want to store. Here's a brief description of each one:
Current Values — stores the current values of the selected object's parameters to create a static pose, which is like a hold pose. The action source that is created contains the parameter's current values but no animation. The default action clip length is five frames in the animation mixer.
Fcurves — stores only the fcurves of the selected object's parameters.
All Sources — stores all sources of animation (fcurves, expressions, etc.) on the selected object's parameters.
Animation or Current Values — stores all animated parameters of the selected object, as well as the current static values for non-animated parameters.
To store any type of animation, use any of the Actions Store commands that have All Sources in their command name.
This is the only way to store constraints, linked parameters, and path animation from the interface.
For more information on storing constraints and expressions, see Storing Constraints and Storing Expressions.
Storing transformations for an object means that the animation from its local transformation parameters (scaling, rotation, and translation) is stored.
Choose the appropriate Actions Store command from the Animate toolbar for the type of animation you want to store:
Transformations - Fcurves stores only the fcurves on all the selected object's local and global transformation (scaling, rotation, and translation)
parameters.
Transformations - Current Values stores the current values of the selected object's local and global transformation parameters to create a static pose.
Transformations - All Sources stores all sources of animation (fcurves, expressions, etc.) on the selected object's local and global transformation parameters.
Local Transformations - Animation or Current Values stores all animated local transformation parameters of the selected object's, as well as the current static values for non-animated parameters.
Although you can create an action based on an object's transformation parameters without explicitly marking them, it might still be a good idea to mark them if you want to keep your animation data light and easier to manage; for example, you can mark just the translation in X and leave Y and Z out of the action.
When you mark parameters before you store an action, you can keep the animation data in the action light — you store only what you want to store. For more information on how to mark parameters, see Marking Parameters for Animation [Animation].
Choose the appropriate Actions Store command from the Animate toolbar for the type of animation you want to store:
Marked Parameters - Fcurves stores the fcurves on all the selected object's marked parameters.
Marked Parameters - Current Values stores the current values of the selected object's marked parameters to create a static pose.
Marked Parameters - All Sources stores all sources of animation (fcurves, expressions, etc.) on the selected object's marked parameters.
Marked Parameters - Animation or Current Values stores all animated marked parameters of the selected object's, as well as the current static values for non-animated marked parameters.
You can also create a marking set for the object with the appropriate parameters in them and then store the animation. You can then store actions for the whole set or just specific parameters within the set. See Storing Animation for Custom Parameters and Marking Sets.
You can store the animation on an object's keyable parameters, which are the parameters that are displayed in the keying panel. Keyable parameters let you keep a specific set of parameters always available for an object, without needing to mark them first.
Keyable parameters can be any type of parameters you choose, but by default they include an object's local transformation parameters. You can set which parameters are keyable or not for an object using the keyable parameters editor. For more information, see Keying Keyable Parameters in the Keying Panel [Animation].
Choose the appropriate Actions Store command from the Animate toolbar for the type of animation you want to store:
Keyable Parameters - Fcurves stores only the fcurves on all the selected object's keyable parameters.
Keyable Parameters - Current Values stores the current values of the selected object's keyable parameters to create a static pose.
Keyable Parameters - All Sources stores all sources of animation (fcurves, expressions, etc.) on the selected object's keyable parameters.
Keyable Parameters - Animation or Current Values stores all animated keyable parameters of the selected object's, as well as the current static values for non-animated keyable parameters.
You can store the animation on an object's keyable parameters that are part of a character key set. A character key set lets you keep a specific set of keyable parameters available for quick keying without needing to select anything first.
Actions are stored for only the character key set that is set as being current, regardless of what is selected in the scene. For more information, see Keying with Character Key Sets [Animation].
Choose the appropriate Actions Store command from the Animate toolbar for the type of animation you want to store:
Character Key Set - Fcurves stores the fcurves on all the keyable parameters in the current character key set.
Character Key Set - Current Values stores the current values of the keyable parameters in the current character key set to create a static pose.
Character Key Set - Animation or Current Values stores all animated keyable parameters in the current character key set, as well as the current static values for non-animated keyable parameters in the set.
You can store the animation on any of the selected object's parameters that are animated.
Choose the appropriate Actions Store command from the Animate toolbar for the type of animation you want to store:
To store expressions, use any of the command with All Sources in its name. You can also use the Store Animated Parameters - Fcurves & Expressionscommand to store an action containing all the parameters of the selected objects that are animated with function curves and
expressions. You don't need to mark any parameters first.
When you store an action source that contains an expression, the model name of the target parameter is not stored. The target must be an item within the model. This lets you transport an action with an expression between models.
For expressions and constraints, each clip maintains its own local data — you can edit this data independently for each clip as described in Modifying Action Clip Values.
To store constraint animation in an action source, there are three main things you need to consider:
You must mark the parameters affected by the constraint, not the constraint itself. For example, if you apply a Direction constraint to an object, its rotation
parameters are affected, so those are the ones that you would mark. Then you can store the constraint's animation with the
Store Marked Parameters - All Sources command.
Remember that constraints act in global space, not local space. If you are using constraints and marking parameters, you must
mark the global transformations (kine.global.*), as shown on the left, not the constraint itself, and store the actions with Store Marked Parameters - All Sources.
If you are storing transformations instead of marked parameters, the constraints in global space take precedence over other
animation in local space. You then choose Store Transformations - All Sources.
You can store more than one constraint in an action source. For example, if you have both a position and direction constraint on an object, you can store the affected parameters for both constraints in an action source.
If you store an action with multiple constraints of the same type (such as multiple position constraints), all constraints are stored. If you apply this action, both constraints are reapplied and you can still blend the weight. However, if you instantiate the action (create a clip from the action source), only the last-created constraint is used.
If there is an up-vector on a constraint (see Up-vector Constraints [Animation]), the up vector is not included with the constraint in the action. Function curves are the only animation sources driving constraint parameters that can be stored in actions.
If the name of the constraining object changes after you create (instance) a clip from the constraint source, the clip cannot reference that object anymore. You must delete the clip and instance that source again.
For more information on constraints in general, see Animating with Constraints [Animation].
Constraints drive the global transformation of an object, whereas other types of animation typically drive the local transformation of the object. This matters when you want to mix constraints with other animation in the animation mixer. There is no parameter overlap between global and local animation in the mixer, which means that they simply can't mix.
Using the mixer, you can calculate the results of different types of constraints against each other, but you can't mix constraints with function curves or expressions unless the animation has been created globally (see the following for a workaround).
One workaround to mixing constraints locally is to create an intermediate object (for example, a cone) that shares the same parent as the target object you want to mix (for example, a cylinder) and constrain the cone instead. Then write a local expression to drive the cylinder from the cone's animation (for example, cylinder.posx = cone.posx). Store the local expressions in an action and then use that action instead of a constraint-action. The advantage is that you're getting the full power of the constraint itself.
To store actions for an path-animated object, you must first mark the global parameters of the path-animated as you do for constraints (see Storing Constraints). This is because constraints are animated in global space, and a path is a type of a constraint.
Then you can use either of these commands from the Actions Store menu:
You can store actions for individual custom parameters in a set or for the whole parameter set itself. This also applies to marking sets because they are also custom parameter sets.
Either way, make sure the you mark the correct items first and then use the appropriate Store Marked Parameters command (see Storing Marked Parameters).
To mark the whole custom parameter or marking set, click the set's name in the Marked Parameter list. All its parameters are also marked.
To mark the individual custom parameters, click them in the explorer of the Marked Parameter list as you would any other parameter.
For more information on custom parameters, see Custom and Proxy Parameters [Customizing Softimage].
If your sources will contain animated skeletons, you need to store different parameters depending on how they are animated:
If you are working with inverse kinematics (IK), select the effectors and mark the local translation values (kine.local.pos). Then use the appropriate Store Marked Parameters command (see Storing Marked Parameters).
You can also set the effectors' local translation parameters as keyable parameters, then put them in a character key set and use the Store Character Key Set - Fcurves command (see Storing Character Key Sets).
If you are working with forward kinematics (FK), select the bones and mark the local rotation values (kine.local.rot). Then
use the appropriate Store Marked Parameters command.
You can also set the bones' local rotations as keyable parameters, then put them in a character key set and use the Store Character Key Set - Fcurves command (see Storing Character Key Sets).
Use the Store Skeleton Pose command to properly store a complete skeleton pose (see below).
To store a pose (static action), you can store the animation on transformation parameters, marked parameters, keyable parameters,
or the parameters in the character key set. Choose any of the Actions Store commands with Current Values in its name for the type of animation you want to store.
These commands saves an action with the current values but no animation. The default action clip length is five frames in the animation mixer.
After you store poses, you can set up a sequence of them and then create transitions between them for pose-to-pose animation in the mixer. For more information on transitions, see Creating Transitions between Clips. You can also store key poses and experiment with placing them on the tracks in the mixer to block out a rough animation.
The Create Skeleton Store Skeleton Pose command creates a pose (static) action for the selected skeleton at the current frame. When you store skeleton poses in an
action source using this command, the parameters of the bones, joints, and chain that define the current pose of the skeleton
at the current frame are saved. This is similar to other pose actions you can create for animation, except that it is specifically
for skeletons.
For information on this command, see Storing a Skeleton Pose in an Action Source [Character Animation].
Except where otherwise noted, this work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License