Rigging and character animation

In short

Rigging builds the controllable skeleton, deformers and control handles that let a static 3D model move; character animation is the keyframed or captured motion applied through that rig. The two are examined together because a rig is judged only by the poses it can hold without breaking, and animation is limited by the rig it drives. Indian university B.Sc/B.Des syllabi examine skeleton hierarchy, FK/IK, skinning and weighting, deformers, blend shapes, the 12 principles, cycles and the graph editor; placement tests ask for a clean rig file, a weighted arm bend and an 11-second acting shot or a walk cycle. Rigging TD and animator roles at DNEG India, Framestore Mumbai, Prana, 88 Pictures, Cosmos-Maya, Green Gold, Toonz, Phantom FX, Basilic Fly, Lakshya Digital and Ubisoft/Rockstar India hire on exactly these skills. Industry software is Maya, Blender, 3ds Max, Houdini, MotionBuilder, Unreal and Unity, with FBX, Alembic, USD and glTF as interchange formats.

Explained

Skeleton, joints and transform hierarchy

• A joint (Maya) or bone (Blender/Max) is just a transform node with a pivot; the visible "bone" is the drawn link between a joint and its child. Animation keys the rotation of joints, almost never the translation (except root, COG and sometimes clavicle/jaw).
• Every node carries a local matrix built from translate, rotate (with a rotation order), scale and, in Maya, jointOrient. The world matrix is the local matrix multiplied up the parent chain, so a parent's rotation carries all descendants.
• Degrees of freedom (DOF): a free joint has 3 rotational DOF; hinge joints (elbow, knee) are limited to 1 and the rest locked, which is what makes an IK solve well behaved.
• Joint orientation must be consistent — primary axis down the bone (commonly X), secondary along the bend plane — else the elbow bends on two axes at once and mirroring fails.
• Naming and sides: L_arm_01_JNT, R_arm_01_JNT; a strict convention is what lets scripts mirror, retarget and batch-publish rigs.
• Typical joint counts: a film biped 150–300 joints with face; a game biped 50–80 (Unreal's standard skeleton has about 70), because every joint costs palette space and CPU on the GPU skinning path.
• Preferred angle / rest pose: T-pose or A-pose, limbs slightly bent, so the IK solver knows which way the knee goes and the skin binds cleanly.

Forward and inverse kinematics, constraints, drivers

• FK (forward kinematics): rotate each joint from root outward; the end effector's position is the result. Good for arcs, overlapping action and free limbs.
• IK (inverse kinematics): specify the end effector's position; the solver computes the joint rotations. Good for contact — feet on the ground, hand on a prop.
• Solvers: *analytic two-bone* (rotate-plane, exact, used for arms and legs, needs a pole vector to fix the bend plane), *CCD* (cyclic coordinate descent, iterative, fast, can wobble), *FABRIK* (position-based, popular in game engines), *spline IK* (spine, tail, tentacle) and full-body IK (HumanIK, Control Rig).
• IK/FK blend: a switch attribute drives a blend between two duplicate chains so an animator can hold a hand in world space for a push and switch to FK for a throw; matching scripts copy the pose across the switch.
• Constraints: parent, point, orient, scale, aim, pole-vector; each has *maintain offset* and *weight*, and weights can be blended to make space switching (hand in world / chest / head space).
• Drivers: set-driven keys, driven keys, expressions, node networks (multiply-divide, condition, remap) and Blender's drivers — used for finger curls, foot-roll, auto-clavicle and corrective shapes.
• Deformer and evaluation order: skinCluster, blendShape, lattice, wrap, wire, delta-mush, cloth; order in the deformation stack changes the result, and corrective blend shapes placed before skinning behave differently from after.

Skinning and weighting

• Binding associates each vertex with a set of joints and weights. Linear blend skinning (LBS) / smooth skin is the standard: the vertex's final position is the weighted average of its position transformed by each influencing joint.
• Normalisation: weights per vertex must sum to 1, otherwise the surface shrinks or explodes. Max influences is usually 4 for games (hardware palette limit) and 8 or more for film.
• Bind methods: closest distance, closest in hierarchy, heat map, geodesic voxel (Maya) or *automatic weights* with envelopes (Blender). Auto-binding is a starting point only.
• Weight painting tools: paint, smooth, flood, mirror, copy weights between meshes, component editor for numeric values, and .xml/.json weight export so weights survive a topology change.
• LBS artefacts: the candy-wrapper twist (180° wrist rotation collapses the mesh), elbow/knee volume loss, and the shoulder crease. Fixes: twist/roll joints distributing rotation over several joints, half-rotation (bendy) joints, corrective blend shapes, dual quaternion skinning (preserves volume but bulges), delta-mush or muscle/flesh simulation for high-end film.
• Blend shapes (shape keys / morph targets): per-vertex offsets from a sculpted target, driven 0–1. Used for faces, correctives and squash shapes. They are linear, so large rotations must be done by joints, not shapes.

Facial rigging

• Joint-based: small joints for jaw, eyes, lids, lips and cheeks — cheap, real-time, standard for games; drives well from mocap.
• Blend-shape based: sculpted expressions, usually organised on FACS action units (brow raiser, lid tightener, lip corner puller etc.); gives the artist exact shapes. Apple's ARKit set of 52 shapes and Epic's MetaHuman face board are the de-facto game/real-time targets.
• Hybrid is the normal film solution: jaw and eyes on joints, expression detail on shapes, with in-between and combination shapes to fix pairs that interfere.
• Rules: jaw rotates from the condyle near the ear (not the chin); eyelids follow the eyeball sphere; lips need sticky-lip behaviour; teeth and tongue are separate parented geometry.
• Phoneme/viseme sets drive lip sync — typically 10–14 visemes (AI, E, O, U, MBP, FV, L, WQ, etech, rest), examined as "Preston Blair mouth shapes".

The 12 principles and animation workflow

• The 12 principles (Thomas and Johnston, Disney): squash and stretch; anticipation; staging; straight-ahead vs pose-to-pose; follow-through and overlapping action; slow in and slow out; arcs; secondary action; timing; exaggeration; solid drawing (solid posing in 3D); appeal.
• Timing = how many frames an action takes; spacing = how the in-betweens are distributed. Even spacing reads as mechanical; tightening spacing at the extremes creates ease.
• Workflow: (1) reference and thumbnails, (2) blocking on stepped keys, (3) blocking-plus / breakdowns, (4) splining (convert to Bezier/auto tangents), (5) polish — arcs, overlap, offsets, contact fixes, (6) final — collision, texture of motion, camera check.
• Graph editor: curves per channel; tangent types stepped, linear, spline/auto, flat, broken; euler filter to remove 360° flips; cycle and cycle-with-offset infinity for loops.
• Cycles: walk, run, jog, idle. A walk has contact, down, passing and up positions per step (4 keys × 2 steps = 8 core poses). Typical film walk ≈ 24 frames per full cycle at 24 fps; a run ≈ 12–16; stylised TV walks are often 12–16.
• Rotation representation: Euler angles are animator-friendly but suffer gimbal lock when two axes align — fix with a correct rotation order (e.g. ZXY for a shoulder) or quaternion interpolation. Quaternions avoid gimbal lock and give shortest-arc slerp, but are not directly editable in curves.
• Frame rates in India: theatrical film 24 fps; broadcast on the PAL/625 standard 25 fps; web/OTT 24, 25 or 30; games 30 or 60 fps target. Mocap is captured at 60–240 Hz and resampled.

Motion capture, retargeting and game pipelines

• Capture types: optical marker (Vicon, OptiTrack — used by Prana and several Indian studios and by game outsourcing houses), inertial suits (Xsens, Rokoko), markerless video, and performance capture for the face (head-mounted camera, iPhone ARKit for previs).
• Pipeline: calibrate → capture → solve to a skeleton → clean (gap-fill, filter, remove jitter and foot slide) → retarget to the character rig (HumanIK, MotionBuilder, Control Rig, Blender's Rokoko/Auto-Rig Pro) → layer keyframes on top.
• Retargeting issues: different limb proportions change contact points; retargeting is driven by rotations with the hips/root solved for position; T-pose match and joint-orient match must be right or the character goes cross-legged.
• Game constraints: joint budget, 4 influences per vertex, no scale in most engines, additive and layered animation, root motion vs in-place with a locomotion blend, blend trees/state machines, IK foot placement on slopes at runtime, LOD skeletons.
• Rights and legal practice in India: animation and VFX work is normally work for hire assigned by written agreement under the Copyright Act, 1957 — the producer is the author of a cinematograph film, and the 2012 amendment strengthened authors' rights, so assignment clauses matter. A mocap actor's performance attracts performer's rights under the Copyright Act's performers' rights provisions (inserted by the 1994 amendment and strengthened in 2012), so a release/consent is standard. Animation and VFX services are taxed at 18% GST (export of services is zero-rated against LUT/refund), and studio employment now falls under the four Labour Codes in force from 21 November 2025. Government support comes through the AVGC-XR policy track and the Indian Institute of Creative Technologies (National Centre of Excellence for AVGC-XR), Mumbai; many state AVGC policies offer incentives — the specific rates change, so check the current state policy rather than quoting a figure.

Key points

• Joint - a transform with a pivot; animation keys rotations, and the world matrix is the product of local matrices up the hierarchy.
• Rotation order - the sequence Euler angles are applied in; the wrong order causes gimbal lock on the most-used axis.
• FK - rotate joints, end effector follows; IK - place the effector, solver finds rotations.
• Pole vector - the control that fixes which way an IK elbow or knee points.
• Analytic two-bone IK - exact cosine-rule solution for a 2-link chain; CCD and FABRIK are iterative solvers for longer chains.
• Constraint - a node that drives one transform from another (parent, point, orient, aim, scale); weights enable space switching.
• Skinning / skinCluster - vertex-to-joint weight map; weights per vertex must normalise to 1.
• LBS - weighted average of rigid transforms; cheap, but loses volume and candy-wraps on twist.
• DQS - dual quaternion skinning preserves volume on twist but can bulge on bend.
• Twist joints - extra joints splitting a limb's roll so no single joint rotates 180°.
• Blend shape - linear per-vertex offset target, driven 0–1; good for faces and correctives, bad for rotation.
• FACS - anatomical action-unit system used to organise facial shapes; ARKit's 52 shapes are the real-time standard set.
• Blocking - stepped-key stage establishing poses and timing before splining.
• Timing vs spacing - frame count of an action vs distribution of in-betweens; spacing creates ease and weight.
• Arcs - natural motion follows curved paths; straight-line translation reads as robotic.
• Walk cycle poses - contact, down, passing, up, per step; ~24 frames per cycle at 24 fps for a natural walk.
• Retargeting - mapping captured joint rotations onto a differently proportioned rig; needs matched T-pose and joint orients.
• Game budget - 4 influences per vertex, 50–80 joints, no non-uniform scale, root motion for locomotion.

Formulas and examples

Example 1 — LBS at an elbow and the volume-loss artefact. Rest vertex v = (2, 0, 0) m near the elbow. Upper-arm joint A stays at identity; forearm joint B rotates 90° about Z through the origin. Weights wA = 0.7, wB = 0.3.

• A's contribution: (2, 0, 0). B's contribution: rotating (2,0,0) by +90° about Z gives (0, 2, 0).
• v' = 0.7(2, 0, 0) + 0.3(0, 2, 0) = (1.4, 0.6, 0).
• |v'| = √(1.96 + 0.36) = √2.32 = 1.523 m against a rest length of 2 m — a 24% collapse. This is exactly why LBS loses volume at bends and why correctives, DQS or delta-mush are added.

Example 2 — two-bone IK for an arm. Upper arm L₁ = 30 cm, forearm L₂ = 25 cm, hand target at d = 40 cm from the shoulder.

• Reach check: |30 − 25| = 5 ≤ 40 ≤ 55 — solvable.
• cos(elbow) = (900 + 625 − 1600)/(2 × 30 × 25) = −75/1500 = −0.05 → elbow interior angle = 92.87°, i.e. a bend of 180 − 92.87 = 87.13° from straight.
• cos(shoulder offset) = (900 + 1600 − 625)/(2 × 30 × 40) = 1875/2400 = 0.78125 → 38.63° between the upper arm and the shoulder-to-target line.
• If the animator pulls the target to d = 60 cm, d > 55 cm: the solver clamps, the arm locks straight and the hand pops away — the classic "IK snap" seen in exam vivas.

Example 3 — jump timing at 24 fps. A character's hips rise 0.5 m during a jump.

• t_up = √(2 × 0.5 / 9.81) = √0.10194 = 0.3193 s → 0.3193 × 24 = 7.66 → 8 frames up.
• Total air time = 0.6386 s → 15.3 → 15 frames airborne (8 up, 7 down, apex key held one frame for the floating feel).
• Spacing: largest gaps near take-off and landing, smallest around the apex. Add 4–6 frames of anticipation crouch and 6–10 frames of landing settle (squash then overshoot recovery).

Example 4 — walk cycle speed and foot slide. A 24-frame cycle at 24 fps, 2 steps per cycle, stride 0.75 m per step.

• Cycle duration = 24/24 = 1.00 s; distance per cycle = 2 × 0.75 = 1.5 m → speed = 1.5 m/s (5.4 km/h).
• Root must advance 1.5/24 = 0.0625 m (6.25 cm) per frame. If the root is keyed at 1.6 m per cycle while the feet still plant 1.5 m, the planted foot slides 10 cm per cycle — visible foot slip; fix by matching root distance to contact positions, or by extracting root motion from the foot plants.
• At 25 fps (broadcast) the same 24-frame cycle plays in 0.96 s → speed = 1.5/0.96 = 1.5625 m/s, so cycles must be re-timed, not just re-labelled, when a show changes frame rate.

Example 5 — game animation budget. A 70-joint skeleton, rotation only as quaternions (4 channels × 2 bytes compressed = 8 bytes per key), 30 keys per second, 2-second clip, keys on every frame.

• Keys = 70 × 60 = 4,200 joint-keys → 4,200 × 8 = 33,600 bytes ≈ 33 KB per clip.
• 400 such clips ≈ 13 MB — which is why curve-fitting, key reduction and dropping unanimated joints matter on mobile titles produced by Indian outsourcing studios.

Where it is used

• Feature VFX and animation: DNEG India, Framestore Mumbai, Prana Studios, 88 Pictures, Phantom FX, Basilic Fly and Anibrain rig creatures and digital doubles and animate shots for Indian and international features and series.
• Indian TV and OTT animation: Green Gold (Chhota Bheem), Cosmos-Maya, Toonz (Thiruvananthapuram), Assemblage and Reliance Animation run high-volume rigs with reusable templates, library cycles and strict joint budgets for 11-minute episodic output.
• Games: Rockstar India (Bengaluru, formerly Dhruva Interactive), Lakshya Digital (Keywords, Gurugram), Ubisoft Pune/Mumbai, Sumo India, Zynga, Nazara and Dream11-adjacent studios need engine-ready skeletons, retargeted mocap, state machines and runtime IK.
• Job roles: character TD / rigging artist, technical animator, animator (body and facial), mocap solver/cleanup artist, pipeline TD writing Python/MEL rig-build tools, and crowd TD on Houdini/Golaem.
• Beyond entertainment: AR/VR avatars and metaverse products, medical and safety training simulations, architectural walkthrough figures, e-learning explainers, defence and ISRO visualisation, and virtual anchors/influencers.
• Live and virtual production: real-time puppeteering of mascots and news avatars in Unreal with iPhone face capture, used by Indian broadcasters and ed-tech firms.

Interview questions

• Q: When would you give an animator IK rather than FK on an arm? A: When the hand must stay fixed in world or prop space — a push, a weapon grip, a hand on a table — because IK holds the contact while the body moves; FK is better for free swings and overlap.
• Q: What is a pole vector and why does an IK knee flip without it? A: It is a control defining the plane of the two-bone solve; without it the solver has infinite valid bend planes and small changes make the knee snap between solutions.
• Q: Why must skin weights normalise to 1? A: The skinned position is a weighted average of transformed rest positions; if the weights sum to less than 1 the vertex collapses toward the origin, and if more than 1 it overshoots.
• Q: What is the candy-wrapper artefact and how do you fix it? A: Linear blending of two very different rotations (a 180° wrist twist) pinches the mesh to zero radius; fix with twist/roll joints splitting the rotation, dual quaternion skinning, or corrective shapes.
• Q: Explain gimbal lock and your practical fix. A: When two Euler axes align, one DOF is lost and the curves flip; choose a rotation order that puts the most-used axis last (ZXY for shoulders), apply a Euler filter, or use quaternion interpolation.
• Q: Why do we animate rotations and not translations on limb joints? A: Real joints rotate about fixed pivots; translating a joint stretches the bone, breaks skinning volume and is unsupported by most game engines.
• Q: What is the difference between timing and spacing? A: Timing is how many frames an action occupies; spacing is how the in-between positions are distributed within those frames — spacing is what creates weight and ease.
• Q: Why does retargeted mocap often produce foot sliding, and how do you fix it? A: Limb proportions and hip height differ from the actor's, so the solved root travel no longer matches the foot plants; fix by locking contacts with IK, re-deriving root motion from the plants, and layering corrective keys.
• Q: How many influences per vertex do you keep, and why? A: Four for games, because the GPU skinning path and most engines support a four-bone palette; film can go to eight or more for smoother shoulders.
• Q: Blend shapes or joints for a face in a mobile game? A: Mostly joints, with a small ARKit-compatible shape set if face capture is needed — joints are cheaper, scale to many characters and retarget easily.
• Q: What checks do you run before publishing a rig? A: Extreme-pose deformation test, zeroed controls returning to the exact rest pose, no double transforms or cycles, locked unused channels, correct joint orients, named and namespaced nodes, referenced-file and scale sanity, and a performance/evaluation test.
• Q: A director wants a 24 fps shot delivered also at 25 fps. What breaks? A: Every timed action plays about 4% faster, so cycles and ballistic timing must be re-computed from the physics, not merely re-labelled; audio sync and mocap resampling must be redone.

Common mistakes

• Binding before fixing topology, scale or joint orients, then painting weights that must be thrown away after the first model revision.
• Leaving default auto-bind weights at shoulders, hips and the jaw, and only noticing in extreme poses — always test the full range of motion.
• Animating with stepped keys and splining everything at once, which destroys the blocked timing; break down and spline in passes.
• Ignoring arcs and keying translation in straight lines, giving mechanical motion with no weight.
• Scaling joints or using non-uniform scale in a rig destined for a game engine, which does not support it.
• Confusing a 180° Euler flip in the graph editor with real motion and polishing around it instead of applying a Euler filter.
• Quoting frame counts without the frame rate — "an 8-frame anticipation" means different things at 24, 25 and 30 fps.

Related topics

3D modelling, texturing and UV mapping · Lighting, rendering and shaders · Principles of animation and storyboarding · Motion capture and virtual production · Game engines: Unity and Unreal · Cloth, hair and dynamics simulation