• 2 homogeneous polygon clippers
• "flat" : constant color

softgl_homoclip_flat.hpp, softgl_homoclip_flat.cpp
• "smooth" : perspectively correct color interpolation

softgl_homoclip_smooth.hpp, softgl_homoclip_smooth.cpp
• 2 triangle rasterizers
• "flat" : constant color

softgl_trirast_flat.hpp, softgl_trirast_flat.cpp
• "smooth" : perspectively incorrect color interpolation

softgl_trirast_smooth.hpp, softgl_trirast_smooth.cpp

• homogeneous polygon clipping with smooth color and texture coordinate interpolation (perspectively correct)

softgl_homoclip_smooth_tex.hpp, softgl_homoclip_smooth_tex.cpp
• 3 more triangle rasterizers
• "smooth_tex" : perspectively incorrect color and texture coordinate interpolation

softgl_trirast_smooth_tex.hpp, softgl_trirast_smooth_tex.cpp
• "smooth_pc" : perspectively correct color interpolation

softgl_trirast_smooth_pc.hpp, softgl_trirast_smooth_pc.cpp
• "smooth_tex_pc" : perspectively correct color and texture interpolation

softgl_trirast_smooth_tex_pc.hpp, softgl_trirast_smooth_tex_pc.cpp

• clamp and repeat wrapping modes : Wrapping={0,1}
• nearest and bilinear filtering: Filtering={0,1}
• replace and modulate application modes: Function={0,1}

In addition, in order to test your new implementations, write your own mini-SoftGL (no API support) that tests out all of the clippers and rasterizers using the above files and the following:

• vec3fv.hpp, vec3fv.cpp : vector libraries
• mat16fv.hpp, mat16fv.cpp : matrix libraries (including all OpenGL transformations)
• draw2ppm.hpp, draw2ppm.cpp : routine to write unsigned char array (color buffer) to a PPM file
• makefile : UNIX makefile
• main.cpp : module in which to write the mini-SoftGL

You will only need to modify the main.cpp file to implement your mini-SoftGL pipeline. You will need to create some geometry, run the geometry through a "Modelview" and "Projection" transformation pipeline, perform clipping, perspective divide, and setup for perspectively correct interpolation. This exercise will test your knowledge of how to organize the components of the standard graphics pipeline in order to correctly transform, clip, and render a scene. You will not be required to support any front-end OpenGL-like API. Just implement enough to thoroughly test the components.

We will be integrating these new components into SoftGL later (after the infrastructure has been built).

After completing and testing the new components in your mini-SoftGL, do the following:

• create and render a quadrilateral with a different color at each vertex (RGB quad from previous tests). Compare the results for perspectively incorrect and correct color interpolation for your triangle rasterizers using a perspective projection with a 45 degree field-of-view for the following cases:
• quad is perpendicular to the viewing direction and completely in the viewing frustum
• quad is at a 45 degree angle to the viewer (about the Y-axis - UP vector)
What is the difference? Why?
• repeat the previous test, but using a checkboard texture-mapped quadrilateral
• explain the steps in obtaining a perspectively-correct screen-space interpolation of vertex values. Why does this work? Is the depth (or z values) perspectively correct? Why or why not? Does it matter? Why?
• use your mini-SoftGL to generate a single interesting, high-resolution (1600x1200) image using all of your new components. This image should focus on showing the different texturing options. Everything should be rendered with a perspective projection with perspectively-correct interpolation.