While the previous explanation detailed the general architecture of GPU execution, a distinctly different and equally complex process occurs when a program specifically requests the rendering of 3D imagery. This is known as the Graphics Pipeline. It is a strictly ordered assembly line that transforms mathematical coordinates in a virtual three-dimensional space into the colored pixels that illuminate the monitor. This process requires the GPU to act less like a massive calculator and more like a dedicated visual synthesizer, processing geometry through a fixed sequence of programmable and fixed-function stages.
The Input Assembler and Vertex Processing
The pipeline begins when the application feeds raw geometric data—points, lines, and triangles—into the GPU. These primitives are defined by “vertices,” which are data structures containing spatial coordinates ($x, y, z$), colors, and texture mapping coordinates ($u, v$). The first programmable stage, the Vertex Shader, receives these vertices. Its primary responsibility is coordinate transformation. The shader applies a series of matrix multiplications to move the 3D model from its own local space into “world space,” then relative to the camera’s position in “view space,” and finally into “clip space.” This final transformation distorts the geometry based on perspective, simulating how distant objects appear smaller, effectively squashing the 3D world into a shape the screen can understand.
Rasterization and Interpolation
Once the geometry is correctly positioned, the GPU enters the Rasterization stage. This is a fixed-function hardware process, meaning it is hard-wired and generally not programmable by the software developer. The rasterizer takes the mathematical shapes—now projected onto a 2D plane—and determines which specific pixels on the screen are covered by the geometry. It “scan converts” the continuous mathematical lines of a triangle into discrete square fragments on the pixel grid. During this process, the rasterizer performs interpolation. It takes the data defined at the three corners of a triangle (such as color or normal direction) and mathematically blends them across the surface of the shape using barycentric coordinates. This ensures that a red corner and a blue corner create a smooth gradient of purple across the triangle’s face.
The Fragment Shader
For every pixel-sized fragment generated by the rasterizer, the GPU spawns a thread to run the Fragment Shader (also known as the Pixel Shader). This is the most computationally expensive stage of modern graphics. The Fragment Shader determines the final color of the pixel. It calculates lighting physics, determining how light rays interact with the surface angle (computed via normal vectors). It performs texture lookups, retrieving color data from images stored in VRAM to wrap “skin” onto the geometry. It may also calculate complex effects like reflections, shadows, or bump mapping to simulate depth on flat surfaces. If a scene runs at 4K resolution, this shader must execute over 8 million times per frame, sixty times per second.
The Raster Operations (ROP)
The final stage occurs after the color is calculated but before it is permanently written to the screen. The Raster Operations (ROP) unit acts as the gatekeeper of the Framebuffer. It performs crucial visibility tests, most notably the Depth Test (Z-Buffering). The ROP checks the depth value of the new fragment against the depth value of the pixel currently existing in the buffer. If the new fragment is “behind” what is already there (occluded by a wall or another object), the ROP discards it instantly to save bandwidth. If the fragment is transparent, the ROP blends its color with the existing pixel color. Only after passing these tests is the value written to the Back Buffer. Once the entire frame is drawn, the “front” and “back” buffers are swapped during the vertical blanking interval of the monitor, presenting the complete image to the user without visual tearing.