Rasterization is the process of converting a vector description of three-dimensional primitives (triangles, lines, points) into a set of pixels (fragments) for display on a screen. According to Khronos Group, 2025, rasterization is an automatic (non-programmable) stage of the graphics pipeline located between the Vertex Shader and Fragment Shader. Rasterization determines which screen pixels belong to which triangle and computes interpolated attributes for each fragment.
Key Takeaways
Rasterization is a stage of the graphics pipeline that converts geometric primitives (triangles, lines) into a set of fragments for further processing by the Fragment Shader. The input consists of triangle vertices in screen coordinates and their attributes (color, normals, UV). The output is a set of fragments with interpolated attributes.
Unlike programmable shaders (Vertex and Fragment Shader), rasterization is a fixed (non-programmable) stage. The developer cannot change the rasterization algorithm but can control its parameters: culling mode, line width, polygon offset, and multisampling.
Virtually all modern real-time graphics — games, UI, AR/VR — use rasterization. It is the most performant rendering method, capable of processing millions of triangles per frame at 60 FPS. GPU rasterizers are optimized for parallel processing of thousands of triangles simultaneously through specialized ROP (Render Output Units) blocks.
Triangle rasterization begins after the Vertex Shader has transformed the vertices into screen coordinates. The GPU takes the three vertices of a triangle and determines which screen pixels lie inside that triangle.
The process includes three sequential steps: determining the triangle’s bounding box in pixels — checking each pixel inside the bounding box for triangle membership (edge function) — computing interpolated attributes (barycentric coordinates) for each covered pixel. Edge function is a linear equation that determines which side of the triangle edge a point lies on.
| Stage | Description | Result |
|---|---|---|
| Clipping | Clipping triangles outside the viewport boundaries | Visible primitives |
| Viewport transform | Transformation into screen coordinates | Pixel coordinates |
| Triangle setup | Computing edge functions and bounding box | Rasterization parameters |
| Fragment generation | Coverage testing and interpolation | Fragments + attributes |
Rasterization can be implemented using various algorithms, each with its own trade-offs between performance and quality. Modern GPUs use a combination of several approaches.
The classic rasterization algorithm developed for early GPUs. The triangle is processed line by line (scanline): for each screen line, the entry and exit points of the triangle are determined, and all pixels between them are filled. Scanline conversion is efficient for large triangles but requires complex logic for triangles of arbitrary shape.
Modern GPUs use the half-space rasterization method: for each side of the triangle, an edge function is computed — a linear equation that is positive on one side and negative on the other. A pixel belongs to the triangle if all three edge functions are positive. Half-space rasterization is easily parallelizable and well-suited for SIMD GPU architectures.
Mobile GPUs (Qualcomm Adreno, ARM Mali) use Tile-Based Rendering (TBR). The screen is divided into small tiles (16x16 or 32x32 pixels), and rasterization is performed for each tile separately. This minimizes memory accesses by storing the framebuffer in fast local memory (tile memory). TBR reduces power consumption, which is critical for mobile devices.
Rasterization and ray tracing are two fundamentally different approaches to 3D graphics rendering. Rasterization dominates real-time applications, while ray tracing is used in offline rendering and is gradually entering real-time (on RTX-compatible GPUs).
| Parameter | Rasterization | Ray Tracing |
|---|---|---|
| Principle | Triangle → fragments | Ray → scene intersection |
| Speed | Very fast (millions of triangles/frame) | Slow (thousands of rays/frame) |
| Quality | Requires additional techniques (shadows, reflections) | Physically correct shadows and reflections |
| Mobile GPUs | Standard method | Limited support (A17 Pro, Snapdragon Gen 3) |
| Power consumption | Low | High |
Rasterization introduces the problem of aliasing — jagged edges (jaggies) at triangle boundaries. This occurs because a pixel is discrete and cannot be partially covered by a triangle. Multisampling (MSAA) is used to combat aliasing.
MSAA (Multisample Anti-Aliasing) performs rasterization at an increased sampling rate (2x, 4x, 8x). Instead of one sample per pixel, multiple sub-samples are used, each tested for triangle coverage. MSAA 4x processes 4 sub-samples per pixel, providing noticeable edge smoothing without fully increasing the rendering resolution.
Unlike MSAA, post-process anti-aliasing methods (FXAA, SMAA, TAA) work after rasterization by analyzing the final image. FXAA (Fast Approximate Anti-Aliasing) detects image edges and applies blur for smoothing, working significantly faster than MSAA but with less quality.
Rasterization on modern GPUs is performed by specialized hardware blocks — ROP (Render Output Units). The number of ROPs directly affects the fill rate — the number of pixels the GPU can process per second.
For mobile GPUs (Tile-Based Rendering), critical factors include: minimizing overdraw through early-Z rejection, using back-face culling to remove invisible triangles, and occlusion culling to reject triangles fully covered by other objects.
Frequently Asked Questions
Rasterization is the process of turning triangles into pixels on the screen. The GPU takes a three-dimensional triangle, determines which screen pixels it covers, and passes them to the Fragment Shader for coloring.
Rasterization projects triangles onto the screen and determines pixel coverage (very fast). Ray tracing casts rays from the camera and checks intersection with geometry (physically more accurate but significantly slower).
During rasterization, a pixel either fully belongs to a triangle or does not — hence jagged edges (aliasing). MSAA smooths edges using multiple sub-samples per pixel, while FXAA applies a filter to the final image.
No, rasterization is a fixed stage of the graphics pipeline. The developer cannot change the algorithm but can control settings: culling, polygon offset, rasterization mode (points, lines, triangles), and MSAA parameters.
Tile-Based Rendering (TBR) divides the screen into tiles and processes them in fast local memory rather than global VRAM. This radically reduces power consumption and bandwidth, which is critical for battery-powered mobile devices.
Summary
We will develop a mobile application turnkey
IT Sectr creates iOS and Android applications for startups and businesses since 2017. We will advise you and propose the best solution.
Read also