Recap

• Color Interpolation
• Parametric Equations for lines
• Parametric Equations for triangles and quadrilaterals
• GL, GLU, GLUT
• GLUT objects

New Material

• Bounding Boxes (for a scene and for an object)
• TW objects
• How to use them: reference point (local origin) and different coordinate systems
• Affine Transformations (math next time)
• matrix multiplication
• affine transformations as matrix multiplications
• homogeneous coordinate systems

GLUT Objects

There are a number of built-in GLUT objects. There are more in the readings, but here are a few.

void glutWireSphere(GLdouble radius, GLint slices, GLint stacks);
void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);
void glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);
void glutWireCube(GLdouble size);
void glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);
void glutWireDodecahedron(void);
void glutWireTeapot(GLdouble size);

• What are slices and stacks? We'll look at the demos/modeling/Torus.py demo.
• What is the silhouette edge problem? We'll run the SilhouetteEdge.py demo.
• Where is the object put? We'll run the Cone.py demo
• What is its origin (reference point) and bounding box? We'll run the Teapot.py demo

Disadvantages of Built-in Objects

Is there any disadvantage to using these? Why do you think we didn't use glutSolidCube for the color cube?

Working with Affine Transformations in OpenGL

It's important to remember that the initial coordinate system has the z axis coming out of the screen.

When you T, R, or S, you change the coordinate system for all subsequent operations; that is, you change the interpretation or meaning of vertices. The vertex (2,3,4) means something different as a result.

However, these are affine transformations, which means that lines stay lines and planes stay planes. Therefore, to transform a line, you transform the endpoints and draw the line between the transformed endpoints.

The affine transformation functions are:

• glTranslatef(x,y,z): move the origin to some location in the scene
• glRotatef(degrees,x,y,z): rotate the axes CCW around the given axis to some new orientation
• glScalef(x,y,z): scale the axes

We also need to know:

• glPushMatrix(): save the current transformation matrix (CTM) on a stack
• glPopMatrix(): restore the previous CTM from the stack

So, one take-home message of this is:

Define your object in a coordinate system that is convenient, then use affine transformations to place your object in the scene.

Placing Boxes

We'll carefully walk through the code for the demos/modeling/Blocks.py demo. We'll spend a good deal of time on the Blocks.py demo. Then we'll turn to:

• demos/modeling/Cone.py

Exercise: place two boxes in a scene, one sitting on the ground and the other tilted next to it, as if it just fell off.

For more fun, try to build a snowman.

We'll turn to some more complex examples:

• demos/modeling/TeddyBear.py demonstrates embedded frames
• demos/modeling/Mobile.py also demonstrates embedded frames
• demos/modeling/Fence.py demonstrates display lists (for speed) and iterated transformations

TW Objects

The TW API defines the following for your use

• twDisk
• twCylinder
• twSolidCylinder
• twTube
• twSolidBarn
• twTeddyBear

We'll look at their code and documentation in TW.py

Contributed Objects

Over the last few years, the 307 students have been building up a library of objects. These all need to be recoded in Python, but I've done one:

• demos/modeling/Scene-Using-Library-Temple.py demonstrates using a contributed object.
• JAylmer.py is the library module

Next Time

Next time, we'll look at the math of affine transformations.

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

This work is licensed under a Creative Commons License.