Moment-Based Order-Independent Transparency

• The technique extends moment-based OIT to continuous volumetric media using 3D Gaussian Splatting, enabling analytic per-pixel moment computation without explicit sorting.
• It employs a differentiable, GPU-friendly pipeline that integrates moment computation, quadrature sampling, and adjoint rendering for efficient real-time visualization.
• Comparative evaluation demonstrates reduced artifacts in overlapping semi-transparent regions, balancing physical accuracy with moderate rendering cost.

Moment-based order-independent transparency (OIT) is a volumetric rendering methodology that extends the principles of moment-based OIT for surfacic geometry to continuous volumetric media, specifically leveraging statistical moments to reconstruct physically consistent transmittance without ray tracing or explicit sorting. Most recently, this approach has been applied to the rasterization-based rendering of 3D Gaussian Splatting (3DGS), enabling the synthesis of complex, overlapping semi-transparent objects with physically accurate volumetric occlusion. The defining characteristic of this framework is its analytic, per-pixel moment computation and inversion, yielding a smooth, order-independent transmittance function suitable for high-fidelity, real-time rendering (Müller et al., 12 Dec 2025).

1. Foundations of Order-Independent Transparency

Classic OIT for polygonal or surfacic geometry, such as A-buffer and depth peeling, achieves physically correct compositing through explicit layering or sorting, but at considerable computational expense. Real-time approximations include weighted blended OIT and stochastic approaches. The moment-based transparency method (Münstermann et al., 2018) introduced the use of raw moments to capture the occlusion profile for a set of sorted (or unsorted) discrete layers: given a set of layers at depths $\{z_k\}$ with opacities $\{\alpha_k\}$, the absorbance function $A(z)$ is modeled as a step function with Lebesgue–Stieltjes measure $\mu_A$, and the first $2N+1$ moments

$$m_k = \int z^k d\mu_A(z) = \sum_k z_k^k [ -\log(1 - \alpha_k) ]$$

suffice to reconstruct rigorous lower and upper bounds on cumulative absorbance, independent of sorting.

Recent advances generalize moment-based OIT from discrete layers to continuous volumetric media, specifically targeting 3DGS, where volumetric density is modeled as a sum of overlapping 3D Gaussians. This generalization resolves order-dependent artifacts and provides accurate modeling of light attenuation even in highly overlapped, heterogeneous semi-transparent regions (Müller et al., 12 Dec 2025).

2. Volumetric Gaussian Representation and Ray Parameterization

Scenes are represented as $M$ weighted 3D Gaussians:

$$\rho(x) = \sum_{i=1}^M w_i \cdot \exp\left[ -\tfrac{1}{2}(x - p_i)^\top \Sigma_i^{-1} (x - p_i) \right]$$

For each camera ray $r(t) = o + t d$, the intersection with a given Gaussian $i$ reduces to a 1D Gaussian in $t$:

$$\rho_i(t) = w'_i \exp \left[ - \frac{(t - \mu_i)^2}{2 \sigma_i^2} \right]$$

where

$$\begin{align*} \mu_i &= \frac{ d^\top \Sigma_i^{-1} (p_i - o) }{ d^\top \Sigma_i^{-1} d } \ \sigma_i^2 &= \frac{1}{ d^\top \Sigma_i^{-1} d } \ w'_i &= w_i \exp \left[ -\frac{1}{2} \left( (p_i - o)^\top \Sigma_i^{-1} (p_i - o) - \mu_i^2 (d^\top \Sigma_i^{-1} d) \right) \right ] \end{align*}$$

This analytic parameterization avoids per-pixel matrix inversion, supporting efficient rasterized implementation.

3. Moment Computation and Inversion

To characterize total density along each ray, per-pixel raw moments of density are computed:

$m_k = \int_{t_n}^{t_f} t^k \rho(t) dt$

High-order moments are susceptible to numerical instability; to mitigate this, the framework adopts either power-transformed moments $m_k = \int_{t_n}^{t_f} [g(t)]^k \rho(t) dt$ for monotonic $g$, or complex-exponential (Fourier) moments $m_k = \int e^{i a g(t)} \rho(t) dt$. For each split Gaussian, these admit closed-form solutions and stable recurrences:

• For $k=0$:

$$(m_0)_i = w_i' \sigma_i \sqrt{ \pi / 2 } [1 - \mathrm{erf}( (t_n - \mu_i) / (\sqrt{2} \sigma_i))]$$

• For $k=1$:

$$(m_1)_i = g(\mu_i) (m_0)_i - g'(\mu_i) w'_i \sigma_i^2 \exp[ -\tfrac{1}{2} ((t_n - \mu_i)/\sigma_i)^2 ]$$

• For $k\geq2$:

$$(m_k)_i = g(\mu_i) (m_{k-1})_i + B (m_{k-2})_i - B_i(k)$$

with $B$ and $B_i(k)$ as explicit analytic expressions.

