Deprecated: Function set_magic_quotes_runtime() is deprecated in /storage/content/76/1004576/ on line 33 Deprecated: Function split() is deprecated in /storage/content/76/1004576/ on line 95 Deprecated: Function split() is deprecated in /storage/content/76/1004576/ on line 743 docs:overview [DokuWiki]


This document is intended to provide a broad overview of how animation is accomplished in JPatch. For a detailed explanation of specific functions, please refer to the User Manual. The following topics will be covered:

  • The Timeline What the timeline is, and how to read it.
  • Key Frames and Inbetweening What they are, and how they relate.
  • Bones and Morphs What they are, and how they are used to animate a character.

The Timeline

Frames Per Second

Films display a series of seperate images to the viewer. At a rapid enough rate, the images fuse into a smoothly moving image. Frame rate is measured in frames per second (fps). The following frame rates are standard:

  1. 24 frames per second for film
  2. 25 frames per second for PAL (European video)
  3. 30 frames per second for NTSC (American video)

The frame rate is set in the Animator module.

An animator typically thinks in terms of film FPS - 24 frames a second. Creating one second worth of animation means creating 24 seperate drawings; one minute of animation requires 1440 drawings.

So questions about timing aren’t asked in terms of “how long”, but “how many frames?”

Reading the Timeline

For an animator, navigating through time means moving forward or back a given number of frames. The display of time in JPatch is in the form:


The frame number begins with 1, while the time begins with zero. That is, the display doesn’t show the time for the current frame, but how much time has already passed. The frames value indicates the fractional amount of one second that has passed, relative to the current framerate. So at frame 1, JPatch displays:


No time has passed. Move forward to frame 2, and JPatch shows:


Assuming a framerate of 24 fps, the trailing .01 indicates that 1/24th of a second has passed. Move ahead to frame 25, and JPatch shows that 1 second has passed, with no fractional seconds:


At frame 241, JPatch displays that 10 seconds have passed, again with no fractional seconds:






Keyframes and Inbetweening

Unlike traditional 2D animation, where the animator was required to create a new drawing for every frame of animation1), it’s possible to create only key poses, and have the computer interpolate the “in between” frames of the animation. This is (in theory) one of the great time savers of computer animation. Of course, nothing’s ever as simple as that.

Extreme and Key Poses

Up to the 1920s, each animator was expected to draw every frame of their animation. Dick Huemer is attributed of coming up with the idea of the inbetweener2), where the lead animator would create the “extreme” frames for the animation, and an assistant would then draw the “inbetween” frames.

Although the phrase key has a very specific meaning to traditional animators, in JPatch it is synonymous with extreme pose.


Two systems of animating have developed among traditional animators: straight ahead and pose to pose.

  1. In the straight ahead system, an animator would begin animating at frame one, and progress forward and see how the animation went. It’s a great system for discovery, but there’s no guarantee that the scene would turn out right.
  2. In the pose to pose system, an animator would begin by setting up “key” frames - critical poses they wanted to hit during the animation. They would then break the keys down to “extreme” poses, and finally break those down to the inbetween frames. It’s a very structured system, and works well with computer animation.

JPatch will automatically create the inbetween poses between key frames. For example, if has a key frame where the arm is down at frame 1 and up at frame 25, JPatch will automatically calculate the poses so the arm raised between frames 1 and 25. If the values at the keyframe are later changed, JPatch will automatically recalculate the poses to reflect the changes.

Types of Interpolation

There are two types of interpolation available in JPatch: linear, and spline.

  1. With linear interpolation, the rate of change between the one key frame and the next is constant. This is good for mechanical motion, but not representative of natural motion.
  2. Spline interpolation is a more natural movement, where the rate of change slowly accelerates, and then decelerates. In traditional animation terms, spline interpolation automatically adds “ease in” and “ease out”, so the motion is more natural. Because it is generally the type of motion that’s preferred, this is the default type of interpolation that JPatch will use.

One common problem with using spline interpolation is overshoot, where instead instead of stopping an action at the key, the value actually overshoots the value before returning to the desired value:

<insert graphic here>

JPatch will automatically correct overshoot.

If you don’t like the type of interpolation that JPatch is using, you can change the type of interpolation that JPatch uses by opening up the motion curves in the timeline.

Keyframes Only Store Changes

JPatch only stores information about what’s been changed at keyframes. Consider the following sequence:

  1. At keyframe 1, you move the puppet’s arm.
  2. At keyframe 25, you turn the puppet’s head.
  3. At keyframe 50, you move the puppet’s arm.
  4. At keyframe 75, you move the puppet’s head.

Because the arm wasn’t moved at keyframe 25, the keyframe only relates to the puppet’s head. Likewise, since the head wasn’t moved at keyframe 50, that keyframe only relates to the puppet’s arm.

When JPatch animates the puppet:

  • The values at keyframes 1 and 50 are used to interpolate the arm’s movement.
  • The values at keyframes 25 and 75 are used to interpolate the head’s movement.

Perhaps more clearly put: the keyframe at frame 25 will not effect the movement of the head, and the keyframe at 50 will not effect the movement of the arm.

