Lab Assignment 4: A Gray Lumpy Donut

To complete this assignment, combine your polygon-filling code with your wire frame drawing code and add the following capabilities:

• Flat Shading: Fill each face with one intensity, calculated by applying the light model including ambient light and diffusely and specularly-reflected light to the central point on the face. The vertex list in your scene file will include normal vectors with each vertex. When calculating the reflected light at the center point of a face, calculate the normal vector at that point by simply averaging the normal vectors for the vertices of the face. Select flat shading by including in your view file the command flat.
• Gouraud Shading: Use the Gouraud shading algorithm to fill each face. First calculate the intensity of reflected light at each of the vertices of the face, using the material properties of the face. Then fill the face by linearly-interpolating the intensities as you fill each scanline for the face. Select Gouraud shading by including in your view file the command gouraud.
• Phong Shading: Use the Phong shading algorithm to fill each face. The normal vector and location in x, y, z for each point on the face is calculated by linearly-interpolating the vertex normals and x, y, z locations for each point during the polygon-filling process . The calculate the intensity of reflected light at each point. Select Phong shading by including in your view file the command phong.
• Depth Buffer: Implement the depth buffer algorithm and use it when rendering with flat, Gouraud, and Phong shading. The n-coordinate of the transformed vertices is linearly-interpolated during filling. This value is compared with the depth for that pixel stored in a depth buffer. If nearer, the pixel is drawn and the depth buffer updated. If farther, the pixel is not drawn.
• Clipping to View Volume: The viewing coordinates of the point corresponding to a pixel are clipped against the view volume, given by the ranges: width*viewportleft < u < width*viewportright, height*viewportbottom < v < height*viewporttop, and -1 < n < 0. The viewing coodinates of the pixel specified by column and row are (column, row, n), where n is interpolated from vertices.

To accomplish this, your program must perform the following steps:

1. Process the scene data by parsing the vertex list and face list.
2. Calculate outward-directed normal vectors for each face by averaging the normal vectors for each vertex of a face. Be sure your result is a unit-length vector.
3. Process the view data to obtain:
   • the view reference point, r (was called vrp in previous assignment), a point to look at, lookat, a guess at an up vector, up, and the location of the eye, e along the n axis,
   • the specifications for the window, front and back planes, and the viewport, a total of 10 numbers,
   • the shading command, which must be wire, flat, gouraud, or phong,
   • the intensity of ambient light in the scene,
   • the locations and intensity of each light.
4. Calculate u, v, and n.
5. Calculate M, the matrix that performs the entire 3-D to 2-D perspective transformation.
6. Transform all vertices.
7. Render the scene, depending on the specified render method:
   • If wire was specified, draw all face edges, then draw the normal vectors as pins. Draw the normal vectors as given in the scene file for all vertices.
   • If flat was specified, fill each face, one at a time. Fill each face with the single intensity calculated for the center point of the face using the calculated face normal. Use the depth buffer algorithm and clipping while filling.
   • If gouraud was specified, then for each face, calculate the intensities at the face's vertices and interpolate these intensities as you fill the face. Use the depth buffer algorithm and clipping while filling.
   • If phong was specified, then for each face, interpolate the vertex locations and normals and calculate the intensity for each pixel while filling. Use the depth buffer algorithm and clipping while filling.

   Input Files

   Make sure your program displays the lumpy donut correctly using this lab4.scene file and this lab4.view file. The format of the scene file is the same as the one used in the previous assignment, except for several additions. After the x, y, and z coordinates of a vertex are three more numbers. These are the x, y, and z coordinates of a unit-length normal vector for the vertex. So, the first few lines of the vertex list might be:

   550
   0.000000 0.000000 0.000000 0.000000 0.000000 1.000000
    2.500000 0.000000 0.000000 0.000000 0.000000 1.000000
    5.000000 0.000000 0.000000 0.000000 0.000000 1.000000
    7.500000 0.000000 0.000000 0.000000 0.000000 1.000000
   

   where 550 is the number of vertices. The face list also has some additions. After the indices into the vertex list for each vertex of the face, the material properties of the face are given as a diffuse coefficient and a specular coefficient and a specular exponent. Just to make this obvious, the file includes the words diffuse and specular before the correponding values. So, the first few lines of the face list (which comes after the entire vertex list), are something like

   455
   
   4
   0 1 6 5  diffuse 0.600000 specular 0.700000 50.000000
   
   4
   1 2 7 6  diffuse 0.500000 specular 0.500000 50.000000
   
   4
   2 3 8 7  diffuse 0.500000 specular 0.500000 50.000000
   

   where 455 is the number of faces and each face shown has four vertices and the diffuse reflection coefficient of the first face is 0.6, the specular reflection coefficient is 0.5, and the specular exponent is 50.

   You may need to redefine some constants in xparms.c so that the text widgets can hold more lines of text. I replaced the obvious line in xparms.c with this one:

   #define MAXLINES  5000
   

   The lab4.scene file contains 1918 lines (use the unix command wc to count the lines).

   Check In

   To check this assignment in, check in a tar file of all of the following files:

   • your source code (do not hand in xparms.c or xparms.h),
   • your scene file containing the vertices and faces for your original object,
   • your view file for viewing your original object,
   • a file named readme.txt that describes how to compile your program and a short description of what you original scene is,
   • optionally, a makefile for compiling and linking your program.

   We will grade your program by compiling it and running it with our donut data.

   Here is what your donut should look like.

   

   Debugging

   To help you debug your program, I ran my program with this short scene file consisting of just two faces. The second appears in front of the other using the lab4.view file. After inserting tons of print statements, I get the this text file of output. I hope this helps.