Z-Buffer Depth Testing

Topic Overview

The Visibility Problem

When multiple triangles overlap on screen, which one is visible? The z-buffer (depth buffer), invented independently by Wolfgang Straßer and Edwin Catmull in 1974, solves this with a second buffer parallel to the color framebuffer.

Algorithm:

1. Initialize z-buffer to far depth (e.g., 1.0)
2. For each triangle, rasterize covered pixels
3. Interpolate depth at each pixel
4. If depth < z-buffer[x][y], update z-buffer and write color

Screen-Space Depth and Z-Fighting

The z-buffer operates in screen space after vertex transformation. Each vertex carries (x, y, z) in normalized device coordinates where z typically runs 0 (near) to 1 (far).

cCopy
Loading…

For example, a red triangle at z=0.3 and a blue triangle at z=0.7 both covering pixel (5,5): the red triangle wins because 0.3 < 0.7. Z-fighting occurs when two surfaces are nearly equal in depth; limited float precision makes them flicker. Perspective-correct interpolation uses 1/z, not linear z, for accurate results under projection.

• Advantage: no triangle sorting needed, trivially parallel per pixel
• Cost: extra memory buffer (width * height floats)
• Alternatives: painter's algorithm (sort back-to-front), ray tracing

For This Exercise

You will implement a 10x10 z-buffer with two overlapping triangles and print the final framebuffer colors. This task requires depth testing on every covered pixel. Z-buffering is the visibility algorithm behind Quake through Unreal Engine 5, and z-fighting bugs appear in every graphics programmer's career eventually.

Your Task

Implement a z-buffer with a realistic twist: depth is stored as an N-bit integer, so it has limited precision. Rasterize triangles in order. Each fragment interpolates its depth exactly, quantizes it to the buffer's format, and passes only if it wins the depth compare. With enough bits, intersecting triangles resolve cleanly. With too few, surfaces that are close together quantize to the same value and the result depends on the compare function: that is z-fighting.

Input

# starts a comment line.

cCopy
Loading…

Rules

• Coverage: the same as the rasterizer tasks. Pixel centres (px+½, py+½) are tested against integer edge functions on a doubled grid (vertex (x, y) → (2x, 2y), centre → (2px+1, 2py+1)), with the top-left rule for zeros: top edge ay == by && bx > ax, left edge by < ay. Triangles of either winding are drawn, and zero area prints NAME: degenerate.
• Depth: the exact depth is Σ wᵢzᵢ / Σwᵢ (a fraction, in 1/10000 units). The stored value is floor(depth × (2^bits - 1) / 10000). The clear value is quantized the same way.
• Compare: a fragment passes if q < stored (less), q ≤ stored (lequal) or q > stored (greater). A passing fragment writes its quantized depth and its triangle's letter.
• Ties: every fragment with q == stored counts as an equal depth, whether it passed or not.
• Settings: depthbits and canvas clear the buffers. Settings persist between draws.

Output

cCopy
Loading…

• Canvas: draw prints its header, one line per triangle, then the canvas (. where nothing was drawn).
• Plurals: fragment(s), equal depth(s).
• Errors:
  • canvas: W (1-64) H (1-32), depthbits: 8, 16, 24 or 32, compare: less|lequal|greater, clear: DEPTH (0-10000)
  • tri: NAME(one letter) X0 Y0 Z0 X1 Y1 Z1 X2 Y2 Z2, tri: depth 0-10000, coordinates within +-1000, tri: at most 8 triangles
  • probe: X Y inside the canvas
  • unknown command X

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Interpolate depth exactly, then quantize once, as fixed-function depth units do. Never compare unquantized values.
2. Use unsigned 64-bit arithmetic for the quantization (numerator × (2^bits-1) can exceed 32 bits).

Hidden tests cover nearly coplanar surfaces at 8, 16 and 24 bits, lequal resolving ties the other way, a reversed-Z setup (greater with the buffer cleared to 0), probes, and argument errors.