Rigging with Houdini 18.5 - KineFX

Set up a Houdini project, import tentacle geometry and textures, assign materials, split into tentacle and metal grate outputs, and export a two-output digital asset for HDR.

Encapsulate all external references into a self-contained tentacle geometry digital asset by bundling geometry and texture maps and updating references to operator definitions.

Create a simple rigid tentacle rig by building a one-joint skeleton, packing geometry, and rigidly attaching it to the joint, then verify the deformation using the attached geometry.

Build the tentacle skeleton with geometry, rest, and animate skeletons, then name points programmatically using a tentacle prefix and point numbers, and capture with harmonic bone capture.

Apply the bone deformation modifier and capture layer paint to refine tentacle deformation, rigidly bind bottom vertices to the root, and blend two skeletons into a single asset.

Merge rigid and bi-harmonic capture data streams to drive a tentacle rig, align rest and animated skeletons, and package the setup as a digital asset.

Build an animator-friendly tentacle rig in Houdini 18.5 KineFX by adding attach control geometry, naming controls, and creating master, tentacle, and root controls with a procedural, wildcard-based workflow.

This lecture guides debugging a Houdini tentacle rig by tracing and repairing lost skinning weights, using a digital asset flow, capture layers, and data visualization to restore smooth deformation.

Build a tentacle rig in Houdini 18.5 with KineFX, promote parameters to a digital asset, and design a three-output system and master controls UI for forward kinematics and visibility.

Enhance the tentacle rig by exposing controls in the digital asset, setting the default visible nodes, and adding a Python-powered reset button to zero out channels and clear keyframes.

Create and package a zombie geometry asset in Houdini by importing the zombie GO file, applying normal and roughness textures, and saving as a self-contained digital asset.

Build a zombie capture skeleton in Houdini using the skeleton node, detailing spine, neck, head, and legs, with world-space alignment and clear joint naming.

Explore zombie rigging with Houdini 18.5 KineFX in the third installment, focusing on building and controlling a dynamic zombie character rig.

Explore the zombie rig 04 in rigging with Houdini 18.5 KineFX, mastering practical techniques for building and refining character rigs.

Explore the next steps in building a zombie rig with KineFX in Houdini 18.5, emphasizing stepwise rigging techniques and practical workflow considerations.

Capture the skeleton and geometry, isolating rigid parts like eyes and teeth. Explore methods to convert the mesh for by harmonic capture, including text form, rematch, and tetrahedral options.

Practice rigging the zombie rig in Houdini 18.5 with KineFX. Leverage these tools to understand zombie rig construction within Houdini's KineFX framework.

Explore zombie rigging in Houdini 18.5 using KineFX as part of the rigging course, focusing on the zombie rig 08.

Chop skeleton into discrete modules and build ui-driven animation controls on top. Use network boxes to organize spine, center of gravity, arms, and legs, then blend back into capture skeleton.

Explore the zombie rig 10 in rigging with Houdini 18.5 via KineFX to understand practical rigging workflows for character deformation.

Explore the zombie rig in Houdini 18.5 using KineFX, focusing on rigging workflows for character animation.

Learn to build an inverse kinematic system for the legs using IK drivers and world-space alignment, with control geometry and the rate up node to blend transforms.

Apply inversed kinematics for the zombie rig’s legs in Houdini 18.5 using the exchange node, creating left and right leg chains matched by name.

Explore zombie rig techniques in Houdini 18.5 using KineFX to build and control a flexible, animated character rig.

Apply an orientation constraint to wrist controls so the hand follows the control object's rotation, using a parent constraint, world-space blending, and optional wrist-to-world settings.

Explore the zombie rig in Houdini 18.5 with KineFX, as introduced in the zombie rig 16 lecture for the rigging with Houdini course.

Explore zombie rigging using Houdini 18.5 KineFX to build flexible creature rigs and master practical rigging workflows for animated characters.

Refine a zombie rig in Houdini 18.5 KineFX with Canafax by organizing the digital asset UI, adding a head folder, space switch, and finalizing animation controls.

Isolate the finger joints, attach control geometry, and lock translations and rotations to build a simplified rig with Witkin effects, then test finger poseability.

