Revision as of 12:44, 12 October 2013

Project 3: Rasterization

In this project you will need to implement your own software rasterizer. This means that you are going to implement the entire graphics pipeline from 3D vertices to filled triangles in a software frame buffer yourself. We provide a code template for the interface between your software rasterizer and OpenGL, which is needed to display the frame buffer on the screen.

This assignment is due Friday, October 18th. It will be discussed by TA Matteo on Monday, October 14th at 3pm in Center Hall 105.

This assignment is currently under construction. Feel free to start working on it, but it won't be finalized until early afternoon on Oct 12th when this message will have disappeared.

We provide a code template for you which displays a software frame buffer on the screen. Your task is to rasterize your scene (described below) into this frame buffer. Throughout this assignment do not use any OpenGL routines which aren't already in the base code! Instead, use your own vector and matrix classes from assignment #1 and add your own rasterization code.

1. Rendering Vertices (30 points)

The goal of the first step towards building your software rasterizer is to project vertices of given geometry to the correct locations in the output image (frame buffer). Use the house geometry from homework assignment 2 as your geometry.

You can re-use your model (M), camera (C), and projection (P) matrices from the previous assignment. Add a viewport matrix (D). Implement a method to set the viewport matrix based on the window size (window_width and window_height) and call it from the reshape function. Your program must correctly adjust projection and viewport matrix, as well as frame buffer size when the user changes the window size. Correctly means that the house needs to remain centered in the window and get uniformly scaled to match the window size. (10 points)

Then write a method to rasterize a vertex. You can use drawPoint from the base code to set the values in the frame buffer. Call this method from the draw callback (display function in base code) for every vertex in the sample scene. For this part of the assignment, create a method rasterizeVertex which projects each vertex of the house to image coordinates and sets the color of the corresponding pixel to white using drawPoint. (15 points)

To verify that your implementation is correct, use the same values for camera and projection matrix as in Image 2 of Exercise 1c of homework assignment 2, and compare the result of your rasterized vertices to that image. (5 points)

2. Rendering Triangles (40 points)

Next you will need to implement a triangle rasterizer based on barycentric coordinates as discussed in class. The rasterizer should first compute a bounding box around the triangle, limited to the extent of the triangle. It then needs to step through all pixels of the bounding box and test if they lie within the triangle by computing their barycentric coordinates.

Fill the triangles using linear interpolation of colors using barycentric coordinates, as discussed in class. Implement a z-buffer data structure to resolve visibility when rendering multiple triangles. For z-buffering, you should linearly interpolate z/w and scale it from [0,1] and use it as the value in the z-buffer.

To test your rasterization code, first render the house from part 1 in the two orientations. Allow switching to the two views of it on function keys 'F8' and 'F9'.

Once that works, add support for the spinning cube from assignment 1 and 2, but render it with your software rasterizer. Allow switching to it with function key 'F1'.

Then add support for the five OBJ files from assignment 2 and allow switching to them with function keys 'F2' through 'F6', just like in assignment 2, but again, render them with your software rasterizer and display the rendering time (in milliseconds).

In Windows, the clock() function allows you to measure time. In Linux (and Mac OS?), use gethrtime() or a different function to measure the time.

You will notice that some of the 3D models will take a long time to render. Depending on your graphics hardware, this could take too long to demonstrate in class (more than 5 seconds) -- for those data sets measure the rendering time beforehand and tell us how long it took when we grade you.

Your score will consist of the following components:

• Triangles render in correct depth order (using your z-buffer algorithm): 15 points
• Correct coloring of triangles: 15 points
• Function keys supported as described: 5 points
• Measured rendering times for all 5 OBJ files: 5 points