Difference between revisions of "Project3Fall13"
(→1. Rendering Vertices (30 points)) |
|||
| Line 7: | Line 7: | ||
<b>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.</b> | <b>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.</b> | ||
| − | We provide [[rasterizer.cpp | 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 <b>do not use any OpenGL routines which aren't already in the base code!</b> Instead, use <b>your own</b> vector and matrix classes from assignment #1 and add your own rasterization code. | + | We provide [[rasterizer.cpp | 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 <b>do not use any OpenGL routines which aren't already in the base code!</b> Instead, use <b>your own</b> vector and matrix classes from assignment #1 and add your own rasterization code. |
==1. Rendering Vertices (30 points)== | ==1. Rendering Vertices (30 points)== | ||
| Line 19: | Line 19: | ||
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. (<b>5 points</b>) | 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. (<b>5 points</b>) | ||
| − | + | ==2. Rendering Triangles (<b>40 points</b>)== | |
| − | + | ||
| − | ==2. Rendering Triangles== | + | |
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. | 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. | ||
| Line 27: | Line 25: | ||
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. | 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 [http://www.cplusplus.com/reference/clibrary/ctime/clock/ clock()] function allows you to measure time. In Linux (and Mac OS?), use [http://docs.sun.com/app/docs/doc/816-5168/gethrtime-3c?a=view 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): <b>15 points</b> | |
| + | * Correct coloring of triangles: <b>15 points</b> | ||
| + | * Function keys supported as described: <b>5 points</b> | ||
| + | * Measured rendering times for all 5 OBJ files: <b>5 points</b> | ||
| − | + | <!-- | |
| − | + | ==3. Two-level hierarchy (<b>30 points</b>)== | |
| − | + | Extend your rasterizer by adding a two-level hierarchy as discussed in class: The main idea is to split each projected triangle's bounding box into <b>n*n</b> smaller tiles of equal size. Before testing each pixel within a tile, the rasterizer determines if the triangle overlaps with the tile. The whole tile can be skipped if this is not the case. Use the house geometry from exercise 1, not the colorful house. (<b>10 points</b>) To demonstrate how the algorithm works, outline the tile boundaries of one triangle in the frame buffer in red. (<b>5 points</b>) | |
| − | + | Test the performance of the tiling approach by measuring rendering times for at least three different numbers of tiles (different values of <b>n</b>): let the house rotate about its origin and measure the time it takes to render 100 frames of the rotating house. Report the average frame rate (=number of frames rendered per second) in the console window. Support three different tile sizes and allow the user to switch between them using the keys '1', '2', and '3'. Don't draw the bounding boxes for this performance test. Your algorithm must show a speedup for certain values of <b>n</b>, compared to <b>n</b> = 1. What value of <b>n</b> gives you the best performance? (<b>5 points</b>) | |
| − | + | ||
| − | + | ||
| − | |||
| − | + | ==4. Optional: Translucent Triangles(<b>10 points</b>)== | |
| − | + | 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. | |
| − | + | Make both spheres translucent by mapping an opacity value (=alpha value) of 50% (or 0.5 on a scale between 0 and 1) to all triangles. 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. | |
| − | + | ||
--> | --> | ||
Revision as of 11: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
