CSE581; AU'11; Lab #4: Illumination

Due: Monday, Nov. 14, 11:59pm

SUBMISSION - zip up the CL112D-MSVS2010 runnable project and upload it using the Carmen Dropbox

FINAL VERSION - although I might add some more notes or comments as I get feedback from students

Topics: Menu, Subdividing, Illumination, Materials, and Decals

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, use of a semi-transparent drop shadow interactive control of a vehicle using keystrokes right button pull down menu to control lighting move eye relative to vehicle

• Environment
  • a groundplane, of at least +/- 100 in x and z, that has no specular reflection; subdivide the groundplane (I used 50x50) of alternating colors.
  • three sides, at least 100 units tall that has high specular reflection. Also, display the backside of the wall (GL_BACK) using lines (GL_LINE) with the glPolygonMode() command
  • Smooth shade all of these planes.
  • Subdivide all of these planes to a resolution that supports smooth shading; I suggest 50x50 See below for subdivision pseudo-code.
  • Apply a semi-transparent using polygon stippling decal for the drop shadow of the vehicle using the stencil buffer

• 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, facets or alternate colors of the side panels of a cylinder used as the wheels. In my example, I used an 8 sided faceted cylinder. See below for pseudo-code to define a cylinder that can be used for the wheels. The wheels are a simple form of hierarchical animation.
  • 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.

• Use various light source modeling including at least one each of:
  • a directional light to simulate daylight sun
  • a point light source in the form of a light - represent it somehow in the scene. For example use a lamppost will a bare light on top - make the top have have 'emission'
  • a spot light in the form of a street light - represent it somehow in the scene. For example use a lamppost will a hooded light light on top - have the light have 'emission'
  • 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
  Use reasonable values to support user interaction.

• As in Lab #3, 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 (for day/night), one spot light, one point light, and the headlight of the car (also a spot light). Update the menu items indicating the new selection when an item has been changed (e.g. if 'Turn on spot light' was selected, once it's 'on' change the menu to say 'Turn off spot light').

• 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 #5 will be an extension of this lab so pay attention to good programming practices.

• Vehicle motion:
  • Keep the current direction (rotation by gamma, for this discussion) and position (translation) of the vehicle - these are used to transform your vehicle model into world space
  • The steering wheel turn angle (delta-gamma) is used to update the direction of the vehicle, gamma
  • Every frame,
    • update the position of the vehicle by adding speed times the direction vector: [cos(gamma), 0.0, sin(gamma)], for example.
    • update the direction (gamma) by adding to it the steering wheel turn (delta gamma)
  • the arrow keys will add (or subtract) a delta-delta-gamma angle (change in wheel turn) to the delta-gamma (wheel turn).
  • to rotate the wheels of the car, 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 π
  • The scaled wheel turn is the rotation (around the y-axis) to apply to the front wheels.

• 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(v[3],v1[3],v2[3],n,m)
    pi = v
    dvi = v1/n
    dvj = v2/m
    n = v1 X v2
    glBegin Quads
    glNormal3fv(n)
    for (i=0 to n)
      pj = pi
      for (j=0 to m)
        glVertex(pj)
        glVertex(pj+dvi)
        glVertex(pj+dvi+dvj)
        glVertex(pj+dvj)
        pj += dvj
      pi += dvi
    glEnd
  

  Replace any quad with a call to 'subdivide'. For example, if you had a groundplane quad that went from -100 to +100 in x and z, then to subdivide it into 50x50 mini-quads, call:

  Subdivide(-100,0,-100, 200.0,0.0,0.0, 0.0,0.0,200.0, 50,50);
  

  Be careful with how you write the routine and call it so that you maintain the correct orientation of the quads (CW v. CCW). To use a two-color groundplane, rewrite the subdivide code with two color commands. just keep toggling a binary variable every time at the end of the inner loop and every time at the end of the outter loop. For example, k = 1-k. If k == 0, use one of the colors; if k == 1, use the other color for that quad.

• 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 = 2*PI to 0 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 = 0 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 -
    1. to do stencil testing you have to have a stencil buffer. In main():

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

    2. 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.

• (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.