Z-buffer method with limitation

Z-buffer algorithm

The Z-buffer (depth-buffer) method is an image-space method that keeps the nearest surface at every pixel using two arrays:

• zbuf(x, y): depth of the nearest surface so far (initialised to the maximum depth, 1).
• frame(x, y): colour of that surface (initialised to the background).

for each polygon P:
    for each pixel (x,y) in the projection of P:
        z = depth of P at (x,y)
        if z < zbuf(x,y):
            zbuf(x,y) = z
            frame(x,y) = colour of P at (x,y)

At the end the frame buffer holds the visible surfaces. Polygons may be processed in any order.

Calculating the depth

The plane is Ax + By + Cz + D = 0, so z = (−Ax − By − D)/C.

1. Moving along a scan line, x increases by 1: z' = z − A/C (a constant increment).
2. Moving from a scan line to the next along a left edge with slope m: x' = x − 1/m, y' = y − 1, giving z' = z + (A/m + B)/C.
3. The depth at the top vertex is computed from the plane equation; the other values are found incrementally by addition only.

Limitations

1. No transparency: only one surface (the nearest) is stored per pixel, so transparent and translucent surfaces cannot be rendered correctly.
2. Aliasing: only one sample per pixel, so jagged edges appear and anti-aliasing is difficult.
3. Extra memory is needed for the depth buffer (same size as the frame buffer).
4. Limited depth precision: two nearby surfaces can have the same quantised depth (z-fighting).
5. Time is spent on surfaces that are finally hidden (overdraw).

The A-buffer method overcomes limitations 1 and 2.