Hand-keyed animations are powerful, but they break the moment a character needs to react dynamically to the world—a tail swaying as a creature runs, hair bouncing on impact, a backpack shifting with each stride. Procedural, bone-driven physics give your game characters that missing layer of life, and Blender's constraint system lets you build it without a single physics engine dependency.
This guide walks you through the full workflow: setting up bone constraints for secondary motion, chaining damped track and copy rotation modifiers for believable jiggle, baking the result for engine export, and wiring it up in Unity, Unreal Engine 5, and Godot 4.
What Is Procedural Animation and Why Game Characters Need It
Procedural animation refers to motion generated by rules, physics simulations, or constraint chains at runtime or bake-time—rather than authored frame by frame. For game characters, this typically means secondary motion: the parts of a character that don't drive locomotion but should still move plausibly (cloth panels, ponytails, antenna, capes, satchels).
The alternative—hand-keying every secondary element for every animation state—is unsustainable at scale. A character with twelve animations and three secondary elements would need thirty-six separate animation passes to look right. Bone-driven constraints cut that work to near zero: you configure the physics once and it applies across all animations automatically, or you bake it per-clip in a single pass.
Procedural rigs also respond correctly to blended states. If your locomotion system blends between a walk and a sprint, a constraint-driven ponytail will interpolate naturally. A hand-keyed ponytail will not.
Setting Up Bone Constraints in Blender
The foundation of procedural secondary motion in Blender is the Copy Rotation and Damped Track constraint stack. Here's the recommended setup for a tail or hair chain:
- Build the secondary bone chain alongside your main deform rig. These bones should not be parented to the main rig hierarchy—they'll be driven by it via constraints, not direct parenting.
- Add a Copy Rotation constraint to the root of the secondary chain, targeting the corresponding deform bone. Set Influence to 0.4–0.6 to add lag.
- Stack a Damped Track constraint pointing to a tracking target empty. This forces the bone to always face a point in space, creating the rubbery follow-through effect.
- Use a Child Of constraint on the tracking empty, parented to the deform bone that drives motion. When the character moves, the empty lags behind based on its object constraint settings.
```python
# Blender Python: Add Copy Rotation constraint to secondary bone
import bpy
obj = bpy.data.objects["Armature"]
bpy.context.view_layer.objects.active = obj
bpy.ops.object.mode_set(mode='POSE')
bone = obj.pose.bones["tail_01"]
constraint = bone.constraints.new('COPY_ROTATION')
constraint.target = obj
constraint.subtarget = "spine_03" # driving deform bone
constraint.influence = 0.45
constraint.use_x = True
constraint.use_y = False
constraint.use_z = True
constraint.mix_mode = 'ADD'
```
Repeat this pattern down the chain, reducing influence by 0.05–0.1 per bone to create a natural falloff. A five-bone tail might have influence values of 0.45, 0.38, 0.30, 0.22, 0.15.
Secondary Motion with Damped Track and Copy Rotation Chains
Once the root bone is set up, propagating motion down the chain requires careful ordering of constraints. Blender evaluates constraints top to bottom, so sequence matters.
| Chain Bone | Copy Rotation Influence | Damped Track Target | Notes |
|---|---|---|---|
| tail_01 | 0.45 | empty_tail_root | Driven by spine |
| tail_02 | 0.38 | empty_tail_01 | Lags tail_01 |
| tail_03 | 0.30 | empty_tail_02 | Lags tail_02 |
| tail_04 | 0.22 | empty_tail_03 | Soft tip |
| tail_05 | 0.14 | empty_tail_04 | Maximum softness |
Each tracking empty is parented (Child Of constraint, not direct parent) to the bone one step up the chain. This creates a cascade: the spine drives tail_01, tail_01 drives the empty that tail_02 tracks, and so on. The result is a wave-like follow-through that behaves correctly across any animation.
Tip: Use Blender's NLA editor to test the constraint chain across multiple animations before baking. Stack your walk, run, and idle clips on separate NLA tracks and scrub through each. If the secondary motion looks correct on all three without adjustment, your constraint setup is solid.
For hair or cloth-like elements, add a Limit Rotation constraint after the Copy Rotation to cap how far each bone can deviate from rest pose. Without this, fast animations can flip bones to impossible angles.
Exporting Procedural Rigs to Unity, Unreal Engine 5, and Godot 4
Constraint-driven procedural rigs cannot be exported live. Game engines don't understand Blender constraints. You must bake the motion to keyframes before export.
Baking workflow in Blender:
```
1. Pose Mode → Select all secondary bones
2. Object → Animation → Bake Action
- Frame Range: match your animation clip
- Only Selected Bones: ✓
- Visual Keying: ✓ ← critical: captures the constraint result
- Clear Constraints: ✓ ← removes constraints post-bake
- Bake Data: Pose
3. Export to FBX or GLB as normal
```
Unity: Import the FBX with your baked secondary bones. In the Animator, create a dedicated layer for secondary motion with Additive blending weight 1.0. This lets the secondary bones play their baked curves on top of any locomotion state without conflicts.
Unreal Engine 5: Import via the standard skeletal mesh pipeline. In the Animation Blueprint, use a Layered Blend per Bone node to apply secondary motion on top of locomotion. Add the root of your secondary chain to the blend list and set Blend Depth to the length of the chain (e.g., 5 for a five-bone tail).
Godot 4: Import the GLTF or FBX. In AnimationPlayer, secondary bone tracks will appear automatically. Use AnimationTree's BlendTree to layer secondary animations over base locomotion using an `AnimationNodeAdd2` node.
Find production-ready rigged character assets with pre-built secondary bone chains at BitSoul Marketplace—a faster starting point than building constraint rigs from scratch.
Performance Considerations and Baking to Keyframes
Procedural rigs have no runtime cost—they're baked. But baked animations do have memory and performance implications:
Keyframe density: Visual keying from constraints produces a keyframe every frame. For a 60-frame idle at 30fps, that's 60 keyframes per secondary bone. Use Blender's Decimate Modifier on the F-curves (Graph Editor → Channel → Decimate) to reduce keyframe count by 40–60% with minimal visual impact. Set the Error threshold to 0.001–0.005.
Bone count budget: Most mobile platforms handle up to 75 bones per mesh efficiently. Desktop targets push to 150–200. Count your secondary bones before export; a full hair simulation with 20 bones across four chains adds up fast.
LOD strategy: Secondary bone animation is a good candidate for LOD culling. At LOD2 and beyond, disable secondary bone influence entirely and blend to a static pose. In Unreal Engine 5, this is controlled per LOD in the skeletal mesh editor under the Per-LOD bone reduction settings.
```python
# Blender Python: Select secondary bones for F-curve decimation
import bpy
obj = bpy.data.objects["Armature"]
action = obj.animation_data.action
# Print keyframe count per secondary bone fcurve before decimation
for fcurve in action.fcurves:
if 'tail' in fcurve.data_path or 'hair' in fcurve.data_path:
print(f"{fcurve.data_path}: {len(fcurve.keyframe_points)} keyframes")
# In Graph Editor: Channel > Decimate with error=0.003
```
For characters that need runtime secondary motion—not baked—consider engine-native solutions: Jiggle Bones in Unity's Animation Rigging package, Control Rig in Unreal Engine 5, or SkeletonModificationStack in Godot 4. These evaluate physics per frame and require no baking, but add CPU cost proportional to chain length.
Closing: Build Once, Animate Everywhere
Procedural bone constraints in Blender let you author secondary motion once and distribute it across every animation in your project through baking. The constraint-to-bake-to-export pipeline is reliable, engine-agnostic, and produces results that would take weeks to hand-key.
The key steps: build your secondary chain separate from your deform rig, stack Copy Rotation and Damped Track constraints with decreasing influence down the chain, bake with Visual Keying enabled, decimate F-curves before export, and layer the result in your engine's animation graph.
Need a head start? Browse the rigged character and animation asset catalog at BitSoul Marketplace for game-ready skeletal meshes with secondary bone setups ready for Unity, Unreal Engine 5, and Godot 4.