What Is Rasterization? How Graphics Cards Turn 3D Scenes Into Images

Rasterization is one of the fundamental techniques used by graphics cards to transform a 3D scene from a game or application into a regular 2D image on your monitor. While the 3D world is made up of models, surfaces, and millions of triangles, the screen can only display a grid of colored pixels.

During rendering, the GPU determines the position of objects relative to the camera, projects them onto the screen, figures out which pixels they occupy, and then calculates their color based on materials, textures, lighting, and other effects. This process enables the mathematical description of a virtual world to be turned into a ready-to-display frame in fractions of a second.

Despite the advancements in ray tracing and path tracing, rasterization remains the backbone of computer graphics, used in nearly all modern games thanks to its speed and efficiency.

What Is Rasterization in Simple Terms?

Rasterization is the process of converting geometric objects from a 3D scene into the set of elements for the final image on your screen. In other words, the graphics card takes virtual objects made up of polygons and determines which parts of the screen they should occupy.

Most 3D models in games are built from numerous triangles. Even if a character, car, or building appears round and complex, geometrically its surface can be represented as a mesh of many small triangles.

The monitor cannot display triangles or 3D coordinates directly; it only shows a two-dimensional grid of pixels. Therefore, before displaying a frame, the graphics card must determine where each triangle lands relative to the camera and which screen area it covers.

This is where rasterization begins. After projecting the geometry onto a 2D plane, the GPU determines which pixels are inside each triangle. For these areas, it creates fragments-data used to calculate color, textures, lighting, and other image parameters later on.

It's important not to confuse rasterization with the entire rendering process. Rendering includes many stages: geometry processing, shader work, depth testing, lighting, and assembling the final frame. Rasterization is just one of these steps, but it's the critical link between 3D geometry and the 2D pixel grid.

In games, rasterization is primarily used for its speed. Modern GPUs can process vast numbers of triangles and fragments in parallel, allowing even complex scenes to be turned into images dozens or even hundreds of times per second.

How Does a Graphics Card Turn a 3D Scene Into an Image?

What Makes Up a 3D Scene?

For a graphics card, a game world is not a finished picture but a set of data. Objects are described by vertices with 3D coordinates, and these vertices are connected into triangles. The engine also passes along information about materials, textures, light sources, and the camera's position.

Even a detailed character model may consist of tens or hundreds of thousands of triangles. The more triangles, the more accurately a surface's shape can be conveyed-but the more geometry the GPU needs to process.

Before rasterization, the graphics card must determine the position of each vertex relative to the camera. Objects can move, rotate, and scale, so their coordinates are sequentially transformed from the model's local space to the scene's space, and finally relative to the virtual camera.

How 3D Coordinates Become a Screen Image

Once object positions are processed, projection takes place, converting 3D coordinates into 2D screen coordinates while retaining depth information. Thanks to perspective projection, distant objects appear smaller and closer ones larger, mimicking natural sight or a camera lens.

The graphics card doesn't process all geometry equally. Triangles that are fully outside the camera's view can be discarded. Some geometry on the frame's edge is clipped, so only visible areas are processed further.

GPUs and engines also avoid wasting resources on surfaces that can't be seen-such as the back side of an enclosed object, which can often be excluded before pixel calculations even begin.

After these stages, each remaining triangle has a defined position on the 2D plane of the upcoming frame. The graphics card can now move on to rasterization, determining which screen areas each triangle covers.

The parallel architecture of GPUs enables them to perform these operations on huge numbers of vertices and other graphics data simultaneously. For more on NVIDIA graphics card computational blocks, see the article What Are CUDA Cores in NVIDIA Graphics Cards and How Do They Impact GPU Performance.

How Triangle Rasterization Creates Pixels

Why Do Graphics Cards Use Triangles?

A triangle is the simplest geometric figure that always defines a unique plane. Three vertices can't be arranged to create an ambiguous surface, making triangles fast and convenient for GPUs to process.

Virtually any complex shape can be broken down into triangles. Spheres, car bodies, character faces, or vast game environments are ultimately presented to the graphics card as a collection of basic primitives.

Which Pixels Belong to a Triangle?

After a triangle is projected onto the screen, rasterization begins. The GPU determines which points in the screen grid are inside its boundaries, creating fragments-candidates for the final image's pixels.

But it's not enough for the graphics card to know that a certain point is inside a triangle-it also needs to compute surface parameters at that location: depth, texture coordinates, surface normal direction, and more.

These values are interpolated between the triangle's vertices. For example, if each vertex has assigned texture coordinates, the GPU calculates intermediate coordinates for all fragments in between. This allows a single texture to stretch smoothly across a model's surface without having to specify data for every pixel.

