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-engine reproduced 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 to export 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 to export 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 slerp in 2D Did this once before, but will do it again quickly, as an introduction to the lerp derivation

15 What happens when we lerp 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 a substitution 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 for the 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 order by 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 with playing 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 effects in 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 data in 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 IK for 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 might want 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?