yawiki.org entry for Z-buffering

	Navigation Home Recent Most Active Popular Blog Credits RSS
	Interaction Register Statistics
	Help Suggestions Contact Us How to Edit Help

[Edit]

In computer graphics, z-buffering is the management of image depth coordinates in three-dimensional (3-D) graphics, usually done in hardware, sometimes in software. It is one solution to the visibility problem, which is the problem of deciding which elements of a rendered scene are visible, and which are hidden. The painter's algorithm is another common solution which, though less efficient, can also handle non-opaque scene elements. Z-buffering is also known as depth buffering.

When an object is rendered by a 3D graphics card, the depth of a generated pixel (z coordinate) is stored in a buffer (the z-buffer or depth buffer). This buffer is usually arranged as a two-dimensional array (x-y) with 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 closer to the observer. The chosen depth is then saved to the z-buffer, replacing the old one. In the end, the z-buffer will allow the graphics card to correctly reproduce the usual depth perception: a close object hides a farther one. This is called z-culling.

The granularity of a z-buffer has a great influence on the scene quality: a 16-bit z-buffer can result in artifacts (called "z-buffer fighting") when two objects are very close to each other. A 24-bit or 32-bit z-buffer behaves much better. An 8-bit z-buffer is almost never used since it has too little precision.

    Z-buffering
        Developments
        Z-culling
        Mathematics
            W-buffer
        Javascript
        See also
        Notes

top

Developments

Even with enough granularity, quality problems may arise when precision in the z-buffer's distance values is not spread evenly over distance. Nearer values are much more precise (and hence can display closer objects better) 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 z-buffering which results in more evenly distributed precision is called w-buffering (see below).

At the start of a new scene, the z-buffer must be cleared to a defined value, usually 1.0, because this value is the upper limit (on a scale of 0 to 1) of depth, meaning that no object is present at this point through the viewing frustum.

The invention of the z-buffer concept is most often attributed to Edwin Catmull, although Wolfgang Straßer also described this idea in his 1974 Ph.D. thesis¹.

On recent PC graphics cards (1999-2005), z-buffer management uses a significant chunk of the available memory bandwidth. Various methods have been employed to reduce the impact of z-buffer, such as lossless compression (computer resources to compress/decompress are cheaper than bandwidth) and ultra fast hardware z-clear that makes obsolete the "one frame positive, one frame negative" trick (skipping inter-frame clear altogether using signed numbers to cleverly check depths).

top

Z-culling

In rendering, z-culling is early pixel elimination based on depth, a method that provides an increase in performance when rendering of hidden surfaces is costly. It is a direct consequence of z-buffering, where the depth of each pixel candidate is compared to the depth of existing geometry behind which it might be hidden.

When using a z-buffer, a pixel can be culled (discarded) as soon as its depth is known, which makes it possible to skip the entire process of lighting and texturing a pixel that would not be visible anyway. Also, time-consuming pixel shaders will generally not be executed for the culled pixels. This makes z-culling a good optimization candidate in sitations where fillrate, lighting, texturing or pixel shaders are the main bottlenecks.

While z-buffering allows the geometry to be unsorted, sorting polygons by increasing depth (thus using a reverse painter's algorithm) allows each screen pixel to be rendered to only once. This can increase performance in fillrate-limited scenes with large amounts of overdraw.

top

Mathematics

The range of depth values in camera space (See 3D projection) to be rendered is often defined between a

mathit

and

mathit

value of

z

. After a perspective transformation, the new value of

z

, or

z'

, is defined by:

z'=
rac +
rac (rac)

Where

z

is the old value of

z

in camera space, and is sometimes called

w

w'

.

The resulting values of

z'

are normalized between the values of -1 and 1, where the

near

plane is at -1 and the

far

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 z-buffer, the values of

z'

are linearly interpolated across screen space between the vertices of the current polygon, and these intermediate values are generally stored in the z-buffer in fixed point format. The values of

z'

are grouped much more densely near the

near

plane, and much more sparsely farther away, resulting in better precision closer to the camera. The closer the

near

plane is set to the camera, the less precision there is far away -- having the

near

plane set too closely is a common cause of undesirable rendering artifacts in more distant objects.

top

W-buffer

To implement a w-buffer, the old values of

z

in camera space, or

w

, 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

w

, as opposed to

z'

, are spaced evenly between

near

and

far

.

Whether a z-buffer or w-buffer results in a better image depends on the application.

top

Javascript

When using the tag with JavaScript, you can use the following as a Z-Buffer formula.

//F=far, N=near, Z=final return

f=0;

n=0;

z=0;

z=((f+n)/(f-n))+((1/z)((-2fn)/(f-n)));


// Optimized: z=(f+n-2fn/z)/(f-n)

top

	Source Privacy License Download Contact Us Atlas Scientus.org Dictionary (Yet Another Wiki) RC : 1.39 MIT OpenCourseWare This article is licensed under the GNU Free Documentation License [copyleft]. It uses material from the Wikipedia article "Z-buffering". link