Add foveated contribution culling to the GPU-sort gsplat renderer (#8869)

Raises the contribution-culling threshold radially from the screen centre, so
low-impact splats are culled increasingly toward the edges where peripheral
overdraw dominates XR frame cost. Effective threshold:
minContribution + foveationStrength * smoothstep(foveationCenter, 1, length(ndc))

- GSplatParams: new foveationStrength (default 0 = off) and foveationCenter
  (default 0.3, protected-centre radius) — GPU-sort (hybrid) renderer only.
- Projector: values plumbed via dispatch params and the projector UBO; the
  cull in computeSplatCov applies the radial boost (exact no-op at strength 0).
- Compute-local renderer is unaffected (passes inert constants).
- vr-lod example: in-XR HUD number row to tune strength (+/- 5, 0..50).

Co-authored-by: Martin Valigursky <mvaligursky@snapchat.com>

Author: mvaligursky

examples/src/examples/gaussian-splatting-xr/vr-lod.example.mjs

@@ -216,6 +216,8 @@ assetListLoader.load(() => {
     data.set('splatBudget', 2);
     // XR framebuffer scale factor (applied only when starting an XR session; does not affect 2D).
     data.set('framebufferScaleFactor', 1);
+    // Foveated contribution culling strength (GPU-sort renderer only; 0 = off).
+    data.set('foveationStrength', 0);
     data.set('data.stats.gsplats', '—');
     data.set('data.stats.resolution', '—');
 
@@ -288,7 +290,9 @@ assetListLoader.load(() => {
                 { type: 'number', label: 'Contribution', value: '5', decEvent: 'contribution:dec', incEvent: 'contribution:inc' },
                 // [7] number row: alphaClipForward, stepped 1/255 .. 1/2
                 { type: 'number', label: 'AlphaClip', value: '1/16', decEvent: 'alphaclip:dec', incEvent: 'alphaclip:inc' },
-                { label: 'EXIT XR', eventName: 'xr:end' } // [8] interactive: ends the XR session
+                // [8] number row: foveated contribution culling strength (GPU-sort renderer only)
+                { type: 'number', label: 'FovCull', value: '0.0', decEvent: 'fovcull:dec', incEvent: 'fovcull:inc' },
+                { label: 'EXIT XR', eventName: 'xr:end' } // [9] interactive: ends the XR session
             ],
             fontAsset: assets.font,
             alwaysVisible: true,
@@ -387,6 +391,23 @@ assetListLoader.load(() => {
     });
     applyAlphaClip(); // seed the readout
 
+    // Foveated contribution culling strength (number row [8]). +/- 5, clamped to 0..50
+    // (default 0 = off). Only affects the GPU-sort (hybrid) renderer.
+    const FOVCULL_ROW = 8;
+    const applyFovCull = () => {
+        const v = data.get('foveationStrength') ?? 0;
+        app.scene.gsplat.foveationStrength = v;
+        xrHud?.setItemValue(FOVCULL_ROW, v.toFixed(1));
+    };
+    data.on('foveationStrength:set', applyFovCull);
+    app.on('fovcull:dec', () => {
+        data.set('foveationStrength', Math.max(0, (data.get('foveationStrength') ?? 0) - 5));
+    });
+    app.on('fovcull:inc', () => {
+        data.set('foveationStrength', Math.min(50, (data.get('foveationStrength') ?? 0) + 5));
+    });
+    applyFovCull(); // seed the engine value and readout
+
     /** @type {pc.Entity|null} */
     let gsplatEntity = null;
     /** @type {any} */

src/scene/gsplat-unified/gsplat-manager.js

@@ -1762,6 +1762,8 @@ class GSplatManager {
             alphaClip,
             minPixelSize: gsplat.minPixelSize * 0.5,
             minContribution: gsplat.minContribution,
+            foveationStrength: gsplat.foveationStrength,
+            foveationCenter: gsplat.foveationCenter,
             viewportWidth,
             viewportHeight,
             flipY: !!cameraNode.camera.renderTarget?.flipY,

src/scene/gsplat-unified/gsplat-params.js

@@ -72,6 +72,8 @@ class GSplatParams {
         this._material.setParameter('alphaClipForward', 1.0 / 255.0);
         this._material.setParameter('minPixelSize', 2.0);
         this._material.setParameter('minContribution', 3.0);
+        this._material.setParameter('foveationStrength', 0);
+        this._material.setParameter('foveationCenter', 0.3);
     }
 
     /**
@@ -658,6 +660,53 @@ class GSplatParams {
         return this._material.getParameter('minContribution')?.data ?? 3.0;
     }
 
+    /**
+     * Sets the foveated contribution culling strength. Only used by the
+     * {@link GSPLAT_RENDERER_RASTER_GPU_SORT} renderer. When greater than zero, the contribution
+     * culling threshold is raised radially from the screen centre: the effective threshold is
+     * `minContribution + foveationStrength * smoothstep(foveationCenter, 1, length(ndc))`, so the
+     * centre of the screen is unaffected and low-contribution splats are culled increasingly
+     * toward the edges, reaching full strength at the screen edge and beyond (corners). Set to 0
+     * to disable. Defaults to 0.
+     *
+     * @type {number}
+     */
+    set foveationStrength(value) {
+        this._material.setParameter('foveationStrength', value);
+        this._material.update();
+    }
+
+    /**
+     * Gets the foveated contribution culling strength.
+     *
+     * @type {number}
+     */
+    get foveationStrength() {
+        return this._material.getParameter('foveationStrength')?.data ?? 0;
+    }
+
+    /**
+     * Sets the protected centre radius for foveated contribution culling. Only used by the
+     * {@link GSPLAT_RENDERER_RASTER_GPU_SORT} renderer. Expressed in NDC radius units (0 at the
+     * screen centre, 1 at the edge): within this radius {@link foveationStrength} has no effect,
+     * and the falloff ramps smoothly from this radius to the screen edge. Defaults to 0.3.
+     *
+     * @type {number}
+     */
+    set foveationCenter(value) {
+        this._material.setParameter('foveationCenter', value);
+        this._material.update();
+    }
+
+    /**
+     * Gets the protected centre radius for foveated contribution culling.
+     *
+     * @type {number}
+     */
+    get foveationCenter() {
+        return this._material.getParameter('foveationCenter')?.data ?? 0.3;
+    }
+
     /**
      * Enables anti-aliasing compensation for Gaussian splats. Defaults to false.
      *

src/scene/gsplat-unified/gsplat-projector.js

@@ -271,7 +271,9 @@ class GSplatProjector {
             new UniformFormat('alphaClip', UNIFORMTYPE_FLOAT),
             new UniformFormat('minContribution', UNIFORMTYPE_FLOAT),
             new UniformFormat('minDist', UNIFORMTYPE_FLOAT),
-            new UniformFormat('invRange', UNIFORMTYPE_FLOAT)
+            new UniformFormat('invRange', UNIFORMTYPE_FLOAT),
+            new UniformFormat('foveationStrength', UNIFORMTYPE_FLOAT),
+            new UniformFormat('foveationCenter', UNIFORMTYPE_FLOAT)
         ];
 
         this._projectorUniformBufferFormat = new UniformBufferFormat(device, baseFields);
@@ -590,6 +592,10 @@ class GSplatProjector {
      * @param {number} params.alphaClip - Alpha cull threshold.
      * @param {number} params.minPixelSize - Minimum on-screen pixel size before culling.
      * @param {number} params.minContribution - Minimum total contribution before culling.
+     * @param {number} params.foveationStrength - Foveated culling strength added to
+     * `minContribution` toward the screen edges (0 disables).
+     * @param {number} params.foveationCenter - Protected centre radius (NDC units) within which
+     * foveated culling has no effect.
      * @param {number} params.viewportWidth - Render viewport width in pixels.
      * @param {number} params.viewportHeight - Render viewport height in pixels.
      * @param {boolean} params.flipY - Whether the active render target uses `flipY` (must match
@@ -610,6 +616,7 @@ class GSplatProjector {
             workBuffer, cameraNode, compactedSplatIds, sortElementCountBuffer,
             totalCapacity, radialSort, numBits, minDist, maxDist,
             alphaClip, minPixelSize, minContribution,
+            foveationStrength = 0, foveationCenter = 0.3,
             viewportWidth, viewportHeight, flipY,
             pickMode = false,
             fisheyeProj,
@@ -734,6 +741,8 @@ class GSplatProjector {
         compute.setParameter('alphaClip', alphaClip);
         compute.setParameter('minPixelSize', minPixelSize);
         compute.setParameter('minContribution', minContribution);
+        compute.setParameter('foveationStrength', foveationStrength);
+        compute.setParameter('foveationCenter', foveationCenter);
         compute.setParameter('isOrtho', cam.projection === PROJECTION_ORTHOGRAPHIC ? 1 : 0);
         compute.setParameter('splatTextureSize', workBuffer.textureSize);
         compute.setParameter('numBins', GSplatSortBinWeights.NUM_BINS);

src/scene/shader-lib/wgsl/chunks/gsplat/compute-gsplat-common.js

@@ -46,6 +46,8 @@ fn computeSplatCov(
     isOrtho: u32,
     alphaClip: f32,
     minContribution: f32,
+    foveationStrength: f32,
+    foveationCenter: f32,
     #ifdef GSPLAT_FISHEYE
         fisheye_k: f32,
         fisheye_inv_k: f32,
@@ -174,8 +176,18 @@ fn computeSplatCov(
     // Rejects splats whose total visual contribution (opacity * projected area) is
     // negligible. Near the camera, projected areas are large so contributions naturally
     // exceed the threshold; at distance, areas shrink and low-impact splats are culled.
+    //
+    // Foveation: the threshold is raised radially from the screen centre. Within
+    // foveationCenter (NDC radius) there is no effect; the boost ramps with a smoothstep
+    // to full foveationStrength at the screen edge (r = 1) and beyond (corners). With
+    // strength 0 this is an exact no-op.
+    let fovNdc = screen * vec2f(2.0 / viewportWidth, 2.0 / viewportHeight) - vec2f(1.0);
+    // manual smoothstep with a guard so foveationCenter near 1.0 cannot divide by zero
+    let fovT = saturate((length(fovNdc) - foveationCenter) / max(1.0 - foveationCenter, 1e-4));
+    let effMinContribution = minContribution + foveationStrength * fovT * fovT * (3.0 - 2.0 * fovT);
+
     let totalContribution = opacity * 6.283185 * sqrt(det);
-    if (totalContribution < minContribution) {
+    if (totalContribution < effMinContribution) {
         return result;
     }
 

src/scene/shader-lib/wgsl/chunks/gsplat/compute-gsplat-local-tile-count.js

@@ -101,6 +101,8 @@ fn main(
         uniforms.alphaClip,
         uniforms.minPixelSize,
         uniforms.minContribution,
+        // foveated culling is not supported by the compute-local renderer (strength 0 = off)
+        0.0, 0.3,
         uniforms.viewMatrix,
         uniforms.viewProj,
         uniforms.focal,

src/scene/shader-lib/wgsl/chunks/gsplat/compute-gsplat-project-common.js

@@ -32,6 +32,8 @@ fn projectSplatCommon(
     alphaClip: f32,
     minPixelSize: f32,
     minContribution: f32,
+    foveationStrength: f32,
+    foveationCenter: f32,
     viewMatrix: mat4x4f,
     viewProj: mat4x4f,
     focal: f32,
@@ -78,6 +80,7 @@ fn projectSplatCommon(
         focal, viewportWidth, viewportHeight,
         nearClip, farClip, opacity, minPixelSize,
         isOrtho, alphaClip, minContribution,
+        foveationStrength, foveationCenter,
         #ifdef GSPLAT_FISHEYE
             fisheye_k, fisheye_inv_k,
             fisheye_projMat00, fisheye_projMat11,

src/scene/shader-lib/wgsl/chunks/gsplat/compute-gsplat-projector.js

@@ -57,6 +57,8 @@ struct ProjectorUniforms {
     minContribution: f32,
     minDist: f32,
     invRange: f32,
+    foveationStrength: f32,
+    foveationCenter: f32,
     #ifdef GSPLAT_XR
         // Eye-1 view-projection (raw XR projViewOffMat). Eye 0 uses viewProj above.
         // Appended only for the stereo variant - matches the conditional CPU UBO field.
@@ -118,6 +120,8 @@ fn main(
         uniforms.alphaClip,
         uniforms.minPixelSize,
         uniforms.minContribution,
+        uniforms.foveationStrength,
+        uniforms.foveationCenter,
         uniforms.viewMatrix,
         uniforms.viewProj,
         uniforms.focal,