Zbuffering
From Academic Kids

Zbuffer.jpg
In computer graphics, zbuffering is the management of image depth coordinates in 3d graphics, mainly used in hardware, more seldom in software. It is one solution to the visibility problem, which is the problem of deciding which elements of a rendered scene are drawn in front, and which are hidden. The painter's algorithm is another common solution.
When an object is rendered by a 3D graphics card, the depth of a generated pixel (z coordinate) is stored in a buffer (the zbuffer). This buffer is usually arranged as a twodimensional array (xy), one element for each screen pixel. If another object of the scene must be rendered in the same pixel, the graphics card compares the two depths and chooses the one closest to the observer. The chosen depth is then saved to the zbuffer, replacing the old one. In the end, the zbuffer will allow the graphics card to correctly reproduce the usual depth perception: a close object hides a farther one.
The granularity of a zbuffer has a great influence on the scene quality: an 16bit zbuffer can result in artifacts (called zbuffer fighting) when two objects are very close to each other. A 24bit zbuffer behaves much better. An 8bit zbuffer is almost never used since it has too little precision.
Additionally, precision in the zbuffer distance values is not spread evenly over distance. Nearer values are much more precise (and hence can display closer objects more properly) than values which are farther away. Generally, this is desirable, but sometimes it will cause artifacts to appear as objects become more distant. A variation on zbuffering which results in more evenly distributed precision is called wbuffering.
At the start of a new scene, the zbuffer must be cleared to a defined value (usually zero).
On recent PC graphics cards (19992005), zbuffer management uses a significant chunk of the available memory bandwidth. Various methods have been employed to reduce the impact of zbuffer, such as lossless compression (compute resources to compress/decompress are cheaper than bandwidth) and ultra fast hardware zclear that makes obsolete the "one frame positive, one frame negative" trick (skipping interframe clear altogether using signed numbers to cleverly check depths).
Mathematics
The range of depth values in camera space (See 3D projection) to be rendered is often defined between a <math>\mathit{near}<math> and <math>\mathit{far}<math> value of <math>z<math>. After a perspective transformation, the new value of <math>z<math>, or <math>z'<math>, is defined by:
<math>z'= \frac{\mathit{far}+\mathit{near}}{\mathit{far}\mathit{near}} + \frac{1}{z} \left(\frac{2 \cdot \mathit{far} \cdot \mathit{near}}{\mathit{far}\mathit{near}}\right) <math>
Where <math>z<math> is the old value of <math>z<math> in camera space, and is sometimes called <math>w<math> or <math>w'<math>.
The resulting values of <math>z'<math> are normalized between the values of 1 and 1, where the <math>near<math> plane is at 1 and the <math>far<math> plane is at 1. Values outside of this range correspond to points which are not in the viewing frustum, and shoudn't be rendered.
To implement a zbuffer, the values of <math>z'<math> are linearly interpolated across screen space between the vertices of the current polygon, and these intermediate values are generally stored in the zbuffer in fixed point format. The values of <math>z'<math> are grouped much more densely near the <math>near<math> plane, and much more sparesly farther away, resulting in better precision closer to the camera. The closer the <math>near<math> plane is set to the camera, the less precision there is far away  having the <math>near<math> plane set too closely is a common cause of undesireable rendering artifacts in more distant objects.
To implement a wbuffer, the old values of <math>z<math> in camera space, or <math>w<math>, are stored in the buffer, generally in floating point format. However, these values cannot be linearly interpolated across screen space from the vertices  they usually have to be inverted, interpolated, and then inverted again. The resulting values of <math>w<math>, as opposed to <math>z'<math>, are spaced evenly between <math>near<math> and <math>far<math>.
Whether a zbuffer or wbuffer results in a better image depends on the application.
See also
 Edwin Catmull  the inventor of the zbuffer concept.
 3D computer graphicsde:ZBuffer