Notes on [Real-Time] Graphics Rendering Pipeline pt.1

Jupiter_Dev — Fri, 16 Oct 2026 07:23:51 +0000

The graphics pipeline, or simply the pipeline is the core subsystem on modern computers that efficiently draws a 2D image given a collection of raw data.

Pipeline's architecture

The pipeline stages runs in parallel, though each stage is dependent of the previous one. In a way that the render time lower bound is the slowest stage, this stage is then called bottleneck.

The render time is directly connected with FPS (Frames per second) that is the number of images rendered per second.

In the image above we present four functional stages - each one is in itself a pipeline that is has several sub-stages responsible for functional implementation.

Application Stage

The Application Stage is the one that runs on CPU Side thus we have full control over this process. The most important function of the application stage is to prepare and send geometry data into the geometry processing stage (other important things like collision detection, input handling are also performed here).

Geometry Processing

Like the name implies, the geometry processing is a GPU Side stage responsible for compute geometry data (primarily Vertex) like a vertex's position or whatever the programmer has coded into it. We can split this stage in four implementation stages:

A big part of Projection, Clipping and Screen Mapping it is done by the GPU , but can have some customization via an API. Although, output and configurations of what to do with each vertex in the Vertex Shading (it's called Shading by historical reasons) can is done via coding, like model's material, light properties, transforms, texture coordinates etc.
Another task of vertex shading is more mathematical: VS will do a series of transformations moving from one space to another, like the image below:

After this the GPU will compute a Orthographic or Perspective Projection these two has important geometry and visualization consequences, and then move the object to Clip Space, which is a unit cube. Next, Clipping is performed: which consists in cutting geometry that is out-of-camera-bounds, called sectioning. Finally , perspective division is performed, which places the resulting triangle's positions into three-dimensional normalized device coordinates (NDC) ranging from (-1, -1, -1) to (1, 1, 1).
After that, clipped primitives inside the view are passed to screen mapping (in general, the coordinates depends upon the API) to set geometry position in window coordinates.
Until here, we still don't get nothing renderer, for this we need more two stages: Rasterization and Pixel/Fragment Processing. These two will be discussed in a pt.2

DEV Community: Jupiter_Dev

Notes on [Real-Time] Graphics Rendering Pipeline pt.1

Pipeline's architecture

Application Stage

Geometry Processing