Advanced Graphics, Rasterizer homework

Basic assignment

For this homework assignment, we will be implementing the rasterizer of a simple software rendering engine.

You will need to download this project: RasterizerHomework.zip (modified 1/22). In it you will find a file called "Homework.cpp" with one MyRendererFunctions::Rasterize function whose body is a stub.

The rasterizer is the part of the graphics processor that takes three vertices, with positions (X,Y) in screen space and some set of additional attributes. It performs two tasks:

• It figures out which pixels form part of the triangle.
• It also interpolates the attributes for each pixel.

One reasonably simple way in which the first task can be achieved is to first find a box that contains the triangle in its entirety, and then iterate over all the pixels, performing a "point-in-triangle" test.

Several possible issues appear that should be contemplated in order to create a robust rasterizer:

• Adjacent triangles that share an edge should guarantee that no "holes" (unrendered pixels) will be left along the common edge.
• Adjacent triangles that share an edge should also guarantee that none of the pixels along the edge will be rendered twice. Otherwise, alpha-blended rendering would show increased opacity randomly along the edges.
• To begin with, you may decline to interpolate the attributes and z-buffer value. Instead, you can just copy them verbatim from one of the input vertices, just like it's done in the stub.
• Attribute interpolation can be linear. This is done by finding the barycentric coordinates of each pixel, and using those coordinates as weights for the vertex-defined attributes.
  • Barycentric coordinates are the normalized distances to the three edges. They should become one at the edge's opposite vertex, and zero along the edge. They will always add up to one.
• Perspective-correct interpolation is better than linear, and is easily achievable by interpolating the attribute divided by the clip-space W, also interpolating one divided by the W, and then dividing the two at each pixel.
  • Note that the vertex.position.w value contains the clip-space W but with the division already performed (it contains 1/W).
• When handling perspective correction, pixels near the camera plane will experience precision issues (division by near-zero). In order to solve this problem, near-Z clipping (dropping a pixel when its Z is negative) should also be performed.

The basic assignment is to find the pixels that belong to the triangle, and output them. If this is done successfully, the various figures (a spinning cube, a teapot and a sphere) will become visible. It will be worth 8 points.

Rasterizer function specification:

The triangle parameter contains an array vtx of three vertices. Each vertex has a 4D position vector, and some extra data (two colors, one set of 2D texture coordinates and a fog value).

• triangle.vtx[#].position.x and triangle.vtx[#].position.y contain the screen coordinates of a vertex in range [0, 0]-[width,height].
• triangle.vtx[#].position.z contains the z-buffer value of a vertex.
• triangle.vtx[#].position.w contains the clip-space 1/W value.
• triangle.vtx[#].fog contains the fog attribute for the vertex.
• triangle.vtx[#].data contains several attribute values for the vertex: diffuse color, specular color and texture coordinates.

The params parameter contains the coordinates and extents of the rectangle where we're rendering. It is illegal to generate pixels outside of this rectangle.

The pixels array must be filled with the generated pixels, up to pixelsSize pixels and the function must return the number of pixels generated.

• pixel.x and pixel.y are the positive integer coordinates of the pixel.
• pixel.z is the interpolated z-buffer value. Note that this attribute doesn't need perspective correction.
• pixel.fog contains the interpolated fog value.
• pixel.data contains the interpolated attributes.

Program usage:

• On boot, the program will use the stub rasterizer, so nothing will be rendered and the screen will appear black.
• Press the "R" key to toggle between the rasterizer in Homework.cpp that you will be implementing and the provided reference implementation.
• Press the SPACE bar in order to toggle between four simple scenes that show various features of the rasterizer.
• Press the "G" key to toggle gamma-correct rendering on and off (we'll talk about gamma at a later class).
• The title bar of the application will display the current position of the above toggles.

Submitting

You must send to JCAB your completed Homework.cpp file according to the instructions.

Extra grade

Extra grade will help you compensate your grade if you don't manage to successfully complete one or more basic assignments.

I will be granting the following:

• One bonus point for correctly interpolating all the vertex attributes.
• One bonus point for not having any issues in the edges between adjacent triangles.
• One bonus point for correctly implementing perspective-corrected interpolation for all the attributes.
• One bonus point for being faster than the reference implementation (this is doable).

Solution available

Download it here.

There are four different solutions in the file:

• Barycentric is a simple but complete solution based on looping the bounding rectangle, performing edge tests and interpolating using barycentric coordinates. It works well, but has a very subtle math imprecision, which boils down to (a/d) * x + (b/d) * y + (c/d) giving different results than (a * x + b * y + c) / d
• BarycentricCorrect is basically the same, but with the error corrected.
• ScanLineFloatPoint is the same as the reference rasterizer.
• ScanLineFixedPoint is the fastest.