Poses and Rigs

Before you can make a character move, you have to answer a blunt question: what, exactly, are you animating? Not the mesh — you never touch a million triangles by hand. Not raw pixels. You animate a small set of numbers: the angle of an elbow, the twist of a spine, the position of a hand. Freeze those numbers at one instant and you have a pose. Let them change through time and you have animation. This page names the two objects the whole craft is built on — the pose and the rig — and shows how a handful of animator-friendly controls end up commanding a whole skeleton.

It sits on top of transform hierarchies: a rig is a hierarchy of transforms with a friendly steering wheel bolted on. This is a signposting overview — forward kinematics, skinning, IK and blend shapes each get their own lesson later; here we lay out the map.

A pose is a point in pose space

A skeleton is a tree of joints (bones), each carrying a local transform relative to its parent — usually a rotation, sometimes a translation or scale. A pose is a complete assignment of a transform to every joint at one instant: the shoulder rotated this much, the elbow bent that much, and so on down the tree.

A pose is one value for every animatable channel of the rig at a single instant — a complete set of joint transforms.
A degree of freedom (DOF) is a single number the animator can independently set: one rotation axis of one joint, one translation component, one control value.
The configuration vector q stacks all those numbers into one list, q = (q_1, q_2, \dots, q_n), where n is the total DOF count. A pose is then a single point q \in \mathbb{R}^n in the rig's pose space.

This is the key mental shift: a pose is not a picture, it is a point in a high-dimensional space. A rig with 60 DOFs poses in a 60-dimensional space; every distinct pose the character can strike is one point in that space, and every point is a pose you could snap to.

The skeleton is a tree of DOFs

Below is a tiny skeleton drawn as its transform hierarchy: a root (which can both move and turn — 6 DOF, three translations plus three rotations), a spine joint, and one arm chain (shoulder, elbow, wrist). Each node is labelled with how many degrees of freedom it contributes. Add them up and you have the length of this rig's configuration vector q.

Notice the elbow gets only one DOF: it is a hinge, and a real elbow only bends about a single axis. Choosing how many DOFs each joint deserves — hinge vs ball joint — is part of building the rig, and it is a modelling decision about the character, not a mathematical accident.

Worked example: counting an arm's DOFs

Take just the arm chain — shoulder, elbow, wrist — and count its rotational degrees of freedom.

Shoulder: a ball-and-socket joint. It can pitch, yaw and roll, so 3 rotational DOF.
Elbow: a hinge. It bends about one axis only, so 1 DOF.
Wrist: modelled as another ball joint (bend, tilt and twist), so 3 DOF.

The total is

n = \underbrace{3}_{\text{shoulder}} + \underbrace{1}_{\text{elbow}} + \underbrace{3}_{\text{wrist}} = 7.

So a single arm has a 7-dimensional configuration vector

q = (\theta^{\text{sh}}_x, \theta^{\text{sh}}_y, \theta^{\text{sh}}_z,\; \theta^{\text{el}},\; \theta^{\text{wr}}_x, \theta^{\text{wr}}_y, \theta^{\text{wr}}_z).

Each entry is one channel the animator can key. Reaching for a coffee cup is choosing a specific point q \in \mathbb{R}^7; a whole reaching motion is a curve through that 7-D space. (A human arm having 7 DOF, one more than the 6 needed to place the hand, is exactly why you can keep your hand still and swing your elbow — the arm is redundant, a fact inverse kinematics has to grapple with.)

The rig: a friendly control layer

Posing a character by typing joint angles would be torture — dozens of numbers, most of them unintuitive. The rig is the layer that fixes this. It sits on top of the raw skeleton and mesh and exposes a small set of animator-friendly controls that drive the many underlying joint transforms.

A rig is a control layer over a skeleton and mesh. It typically provides:

Control handles — on-screen objects (a foot control, a hand control, a face slider) the animator grabs instead of raw joints.
Constraints — rules tying one thing to another (keep the eyes aimed at a target; stick the hand to a prop).
IK / FK switches — a toggle between posing a limb joint-by-joint (forward kinematics) and posing it by dragging its tip (inverse kinematics).
Driven keys — one control automatically driving several joints at once (a single "make a fist" slider curling all the finger joints).

You can think of the rig as a function: it maps a few control values to the full configuration vector,

q = R(c), \qquad c \in \mathbb{R}^m,\; q \in \mathbb{R}^n,\; m \ll n.

The animator lives in the small control space c (a handful of intuitive knobs); the rig R expands each setting into the large space of joint transforms q that forward kinematics then turns into world-space bone positions, which skinning finally uses to deform the mesh. Facial expressions often skip joints entirely and blend whole shapes — that is blend shapes, another lesson of its own.

Animation is a trajectory q(t)

A single pose is one point. Animation is motion of that point through pose space: a time-varying configuration vector

q(t) = \big(q_1(t),\, q_2(t),\, \dots,\, q_n(t)\big).

Each coordinate q_i(t) is a scalar function of time — and that is precisely what a keyframe tool stores as an F-curve (function curve) for that channel. Watch the animation graph editor and you are literally looking at the components of q(t), one wiggly curve per DOF. Playing the shot back is evaluating every F-curve at the current time t, assembling q(t), and drawing the pose. How those curves are shaped — their timing, spacing and easing — is where the acting lives.

Separation of concerns: three jobs, three spaces

The pose/rig picture cleanly divides the pipeline's labour, which is why studios split it across different specialists:

Role	Builds / works in	Owns
Modeller	the mesh	the geometry — how the character looks in a rest pose
Rigger	the skeleton + rig R	the controls, constraints, IK/FK, driven keys
Animator	the control space c(t)	the performance — the trajectory through pose space over time

The animator never edits the mesh and rarely touches raw joints; they drive the rig's handles and shape the F-curves. The rigger never acts a scene; they build the machine that makes acting possible. A great rig is invisible — it lets the animator forget the skeleton entirely and just think about the performance.

A rig is a compromise on the size of the control space m. Too few controls and the animator can't hit the pose they see in their head — the rig can't reach that corner of pose space. Too many and the rig becomes as painful as posing raw joints, defeating the point. Great riggers layer it: a small set of primary handles for the broad strokes, with finer controls tucked underneath for the shots that need them. The art is exposing exactly the DOFs the story needs and hiding the rest behind sensible defaults and driven keys — so the common motions are one drag, and the rare ones are still possible.

It is tempting to give every rotational joint three tidy Euler-angle DOFs — a pitch dial, a yaw dial and a roll dial. But three Euler angles applied in a fixed order can collapse: at certain orientations two of the three axes line up, and you lose a whole degree of freedom — no combination of the dials produces the rotation you want. That is gimbal lock, and on a rig it shows up as a control that suddenly "goes dead" or a joint that flips wildly as an F-curve passes through the singular pose. The count of DOFs is right — a ball joint really is 3-DOF — but the Euler parametrisation of those three DOFs is degenerate. Riggers dodge it by choosing joint axis orders carefully, adding an extra "gimbal" joint, or driving orientation with quaternions under the hood while still showing the animator three friendly dials.