Plan

• (5) Grading Schedule
• (5) Midterm Prep
• (5) Questions on Texture-mapping
• (30) Animation
• (20) Animation lab

Animation

Simple animation is surprisingly easy. OpenGL draws a succession of frames, starting the next one the moment the previous one is finished. Technically, it invokes the idle callback function whenever it is idle, so by putting code in that callback that

• Modifies some global variable that is used by the display function, just as we have with our keyboard callbacks, and
• Invokes glutPostRedisplay()

A moderately complex demo is

tw/demos/animation/MovingMobile.cc

Here's the code to start/stop spinning. To register a function as the idle callback, use the first of the following, and the second to turn it off:

if(Spinning) 
    glutIdleFunc(spin);
else 
    glutIdleFunc(NULL);
break;

The hard part of animation can be:

• Making the motion realistic. This is essentially a job for physical simulation. There's a course on that in the Math department.
• Dealing with the speed of different graphics cards.

• How to move a particular way and then stop. Here's the idea:
  • Decide how many steps or frames you want. Call it NFrames.
  • Define a global variable, say Frame, that starts at zero.
  • In your idle callback, if Frame < NFrames, increment Frame.
  • In your display callback, compute a parameter, t = Frame/(NFrames-1)
  • Use parametric equations to compute the position, color, or whatever of the object. Functions like twPointOnLine() in tw/src/tw-geometry.cc may help.
  • They don't even have to be linear parametric equations!
• A demo that shows some of this is

  tw/demos/animation/Laser.cc

  Use the '+' key to start the animation, and 'p' to pause it.

Double Buffering

An important issue comes up that is demonstrated by the following demo:

tw/demos/animation/SingleDouble.cc

Essentially, you want to synchronize with the display updating process, which is reading out from the frame buffer. You never want it to be refreshing the display from a partially completed picture.

This demo doesn't work on the Macs, because Macs automatically double-buffer for us. However, it does work on the Linux machines, so try it!

MPEG movies

I've written this up in the reading. Remember on the Linux machines to do your work (save all your frames, that is, your PPM files) in /tmp, so that you don't run into any quota issues.

Mass-Spring

If there's time, let's spend a bit more time on the tw/demos/animation/MassSpring.cc animation. Here is a good web sites about Mass Spring systems; there are many others.

Key Frames and Tweening

"Tweening" is when software computes the intermediate frames between two positions. Maya will do this. It's essentially a linear mapping (though it could, in principle, be quadratic or cubic, if we gave more key frames). We've done many linear mappings this semester.

How would you design software to let you do tweening easily? For example, a robotic arm? What are some difficulties?

Lab Exercise

Make an animation of the barn growing:

• copy demos/early/Barn.cc
• add an idle callback to grow the front peak
• increase the bounding box, so that you'll be able to see the growing barn
• add a keyboard callback to start/stop the animation
• adjust the growth rate to be reasonable.
• add a way to save the frames, modeled after the code in 15-MovingMobile.cc
• make an MPEG movie of it.

Here's a result, not necessarily ideal, but good enough for a short exercise. We'll discuss deficiencies.

tw/demos/animation/animationLab.cc

Let's discuss how to create interesting objects:

• bouncing ball
• train wheels with traction bars
• robotic arm
• what else?

Timed Animation

So far, our animations run as fast as the machine is capable of: as soon as it's done rendering a scene, it becomes idle, the idle callback is executed, and the machine starts rendering the next scene. There are two drawbacks this:

• Sometimes, for a simple scene, the animation is too fast. For example, animating the rotatation of the barn can result in the barn zipping around so quickly it becomes a blur. We can slow this down by reducing the change between frames, either by reducing the time step, delta t (DT) or by reducing the change in the state variables at each step.
• Sometimes, we know we're going to create an MPEG movie of the animation at a given number of frames per second, and it would be nice to have our graphic program show us roughly what that looks like.

To have the state variables updated when a certain amount of time has passed, rather than as soon as possible (that is, when the machine is idle), we specify a timer callback, using:

void glutTimerFunc(unsigned int msecs, void (*func)(int value), value);

Arguments:

• msecs: Number of milliseconds to pass before calling the callback.
• func: The timer callback function.
• value: Integer value to pass to the timer callback.

Let's talk about how to read that information from the man page.

The tw/demos/animation/Timer.cc demo shows this in action.

Written by Scott D. Anderson
scott.anderson@acm.org

This work is licensed under a Creative Commons License.