Given the accumulated moments, inversion proceeds by forming the Hankel matrix $H_{ij} = m_{i+j}$, determining the “kernel polynomial” roots $\{x_j\}$, solving the Vandermonde system for weights $\{w_j\}$, and thus constructing pointwise lower/upper bounds on integrated density at any $t$. The interpolated optical depth $\hat{\tau}(t)$ is then computed and transmittance $T(t) = \exp(-\hat{\tau}(t))$ is obtained. This yields a differentiable, order-independent reconstruction of per-pixel transmittance.

4. Per-Gaussian Quadrature and Sampling

The pixel radiance is given by integrating, for each Gaussian $i$,

$$L_i = \int_{t_n}^{t_f} T(t_n \to t) \rho_i(t) \ell_i(d) dt$$

where $\ell_i(d)$ is the direction-dependent radiance (often represented via spherical harmonics). For practical evaluation, the interval $[t_n, t_f]$ is partitioned into $N$ nodes $\{t_j\}$, and a piecewise-constant quadrature is applied:

$$L_i \approx \sum_{j=1}^N [T(t_n \to t_j) - T(t_n \to t_{j+1})] \rho_i(t_j) \ell_i(d)$$

Importance sampling is achieved via precomputed standard-normal variates $x_j$ (e.g., Gauss–Hermite nodes), mapping to

$t_j = \mu_i + K \sigma_i x_j$

with $K\approx 3$, and clamping to $[t_n, t_f]$ as necessary. This “per-splat, inverse-CDF” importance strategy concentrates quadrature in regions of significant density and does not require sorting.

5. Algorithmic Pipeline and GPU Implementation

The rendering pipeline is implemented via a sequence of GPU rasterization passes (notably using Vulkan and Slang-D for adjoint derivatives):

1. Frustum Culling: Discard splats outside the current view frustum.
2. Moment Pass: Rasterize each splat and, in the pixel shader, compute $1\mathrm{D}$ projection parameters $(\mu_i, \sigma_i, w'_i)$, evaluate moments ${m_k}_i$ via recurrence, and accumulate per-pixel raw moments $m_k$.
3. Quadrature Pass: Given the per-pixel moments, reconstruct $T(t_n \to t)$ at sampling nodes $t_j$, and for each splat, evaluate the quadrature contribution to radiance and accumulate per-pixel penalties if required.
4. Final Composite: Perform per-pixel compositing, including opacity stabilization. The stabilization rescales total radiance based on the ratio of “true” scene opacity from $m_0$ ($1-e^{-m_0}$) to estimated opacity, and blends with the background contribution $L_{\mathrm{bg}}$:

$$L_{\mathrm{out}} = \frac{1-e^{-m_0}}{\max(\epsilon, O)} \sum_i L_i + e^{-m_0} L_{\mathrm{bg}}$$

1. Backward Pass (Differentiable Rendering): Consists of a two-pass adjoint rendering. The adjoint–moment pass computes derivatives $\partial C/\partial m_k$ w.r.t. loss $C$ via the chain rule, followed by a gradient pass that reduces over covered pixels to yield gradients $\partial C/\partial(w, p, \Sigma, f)$.

This pipeline is compatible with single-pass GPU rasterization and is fully differentiable, supporting end-to-end optimization.

6. Evaluation and Comparative Advantages

A comparative analysis highlights several salient differences:

Method	Sorting Required	Physical Accuracy	Rendering Cost
3DGS (alpha-blending)	Yes	Low in translucent overlaps	Low
Ray-traced Gaussian	No	High (volumetric correct)	High (BVH traversal)
Moment-based OIT	No	High (OIT, continuous)	Moderate

• Standard 3DGS uses order-dependent alpha blending with a single opacity parameter, producing artifacts in translucent overlaps.
• Ray-traced Gaussian primitives perform physically correct volumetric rendering at substantial per-pixel computational cost.
• Moment-based OIT reconstructs continuous, order-independent transmittance for overlapping Gaussian media, supporting single-pass rasterization and high differentiability. It improves visual fidelity and blending in complex translucent regions at moderate overhead compared to baseline 3DGS, and is orders of magnitude faster than ray-traced approaches (Müller et al., 12 Dec 2025).

A plausible implication is that moment-based OIT techniques, by bridging the gap between rasterization and physical accuracy, enable scalable and accurate novel-view synthesis across a range of semi-transparent volumetric scenes.

7. Broader Implications and Applications

Moment-based order-independent transparency, as instantiated in the described 3DGS extension, advances the state-of-the-art in real-time rendering of complex, semi-transparent volumetric scenes. It enables high-fidelity, physically consistent novel view synthesis for graphics, vision, and simulation tasks where both rendering speed and volumetric accuracy are paramount. Its order-independence, differentiability, and compatibility with modern GPU rasterization pipelines position it as a foundational technique for neural rendering, differentiable rendering, and physically based synthesis applications that handle complex occlusion and transmittance phenomena in real time (Müller et al., 12 Dec 2025).