Houdini and Unity tools
Combining Houdini’s generative capabilities with Unity’s interactivity, these tools enable rapid iteration for XR and game-ready content.
Armor Peeling System
A Houdini-to-Unity pipeline for procedurally rigged armor pieces with interactive, collision-based detachment logic driven by a user-placed gizmo.
In Houdini:
Each armor piece was procedurally extracted from the base mesh. A centroid joint was created for every part and parented to the main skeleton. Using Capture Pack Geometry, each piece was skinned by name. The result was a single FBX with cleanly rigged armor, ready for Unity.
⸻
In Unity:
A custom runtime script (ArmorPeelingGizmo.cs) enables manual placement of a gizmo. When triggered, it detects overlapping armor pieces, evaluates contact direction and velocity, and detaches them by unparenting and applying physical force.
⸻
Why this matters:
This pipeline allows fully procedural armor setup and interactive detachment — perfect for hit reactions, scripted events, or stylized destruction. Lightweight and optimized for mobile (tested on Android), it’s flexible for future gameplay extensions.
Fence Placement Tool
A designer-friendly procedural fence system built in Houdini as an HDA, used directly inside Unity.
In Houdini:
The fence system was built as a game-ready HDA, designed to receive a curve input from Unity. It procedurally generates posts, wires, and supports with user-defined parameters like length, spacing, and height. Geometry is packed with clean UVs and proper naming. Poles can be flagged as destructible using attributes. Outputs include FBX for static placement, or Alembic/VAT for destruction playback.
⸻
In Unity:
A designer draws a curve in the scene to define fence placement. The HDA builds the full fence layout — either live via Houdini Engine or from a pre-exported FBX. Destructible poles can be triggered at runtime using VAT or Alembic playback, with each segment trackable via Houdini-set attributes. Unity scripts handle zone triggers, collisions, or other interactions.
⸻
Why this matters:
This setup enables fast, curve-based fence design directly in Unity. It removes manual modeling, supports procedural destruction, and scales well for games, XR, or sandbox environments.
Animation Retargeting
A custom animation pipeline built in Houdini using KineFX to unify, blend, and re-target motion from multiple rigs for real-time deployment in Unity.
In Houdini:
The system imports animations from various rig sources like Mixamo or mocap. All motion is first retargeted to a shared T-pose base rig to normalize the skeleton. Using KineFX, you can blend full-body or partial animations (e.g. run + wave), and split motion into regions for modular layering. The result is then retargeted to a custom Unity-compatible rig and exported as a clean, skinned FBX for prefab use.
⸻
Why It Matters:
This non-destructive pipeline allows mixing animations from inconsistent rigs without re-authoring. It’s fully procedural, supports versioning, and is ideal for rapid real-time development.
⸻
Example:
Blend a Mixamo run with a mocap aim pose, retarget it to your game rig, and export to Unity as a prefab animation.
Crowd VAT Generator
A scalable system for real-time character variation using a single VAT texture with multiple embedded animations, driven by runtime logic in Unity.
In Houdini:
Multiple animation clips were combined into a single Vertex Animation Texture (VAT). Each motion cycle—such as idle, walk, and turn—was offset in the texture timeline and encoded into RGB channels. A single geometry mesh and texture sheet represented all animations. Metadata like frame ranges, loop points, and total durations were exported to guide playback. The final mesh and textures were optimized for lightweight engine integration.
⸻
In Unity:
A single prefab was used for each crowd agent, all referencing the same mesh and VAT texture. On spawn, each instance randomly selected an animation cycle and applied a phase shift to desynchronize movement. Per-instance data was set via Material Property Blocks. A custom shader read this data to animate each character accurately, using no bones or rig overhead.
⸻
Why It Matters:
This approach allows massive crowds with low draw calls and no skeletal animation load. It simplifies asset setup, conserves memory, and works smoothly for XR, mobile, or large-scale cinematic scenes.
Built with Houdini
Implemented in Unity
