Programming Assignment 1

Feb 18-2007: Typo fixed in the requirements
Feb 12-2007: Some commentary has been added at the end

This is meant as a smallish programming assignment to get you started thinking about writing interactive graphics programs where performance matters, and to experiment with some animation techniques. Another aspect of this assignment is for you to get some idea as to how to plan a project in a short time period, and to have realistic expectations of what you can produce in this amount of time.

You will need to write a program (actually, programs - I recommend writing 2 seperate programs, although you may share a lot of code between them) to

1. Compare Quaternion interpolation and other forms of rotation interpolation
2. Make a ball bounce applying the principles of animation.

The basic requirements are pretty minimal. So you shouldn't need much time. And you don't have it - the whole thing is due in 2 weeks.

There is one "catch" that you need to make sure your programs maintain a constant frame rate (like a game would). And... meeting the minimum requirements (and having reasonable documentation) will not get you an A. To get an A, you'll need to think up some bells and whistles to add.

Executive Summary

1. 2 people, (not quite) 2 weeks, 2 programs
2. Any language you want, any tools/libraries (within reason) - but you have to use source control and the programs must run on the machines in B240.
3. One program to interpolate orientations by interpolating Euler Angles, SLERP, and NLERP. And allow for making easy comparison between these.
4. One program to show an animated bouncing ball in (at least) 4 ways: simple rigid bouncing, "animated", rigid bouncing with a mind of its own, "animated" bouncing with a mind of its own (typo fixed 2/18)
5. Your program(s) must maintain a constant framerate.
6. Bells and whistles added as time allows.

1.  Basic stuff

Your programs must maintain a constant frame rate. This should be 60fps, but if you hit some snag and its 30fps, then that's OK. The constancy of frame rate is what's important - not the absolute speed.

Your program should maintain the frame rate even during user input.

You should have a frame rate display.

2.  Program 1: Quaternion Interpolation

For this part of the assignment, your program needs to display a 3D object that has a definitely top and front. You need to allow the user to specify a beginning and ending orientation, and your program needs to animate the object interpolating between the two.

Your program should do interpolation in (at least 3 ways):

• linear interpolation of Euler Angles
• SLERP
• linear interpolation (and normalization) of quaternions (NLERP)

Hint: its easy to convert from Euler Angles to Quaternions, but not as easy to go in the other direction.

Your program needs to be good enough that you can experiment with these different interpolation methods and compare and contrast them. You probably want to show 3 objects all moving together, and maybe even add some other visualization to better see what's going on.

2.1  Learning from your program

Use your program to find examples (i.e. begin/end orientations to interpolate) where:

1. Euler Angles work reasonably well (and give similar answers to Quaternions)
2. Euler Angles give long "non-straight" paths where quaternions give nice "interpolation".
3. The singularities in Euler Angles manifest themselves in unusual motions even though you'd expect nice direct ones (this may be the same answer as #2).
4. The difference between SLERP and NLERP can be seen

3.  Program 2: The bouncing ball

