You can import characters into your network, or create the elements of a character (skeleton, geometry capture weights, rig) all at the SOP level. The character elements can be assembled into a character, and multiple characters can then be added to an animation scene that is input into Houdini’s viewport animation environment, the animate state.

KineFX is built on the principles of procedural rigging, which allow you to quickly make iterations on your rigs, and experiment non-destructively. Rigging in KineFX is driven by APEX, a graph evaluation framework where character rigs are represented using APEX graphs.

KineFX is the umbrella term for Houdini’s SOP-based character toolset, and APEX is the rigging engine that runs underneath it. KineFX makes use of APEX, with some of KineFX’s infrastructure driven by APEX graph evaluation.

Retargeting is the process of taking animation from one character and transferring it to another. KineFX’s flexibility and robustness allows it to handle different morphologies and hierarchical structures between source and target characters. The available tools within the retargeting workflow allow you to make changes to your character and animation using motion capture data, secondary motion effects, and MotionClips.

A character’s skeleton is represented at the geometry level by a collection of points connected by polygon lines. KineFX’s joint-based system allows a character’s joint hierarchy to be created and edited in various ways using SOP nodes. See working with skeletons for more information.

To prepare a skeleton for rigging, extra information can be added to a character’s base skeleton to create a reference skeleton, called a guide skeleton. The information on the guide skeleton is then picked up by rig components downstream to build up the rig functionality of the character. Some of the information that could be added are:

• Extra joints that are used as a reference for creating controls on the rig.

• Tags (labels) that identify groups of joints.

• Properties that set information on the guide skeleton’s joints.

See preparing skeletons for rigging for more information on how to create a guide skeleton.

Once we have a character’s skeleton and skin, we can use skin capture to create weights on the geometry for skin deformation. When the joints move, the geometry is deformed according to the capture weights and position of the joints. See skin capture for the different SOPs that are available for creating and modifying capture weights.

Rigging in KineFX is driven by APEX (All-Purpose EXecution), a graph evaluation framework that builds and runs character rigs. In APEX, character rigs are represented using APEX graphs.

A bit of background ¶

Pre-Houdini 20, a character’s rig logic lived in rig behavior nodes (like the Rig Pose SOP) and was also evaluated on those nodes. This meant that once we came to the point in the network that determined how a rig behaved, this functionality had to be evaluated at that exact place in the network, i.e. the rig logic and rig evaluation were tied together.

In the example below, we have a pre-Houdini 20 rigging setup where a tube geometry is being deformed. The character elements are set up by creating the tube geometry, skeleton, and capture weights on the geometry. On the Rig Pose SOP, the pose of the skeleton can be manipulated (the skeleton deformed), and animation can be added by setting keyframes. The Rig Pose SOP then evaluates the skeleton deformation and animation, and the result of this evaluation is piped into the Bone Deform SOP, where another evaluation is performed and the geometry is deformed.

There are a few issues with this approach:

• To deform the geometry on the skeleton, there are two evaluation steps - one on the Rig Pose SOP and another on the Bone Deform SOP, and there is an evaluation dependency between the two.

• The rig logic and rig evaluation are tied together. Whenever you change the pose of the skeleton on the Rig Pose SOP, this change is evaluated.

• The animation (on the Rig Pose SOP) and the deformed result (on the Bone Deform SOP) must be viewed on different nodes.

Rigging with APEX ¶

With the introduction of APEX in Houdini 20, we still have the same steps for assembling and preparing the character elements, but APEX graphs are now used as the rig logic representation:

	Pre-Houdini 20	Houdini 20
Preparing and assembling character elements	Build a skeleton and create capture weights	Same as pre-Houdini 20
Rig logic	Rig behavior nodes (for example, Rig Pose SOP, IK Chains SOP, Full Body IK SOP)	APEX graphs

The example below shows one workflow of rigging with APEX, where the rig logic is in the APEX graph in the APEX Edit Graph SOP, and the rig is evaluated further down in the APEX Scene Invoke SOP. In this way, users can procedurally build and assemble pieces of the rig, and choose to evaluate the final rig at a later point in the network. This idea of delayed evaluation allows the rig logic and rig evaluation to be decoupled, resulting in significant performance improvements.

Viewport animation is performed in the animate state, a viewer state in the APEX Scene Animate SOP that can display multiple characters, and allow users to perform posing such as FK or IK for characters, interact with character controls, and add constraints between characters. Functionality like physics-based motion and ragdoll can also be applied to animation within the animate state.

The input to the animate state is an animation scene in the packed character format. The animate state picks up the character elements in the packed character format (identified with special extensions) and uses them to build a scene for animation in the viewport.

With SOP-based animation, you can put motion onto your character by building up a network using special SOP nodes. Characters do not need to be assembled into the packed character format for animation in the SOP network editor:

• Apply realistic-looking projectile and pendulum motion using physics-based motion.

• Apply ragdoll simulations to your character.