CS184 Project 1: Rasterizer

Rasterization Process

1. Walk through how you rasterize triangles in your own words.
The original input parameters, (x0, y0), (x1, y1) and (x2, y2), represent coordinates that define a triangle. I first calculated the min and max values for X and Y to ensure that I only considered pixels that could possibly belong to this triangle. This prevents us from having to iterate over the whole screen. For each pixel within this sampling box, I checked whether the center point (x+0.5, y+0.5) lies inside the triangle. If it is, the pixel is covered by the triangle and I fill it. To check whether or not the point is in the triangle, I used the edge function that we learned in class. For each triangle edge, take the cross product of the edge vector AB = B - A and the vector from the same vertex to our sample point AP. If all cross products are non-negative, the sample point is inside the triangle (including the edge itself). If the sample point is inside, I set the pixel to the color of the triangle.

2. Explain how your algorithm is no worse than one that checks each sample within the bounding box of the triangle. The bounding box of the triangle is defined as the smallest rectangle that can be drawn whilst ensuring that the entire triangle is within it.
Each pixel in the bounding box is tested exactly once, at its center. This is a simple rule that determines whether a pixel should be drawn or not, and it’s efficient because we don’t waste resources by checking pixels outside the triangle’s bounding box (determined by taking the min/max values along both axes). We are avoiding a brute-force approach that would look at the entire image.

1. Walk through your supersampling algorithm and data structures. Why is supersampling useful? Explain how you used supersampling to antialias your triangles.

Supersampling is useful because it helps improve the quality of images by smoothing out “jaggies” that appear when we rasterize diagonals or curved shapes. It works by first dividing each pixel into multiple smaller subpixel samples. Then, I tested the coverage of each subpixel sample (i.e. does it lie inside or outside the shape?). Finally, I accumulated all subpixel colors and averaged them to form the final color of the pixel. This produces smoother, antialiased edges because pixels partially covered by the shape will be colored with a lighter shade of the shape color.

Key Data Structures:

• sample_rate: An integer, specifies how many total subpixel samples each pixel contains. For example, sample_rate = 4 means we have a 2x2 grid of sub-pixels per pixel.
• sample_buffer: A 1D array of Color objects, each storing an (R, G, B) value in floating point. It’s size is width * height * sample_rate, and each pixel has sample_rate sub-sample slots.
• rgb_framebuffer_target: This is the final display buffer, storing one 8-bit (R, G, B) per pixel (so 3 * width * height bytes total). This buffer is what we see on display, and we write to it only once after rasterizing in resolve_to_framebuffer().

2. What modifications did you make to the rasterization pipeline in the process?

1. I replaced the original, one color per pixel approach by storing multiple colors (one per subsample) in sample_buffer.
2. Instead of testing only one center point per pixel, I looped over the sub-sample grid inside the pixel. For each sub-sample, I checked if that point is inside the triangle by computing the cross product. And if it was inside, I stored the triangle color into sample_buffer at the corresponding subsample index.
3. After rasterizing all triangles, I call resolve_to_framebuffer(). For each pixel, I sum the sample_rate subsample colors and average them. I then convert this average into an 8-bit color and write it to rgb_framebuffer_target.
4. I make sure to clear the sample_buffer to a default color (white) at the start of each frame clear_buffers() so that the old data doesn’t persist.

Ride-Hailing Robot

To create this ride-hailing robot, I tried playing with four things:

• Color: I changed the color of the robot by transforming the polygon fill value for each box to “#000000” instead of the original “#EF161F”.
• Rotation of the head: I rotated the head back to an upright position (angle = 0).
• The left arm: I rotated the left arm by 270 degrees to give it the semblance that it’s calling for a cab.
• The right arm: For the right arm, I wanted to experiment with the possibility of rotating each “segment” of the arm separately. I kept the upper part of the arm (i.e. the bicep equivalent), but only played with the “hand”. I translated the hand left and up after rotating it 90 degrees.

Explain barycentric coordinates in your own words and use an image to aid you in your explanation.