For this program, you need to animate a ball bouncing. (note: you could even do this in 2D, although, that'd may be less fun). Making a ball bounce is a standard exercize that beginning animators do to experiment with animation principles. You'll just do it in code rather than with a pencil.

You should have a floor. And you should have the camera follow the ball as it moves around (not bounce up and down, but move to the side and keep the ball in view). Shadows and other eye-candy are nice too.

Your program should be able to show each other the following (one at a time is fine, or show multiple simultaneously).

First, you should have it be bouncing with simple "real" physics. Make the ball be perfectly rigid (so this isn't realistic) and have the "bounce" be perfectly energy conserving. Since no energy is being added or removed, the horizontal motion should be constant.

Second - give the ball some personality by applying principles of animation to the motion. Do not try to simulate some complex physics to make the ball be a realistic squishy thing. Do some hacks so that the ball obeys the principles of animation. The overall motion should be about the same as the first (up and down and some horizontal motion in one direction)

For the next two parts, we'll give the ball a mind of its own. After each bounce, it will choose a new place to go, and land there on its next bounce.

The third ball does the "physics" bounce (as the first ball does), but with the direction change as it bounces.

The fourth ball has animation principles and a mind of its own.

3.1  What you should see

If all works according to plan...

• the ball to which animation principles were applied should appear more "alive" and maybe even more "real" even though its movements are exagerated
• it should be much easier to guess where the ball is going when the animation principles are applied.

4.  Grading

Half of your grade will be given at the demo (at the 2 week mark) based on the functionality you show. Yes, you can turn things in after the demo time, but half your grade will already be assigned.

5.  Beyond the basics

If you do everything well (including documentation), you'll have a AB. (If you just meet the basic requirements, you'll get a B).

To get an A, you'll need to add some bells and whistles. If you're curious as to whether you've done "enough" to get an A, ask. Basically, if you pick two from the list below, you'll definitely have an A (if you meet the basic requirements as well). But not all of these things are the same "size", if you do something really cool for one that might be enough, ...

Hopefully people will think of things not on the list.

Here are some ideas of things to add:

• Eye candy and fancy graphics.
• Do multi-way interpolation for program 1, show that SLERP is not associative/commutative, but NLERP is.
• Make a game of the bouncing ball - when the ball is more expressive it (should be) easier to catch.
• Have the ball express emotion as it bounces. Have a "happiness/sadness" slider. (it should express emotion through its movement - putting a smiley face on it when its happy is not what I am thinking of).
• Have objects other than a sphere that can be bounced around. (although, you need to have a ball as well as any other objects).

6.  Due Dates

WARNING: the game design project will have its first phase due on Tuesday, Feb 27th.

7.  What to turn in

You will need to make a Wiki page about your assignment. You only need to put it in one person's WikiGroup (but please link to it from all team member's pages).

Your page should describe what your program does, your examples for the interpolation problems, and all the bells and whistles. You should also describe the motion of your animated ball.

You should also give instructions for building and using your program.

You will also need to turn in everything required to build your program (source code, art assets, ...). And an executable. Details of where to put this stuff will be given closer to the deadline.

8.  Some ground rules

You must work in a team of 2 people. Unless you are assigned to a group of 3 by the instructor. We strongly recommend that at least one person in your group has had the graphics class here (559), not just because they've learned about graphics, but because they've learned how to work in the CSL environment.

Your program must run on the machines in B240. If you want to use development tools (like a more modern version of Visual Studio), you can compile your code somewhere else and turn in both binaries and sources.

You can use any development tools or programming language that you like. However, if its something we don't have familiarity with, we won't be able to help you.

You can use any graphics library that you like (e.g. OpenGL, DirectX, JoGL, Java3D), and any windowing toolkit that you like. If you pick something other than FlTk, we might not be able to help you much. If you'd like help using OpenGL and FlTk in the CS environment, check the 559 Web Page.

You must write your own implementation of quaternion operations. (even though some graphics libraries have it).

If you want to use a higher level toolkit or "game engine" this might be OK. Ask the instructor first. Remember all of the other rules.

You must use some kind of source control system to keep your work safe. We can provide you with space in a CVS archive if you need it (send a request to the TA). If you know how to set it up, we can provide space for a Subversion archive. We'll give you some instructions on using source control in the CS environment.

You must work with a partner. If you cannot find a partner, send email to the instructor and he'll find one for you. In the event that there is an odd number of people in the class, the instructor will assign the last un-partnered person to a group (so there's one group of 3).

Your bouncing ball's motion must be generated programmatically. You can't keyframe it in Flash or Maya.

Your code must be documented well enough so that we can see that it really does what it is supposed to do. If you "borrow" code from some source, be sure to give proper attribution.

9.  Other thoughts

Added Feb 12 2007 - An answer to a question from some students that I think is relevant to everyone.