1

KIPA Game Engine Seminars

Jonathan Blow

Seoul, Korea

December 7, 2002

Day 11

2

Character Animation

• The goal: let artists make animation, and get it into the game

• Usually animation is made in a separate tool– Maya / MAX

• Made out of hierarchical transforms• Probably we need to write an exporter

plugin and some game-engine import code– Unless we use a licensed character animation

system (like Granny)

3

Goals for in-enginereproduced animation

• As much like the art package’s version of the animation as possible

• But small (low memory) and fast

4

How animations are authored

• The artist sets up a bunch of keyframes for transform data– Usually separated into translation, rotation,

scale

• The art tool interpolates between these keyframes at runtime

• Maybe we should export the keyframes and interpolate them in the engine

5

Why you don’t want toexport the keyframes (1)

• They can be in weird formats that require confusing code to interpolate– 3DS max TCB curves

• They can be in formats that are slow to interpolate– Euler angles

• They are not necessarily well-compressed– Keyframes get fragmented over time

– What happens when you import an animation from another package

6

Why you don’t want toexport the keyframes (2)

• Artists use IK tools to help create animations

• You would have to reconstruct all this IK functionality exactly for the animation to look right– Footstep controller– Guy grabbing something from a table

7

A better solution:Sample the transforms

• Don’t worry about the original keyframe data, just evaluate the transforms at some sampling interval

• Save those transforms out, interpolate them at runtime– Sample at perhaps 30Hz

8

Interpolating transforms?

• We don’t want to interpolate a 4x3 matrix– It will denormalize, introduce shear

• Break it into intuitive pieces (translation, rotation, scale)– By matrix decomposition– But… which decomposition you choose

matters!• Shear easily confused with rotation

• Use the polar decomposition

9

Interpolating transforms? (2)

• If samples are close together, our interpolation will not diverge much from the art tool’s– Euler vs slerp for small angles

• But those samples take a lot of memory!– Example of how much

10

Want to compress those samples

• Hopefully at export time (small file size)

• How to compress?– Fourier / Wavelet compression– Curve fitting

• Performance ramifications of each method

11

Compression

• Probably, curve fitting is the best choice

• Each curve stored as an array of unevenly spaced knots

• At runtime we just evaluate a simple polynomial to reconstruct values– For linear values like translation and scale– What about rotation?

12

Rotation interpolation

• For interpolation between two rotations, slerp is the “right answer”

• This may be too slow– Review of slerp code

• Can we do something else

13

Different kinds of rotation interpolation

• slerp

• exponential map

• lerp– lerp approximates slerp for small angles

• sin(x) = x as x -> 0

– It’s not that bad for large angles either

14

Re-derivation of slerpin 2D

• Did this once before, but will do it again quickly, as an introduction to the lerp derivation

15

What happens when welerp two quaternions?

• Assuming they don’t differ by more than 90 degrees– double cover!

• We can analytically quantify the distoritions in angle and length

16

Using lerp as asubstitution for slerp

• Probably we have to renormalize

• Maybe we have to compensate for the angle

• Discussion of fast unit vector normalization– Newton-raphson approximation to 1/sqrt(x) in

the neighborhood near 1– Walk-through of code

17

How to compensate forthe angle

• Discussion of approximating the inverse of the angular distortion

18

Maybe we don’t have to compensate for the angle

• When curve-fitting, we measure our error with respect to the lerped/normalized reconstruction of a spline (not the ideal slerp solution)

• This causes us to insert more knots in the curve when we might need better angle accuracy

• So maybe there is a trade-off here, memory for runtime speed

19

Fitting algorithm

• (discussion on whiteboard, including quirks)

20

Data structures

• An animation structure contains:– Number of nodes, names of the nodes– Keyframe data for compressed curves– Information about how to blend in/out of

animation, when to start/stop

• Explanation of some different ways you might want to arrange things

21

Data structures

• A mesh contains:– Number of nodes, names of the nodes– Vertex data– Vertex weight information

22

Binding data structures

• A lot of systems work by building a table that cross-references between node names in the animations, and node names in the mesh– Animations might not be stored in the same

order node-wise– Some might have nodes that the others don’t

• This is called the “bind step”

23

I don’t like the bind step

• It means that you can’t have animation playback without a mesh attached

• I want animations to be meaningful without meshes yet, i.e. I want to be able to play them back and mix them– Though there are bone length assumptions built into the

animations

• Lately I rewrote my animation system to not use a bind step

24

What I do• An “animation player” class handles animation

playing• One “channel” per animation on the same figure

(so, 2 channels for upper/lower body)• The player has a string hash table that keeps track

of values, and maps each channel’s nodes to a central node array

• To animate an object, we map that object’s node names through the hash table (every frame, potentially)

25

Structuring node orderby dependency

• So you can compose a bunch of relative transforms into object-space transforms in one pass– Only constraint is that any node’s parent has to

have an index less than its own

• If you mix two arrays like this, it is easy to maintain this constraint– So the player’s central animation array will be

correctly ordered

26

Mixing Animations

• Sometimes you want to play back two different animations on various nodes of the body– Description of how this reduces data size and

artist time

• This will produce inappropriate results for some actions– Because the meanings of various rotations

depend on what’s higher up in the hierarchy– Example: Guy swinging a sword

27

Mixing Animations

• Interpolate transforms relative to a common root between the two animations

• Put these into the relative transform slots during animation playback– Or else interpolate in object space, but that

might be inconvenient

28

Brief discussion: quaternion splines

• Very hard to precompute, not cheap to evaluate either

• Though Casey says you can do a de Casteljau-like formulation, using slerp instead of lerp

• I am not sure if this is the “right answer” but it seems to work in many cases

• So if lerp is not good enough, think about using this layered slerp technique

29

Mixing IK withplaying animations

• Evaluate the animations first

• Solve IK given those object-space coordinates

• Mix the IK back in as though it were an animation channel

30

Putting sound effectsin animation data

• Only robust way to generate sound cues at appropriate times!

• Put tag names in the animation; these tags are later converted to sound effect names– based on material contacted, etc…

• (example of footsteps)

31

Putting other auxiliary datain animations

• Example of “attack strength” in swordfighting game

• Advantage: Easy for animator to change this without programmers, easy to keep in sync with animation

• Disadvantage: Maybe animator should not be in charge of this; might be better to have a separate specification system

32

Instead of IKfor aiming things…

• Blending between pre-generated animations

• (Example of aiming a gun)

• Can do an iterated search through the animation space until you find something “close enough”

33

Reasons you still mightwant IK

• Example of two-handed weapon– Shows why requiring a tree hierarchy is bad

34

Facial Animation

• Probably should use morph targets, not a bone system

• Each facial expression is probably a short animation (not a frozen mask)

35

Code Inspection

36

Questions?