Why is z-buffering fast?

Question

When I made my rasterizer, I realized that each pixel needed to compare all the triangles in the model to determine the depth value. But if there are, for example, a million of these triangles, then it turns out that each individual GPU core must compare a million triangles with each other? This all takes an incredibly long time, so I would like to know how this problem is avoided. I heard that this is done in hardware, but by what principle I did not understand

Spektre · Answer 1 · 2022-04-07T08:05:20.227

Depth sorting need to sort all triangles by perpendicular distance to camera and even split intersecting triangles in order to work correctly. That is a huge amount of work scaled with number of entities rendered with ~O(n.log(n)) but does not need too much additonal memory (unless too many splits)... That is why it was used in the past when memory was scarce and CPUs where slow so there where only few entities to render making it still fast enough... Also in some edge cases the depth sorting might be done by simply O(1) back face culling (simple scenes with single convex and non intersecting polygons or too far from each other to block their view)...

Nowadays situations is different we have very complex scenes with lot of entities and fast CPUs and GPUs and lot of memory so Depth buffering is used instead because its O(1), pixel perfect, but needs a shadow screen buffer holding the depths which can be a large chunk of memory ... The rendering is done like this:

clear depth buffer with most distant value

this is the slowest operation but done only once per frame and its just memory filling ... Usually done like this:
```
for (y=0;y<y_resolution;y++)
 for (x=0;x<x_resolution;x++)
     {
     depth[y][x]=z_max
     color[y][x]=background_color;
     }
```
in case the buffers are stored as linear arrays you can use memset or even DMA on some platforms for this.
add condition to rendering pixel and also store rendered depth

to skip pixels if something is already rendered before them like:
```
void pixel(int x,int y,int z,int col)
   {
   if (depth[y][x]>z)
     {
     depth[y][x]=z;   // store new dept value to buffer
     color[y][x]=col; // render pixel
     }
   }
```
as this is done by HW no brunch or CACHE unfrendly operation is involved ...

This approach results in 2 images output one holding the colors (wanted image) and the depth buffer holding the rendered depths so we still have 3D info which allows to do additional processing/effect like ray picking, lighting effects, shadows, scattering and much much more ...

There are also hybrid techniques using both approaches like this:

OpenGL - How to create Order Independent transparency?

Why is z-buffering fast?

1 Answers1