Order-independent transparency

The importance of blending order. The top produces an incorrect result with unordered alpha blending, while the bottom correctly sorts the geometry. Note lower visibility of the skeletal structure without correct depth ordering. Image from ATI Mecha Demo

Order-independent transparency (OIT) is a class of techniques in rasterisational computer graphics for rendering transparency in a 3D scene, which do not require rendering geometry in sorted order for alpha compositing.

Description

Commonly, 3D geometry with transparency is rendered by blending (using alpha compositing) all surfaces into a single buffer (think of this as a canvas). Each surface occludes existing color and adds some of its own color depending on its alpha value, a ratio of light transmittance. The order in which surfaces are blended affects the total occlusion or visibility of each surface. For a correct result, surfaces must be blended from farthest to nearest or nearest to farthest, depending on the alpha compositing operation, over or under. Ordering may be achieved by rendering the geometry in sorted order, for example sorting triangles by depth, but can take a significant amount of time, not always produce a solution (in the case of intersecting or circularly overlapping geometry) and the implementation is complex. Instead, order-independent transparency sorts geometry per-pixel, after rasterisation. For exact results this requires storing all fragments before sorting and compositing.

History

The A-Buffer^[1] is a computer graphics technique introduced in 1984 which stores per-pixel lists of fragment data (including micro-polygon information) in a software rasteriser, REYES, originally designed for anti-aliasing but also supporting transparency.

More recently, depth peeling^[2] in 2001 described a hardware accelerated OIT technique. With limitations in graphics hardware the scene's geometry had to be rendered many times. A number of techniques have followed, to improve on the performance of depth peeling, still with the many-pass rendering limitation. For example, Dual Depth Peeling (2008).^[3]

In 2009, two significant features were introduced in GPU hardware/drivers/Graphics APIs that allowed capturing and storing fragment data in a single rendering pass of the scene, something not previously possible. These are, the ability to write to arbitrary GPU memory from shaders and atomic operations. With these features a new class of OIT techniques became possible that do not require many rendering passes of the scene's geometry.

• The first was storing the fragment data in a 3D array,^[4] where fragments are stored along the z dimension for each pixel x/y. In practice, most of the 3D array is unused or overflows, as a scene's depth complexity is typically uneven. To avoid overflow the 3D array requires large amounts of memory, which in many cases is impractical.
• Two approaches to reducing this memory overhead exist.
  1. Packing the 3D array with a prefix sum scan, or linearizing,^[5] removed the unused memory issue but requires an additional depth complexity computation rendering pass of the geometry. The "Sparsity-aware" S-Buffer, Dynamic Fragment Buffer, "deque" D-Buffer^{[citation needed]}, Linearized Layered Fragment Buffer^[6] all pack fragment data with a prefix sum scan and are demonstrated with OIT.
  2. Storing fragments in per-pixel linked lists^[7] provides tight packing of this data and in late 2011, driver improvements reduced the atomic operation contention overhead making the technique very competitive.^[6]

Exact OIT

Exact, as opposed to approximate, OIT accurately computes the final color, for which all fragments must be sorted. For complex scenes, sorting becomes the bottleneck.

One issue with the sorting stage is low occupancy, in this case a SIMT attribute relating to the throughput and operation latency hiding of GPUs. Backwards Memory Allocation^[8] groups pixels by their depth complexity to improve the occupancy and hence performance of sorting and compositing low depth complexity pixels in the context of a potentially high depth complexity scene. Up to a 3× overall OIT performance increase is reported.

Approximate OIT

Approximate OIT techniques relax the constraint of exact rendering to provide faster results. Higher performance can be gained from not having to store all fragments or only partially sorting the geometry. A number of techniques also compress, or reduce, the fragment data. These include:

• Stochastic Transparency: draw in a higher resolution but discard some fragments. Downsampling will then yield transparency.^[9]
• Adaptive Transparency,^[10] a two-pass technique where the first constructs a visibility function which compresses on the fly (this compression avoids having to fully sort the fragments) and the second uses this data to composite unordered fragments. Intel's pixel synchronization^[11] avoids the need to store all fragments, removing the unbounded memory requirement of many other OIT techniques.

OIT in Hardware

• The Sega Dreamcast games console included hardware support for automatic OIT.^[12]

References