CSE581 Lab3

CSE581 Lab3 - Illumination, Materials, and Decals

FINALIZED

Sample Lab3 executable
This is a little different that the lab you're supposed to do:

The right mouse button has more items that what's required by the lab spec - see below.

OBJECTIVE:
to introduce you to more complex shading techniques as well as expanded techniques involving interaction and modeling:

varied light source modeling and control over illumination, including a moving light source
varied material properties of objects,
the application of decals to surfaces, both polygons and text,
interactive control of a vehicle using keystrokes
move eye relative to vehicle

SPECIFICATIONS:

Make a groundplane, of +/- 200 in x and z, that has no specular reflection and a backplane, of dimensions +/- 200 in x and 0:400 in z, that has high specular reflection. Smooth shade both of these planes. Subdivide both of these to a resolution that supports smooth shading. See below for subdivision pseudo-code.
Apply decals to surfaces by using the stencil buffer including at least one each of:
- polygonal decal - place on the groundplace to make a path for the vehicle. Make this decal have high specular reflection.
- text decal - use text of your choosing somewhere on the backplane
Create a vehicle of some sort. It should consist of at least:
- a body and a cab and a headlight (see below for notes about the headlight).
- four wheels, all of which rotate according to the speed of the car. The wheels should be designed so as to facilitate the viewing of their rotation. For example, alternate colors of the side panels of a cylinder used as the wheels. In my example, I defined every other side panel quadrilateral. See below for pseudo-code to define a cylinder that can be used for the wheels.
- two front wheels that also rotate into turns, that has wheels that rotate according to the speed of the object and whose front wheels turn in the direction of travel. Note that the amount of rotation of the front wheels into the turn should not be the same as the amount that the vehicle rotates - use reasonable values.
The wheels are a simple form of hierarchical animation.
Use various light source modeling including at least one each of:
- a directional light
- a point light source
- a spot light
- a moving spot light that is the headlight of the vehicle - include an emittive object that represents the headlight.
Use keyboard interaction to the vehicle as follows:
- right arrow - increase turn to the right
- left arrow - increase turn to the left
- up arrow - increase speed
- down arrow - decrease speed
As in Lab #2, use mouse movement with left and middle buttons to control the polar coordinates of the camera. However, for this lab, make the camera rotate around and zoom relative to your vehicle, not the origin. This can simply be done by adding the vehicle position to the camera position and look-at position in the 'LookAt' command; see the note below.
Use the right mouse button to pop up a menu that can turn on and off (enable/disable) the lights. There should be at least four lights: one directional, one spot light, one point light, and the headlight of the car (also a spot light). Modify the menu item to reflect the light status.

NOTES:

IMPORTANT: it is up to YOU to effectly show that you are using the various lights in your scene. The grader is NOT required to look at your code to check. If he can't tell by looking at your scene, for example, that you are using a spot light source, you won't get credit for it.
Lab #4 will be an extension of this lab so pay attention to good programming practices.
Vehicle motion:
- The wheel turn is the rotation (around the y-axis) to apply to the front wheels. The scaled wheel turn is used to update the direction of the vehicle.
- Keep the current direction (rotation) and position (translation) of the vehicle - these are used to transform your vehicle model into world space
- Every frame,
  - update the position of the vehicle by adding speed times the direction vector.
  - update the direction (theta) by adding to it the speed times gain times the wheel turn.
  - set the direction vector as (cos(theta), sin(theta)) where theta is the current direction.
- the arrow keys will add (or subtract) a delta value to the wheel turn.
- the rotation angle (around the z-axis assuming the vehicle is oriented along the x-axis) for the 'wheels' should be updated by speed divided by the wheel diameter times π
Subdividing Quads: a useful subroutine for this lab is 'subdivide' that can be used to replace any large quad that can benefit from smooth shading. Subidive is passed a starting point (x,y,z), two orthogonal vectors (x1,y1,z1) and (x2,y2,z2) that are the length of the entire quad to be subdivided, and the number of steps to take in each direction, n and m.
```
Subdivide(x,y,z,x1,y1,z1,x2,y2,z2,n,m)
  pi = (x,y,z)
  dvi = v1/n  where v1 = (x1,y1,z1)
  dvj = v2/m  where v2 = (x2,y2,z2)
  glBegin Quads
  for (i=0 to n)
    pj = pi
    for (j=0 to m)
      glVertex(pj)
      glVertex(pj+dvj)
      glVertex(pj+dvj+dvi)
      glVertex(pj+dvi)
      pj += dv2
    pi += dv1
  glEnd
```
Replace any quad with a call to 'subdivide'. For example, if you had a groundplane quad that went from -200 to +200 in x and z, then to subdivide it into 20x20 mini-quads, call:
```
Subdivide(-200,0,-200, 400.0,0.0,0.0, 0.0,0.0,400.0, 20,20);
```
Be careful with how you write the routine and call it so that you maintain the correct orientation of the quads (CW v. CCW).