How Shaders Form Pixel Color

After rasterization, the generated fragments undergo further processing, usually by a pixel (fragment) shader-a program that defines the surface's appearance.

A shader can read color from a texture, take into account material properties, light direction, surface normals, reflections, and much more. The end result is a final color calculated for each fragment.

This process can be much more complex than simply reading a texture. Modern games use normal maps, physically based materials, multiple light sources, shadows, and post-processing. However, the basic principle remains: rasterization determines where geometry appears on screen, while shaders decide how it looks.

For more on why shaders sometimes need to be compiled before launching a game, read Shader Compilation in Games: Why It Happens and How It Works on PC.

The GPU Graphics Pipeline: What Happens Each Frame

Rasterization is just one stage of the larger process called the graphics pipeline. During the creation of a single frame, data passes through several sequential stages: from 3D geometry processing to writing final colors into the image buffer.

First, the game engine sends the graphics card information about the scene-object geometry, textures, material settings, camera position, and more. The GPU then processes the model's vertices, transforming their coordinates based on object and camera placement.

The next stage involves assembling primitives: individual vertices are grouped into triangles, and some geometry may be culled. For example, if a triangle is completely outside the visible area, it's skipped in further processing.

The remaining geometry is sent to the rasterizer, which determines what screen area each triangle covers and creates fragments for those parts of the image. Fragment shaders then calculate their appearance based on textures, materials, and lighting.

However, having a fragment doesn't guarantee it will appear in the final frame. Multiple objects might overlap the same screen region. To determine which surface is closer to the camera, a depth buffer (Z-buffer) is used. If another surface is in front, the hidden fragment isn't output.

After the necessary checks, the calculated color is written to the frame buffer. The contents of this buffer make up the image that's ultimately displayed on the monitor.

Modern graphics APIs give developers low-level control over how the GPU works and how graphics commands are sent. To learn more, see Vulkan vs DirectX 12: Comparing Graphics APIs for Games and Applications.

This entire process is repeated for every frame. At 60 FPS, the graphics card must run through the main graphics pipeline stages about 60 times per second; at 144 FPS, it's 144 times. That's why the speed of geometry processing, rasterization, and shaders has a direct impact on game performance.

Rasterization vs Ray Tracing: What's the Difference?

Rasterization and ray tracing both aim to produce an image of a 3D scene, but they go about it in fundamentally different ways. With rasterization, the graphics card starts with geometry, figuring out which areas of the screen are covered by each triangle.

Ray tracing works differently. Rather than converting geometry directly into screen fragments, the algorithm simulates the travel of rays through the virtual scene. Rays can intersect objects, reflect off surfaces, and contribute to the calculation of shadows and lighting.

This approach allows for more realistic optical effects. For example, reflections can account for actual objects around a surface, and shadows can depend on the light source's position and scene geometry. In conventional rasterization, similar results often require special techniques and pre-baked data.

The main advantage of rasterization is performance. GPUs have been optimized for decades to handle massive numbers of triangles, and many graphics pipeline stages are performed in parallel. This allows graphics cards to render frames at high rates even in complex scenes.

Ray tracing requires far more computation, since each ray's intersection with scene geometry must be analyzed. That's why full replacement of rasterization with ray tracing is still rare in modern games. Instead, developers often use hybrid rendering.

In this approach, the main scene is built using rasterization, while ray tracing is used only where it produces significant visual improvements-such as reflections, shadows, or global illumination. This allows the high performance of classic rendering to be combined with more realistic lighting effects.

An even more computationally intense method is path tracing, which simulates light behavior more completely. For details, read Path Tracing in Games: The Future of Graphics and How It Differs from Ray Tracing.

Conclusion

Rasterization turns a 3D scene into an image through step-by-step geometry processing. The graphics card receives vertices and triangles, transforms them relative to the camera, projects them onto the screen, and determines which parts of each future frame are occupied by each object. Shaders then calculate how surfaces should appear, and depth checks ensure only visible fragments remain.

The main strength of rasterization is speed. Modern GPUs are capable of parallel processing of huge amounts of geometry, repeating this process dozens or hundreds of times per second. That's why this technology remains the foundation of rendering in most games, even as more advanced methods emerge.

Ray tracing and path tracing expand the possibilities of graphics, enabling more accurate light simulation-but they require much more computation. In practice, the most effective approach is combining technologies: rasterization for rapid scene building, with ray tracing enhancing realism where it matters most, such as lighting, shadows, and reflections.