Visibility Buffering Techniques

• Visibility buffering is a GPU rendering technique that captures all scene geometry fragments per pixel, enabling enhanced transparency and accurate relighting.
• It utilizes data structures like per-pixel linked lists, tile A-buffers, and wavelet decompositions to support order-independent transparency and efficient sphere-tracing.
• The approach decouples geometry evaluation from lighting, allowing rapid interactive view changes and realistic indirect illumination in complex scenes.

Visibility buffering encompasses a class of GPU rendering techniques and data structures for capturing, representing, and later evaluating the visibility, transmittance, and occlusion properties of a scene with higher fidelity and flexibility than traditional Z-buffer or G-buffer schemes. Unlike classic approaches that store only the closest fragment per pixel, visibility buffers preserve the multilayer composition of scene geometry, surface/material properties, and sometimes even volumetric or indirect visibility, providing a foundation for advanced visual effects such as view-independent relighting, order-independent transparency, global illumination, and coherent sphere-tracing for implicit surfaces. Notable implementations include Fragment-History Volumes (FHVs), visibility bitmasking for screen-space methods, wavelet decompositions of transmittance, and tile-based A-buffering for implicit surface evaluation.

1. Definition and Rationale

Visibility buffering is defined as the explicit retention of partial or complete visibility (and often other per-fragment) information for all scene geometry intersected by the view frustum, sampled along camera rays, or otherwise implicated in radiometric transport. Whereas a Z-buffer writes only the nearest fragment and a G-buffer aggregates per-pixel surface attributes typically for deferred shading, visibility buffers (A-buffers and their GPU variants) store all relevant fragments—opaque and transparent, visible and occluded—often augmented with world-space position, normal, material ID, and object ID (Inácio et al., 2022). This enables precise reconstruction of the visibility function at each pixel, supporting interactive view changes, sophisticated compositing, and physically-based light transport computations.

The rationale is to decouple geometry evaluation from lighting and compositing, thereby mitigating redundant work when rendering novel viewpoints in static scenes, accurately handling transparency and multiple depth layers, and enabling advanced effects such as indirect illumination and refraction, which require non-local or view-independent access to visibility data.

2. Key Data Structures and Construction Algorithms

Visibility buffering methods implement tailored data structures to balance memory requirements, access patterns, and reconstruction performance. Prominent strategies include:

• Per-Pixel Linked Lists (FHVPPFL): Store for each pixel a linked list of all rasterized fragments, each with world position, normal, material, and back-pointer. The visibility structure is a global fragment pool plus a head-pointer array indexed by pixel. This enables per-pixel full history reconstruction at the cost of high memory ($O(N_p + n_f N_p)$ with $N_p$ pixels and expected $n_f$ fragments/pixel) (Inácio et al., 2022).
• Per-Octant Linked/Array Lists (FHVPOFL/FHVPOFA): Generalize pixel-based approaches spatially by Morton-coding world-space octants, dramatically reducing memory when scene geometry is sparse compared to screen resolution. The array construction—via two-pass (count, fill)—hallows tightly packed, contiguous fragment blocks per octant, optimizing traversal and allocation (Inácio et al., 2022).
• Low-Resolution A-buffers for Tiles: For efficient GPU sphere-tracing of implicit surfaces, tiles (e.g., 8×8 pixels) index into per-tile linked lists of primitive "volumes of interest" (VOIs), each with analytic entry/exit depths. Construction minimizes atomics and memory (e.g., 52 MB for 1K resolution and moderate overlap), supporting dynamic primitives without preprocessing (Zanni, 2023).
• Visibility Bitmasking: For screen-space applications, per-pixel bit fields encode the binary occlusion state of uniformly discretized hemisphere sectors along multiple azimuthal slices. Each sector's bit is raised if occluded by a depth sample plus a fixed thickness; updates are performed using bit-twiddling for $O(1)$ per-sample overhead (Therrien et al., 2023).
• Wavelet Buffers for Transparency: The per-pixel visibility function (transmittance) $T(z)$ is expanded in a truncated Haar wavelet basis, with $O(\log N)$ coefficients per pixel accumulated atomically as fragments are processed. This hierarchical representation supports high-fidelity depth-resolved compositing (Aizenshtein et al., 2022).

Construction algorithms are highly parallelized: rasterization passes generate and gather per-fragment data, compute Morton codes or tile addresses, and invoke atomic operations for buffer insertion or coefficient updates. Specialized techniques (e.g., two-pass array builds, sparse bottom-up tree traversals) minimize contention and exploit GPU memory layouts.

3. Evaluation and Resampling Techniques

Once constructed, visibility buffers facilitate multiple view-independent or view-dependent evaluation methods depending on the application domain:

