Rigger

What they do

A rigger receives a modelled character in a neutral pose, plus facial shapes if the modeler sculpted them, and returns a rig: a joint hierarchy, deformers, constraints, and a set of controls with sensible names, limits and default values. Underneath sit skin weights, blendshapes, corrective sculpts that fire at extreme angles, and often muscle or tissue solvers for creatures. On top sits an interface: which control the animator grabs to hunch a shoulder, whether the arm is FK or IK, how the switch works, and what happens when someone dials a value past what the anatomy allows. Days are split between building and support. Riggers write Python to generate rigs from templates rather than hand-building each one, because a feature carries dozens of characters, each with variants, and every model change means republishing. Then animation tests the rig and files notes, and the rigger fixes deformation in the elbow, adds a control nobody anticipated, and re-weights the neck. Performance is a constant pressure: published work at Disney Animation on real-time playback treats rig speed as a first-order pipeline concern, because a rig that plays back slowly costs the animator iterations and therefore quality. Object-oriented rig-building systems exist specifically to make this repeatable rather than artisanal.

What they decide

The calls that belong to this role and no other.

• The control layout and naming, which is the interface every animator on the show will use
• Where deformation is solved by skin weights, by blendshapes, by correctives, or by a simulation
• Joint placement and hierarchy, and the rotation orders and limits on each control
• How much of the rig is generated from code versus hand-built for this character
• The performance budget: what gets baked, proxied or disabled so playback stays interactive
• Which animator requests get built and which get pushed back as out of scope, with the animation supervisor

Principles of the craft

• The rig is a user interface: an animator under deadline should be able to find the control they want without thinking, and should not be able to break the character by accident. Name controls the way animators talk, put limits where anatomy has limits, and make the default pose the neutral one. Every minute of confusion multiplies by the number of animators and the number of shots.
• Deformation follows anatomy, not geometry: the shoulder is hard because the scapula slides and the deltoid bunches, and no amount of smooth skinning will invent that. Study the underlying structure of what moves, then build the simplest thing that reproduces it.
• Cheap before correct: a rig that runs at interactive speed and is 90 percent right beats an anatomically exact rig that plays back at two frames a second, because the animator's iteration count is what turns into performance. Disney Animation's work on real-time playback exists because rig speed changes the quality of the acting.
• Build rigs with code, not by hand: features carry dozens of characters with variants, and models get republished constantly. A rig generated from a described structure can be rebuilt on a new model in an afternoon, which is the difference between accommodating a design change and refusing it.
• Test at the extremes, then one step past: animators will push a control to its limit and hold it there for eight frames. Any pose that only works within the comfortable middle of the range will fail in the shot that needed it.

Common mistakes

• Handing over a rig that has never been posed hard. It survives the neutral turntable and falls apart in the first shot where the character crouches.
• Building an interface for yourself: hundreds of exposed controls, cryptic names, and no distinction between what an animator touches and what is internal machinery.
• Solving everything with correctives, so the rig accumulates hundreds of shapes and becomes impossible to fix or to republish on a new model.
• Ignoring playback performance until animation complains, by which point the rig is too entangled to strip down.
• The experienced rigger's mistake: an elegant, technically impressive system that only its author can maintain, which becomes a liability the moment they move to another show.

How to learn it

Exercises and routes in, not a reading list.

• Rig one arm in Blender three ways: pure skinning, skinning plus a corrective shape, and a helper-joint setup. Pose it to full flexion and screenshot all three. You will be able to see exactly what each layer is buying.
• Rig a character, then hand it to somebody who has never seen it with a single instruction: make it look angry, in ten minutes, no questions. Watch where they hesitate. Every hesitation is an interface bug you own.
• Read the Disney Animation papers on artist-friendly rig building and real-time playback with production rigs, then measure your own rig's playback rate at the resolution an animator would use, and cut it until it plays in real time.
• Write a Python script that builds your arm rig from a joint list, then run it on a second character with different proportions. Whatever breaks is what you hard-coded.
• Take one facial rig and build only the mouth corners, jaw and brows. Animate a two-word line of dialogue with it. The controls you keep wishing you had are the ones worth building next.