Latest revision as of 23:53, 11 April 2015

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.

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 Points (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, and assign different colors to the vertices, so that none of the faces are rendered in a solid color. 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.

Measure and take notes of the rendering times for each of the five 3D models.

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 five OBJ files: 5 points

3. Optimization (30 Points)

Extend your rasterizer by adding a two-level hierarchy as discussed in class, toggled on and off with the 'o' key. The main idea is to split each projected triangle's bounding box into n*n smaller tiles of equal size. Experiment with different numbers for n (start with 2x2 tiles, then 3x3, then 4x4, ...) and pick one that works particularly well (you will notice that the performance degrades when there are too many tiles). Before testing each pixel within a tile, the rasterizer determines if the triangle overlaps with the tile (we suggest an algorithm for this intersection test on the course slides). The whole tile can be skipped if this is not the case. Allow rendering of all of your 3D models with this optimization (cube, house and OBJ files) (20 points). Note that on newer computers this algorithm will only result in a speedup with low-polygon objects, such as the cube.

To demonstrate how the algorithm works, outline the tile boundaries in red. Toggle this mode on and off with the 'b' key. (5 points)

Test the performance of the tiling approach by measuring the rendering times for each of the five OBJ files. Write those numbers down next to the rendering times without optimization (5 points).

4. Optional: Translucent Triangles (10 Points)

Build a scene out of two spheres from part 2, with one spinning around the other, rotating around the Y axis, so that one sphere is sometimes in front and sometimes behind the other sphere. The spheres should never intersect. Add this scene to your rasterization program by switching to it with the 'F10' key (3 points)

Make both spheres translucent by mapping an opacity value (=alpha value) of roughly 50% (or 0.5 on a scale between 0 and 1) to all triangles (3 points).

Render the overlapping spheres correctly, as if they were made out of translucent glass: to do that the triangles need to be rendered in back-to-front order. To accomplish this you will need to sort all triangles of both spheres from back to front (based on their distance from the camera), every time you render a frame. To sort the triangles, calculate the center point of each triangle, project it into camera coordinates, and use the resulting z value as the sorting criterion. Toggle depth sorting on and off with the 't' key. (4 points)