Create a left-hand spread control with a spread parameter and a fit expression to splay fingers, mapping -1 to 1 to index, ring, and pinky rotations.

Duplicate the left-hand user interface for the right hand, update channel references, and rename internal variables for consistency, then prepare Python scripts to zero out the asset and set keyframes.

Master zombie rigging techniques in Houdini KineFX, applying rigging strategies to create a functional zombie character for animation.

Explore zombie rig concepts in Houdini 18.5 with KineFX. Build practical rigging techniques for animated characters.

Install tentacle digital assets in Houdini, set up a rig, create a two-second idle loop, adjust keyframes for smooth motion, and package the asset for Unreal in SBX.

Export the character as an SBX and its animations separately, then import into Unreal with the uniform scale set to one and appropriate rest pose, attributes, and clip range.

Retarget existing motion clips to rigs using Canafax tools, enabling procedural animation transfer across mismatched skeletons; refine with map points and full body IK for the target rig.

Explore retargeting animation between rigs of different sizes using Canafax and Whodini, tweaking with rig post nodes to quickly adapt and export robust fbx clips for game engines.

Create a game-ready zombie rig in Houdini 18.5 with KineFX, build reusable assets, use Python scripting to save clicks, and design a UI to streamline animation.

Design and build animation-ready control rigs as the rigger or technical animator, tailoring rigs to game animation needs, from simple zombies to complex characters, avoiding overkill with premade tools.

Master rigging fundamentals in Houdini by understanding transformational relationships within a bone hierarchy, aligning transforms, avoiding scaling, and keeping clean, zeroed control objects for game-ready animations.

Learn to rig game characters confidently, quickly, and effectively using Houdini, while understanding rigging fundamentals and building a reusable library of digital assets to streamline future projects.

Set up a fresh Houdini project, import zombie geometry and texture maps, build a basic zombie material, and convert the rig into a digital asset for reuse.

Explore common nodes in Houdini for KineFX rigging, including the bone node, bone tool, bone length, and zero transforms. Learn to split bones, rename chains, and apply kinematic solvers.

Learn to use the no node as the control network cornerstone, drive bone rotations, and clean transforms with pre transforms, while a Python tool automates FK control creation.

Explore constraints and constraint networks in Houdini to manage parent-child relationships, blend between world space and parent space, and achieve independent foot fk control alongside ik.

Create a personalized rigging shelf in Houdini 18.5, add bones and parent blend tools, customize icons, and automate tasks with Python to speed up rigging and digital asset creation.

Build a digital asset called rig pin in Houdini to provide a clear, adjustable control for jaw and head rigging, with configurable length, radius, color, and rotation order.

Build the end null tool in Houdini using Python to automatically create and parent a null at the end of a bone chain, preserving transforms and rotation order.

Create a python end null tool in Houdini to automate rig setup, linking the end null to a bone, keeping position, aligning rotation order, and offsetting z by bone length.

Use Python to cosmetically tweak the end null tool in Houdini, adjusting geo scale, control type, and wireframe color, and position it for a clean, non-selectable network view.

Explore building a Python-based FK control tool in Houdini to generate forward-kinematic controls for selected bones with one click, yielding animation-ready, aligned transforms.

Develop a Python-based FK control tool in Houdini that creates null controls for selected bones, applies clean transforms, re-parents, and aligns rotation order with each bone.

Lock the FK control rotation and automate its connection using Python with relative references, set expressions, and channel expressions for rotate x, y, z on the RCS channel.

Continue refining earthquake control tool by cleaning up nodes, repositioning the FK control, hooking rotations for NOLs, and applying lime green collars and circular shapes while locking unused parameters.

Learn how python powers the fk control tool in houdini to color bones, create bone and control node groups, and tidy the network view with groups for easier rigging.

Create and use a digital asset called the rig helper to streamline animation, allowing zeroing controls, placing keyframes, hiding controls, and linking multiple rigs to control objects.

Create a Houdini rig using a spider leg setup, convert it into a digital asset called new rig helper, add controls with f k and buttons labeled zero, height, key.

