🎛️ Animating with Control Rig

Why Author Animation In-Engine

Everything in this track so far has consumed animation that already existed. You imported a Skeletal Mesh, retargeted a mannequin's walk onto it, dropped that clip into Sequencer, and rendered it. That covers an enormous amount of production, because most motion is bought, captured, or reused. But eventually you hit the wall every animator hits: the exact motion you need is not in any library. A character has to point at a specific doorway. An idle needs a nervous glance your stock idle does not have. A retargeted reach ends with the hand an inch inside the table, and no amount of re-retargeting fixes that one frame.

The old answer was to leave Unreal, open Maya or Blender, animate there, export an FBX, and import it back, then discover the timing was slightly off against the camera and do the whole round-trip again. Control Rig collapses that loop. It is Unreal's built-in system for both building a rig and animating with it, right in the editor, against your real lighting, your real camera, and your real environment.

The point is not that Control Rig replaces Maya for a feature-film character. The point is that for a game or a real-time cinematic, a huge share of the animation work, custom gestures, corrective tweaks, secondary motion, and fully hand-keyed shots, can now happen where the shot actually lives. You iterate against the thing you will ship, not an approximation of it in another program.

Anatomy of a Control Rig: Bones, Controls, Nulls

Open a Control Rig and the first thing you see is a hierarchy, much like a Skeleton Tree, but it holds three different kinds of element that are easy to confuse. Getting them straight is the whole foundation of the tool.

Here is the concrete version, using the real controls from the mannequin's shipped rig (CR_Mannequin_Body). Notice how the control names mirror the body but tag their role: _fk_ctrl for a forward-kinematics joint, _ik_ctrl for an inverse-kinematics target, _pv_ik_ctrl for a pole vector that aims a joint.

Figure: A Control Rig is a layer of controls sitting on top of the skeleton. The grey bones deform the mesh but are driven, not touched · the coloured shapes are the real controls from CR_Mannequin_Body (FK circles, an IK box, a pole-vector diamond, spine and head controls, and a root), each named for the body part it moves and the way it moves it.

Forward Solve and Backward Solve

What actually connects a control you rotate to the bone that bends is a graph, and it runs in a direction. Control Rig has two main directional graphs, and understanding which one runs when is what stops the tool feeling like magic.

Forward Solve: controls drive bones

The Forward Solve is the everyday graph. It runs on every frame of playback and evaluation. It reads the current value of every control, does whatever math the rig defines (chain an FK arm, solve an IK leg, blend an FK/IK switch), and writes the result onto the bones, which then deform the mesh. This is the direction that makes posing work: you move upperarm_r_fk_ctrl, the forward solve reads it, and the arm bones rotate to follow.

Backward Solve: bones drive controls

The Backward Solve runs the other way. It reads the bones' transforms (typically coming from an existing Animation Sequence) and computes what each control's value would have to be to produce that pose, then writes the controls. You use it to bake a canned clip onto the rig: run the backward solve over a walk cycle and suddenly the walk is expressed as keyframes on the controls, where you can grab any one and adjust it. Without a backward solve, a Control Rig could only ever create motion from scratch; with it, the rig can also take over motion that already exists.

flowchart LR
    subgraph FWD[Forward Solve · every frame]
      C1[Controls
you posed] --> G1[Rig graph
FK / IK / blends]
      G1 --> B1[Bones] --> M1[Mesh deforms]
    end
    subgraph BWD[Backward Solve · on demand]
      A2[Animation Sequence
on the bones] --> B2[Bones] --> G2[Rig graph
inverse]
      G2 --> C2[Controls
now keyed]
    end
    style FWD fill:#e8f5e9,stroke:#4CAF50
    style BWD fill:#fff3cd,stroke:#ffc107
                    

There are a couple of other graphs in a full rig, a Construction graph that runs once to build the control shapes and an optional Interaction graph, but for animating you almost only ever care about the forward solve, with the backward solve as the door that lets existing animation in.

FK and IK Controls: Two Ways to Pose a Limb

A limb can be posed two fundamentally different ways, and a good rig gives you both. The mannequin ships each arm and leg with a full FK chain, a full IK setup, and a switch to blend between them (arm_r_fk_ik_switch, leg_l_fk_ik_switch). Knowing which to reach for is a real animation skill.

Figure: The same arm, two control schemes. FK gives you a control on every joint (upperarm_r_fk_ctrl → lowerarm_r_fk_ctrl → hand_r_fk_ctrl) that you rotate in sequence · IK gives you one target for the hand (hand_r_ik_ctrl) plus a pole vector (arm_r_pv_ik_ctrl) to aim the elbow, and solves the joints for you.

Posing and Keying in Sequencer

Now the payoff. A Control Rig on its own is just a puppet; Sequencer is where you pull its strings over time. The workflow is short and it is the same every shot.