• Point-Based and Octree Raycasting: For static geometry, FHVs support interactive view reprojection via direct resampling—all fragments are projected to new viewports and blended using stored surface/material data. Alternatively, full ray traversal through the per-octant octree enables efficient gathering of all relevant fragments, depth sorting, and compositing for high-quality order-independent transparency and shading (Inácio et al., 2022).
• Coherent Sphere-Tracing for Implicit Surfaces: Tiles synchronize sphere-trace intervals and maintain a shared "active list" of overlapping primitives, allowing all 64 threads in an 8×8 tile to evaluate a local, dynamically pruned tree representation of the scene, ensuring coherent memory access and removing divergent branching at the workgroup level. Only fragments overlapping the tile's subfrustum are traversed, so evaluation complexity is proportional to local, not global, geometry count (Zanni, 2023).
• Screen-Space Visibility Bitmask Integration: For ambient occlusion and indirect illumination effects, the bitmask replaces analytical horizon integration: the fraction of unoccluded bits per slice and per ambient cone provides an unbiased estimator for ambient and indirect light, while supporting multi-lobe directional lighting (Therrien et al., 2023).
• Hierarchical Transmittance Evaluation: Wavelet-based visibility enables reconstruction of $T(z)$ at arbitrary depth with $O(\log N)$ memory and compute, retaining sharp features at discontinuities with substantially lower bandwidth than prior moment-based or direct A-buffer approaches (Aizenshtein et al., 2022).

4. Applications in Real-time and Offline Rendering

Visibility buffering unlocks advanced rendering features unavailable or inefficient in traditional buffers:

• Interactive Viewpoint Changes: With full fragment histories, FHVs enable rapid viewpoint changes via resampling, obviating repeated geometry rasterization for static scenes (Inácio et al., 2022).
• Order-Independent Transparency: Both FHVs and wavelet buffers reconstruct the composite transmittance along the view ray, supporting correct blending of extensive transparent geometry, including challenging cases such as overlapping smoke, glass, and refractive materials (Inácio et al., 2022, Aizenshtein et al., 2022).
• Global Illumination and Indirect Lighting: Storage of all surface attributes along the ray allows secondary rays (ambient occlusion, full Monte Carlo GI) to be spawned per fragment, using the same buffer infrastructure, with per-object/material filtering and support for order-independent effects (Inácio et al., 2022).
• Efficient Rendering of Implicit Surfaces: Tile A-buffers and synchronized sphere-tracing scale to thousands of primitives, offering substantial speedups (20–80%) and memory reductions compared to full-tree interpreters or interval-arithmetic methods on large blobtrees (Zanni, 2023).
• Screen-Space Effects: Visibility bitmasking achieves high-quality ambient occlusion and indirect diffuse illumination, especially around thin occluders, with minimal noise and computational overhead, improving upon horizon-based methods and closely approaching true ray-based screen-space solutions (Therrien et al., 2023).

5. Memory, Performance Trade-Offs, and Limitations

Visibility buffering trades increased memory consumption and construction cost for flexibility and speed in subsequent evaluation passes. Summarized metrics from representative approaches:

Method	Build + Shade [ms]	Memory (per-pixel / tile)	Typical Use Case
FHVPPFL	103.5 / 8.9 (GTX/RTX)	460 MB (1K$^2$, over-alloc. list)	View-independent transparency, static scenes
FHVPOFA	99.5 / 13.9, 200 MB	200 MB (octant arrays)	Sparse 3D scenes, efficient raycasting, global illum.
Tile A-buffer	22ms (P1000), 7ms (2080)	52 MB (1K$^2$, 8×8 tiles, 200 frag)	Implicit surfaces, dynamic blobtrees (Zanni, 2023)
Visibility Bitmask	~0.01–0.02 (RTX2080)	Bitfield per-pixel, $N_p$0	Screen-space AO, indirect lighting
Wavelet3 Transparency	1.8 (RTX3090, 1080p)	64 B/pixel	Order-indep. transparency, real-time photorealism

Key trade-offs include:

• Build cost is amortized over frames for static geometry. In dynamic scenes, incremental or asynchronous buffer rebuilds are required.
• Memory scales with the number of fragments per pixel/octant/tile; sparsity (spatial or screen-space) is exploited for efficiency.
• Tile-based schemes dramatically reduce atomics and memory for large implicit models.
• Ray divergence and thread synchronization remain bottlenecks in advanced GI/multi-bounce effects, partially addressed by coherent traversal and Morton ordering.
• Scene complexity and screen resolution jointly constrain quality and buffer occupancy.

6. Comparison to Classic and Alternative Approaches

Visibility buffering generalizes and subsumes prior methods:

• Classic Z- and G-buffers store only foremost surface data, precluding correct transparency and occluder reuse across views.
• Moment and multilayer A-buffers approximate multi-depth compositing but with trade-offs in memory, sharpness, and update cost (Aizenshtein et al., 2022).
• Bitmasking overcomes horizon-based AO’s limitations, allowing light passage through thin/blended geometry (Therrien et al., 2023).
• Tile A-buffers combined with synchronized kernel traversal dramatically accelerate sphere-tracing on complex implicit surfaces (Zanni, 2023).

A plausible implication is that hybrid schemes—combining spatially adaptive fragmentation, hierarchical/layered storage, and direct-integration bitmasking—will continue to bridge the gap between real-time and offline photorealistic rendering, while dynamically trading compute, memory, and fidelity as dictated by scene structure and application demands.