Graphics Pipeline

The Graphics Pipeline

The graphics pipeline is the complete sequence of operations from 3D vertex data to the final pixels on screen. Modern GPUs implement this pipeline in hardware for extreme performance.

Pipeline Overview

Graphics Pipeline Stages:

  ┌─────────────┐
  │   Vertex    │  Transform vertices
  │  Shader     │  (model-view-projection)
  └──────┬──────┘
         v
  ┌─────────────┐
  │  Primitive  │  Assemble primitives
  │  Assembly   │  (triangles, lines, points)
  └──────┬──────┘
         v
  ┌─────────────┐
  │  Clipping   │  Remove primitives
  │             │  outside view volume
  └──────┬──────┘
         v
  ┌─────────────┐
  │ Rasterizer  │  Convert to fragments
  │             │  (potential pixels)
  └──────┬──────┘
         v
  ┌─────────────┐
  │  Fragment   │  Compute final pixel
  │  Shader     │  color and depth
  └──────┬──────┘
         v
  ┌─────────────┐
  │  Per-Frag   │  Depth test, blending,
  │  Operations │  stencil test
  └──────┬──────┘
         v
  ┌─────────────┐
  │  Framebuffer│  Final image
  │  Output     │
  └─────────────┘

Vertex Processing

Vertex Shader (programmable):
  - Transforms vertex positions
  - Computes per-vertex lighting
  - Passes data to fragment shader

  gl_Position = projection * view * model * vec4(position, 1.0);
  fragColor = lightingCalculation(normal, lightDir);

Fixed-function vertex operations:
  - Model-view transformation
  - Projection
  - Viewport mapping

Rasterization

Converts primitives to fragments:

  Input: Triangle vertices (after clipping)
  Output: Fragments (potential pixels)

  For each triangle:
    1. Compute bounding box
    2. For each pixel in bbox:
       - Test if inside triangle
       - Interpolate vertex attributes
         (color, normal, texcoord, depth)
       - Generate fragment with interpolated data

Fragment Processing

Fragment Shader (programmable):
  - Computes final color of each fragment
  - Texture sampling
  - Per-pixel lighting
  - Effects (fog, shadows, reflections)

  outColor = texture(texCoord) * lightColor;

Per-fragment operations:
  - Depth test (Z-buffer)
  - Stencil test
  - Blending (transparency)
  - Logical operations

Early Depth Testing

An optimization where depth testing is performed before the fragment shader. Fragments that fail the depth test are discarded early, saving shader computation.

Standard:
  Fragment Shader → Depth Test

Optimized:
  Depth Test → Fragment Shader (only if depth test passes)

Limitation: Fragment shader cannot modify depth
  (if it does, early depth test is disabled)