The Graphics Pipeline: A Breakdown [14 marks]

A typical graphics processing unit (GPU) utilizes a well-defined pipeline to transform raw 3D
data into the final image displayed on your screen. This pipeline consists of several crucial
stages, each performing specific tasks. Here's a breakdown of these stages:

1. Input Assembly (IA) [2 marks]:

● This stage acts as the entry point, receiving raw geometric data representing the scene's
objects. This data typically includes vertex positions, texture coordinates, and normals.
● IA processes and assembles this data into primitives the GPU understands, such as
triangles, lines, or points.

2. Vertex Processing (VS) [3 marks]:

● Here, the individual vertices of each primitive undergo various transformations.

● Common vertex processing tasks include:
○ Transformations: Moving, scaling, and rotating vertices based on camera position, object
orientation, and animation.
○ Lighting: Calculating lighting effects on each vertex based on light sources in the scene.
○ Projection: Projecting 3D vertices onto a 2D plane for screen representation.
○ Clipping: Discarding vertices that fall outside the viewing frustum (camera's visible area)
to improve efficiency.

3. Geometry Processing (GS) [2 marks (Optional)]

● This stage is optional and not present in all GPUs.

● If available, the geometry shader operates on individual primitives, allowing for advanced
manipulations like:
○ Tessellation: Subdividing existing primitives (like triangles) into more complex ones for
smoother curves.
○ Procedural generation: Creating new geometric details based on algorithms.

4. Rasterization [3 marks]:

● This critical stage converts the processed primitives (triangles) into fragments, which are
essentially pixel samples representing the final image.
● Rasterization calculates properties for each fragment, including:
○ Position: The fragment's location on the screen.
○ Coverage: The percentage of a pixel covered by the primitive.
○ Depth: The distance of the fragment from the camera (used for hidden surface removal).

5. Fragment Processing (FS) [2 marks]:

● Also known as pixel shading, this stage determines the final color of each fragment.
● Shaders, small programs running on the GPU, perform calculations based on factors like:
○ Lighting: Shading the fragment based on light sources, materials, and textures.
○ Texturing: Applying textures (images) to the object's surface for realistic details.
 ○ Blending: Combining colors from multiple fragments overlapping a pixel (transparency
effects).

6. Output Merger [2 marks]:

● This final stage combines the results from fragment processing. It performs actions like:
○ Blending: Combining fragment colors based on transparency settings.
○ Depth Buffering: Comparing fragment depth values and discarding those obscured by
closer objects (hidden surface removal).
○ Z-Buffering: Similar to depth buffering, but stores both depth and color information to
resolve overlapping, semi-transparent objects.
● The final output from the pipeline is a framebuffer containing the color information for each
pixel, which is then displayed on the screen.

By understanding these stages, you gain insight into how complex 3D scenes are efficiently
transformed into the final visuals we experience in games, movies, and other graphics
applications.