Master the rig helper tool to implement a zero button that resets translate and rotate controls per limb or globally, using the Houdini Digital Asset and Python module.

Finish implementing the zero button for the digital asset by looping through f k controls, checking unlock status, and resetting rotate and translate parameters to zero, with debugging tips.

Learn to implement the hide all function for a Houdini 18.5 KineFX digital asset, toggling visibility of FK controls in the viewport for focused animation.

Implement a key all function for a Houdini digital asset to drop keyframes on control objects, enabling global or per-limb keyframing while respecting locked parameters and interpolation.

Plan a zombie rig in Houdini 18.5, using IK legs, a forward kinematic spine with three controls, an FK arm with hands, and a jaw control to teach rigging fundamentals.

Set up a leg rig for a zombie in Houdini 18.5 using the bones tool, position bone chains, and implement inverse kinematics with a twist effector and goal.

Create a control object to drive the IK leg and mirror it to the right side using the rig helper. Clean transforms, lock unwanted parameters, and test the setup.

Add twist controls to the leg rig, align naming and colors, and integrate with the rig helper to build an orthographic spine with a K control for bendy, zeroed rig.

integrate the spine with the leg rig using a center of mass control and a simple blend to separate rotation from position, then create a master node to coordinate controls.

Develop a modular arm rig in Houdini using fk bones from clavicle to elbow, add fk controls and a rec pen shoulder, and prepare an end null for the hand.

Finish the fk arm rig, mirror across, and clean naming with rig helpers and node groups. Then add the hand in the next video.

Add a background image to the network view to map control objects and keep the arms and hands rig layout clear, then position nodes with grid view for tidy organization.

Build an fk hand rig in Houdini with bone nodes, parent to the end bone, inherit arm transforms, and align finger joints by using world-space nulls and axis-aligned rotations.

Build a hand rig in Houdini with KineFX by adding thumb and finger bones, splits, and forward kinematics controls for precise articulation.

Finalize the fk hand rig in Houdini 18.5 KineFX by adding a forward kinematic hand control and mirroring to the opposite side. Test with rotate tools and tidy the viewport.

Finish the head, neck, and jaw rig in Houdini 18.5 using bones, rec pins, and visible controls. Apply space switching with blend constraints to enable flexible head posing.

Learn to implement head space switching in Houdini 18.5 with KineFX by blending between the spine end and zombie space, allowing the head to stay oriented while the rest moves.

Implement space switching for the left hand in Houdini 18.5 KineFX, using a blend node to switch between rest, shoulder, and zombie spaces with a left hand space switcher.

Duplicate the space switching from the last video, set up shoulder, right hand, and zombie spaces with a blend node, and add a right hand space switch parameter.

Tidy the network view by hiding non-control nodes, group bones and transforms into 'rick stuff', color rig helpers, and prepare for packaging into a digital asset with a user interface.

Package the zombie rig as a digital asset, verify global control and control object naming, and set up a master, legs, spine, left, and right parameter interface.

Populate the zombie digital asset user interface using rig helpers across master, spine, arms, and head folders in simple layouts to verify visibility and space switching with a zombie instance.

Wrap up the zombie digital asset by tidying controls, saving the asset, and testing in scene; prepare a clean, library-ready rig for quick animation and sharing.

Apply Houdini’s bi-harmonic capture to attach geometry to the bone network, computing skin weights with watertight meshes and tetrahedra, then adjust weights for better deformation.

Learn to adjust skin weights in Houdini using the edit capture weights and paint capture weight tools, isolating geometry to refine jaw and neck deformation.

Learn the paint skin weights workflow in Houdini 18.5 KineFX, using edit cut weights, spreadsheet tweaks, and the paint capture layer to fine-tune bone influences.

Learn to finalize a Houdini 18.5 rig with skinning and mirrored weights for consistent deformation. Turn the zombie asset into an animation-ready digital asset ready for game engines.

Explore Houdini's animation tools using a digital asset to create a simple idle motion, adjust keyframes, and polish timing with the dope sheet for a Unity game engine transfer.

Export your Houdini rig and animations to Unity using film box and rop nodes, define frame ranges for idle, walk, and run, and ensure the bone deform node is last.