This turns out to be tremendously useful, because you can build up animation in passes. For example, you can build the limb animation in the first pass, finger motion in the next pass, secondary movement in the next pass, then lipsync, and then facial expression.

Now for the “gotcha”: if JPatch can’t find a prior keyframe for a value, it will start the interpolation from the default value at frame zero.

For example, imagine you wanted the character to wave at frame 40, and bow at frame 120. You move to frame 40 and move their hand up, and frame 100 and move it down. You then move to frame 120 and add the bow.

When you play the animation, you discover that the puppet doesn’t behave like you expected it to - it begins the bow from frame zero. This is because even though you set a keyframe at frame 40, because only the arm was moved, only keyframe information for the arm was stored.

To correct the problem, you need to add a keyframe for the waist at the point you want the bow to begin.

A solution that some software packages have the option for keyframing all the joints at each keyframe. This isn’t currently implemented in JPatch.

Bones and Morphs

There are basically three ways a model can be animated:

  1. Translating, Rotating and Scaling. You can changed the position, orientation and size of a character.
  2. Bones: You can can rig a model with an underlying bone system. The control points of the model can be associated with the bones, so they will follow the movement of the bones. You can then animate the character by animating the underlying bones. This is typically how limbs of a character are animated.
  3. Morphs You can edit the look of a model’s control points manually, and save the new shape as a morph target. For example, you could adjust the points on a model’s face so it smiles. That morph can be saved and later applied.

Translating, Rotating and Scaling





Rigging is the process of creating and attaching a set of bones to a mesh, so that the mesh can be animated by moving the bones.

FIXME Is this too much detail? Add pictures!

Bones can be created by clicking on the Add Bone icon, clicking in the modeler at the point where the root of the bone is to begin, and then dragging the mouse to where the bone is to end, and releasing the mouse. Bones can be attached to other bones by dragging one end of the bone to the end of another bone, and left-clicking (the same way splines are linked).


The bottom end of the bone is referred to as the “root” of the bone, and is the point at which the bone rotates. Each axis of rotation is referred to as a “degree of freedom”, of DOF. By default, the bone can rotate freely along all three axis. These rotations are:

  1. Pitch: Rotation about the x axis.
  2. Yaw: Rotation about the y axis
  3. Roll: Roation about the z axis

FIXME Future support for “surge”?

These rotations are relative to the bone’s axis system, not to the global axis system.

JPatch allows you to limit a bone’s rotations, so that the movement is restricted to natural poses. For example, an elbow no yaw, and a pitch and roll restricted to about 90 degrees each.


You may also find it useful to have “connector” bones, which connect bones together, but don’t have any associated control points. For example, you can use connector bones to connect a rabbit’s ear bones to it’s head bone.

Because no control points can be assigned to these bones, they are displayed in JPatch as having no color.

FIXME <insert graphic here>

If you create two bones, and then connect them with another bone, JPatch will automatically make the new bone a connector.

FIXME <insert graphic here>



Assigning Control Points to Bones

Once the bones are created for a model, you need to assign control points to their respective bones. This is done by selecting a bone (with LeftClick), and control points (with Shift+LeftClick) you want to assign to the bone using Assign Controlpoints to Bones in the popup menu under Tools.

FIXME Too much detail?

FIXME <insert graphic here>

If more than one bone is selected, JPatch will assign the control point to the closest selected bone.

The simplest way to rig a model is to select the entire model (mesh and control points) and choose Assign Controlpoints to Bones, then manually correct points that are incorrectly assigned.


Morph Targets

Before rotation, a model may look fine:

But bone rotation may cause the model’s surface to warp and pinch unrealistically, especially close to the joint:

This is because unlike real life models, JPatch’s models are only skin deep. There is no underlying musculature to cause the model to maintain a proper shape and volume. To solve this, a morph target can be created. A morph target is the same as a regular morph, but it is automatically applied when the bone rotates on a given axis. JPatch can create a morph target for every degree of freedom a bone has, in either direction:

Not only can morph targets be used to fix mesh distortions caused by bone rotations, but it can also be used to similate effects such as muscles flexing:

Animating Using Bones

There are two different methods of animating using bones: Forward Kinematics (FK) and Inverse Kinematics.

  • Forward Kinematics (FK) allows you to rotate a bone directly by selecting the root and adjusting the rotation.
  • Inverse Kinematics (IK) allows you to rotate a chain of bones indirectly by assigning a target for them to reach, and having the program calculate how to rotate the bones so they can reach the target.
Forward Kinematics

JPatch doesn’t currently support Forward Kinematics, but it will Really Soon Now.

Inverse Kinematics

JPatch doesn’t currently support Inverse Kinematics, but it’s planned for the 0.8 release.

1) Yes, I’m aware of limited animation, cycles and holds. If you know about these, you probably don’t need to be reading this anyway.
2) The Animator’s Survival Kit, by Richard Williams, pg. 48. If you haven’t got this book get it now. It’s the best animation book ever, bar none.
  docs/overview.txt · Last modified: 2006/01/23 11:53 by (dcuny)