Humanoid Rigging For Games Using Houdini And KineFX

Master how kinefx uses attributes—name as an identifier, position, and a transform for orientation—to define joints, with optional local transform for hierarchies and 3x3 orientation matrices.

Houdini 19 updates replace the attached control geometry node with attached joint geometry, add template inputs and shape libraries, and introduce universal joint scale and per-control color tweaks.

Learn to set up spine orientations by computing transforms from hip to child joints using vectors, unit vectors, and cross products, while visualizing X, Y, and Z directions.

Finish the leg by merging the foot and orientation scripts to update the final point's transformations, using a conditional optimization that runs only when the second input is connected.

Convert finger geometry into joints with blast and convert nodes, name proximal to distal joints for thumb through pinky, then orient and merge into a final fingers-out rig.

Create an initial geometry-based control setup for humanoid rigs, using primitive-attribute naming and color notes to manage directions, center of gravity, and spine, arms, and legs.

Learn to rig the spine using local and global controls, blending translations and rotations with a brain transform setup, and post nodes after the plane for proper evaluation.

Develop a reverse foot drag rig by reordering the control hierarchy from toe to ankle, adding pivot and rotation controls, and enabling retargetable animation with on-the-fly adjustments.

Connect foot controls to joints with a multi-input solver, using VOPs and inline code to drive look at transforms for left and right feet.

Set up arm controls for humanoid rig, reparent joints, create a separate hand joint for wrist-independent orientation, and align shoulder transforms with clavicles for intuitive control.

Learn how the shoulder solver uses elbow and clavicle controls in Houdini with KineFX to project vectors onto the clavicle plane, normalize directions, and guide realistic arm rotation.

Clean up and finalize arm rigging by reconnecting hands to global and local outputs, simplifying shoulder controls with transforms, adjusting visibility, and refining finger joints for clean, accurate animation.

Learn to build a dedicated jaw solver in Houdini and KineFX, wiring skeleton and eye inputs through setpoint and point transforms to animate a modular jaw.

Set up IK/FK arms in Houdini with KineFX by duplicating leg rigs, renaming joints to arm joints, and configuring left and right arm controls and parameter interfaces.

Refine the rig for export by separating control and non-control skeletons. Align the root bone with hip-driven transforms using matrix to vector conversions and correct parenting.

Learn to make rig controls accessible by extending the viewer state and building a visibility interface, including an inter-group ordered menu (Meche, skeleton) and global, local, universal toggles.

Design and implement a visibility system for a rig in Houdini using KineFX. Build a switch-driven interface that toggles root, global, and local controls for hips, spine, and legs.

Configure visibility for the spine and legs by updating visibility nodes, renaming control groups to spine and leg controls, and driving visibility with the visibility parameter.

Create new geometry and skeleton nodes, organize them with dist suffixes, and define weights before building and exporting the rig for game engine.

Position the character and edit the skeleton, then use it to add weights to the mesh, tuning burn capture attributes and bone capture lines while leaving eyes and teeth rigid.

Learn to display deformations by building a rig utils note in Houdini using a subnetwork, with mesh and skeleton inputs and outputs, plus display controls and a reset pose button.

Fixes spine tangent issues by updating object references and correcting unpack node attributes. Improves proxies by controlling influences per point and normalizing weights for stable game exports.

Organize global and local rig controls, implement stash and cache inputs, and drive hips controls and display menus with a Python script to dynamically set attach control geometry in Houdini.

Set up and evaluate the spine solver in Houdini's KineFX by configuring the spine group, adjusting tangents, and profiling performance to identify slow nodes and optimize their placement.

Organize the arms rig with dedicated controls and a solver workflow, linking spine inputs to global and local controls, and export the final animation.

explain how to refine a humanoid jaw rig in Houdini and KineFX by reorganizing joints, updating controls, and validating FK/IK blending with a jaw solver.

Update the export node by configuring clip and source ranges and their integer parameters, then set the animation name and prepare export workflows for frame-based outputs.

Update local arm and head controls in Houdini 19 conversion by attaching joints, configuring menus, and linking shoulder, elbow, wrist, and hand parameters to a clear, test-ready interface.

Create the first box control by building a geometry network, wireframe edges, naming the node box, and exporting the geometry to the geo folder using an object merge.

Create circles on the XY, YZ, and XZ planes and convert them into a sphere geometry, merging groups and testing with a blast node before exporting updated controls.

Create an octahedron in Houdini by duplicating a transform, merging nodes, and rotating 90 degrees on X and Y axes; define a point group named octahedron and scale to 0.5.

Build a directional control by creating an arrow geometry, duplicating it into eight copies along the z axis, and refining with divide, bend, and scale to produce a grid-aligned control.

Explore how KineFx revolutionizes Houdini rigging by using a point-based, SOP-based system that improves motion capture integration, offers modular skeleton, rig, controls, and mesh with flexible import and export.

Master rig naming conventions for bone chains, including root, joints, and effector, with revolute joints. Apply prefixes and suffixes like cont, up, lookup, offset, and clearly mark left or right.

Separate a rig into components: skeleton, weighted mesh, proxy geometry, and controls. Generate the skeleton geometry file, proxy geometry file, and controls file, then feed them into the rig.