The Rendering Pipeline
Turning geometry into pixels follows a fixed sequence of stages; knowing them is the basis for every real-time 3D visualization.
From scene to screen
Real-time rendering transforms 3D geometry into a 2D image through a pipeline of stages, most of which run on the GPU. Understanding the stages explains both what is possible and where performance is spent. The pipeline is the same idea whether accessed through WebGL, a game engine, or a scientific toolkit.
The main stages
- Vertex processing: transform vertices by model, view, and projection matrices.
- Primitive assembly and clipping: group vertices into triangles, discard what is off-screen.
- Rasterization: determine which pixels each triangle covers.
- Fragment processing: compute color and depth per pixel, apply lighting and textures.
- Output merging: depth test and blend fragments into the framebuffer.
Coordinate spaces
Geometry moves through model space to world space to view (camera) space to clip space and finally to screen space. Each transform is a matrix multiply. Getting these transforms right is most of the work in placing and orienting objects and the camera.
Depth and transparency
The depth buffer resolves what is in front. Opaque objects can be drawn in any order thanks to depth testing, but transparency requires sorting or special blending, which is why transparent isosurfaces and volume rendering need extra care.
# clip = Projection * View * Model * position
# position_screen = viewport(clip / clip.w)Kronos use
The browser machine models and field renderings are built on this pipeline; knowing it guides where to spend the client's limited GPU budget.