Basic Auto-Rigging for Games in Houdini

We create the project.

Add the interface for the rig guide

We create the hips and thighs and add basic symmetry.

We set up the modules for the Python scripts.

We set up scripts to add symmetry interactively. This will allow symmetry to be activated and deactivates in the guide interface.

Make the editing the guide easier.

We make a system for saving the position of the guide controls as presets.

Now that we can save presets we need to be able to reload those positions. In this lesson we create the load system.

We add the guide nulls for the legs. We also start to visualize the what the skeleton will look like.

We add the spine neck and head nulls.

We set up the shoulders, arms and hands.

We have now finished with the guide nulls for the simple limbs. And will start on parts of the body which have more specific requirements.

The first of these is the foot.

We are not covering facial rigging in this course but we will still require the most basic parts of a facial setup. The eyes and jaw.

The fingers are the final bones to set up.

We add a representation for the leg rotation plane so that the placement of the leg twist effector can be controlled.

We add a representation for the arm rotation plane so that the placement of the arm twist effector can be controlled.

We prepare the scene and scripts to start building the export skeleton.

We script the bone placement.

The export rig will need to compensate for root motion, here we implement the option to build the skeleton based off the game engine.

We build the bones of the spine.

We add functions to set up the the parenting and begin to build the export rig's hierarchy.

We build the bones for the leg and foot.

We build the shoulders. arms and hands.

We build the eye and Jaw.

We Add The Fingers

I do a basic setup of the export rig and export for unity to test if the skeleton is working for basic animation.

We add a root Bone as well as bone chains for an IK and FK spine.

We add FK Controls for the spine this includes a function to lock unused parameters on the control.

We add the controls for an curve based spine. This includes the controls and a curve. Note when you have very few bones for the back the usefulness (and quality of setup) of this kind spine is limited/

We start the constraint system. First we add the root, which has unique behavior in the rig. We then setup parent and orientation constraint on the root of the leg.

We constrain the spine bones to the curve.

We make a constraint to make the bones blend between the IK and the FK bones.

We add the bones for the legs to the character animation rig.

We add the controls for the leg.

We build the function to add IK to the rig and apply it to the rig.

We setup the IK/FK Blend for the leg.

We build the bones for the arm and the shoulder.

We Add The IK and FK controls for the arm.

We add the IK and FK constraints for the arm. We also fix issues with the IK bone rotations.

We add the foot and toe bones.

We set up controls for a reverse foot rig.

We finish the foot by constraining the foot and toe bones to the controls.

We implement the build hand script and create the fingers and the hand bone.

We continue with the hands adding controls for the hand and fingers.

We create the constraints to manipulate the hands and fingers.

We add the bones for the head, neck, eyes and jaw.

We create controls for the head. Including look-at controls for the head and eyes.

We create the look-at constraint system for the head and eyes as well as simple contraints for the head and jaw.

We create groups so that it is easier to select parts of the rig system.

We add groups and gemoetry nodes to allow for the implementation of proxy geometry in the rig.

We set up a simple, bare bones, animation exporter.

We set up the importer.

We shift from building our rigs in test nodes to building the HDAs dynamically.

Dealing with possible conflicts when scripting HDAs

We update the guide so that the spine will be generated correctly for both IK and FK.

The code-base is a bit of a mess we start to clean it up.

We clean-up the parameters, an and interface. We also remove declarations of parameters from the AddConstraints module.

We finish cleaning up the add constraint script and move the constraints out of the BuildSpine module.

There are two small errors when creating and attaching the save script I fix them here.

The prototype is finished. Whats next?

We do some final In preparation to update the guide, I simplify the code for the onBuildCharacterRig script. We also remove the spare parameters for the HDAs that we generating.

A brief description of The problems that exist with the current setup

A discussion of how to make an object level symmetry system using nodes.

An overview of the basic rig setup using KineFX.

This video covers a very basic IK/FK system in KineFX.