Animation

Keyframes define specific states (positions, shapes, etc.)

Intermediate states are automatically interpolated to create smooth animation

Animator defines only keyframes, not every frame

Parameters can be vertices, normals, color, etc.

The type of parameter usually doesn’t affect the interpolation method

Linear interpolation is simple but often insufficient

For spline surfaces (Bézier, B-spline, NURBS), keyframes can interpolate control points

Actual surface is computed from interpolated control points using curve/surface formulas

Bijective (1:1) correspondence between keyframes is required (same number of parameters)

If keyframes differ in structure, re-meshing algorithms can ensure correspondence

Scene graphs represent hierarchies of rigid bodies

Keyframes define transformations at each node; interpolation gives intermediate poses

Translations and scales can be interpolated directly

Rotation matrices can’t be directly interpolated (components are not independent)

Use Euler angles or quaternions for rotating parts (e.g., via spherical linear interpolation)

Quaternions represent 3D rotations, defined as:

q = a + α, with vector part a = (b, c, d) and scalar α

Unit quaternion:

‖q‖ = √(α² + b² + c² + d²) = 1

Components are not independent, so use spherical linear interpolation (SLERP) to preserve unit length

Can convert a unit quaternion to a rotation matrix R

Rotation of vector v:

Rv = q v q̄, where q̄ = conjugate of q = a – α

Composition:

q₁q₂ = R₁R₂ if both are unit quaternions

Forward kinematics:

• Traverse the scene graph top-down (root to leaves)

• Apply joint transformations step by step

• Final positions of end effectors are computed at the end

Inverse kinematics:

• Traverse bottom-up (from end effector to root)

• Specify desired end-effector positions

• Solve equations to compute joint parameters

Inverse kinematics is more intuitive for animation, but requires solving systems of equations

FFD modifies objects indirectly by deforming a surrounding grid (local coordinate system) instead of the object’s vertices.

Process:

• A grid encases the object (in local u,v space).

• The grid vertices are moved.

• Object vertices are then updated using interpolation (e.g., bilinear) based on their position inside each cell.

Advantages:

• More efficient for complex objects (fewer control points).

• Allows smooth, flexible deformation.

• Commonly used in animation and modeling.

3D FFD is an extension of 2D FFD using a 3D grid structure and trilinear interpolation.

Local coordinates become 3D: (s, t, u).

The grid axes (S, T, U) form a local frame but don’t need to be orthogonal.

Coordinates are normalized:

• Each (s, t, u) is calculated using vector projections and cross products.

Enables flexible deformation of 3D objects like volumes or meshes.

Objects can be segmented into multiple FFD regions (local coordinate systems).

This enables different deformations for different object parts.

Continuity at boundaries must be ensured:

• Control lattices must share control points along boundary planes.

• Enforce colinearity of adjacent control points across boundaries.

Similar to continuity constraints in Bézier solids (surfaces/curves).

Individual FFDs can be modeled and reused for deforming various objects.

Example: A template FFD can be swept through geometry to create animation effects.

Physically-based simulations or functions can compute FFD control points automatically—manual definition isn’t always needed.

FFD tools act as modular, reusable deformation systems for efficient and flexible animation workflows.