flowchart LR
    A[Bind character
in a Level Sequence] --> B[Add a Control Rig
track to the binding]
    B --> C[Go to a frame]
    C --> D[Select a control,
pose it]
    D --> E[Set a key]
    E --> F{More poses?}
    F -->|Scrub to next frame| C
    F -->|Done| G[Play back:
Unreal interpolates]
    style B fill:#fff3cd,stroke:#ffc107
    style E fill:#e8f5e9,stroke:#4CAF50
                    

Add a Control Rig track to a possessed character and every one of its controls becomes a keyable channel in the track, while the manipulators appear on the character in the viewport. From there, animating is exactly the keyframing you learned in Lesson 2, just applied to controls instead of a camera's focal length: park the playhead, pose, key, move on. The difference is that a single "pose" might touch a dozen controls at once, and Unreal interpolates each channel between your keys to produce motion.

Below is a real capture of the character this rig drives: the project's mannequin, shown in the same shot at rest and on a single frame of motion in-engine. Whether that motion comes from hand-keying controls or from a clip driven onto the rig, this is what the loop is for, taking the same skeleton off its rest pose and evaluating it live against the real environment and camera. The manipulators you grab to author it, and the rig graph behind them, live in the Control Rig editor.

Figure: A genuine capture from the ClaudeTest project, same camera and lighting on both sides. Left, SK_Manny (the mesh CR_Mannequin_Body is built for) in its rest pose · right, the same rig driven to a frame of motion in-engine. Control Rig is how you author and shape motion like this without ever leaving the editor.

Baking and Layering

Hand-keying from scratch is only one way to use a Control Rig. The other two are about existing animation, and they are what make the tool a daily driver rather than a special occasion.

Bake a clip onto the controls, then out again

Using the backward solve from Section 3, you can bake an Animation Sequence onto the rig's controls. A retargeted walk from Lesson 4 arrives as keyframes on every control, and now you can fix that one frame where the hand clipped the coat: grab the hand control on that frame, move it out, key it, done, without disturbing the rest of the walk. When you are happy, you bake back out to a brand-new Animation Sequence on the skeleton, which behaves like any other clip in Sequencer and carries no runtime dependency on the rig.

Layer a correction without touching the base

The cleaner option for tweaks is a layered (additive) Control Rig. Instead of editing the baked keys directly, you add a layer on top that stores only your offset from the base animation. The base walk plays untouched; your layer adds a head turn, a limp, a wince. Because the layer is separate, you can tune it, mute it, or delete it without ever risking the original motion. This is the non-destructive way professionals polish canned animation.

Figure: Layered (additive) control rig animation. The base clip is never edited · a separate layer holds only your added offset, so a correction can be tuned, muted, or removed without any risk to the original motion.

flowchart TD
    Q{What do you
need to do?} -->|Motion exists
in no library| SCRATCH[Hand-key controls
from scratch]
    Q -->|Fix a few frames
of an existing clip| BAKE[Backward-solve the clip
onto controls, edit keys]
    Q -->|Add secondary motion
on top of a clip| LAYER[Additive layer
non-destructive]
    SCRATCH --> OUT[Bake out to an
Animation Sequence]
    BAKE --> OUT
    LAYER --> OUT
    style SCRATCH fill:#e8f5e9,stroke:#4CAF50
    style LAYER fill:#fff3cd,stroke:#ffc107
    style OUT fill:#ede7f6,stroke:#7e57c2
                    

Hands-On: Pose and Key a Wave

The fastest way to feel Control Rig is to hand-key a two-pose wave on the mannequin, which arrives with a finished rig so there is nothing to build first.

Knowledge Check

Summary

You moved from consuming animation to making it. Here is the arc:

The reason. Retargeting fills your library with motion that exists elsewhere, but the exact gesture, the custom idle, the one corrective frame, often exists nowhere. Control Rig lets you author and fix animation in-engine, against your real shot, with no round-trip to another program.

The anatomy. A Control Rig is a layer of controls (the manipulators you key) sitting over the skeleton's bones (the output that deforms the mesh), with invisible nulls as scaffolding. The forward solve reads controls and drives bones every frame; the backward solve runs the other way to bake an existing clip onto the controls.

The craft. You pose a limb in FK (rotate each joint, good for arcs) or IK (pin the end, good for contact), switching between them per limb as the shot needs. In Sequencer you add a Control Rig track and run the pose-and-key loop, and for existing motion you bake it onto the controls to tweak or add a non-destructive additive layer, then bake back out to an ordinary Animation Sequence.

Where this fits

Control Rig sits at the source of the motion the rest of the track uses. Where Retargeting brings in a library and Sequencer arranges it under a camera, Control Rig is how you create the shots that library does not have, or fix the ones it does. Those clips then flow straight into Sequencer and out through Rendering Output. In the wider Story-to-Screen pipeline, this is animation authoring inside Phase 4, feeding the shot assembly of Phase 5.