Cylinder: Define a cylinder with a top, a bottom, and some number (e.g. 16) of side panels (quadrilaterals). Use an OpenGL display list. Color side panels so that wheel rotation is easily seen. Be careful to consistenly define the polygons using oriented (CW or CCW) vertices. It should look something like:

// define top flat-shaded polygon, y = 1; all vertices get the same normal
glNormal(0,1,0)
for theta = 0 to 2*Pi by increments of -Pi/8
  glVertex(cos(theta),1.0,sin(theta))

// define bottom flat-shaded  polygon, y = -1; all vertices get the same normal
glNormal(0,-1,0)
for theta = 2*Pi to 2*Pi by increments of Pi/8
  glVertex(cos(theta),-1.0,sin(theta))

// define side quadrilaterals
// each vertex normal of a quadrilateral is vector from the origin to the center of the quad
// alternate the color of each side panel
color[0][4] = one color
color[1][4] = the other color

i = 0;
for theta = 0 to 2*Pi by increments of Pi/8
  assign color[i]
  i = 1-i
  glNormal3f(cos(theta+Pi/16), 0.0, sin(theta+Pi/16))
   glVertex(cos(theta), 1.0, sin(theta))
   glVertex(cos(theta+Pi/8), 1.0, sin(theta+Pi/8))
   glVertex(cos(theta+Pi/8), -1.0, sin(theta+Pi/8))
   glVertex(cos(theta), -1.0, sin(theta))

Because each vertex appears in 3 polygons, You can save a little computation time by precomputing all the vertices first, storying them into arrays, and then indexing into the arrays as you define the polygons. However, because this is one-time code (when it's put in the display list), the savings is not that significant.

The cylinder should be scaled, rotated, and positioned appropriately relative to the vehicle body to form the wheels.

Headlight:
- Place one or two objects on the front of the vehicle that will represent your headlight(s).
- Make the headlight(s) emit light by setting the GL_EMISSION material property for them.
- move the light souce along with the headlight object by issuing its position and direction attribute commands as you place the headlight on the vehicle. These coordinates will be transformed according to the current ModelView matrix.
- Assuming your vehicle is initially oriented so that the front of it extends out the positive x-axis, set the position of a hooded light source at the positive x-axis end of the headlight object with its direction (1,0,0) and set some appropriate intensity and hood angle.
- NOTE: to avoid illumination flashes, display the headlight before the body of the vehicle and display the vehicle before the groundplane. Otherwise, any geometry displayed before updating the linkage light source will be using the old position of the lightsource from the previous frame.

Decal:

template for code in the display callback routine


        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_ALWAYS,1,1);
        glStencilOp(GL_KEEP,GL_ZERO,GL_REPLACE);

        <draw base polygon>

        glDisable(GL_DEPTH_TEST);
        glStencilFunc(GL_EQUAL,1,1);
        glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);

        <draw decal>

        glEnable(GL_DEPTH_TEST);
        glDisable(GL_STENCIL_TEST);

Important: STENCIL BUFFER -

to do stencil testing you have to have a stencil buffer. In main():

        mode = GLUT_RGB | .... | GLUT_STENCIL;
        ..
        glutInitDisplayMode(mode);

and you have to clear the stencil buffer along with the color and depth buffers

         glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);

Track your vehicle: Keep your center of interest on your vehicle and rotate/zoom with respect to it, not the origin. This is easy to do. Simply use your code from Lab 2, but in the 'lookat' command, add the vehicle position to both the 'eye' and the 'center.'
Suggestion on lab development:
1. Make the groundplane and backplane with subdivisions
2. Make lights, and set material properties
3. Use stencil buffer and create decals
4. Make vehicle, with rotating wheels and headlight
Actually the last 3 can be done in any order.

EXTRA CREDIT:

(5 pts) Do multiple layer decaling - using separate stencil bits to separate the layers to get the extra credit
(5 pts) Include a rotating red or yellow lights on top of your vehicle.
(5 pts) Include interesting object models for the point light and static spot light in your scene.