# Smooth interpolation of irregularly spaced keyframes

keyframe value interpolation animation k' keyframes k(t gradient values

Describes a method of grouping keyframes where they're most needed to obtain smooth animation.

**Introduction**

Animating models by manipulating an attached skeleton is a common technique for producing lifelike animations in games. It has both a firm basis in biological reality, and a low memory requirement (compared to, for example, storing vertex and normal vectors for each frame). Also, high frame rates are now expected of animations, and skeletal animation data can easily be interpolated between "key" frames before transformations are applied to the model. It is assumed that the reader is familiar with this process.

A glossary of terms has been included for reference at the bottom of the article.

**Standard interpolation formulae**

The whole animation is represented by a series of values

*k(t)*where

*t*is an integer.There are a number of well-known techniques for interpolating between two values

*k(t)*and

*k(t+1)*. The value

*u*represents the fractional part of

*t*in the equations below, so read

*k(0)*and

*k(1)*as

*k(t)*and

*k(t+1)*. Animations are sped up or slowed down to taste afterwards, so that

*0 = u = 1*during interpolation.

k'(t) = ½[k(t) - k(t-1)]/dx

_{1}+ ½[k(t+1) - k(t)]/dx

_{2}

In the case so far being examined,

*dx*, as these are the intervals between keyframe values of

_{1}= dx_{2}= 1*t*, and

*t*is an integer. But what if keyframes could be placed at any value of

*t*? This would certainly be beneficial for animators, as not all time intervals in an animation contain the same amount of "detail." In the few (very humble) animations I've made, I have found a constant trade-off between the amount of detail you would like one region of your animation to have, and the sheer number of keyframes piling up in your animation. Why not just put in keyframes where you need them, and have them smoothly interpolated while you're at it?

Another problem that this will assist with is when one part of an animation is running just a little too fast or too slow. To tweak this normally, you have to adjust all the frames around the area, but with this system, you can just slide a keyframe or two a tiny bit to correct the error.

This is an ability limited to high-end and non-realtime modelling software, as far as I know. Certainly, I've found no reference to coding it on the web.

**Irregular keyframe timing**

All that now remains is to adapt the interpolation to work with irregular keyframe intervals. We need a new array to store the time offset into the animation of each keyframe, denoted

*kt(i)*for a particular keyframe

*i*. The first change is in calculating the tangents - for example, moving keyframes together will obviously increase the slope of the tangent of the curve. The equation above becomes:

k'(t) = ½[k(i) - k(i-1)]/[kt(i) - kt(i-1)] + ½[k(t+1) - k(t)]/[kt(i) - kt(i-1)]

At the interpolation stage, we first need to find out what keyframes we're between at the moment. This is done easily enough with something like:

while (t >= kt[iKeyFrame+1]) iKeyFrame++;

Then we come across a slight snag - we need the value of

*u*for the spline to work correctly. This is calculated as

*u = (t - kt(i)) / (kt(i+1) - kt(i))*.

The value

*(kt(i+1) - kt(i))*is actually used three times per interpolation, so I give it its own name,

*dx*.

*u = (t - kt(i)) /*dx.

Of course, we've now scaled time, so while

*k(t)*will hold, the tangent values

*k'(t)*will be scaled by the same amount. We must replace

*k'()*in the Catmull-Rom interpolation by

*k'() × dx*. At first glance it may seem that this is the inverse operation to that performed when calculating the tangents, but it is not; both operations are necessary.

You now have your interpolated value of

*k(t)*. Apply this to your Euler angles, or your sleek slerped quaternions, and you will see some real

*smooth*animation. Enjoy!

**Glossary**

k(t)

The value of a keyframe at timek(u)t(one number, so several may be used to represent a complete orientation).

The interpolated value between two valuesk'(t)k(t)andk(t+1)(assuming a spacing of 1).ualways takes a value in the range 0 to 1.

The "gradient" of a keyframe - this is not set by the user, as is the case with splines in many graphics programs, but is calculated as an average of the gradients of lines to the keyframes on either side.kt(i)

The time valuedxtfor keyframe numberi. It must always be the case thatkt(i) < kt(i+1).

The time interval between two particular keyframes. In most keyframing systems,dxis 1, or some constant value. In this system,dxcan take any value, and can vary throughout the animation.

## 0 Comments

Note: GameDev.net moderates article comments.