The Graphics Pipeline: From Vertices to Pixels

Topic Overview

From Vertices to Pixels in Seven Stages

Modern GPUs render images through a multi-stage pipeline. Early GPUs used fixed-function stages; today most stages are programmable shaders, but the data flow remains the same.

The standard pipeline in order:

1. Vertex Input: vertex buffers supply position, color, normals, UVs
2. Vertex Shader: transforms each vertex to clip space, outputs varyings
3. Tessellation (optional): subdivides patches for curved surfaces
4. Geometry Shader (optional): operates on whole primitives, rarely used today
5. Rasterization: fixed-function conversion of triangles to fragments
6. Fragment Shader: per-fragment color, texture sampling, lighting
7. Output Merger: depth test, blending, framebuffer writes

The rasterizer is the bridge between the vertex-centric and fragment-centric worlds. For example, one triangle with three vertices can generate thousands of fragments on a large screen area.

Parallelism and Attribute Flow

Vertex shaders run once per vertex. Fragment shaders run once per fragment. Attributes like color and texture coordinates are interpolated across the triangle surface using barycentric coordinates during rasterization.

cCopy
Loading…

Vulkan, Direct3D 12, and Metal expose this same sequence as explicit pipeline state objects. Engines from id Tech to Unreal execute billions of these stage transitions per frame.

For This Exercise

You will simulate the pipeline for a single triangle, printing what happens at each stage from vertex input through fragment output. This task asks you to trace attribute interpolation and show how three vertices become many fragments. Getting rasterizer barycentric interpolation right here is the prerequisite for the software rasterizer subtrack.

Your Task

Push triangles through a miniature graphics pipeline, with every stage in exact integer arithmetic:

1. Vertex shader: an affine transform.
2. Primitive assembly: vertices grouped in threes, with back-face culling.
3. Clipping: discard what is fully off screen, scissor what is partly off screen.
4. Rasterization: edge functions at pixel centres, with the top-left fill rule.
5. Fragment shading: barycentric interpolation of colour and depth.
6. Depth test.
7. Output: the framebuffer.

Input

# starts a comment.

cCopy
Loading…

Rules

• Coordinates: screen space has y pointing down, and pixel (px, py) has its centre at (px + ½, py + ½). To stay in integers, work on a doubled grid: vertices at (2x, 2y) and centres at (2px+1, 2py+1).
• Triangles: vertices 3k, 3k+1, 3k+2 form triangle k, named A, B, C…. area2 = (x1-x0)(y2-y0) - (y1-y0)(x2-x0).
  • 0 means degenerate: discarded.
  • Positive means front-facing, negative back-facing. With cull back, back-facing triangles are culled. With cull none, swap vertices 1 and 2 of a back-facing triangle before rasterizing.
• Clipping: take the bounding box of the transformed vertices. If maxx <= 0, maxy <= 0, minx >= W or miny >= H, the triangle is outside and clipped. If the box extends past the screen, it is scissored: clamp the box to [0, W] × [0, H].
• Coverage: for each pixel with minx ≤ px < maxx and miny ≤ py < maxy, compute E(a→b) = (bx-ax)(py-ay) - (by-ay)(px-ax) for edges v0→v1 (w2), v1→v2 (w0) and v2→v0 (w1). The pixel is covered if all three are ≥ 0. An edge with E = 0 counts only if it is a top edge (ay == by && bx > ax) or a left edge (by < ay).
• Shading: z = round(Σ wᵢzᵢ / Σ wᵢ), and the same for R, G and B. Round half up, with Σwᵢ = 2·area2 on the doubled grid.
• Depth: the buffer starts at 1000 everywhere. A fragment passes if z < depth, and then it writes the colour, the depth and its triangle's letter.

Output

cCopy
Loading…

• Areas are |area2| / 2 with one decimal.
• Scissored triangles print , partly outside (scissored) before the fragment count.
• Leftovers: extra vertices print primitive assembly: N leftover vertex|vertices ignored after the vertex list.
• Transform offsets print with an explicit sign (x*2-4).
• Framebuffer: uncovered pixels are .. probe reports background for them.
• Errors:
  • viewport: W (1-40) H (1-24)
  • transform: SX SY TX TY (it resets to the identity)
  • cull: back|none
  • vertex: X Y Z(0-999) R G B(0-255), vertex: at most 30 vertices
  • probe: X Y inside the viewport
  • unknown command X

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Rasterize with integer edge functions. Floating point makes shared edges crack or double-draw.
2. Apply the top-left rule, so two triangles sharing an edge cover every pixel exactly once.

Hidden tests cover two triangles sharing a diagonal (watertight coverage), back-face culling on and off, a small triangle in front, an off-screen triangle, a degenerate triangle, a leftover vertex, a scaled and translated triangle that is scissored, a depth-test failure, and argument errors.