Rendering pipeline

Algorithm

Intro

Rasterization

Turn geometric primitives such as triangles into covered screen pixels so the rendering pipeline can shade actual fragments.

graphics

rendering

triangles

pipeline

Interactive playground

Tweak the operator or scene live so the article connects to an immediate visual result.

Rasterization

Turn continuous triangle coverage into actual pixel cells or samples on a discrete screen grid.

Triangle in screen space

Scene view

Covered grid cells

Result view

Increase grid resolution to watch the same triangle occupy more precise but smaller cells.

Geometry skew 12

Grid resolution 14

Family

Rendering pipeline

Rasterization, visibility, and alternate image synthesis strategies such as ray marching.

Builds on

1 topic

Read these first if you want the surrounding pipeline context.

Unlocks

3 next topics

Use these follow-ups when you want to keep turning the image-processing pipeline forward.

Learning paths

This topic appears in curated graphics progressions so the next step is obvious.

Choose this over that

Rasterization vs ray marching

Both produce pixels, but one starts from explicit triangles and the other evaluates implicit distance fields along rays.

Current topic

Rasterization

Choose this when: The scene is built from explicit geometry and you want the classic real-time pipeline.

Choose something else when: Implicit surfaces or procedural distance fields are the real focus.

Rendering pipeline Open topic

Ray Marching and Signed Distance Fields

Choose this when: You want to render implicit shapes by stepping through a signed-distance field.

Choose something else when: Triangle coverage, interpolation, and z-buffering are the main skills to learn.

Geometry & curves Open topic

Clipping

Choose this when: Visibility work has not even reached rasterization yet because geometry must be clipped first.

Choose something else when: Primitive coverage on screen is already the active stage.

Problem

The GPU can shade pixels, but scenes start as geometry. You need a rule that decides which screen pixels a triangle covers before any fragment-level work can happen.

Intuition

Rasterization projects primitives onto the screen and marks the covered samples. Once you know coverage, later stages can interpolate attributes and decide visibility.

Core idea

Clip geometry to the visible region.
Project the primitive into screen space.
Test which pixels or samples fall inside the projected triangle, often with edge functions.
Emit fragments for covered samples so later stages can shade them.

Worked example

A triangle with three projected screen-space vertices becomes a small set of covered pixels on a discrete grid. Rasterization is the stage that says exactly which pixels belong to it.

Complexity

The work scales with the number of generated fragments rather than just the number of input triangles. Small triangles are cheap; large on-screen triangles produce many fragments.

When to choose it

Choose rasterization for the mainstream real-time triangle pipeline.
Choose ray marching when the scene is naturally described by implicit distance fields instead of explicit triangles.
Clipping comes before rasterization because off-screen geometry should be trimmed first.

Key takeaways

Rasterization turns primitives into candidate screen samples.
It is the bridge from geometry to pixel-level shading.
Coverage, interpolation, and depth testing all build on it.
Most real-time rendering still centers around rasterized triangles.

Practice ideas

Write a software triangle rasterizer on a small grid.
Inspect how moving a vertex changes the set of covered pixels.
Add barycentric interpolation after basic coverage works.

Relation to other topics

Clipping trims primitives before rasterization begins.
Barycentric interpolation supplies per-fragment attributes once coverage is known.
The z-buffer decides which rasterized fragment remains visible at each pixel.