Z-buffering

Description

Z-buffering, also known as depth buffering, is a computer graphics technique used to determine which objects, or parts of objects, are visible in a rendered 3D scene. It is a hidden surface removal algorithm that compares the depth (Z-value) of each pixel in the scene and ensures that only the closest surfaces to the viewer are drawn on screen.

The term “Z” refers to the depth axis in the Cartesian coordinate system used in 3D graphics, where the Z-axis typically represents the viewer’s line of sight into the screen.

How It Works

1. When rendering a 3D scene, each pixel’s position includes a depth value (Z-value).
2. A special memory structure called the Z-buffer (or depth buffer) is used to store depth information for each pixel on the screen.
3. When multiple objects overlap in the scene, the Z-buffer is used to keep track of which object is closer to the camera for each pixel.
4. If a new pixel is being drawn and its Z-value is less than the current value in the Z-buffer, it is drawn to the screen and the Z-buffer is updated.
5. If the new pixel is further away, it is discarded.

Illustration Example

This process is repeated for every pixel in the viewport.

Z-buffer Memory Structure

• The Z-buffer is usually a 2D array with the same dimensions as the screen or render target.
• Each cell contains a floating-point or fixed-point number representing the depth at that pixel.
• The precision of the Z-buffer (e.g., 16-bit, 24-bit, 32-bit) determines how finely it can distinguish between objects at similar depths.

Pseudocode Example

for each pixel (x, y):
    z_new = compute_depth(x, y)

    if z_new < Z_buffer[x][y]:
        framebuffer[x][y] = new_color
        Z_buffer[x][y] = z_new

Advantages of Z-buffering

Disadvantages

Z-fighting Explained

Z-fighting occurs when two or more surfaces have nearly identical depth values. The renderer can’t consistently determine which one is closer, leading to flickering or stitching artifacts.

Common Fixes:

• Use higher-precision Z-buffers (e.g., 24-bit or 32-bit).
• Adjust the near and far clipping planes to increase depth resolution.
• Avoid placing polygons at the same depth.

Applications of Z-buffering

Z-buffer vs Other Visibility Algorithms

Z-buffering is often preferred for real-time rendering due to its simplicity and hardware support.

Optimizations

• Early Z-test (Z-culling): Discards fragments before they are shaded if depth test fails.
• Reverse Z-buffering: Uses reversed depth range (1 near, 0 far) for improved precision.
• Hierarchical Z-buffer: Groups of pixels tested together for early rejection.

Hardware Support

Almost all modern GPUs and rendering engines (OpenGL, DirectX, Vulkan, Metal) natively support Z-buffering with customizable depth formats, test functions, and precision control.

Z-buffering in OpenGL (Example)

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

In OpenGL:

• GL_DEPTH_TEST: Enables Z-buffering
• GL_DEPTH_BUFFER_BIT: Clears Z-buffer before rendering frame
• GL_LESS: Passes fragments closer to the viewer

Related Concepts

• Depth Buffer
• Frame Buffer
• Rasterization
• Visibility Determination
• Near/Far Clipping Plane
• Occlusion Culling
• Z-fighting
• Reverse Z-buffer
• Alpha Blending
• Shadow Mapping
• Deferred Rendering

Conclusion

Z-buffering is a cornerstone of modern 3D computer graphics. It ensures that only the visible parts of objects are rendered, enabling scenes to appear realistic and correct from the viewer’s perspective. With widespread hardware acceleration, robust integration in graphics APIs, and ongoing innovations like reverse Z and early Z-culling, Z-buffering remains a powerful and essential tool in both real-time and offline rendering pipelines.