In a triangle with vertices (v0, v1, and v2), we can express any point p inside the triangle as a weighted combination of the vertices. In other words, p = a*v0 + b*v1 + c*v2. The weights a, b, and c must add up to 1, and they must be greater than or equal to zero. These weights are the barycentric coordinates of p relative to the triangle. To interpolate colors, we do the same idea but in color space. This actually makes a lot of sense given that we have three axes in color (RGB) and a triangle has three vertices. Color(p)=αColor(v0​)+βColor(v1​)+γColor(v2​). And Color(v_i) is the color value we assign to vertex i. As p moves around inside the triangle, the barycentric coordinates change, blending the colors.

1. Explain pixel sampling in your own words and describe how you implemented it to perform texture mapping.

Pixel sampling determines how textures map onto surfaces during rendering. When a texture is applied to a 3D surface, each pixel on the screen corresponds to a portion of the texture image. Since the texture’s resolution usually does not match with the screen’s, we have to interpolate colors from nearby texels.

2. Briefly discuss the two different pixel sampling methods, nearest and bilinear.

There are two sampling methods, nearest neighbors and bilinear. Nearest neighbors selects the closest single texel to the sampled texture coordinate. First, I ensured that the UV coordinates stay within [0, 1] by setting up the min/max boundaries. Then, I scaled the UVs to texture dimensions and rounded it to the nearest integer values. Finally, I checked the bounds to prevent accessing texture that is out of bounds. The bilinear approach, on the other hand, blends 4 nearest texels using distance-based weights. First, I found the fractional position between texels, and sampled the 4 nearest texel centers. Then I calculated the weighted average based on the positions of each sub-texel, interpolating the values. Nearest neighbors preserved the sharp jaggies, but bilinear sampling showed blur.

1. Explain level sampling in your own words and describe how you implemented it for texture mapping.

Level sampling selects the appropriate mipmap level for texture mapping based on the distance and angle of the surface relative to the viewer. During rasterization, I calculated the UV coordinates for each sample point through barycentric interpolation. I also computed partial derivatives by examining the neighboring pixels. These derivatives showed how quickly UV coordinates change across the texture space, which allows me to determine the appropriate mipmap level for sampling. My implementation has three sampling methods:

• L_ZERO: Take the simplest approach, always sampling from the base mipmap. This allows us to bypass level calculations entirely.
• L_NEAREST: Compute the optimal mipmap level based on the rate at which UV coordinates change, and rounds to the nearest available level. I had to first ensure that the UV coordinates stay within [0, 1] by setting up the min/max boundaries.
• L_LINEAR: This is the most sophisticated approach. First, I found the fractional position between texels (i.e. bilinear filtering), and sampled the 4 nearest texel centers. Then I calculated the weighted average based on the positions of each sub-texel, interpolating the values. This combination effectively smoothes the transition between mipmap levels when textures change scale.

2. You can now adjust your sampling technique by selecting pixel sampling, level sampling, or the number of samples per pixel. Describe the tradeoffs between speed, memory usage, and antialiasing power between the three various techniques.

Combining high sample rates with trilinear filtering (P_LINEAR + L_LINEAR) achieves the highest visual quality but demands significant compute and memory. On the other hand, (P_NEAREST + L_ZERO) maximizes performance by accessing memory in more simple patterns, but will result in aliasing.

• Pixel Sampling: P_NEAREST performs single-texel lookups, so it delivers the fastest performanc and uses memory minimally. However, it produces noticeable jaggies, especially for textures viewed at angles. P_LINEAR uses bilinear interpolation between four neighboring texels, which gives me smoother outputs. However, it uses four memory reads per sample and is slower too.
• Level Sampling: L_ZERO exclusively uses the baes texture, so it's computationally efficient but requires a lot of memory when it tries to access high-res base textures from afar. L_NEAREST selects the most appropriate mipmap level, which reduces the amount of aliasing artifacts present as well as memory requirements. This is because it accesses smaller mipmaps for textures that are far away. L_LINEAR produces the best quality as it implements full trilinear filtering, but requires twice the texture samples and memory compared to L_NEAREST.
• Sampling Rate: Increases in sampling rate linearly scales both memory usage and the time required for computation. This is because 4x and 16x sampling rates supersamples more samples per pixel.