@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/render/envlight.js

@@ -1,56 +1,34 @@
 import { Matrix4x4, DRef, Vector3, Vector2, Vector4, REVERSE_Z, Disposable } from '@zephyr3d/base';
 import { getSamplerOptions, fetchSampler } from '../utility/misc.js';
 import { getDevice } from '../app/api.js';
-import { decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
+import { getProbeVolumeForDraw } from './gi/probe_volume.js';
+import { declareProbeUniforms, sampleProbeIrradiance } from '../shaders/probes.js';
 
 /**
- * Depth-proportional term of the SSGI history rejection tolerance.
- *
- * The surface history stores `linearDepth * cameraFar` in an `rgba16f` alpha
- * channel, so its quantization error grows with depth: fp16 carries ~11 bits of
- * mantissa, giving a relative error near 4.9e-4 (~0.49 world units at a depth of
- * 1000). A purely absolute tolerance is therefore unusable in the distance -- at
- * `ssgiDepthReject`'s 0.5 default, storage quantization alone consumes the whole
- * budget and the test degenerates into dithered noise. This factor keeps roughly
- * 4x headroom over that error while staying far below the depth step of a real
- * disocclusion.
+ * Depth-proportional term of the SSGI history rejection tolerance. fp16 storage of
+ * `linearDepth * cameraFar` has ~4.9e-4 relative error; this keeps ~4x headroom
+ * while staying far below a real disocclusion's depth step.
  *
  * @internal
  */ const SSGI_DEPTH_TOLERANCE_RELATIVE = 2e-3;
 /**
- * Multiple of the scaled tolerance at which history is dropped outright.
- *
- * Inside this gate the depth term contributes a smooth `exp(-d/tol)` weight
- * rather than a boolean, so confidence decays continuously instead of flipping.
- * At 3x the weight is already down to ~0.05, making the cutoff visually
- * continuous -- which is what keeps a rejection boundary from reading as a
- * staircase after nearest-neighbour sampling quantizes it to texel steps.
+ * Multiple of the scaled tolerance at which history is dropped outright. Inside it
+ * the depth term is a smooth `exp(-d/tol)` weight (~0.05 at 3x), so the cutoff
+ * does not staircase.
  *
  * @internal
  */ const SSGI_DEPTH_GATE_SCALE = 3;
 /**
  * Clamp distance, in texels, at which history repair reaches its widest radius.
- *
- * The clamp distance says how far the reprojection had to travel to get back on
- * screen, which is a direct measure of how unrelated to this pixel the surviving
- * history is. It scales the repair radius rather than gating repair off: the
- * lighting pass only ever sees the previous frame, so a pixel rotating in from
- * off screen has no fresh data anywhere and both alternatives to spreading the
- * taps look worse than the blur does.
+ * Clamp travel measures how unrelated the surviving history is, so it scales the
+ * repair radius rather than gating repair off.
  *
  * @internal
  */ const SSGI_REPAIR_WIDE_CLAMP_TEXELS = 8;
 /**
- * Repair tap radius in texels, from an interior hole to a camera-edge one.
- *
- * The radius is what trades structure against smoothness. At one texel the taps
- * of neighbouring pixels barely overlap, so detail survives -- correct for a hole
- * in the middle of the screen, where the reprojection landed near its true
- * position. Wide taps instead overlap heavily between neighbours, which turns the
- * one strip of history that survives at a screen edge into a smooth low-frequency
- * estimate of the surface's irradiance rather than a per-column copy of single
- * texels, and copying single texels is what draws streaks along the direction of
- * travel.
+ * Repair tap radius in texels, from an interior hole to a camera-edge one. Narrow
+ * taps keep detail; wide taps average the surviving edge strip into a smooth
+ * estimate instead of copying single texels into streaks.
  *
  * @internal
  */ const SSGI_REPAIR_MIN_RADIUS_TEXELS = 1;
@@ -59,6 +37,77 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
  * Base class for any kind of environment light
  * @public
  */ class EnvironmentLighting extends Disposable {
+    /**
+   * Declares the scene's probe volume where the draw reads it (see
+   * {@link getProbeVolumeForDraw}); call from `initShaderBindings` in the fragment stage.
+   * @internal
+   */ initProbeBindings(pb, ctx) {
+        if (pb.shaderKind === 'fragment' && getProbeVolumeForDraw(ctx)) {
+            declareProbeUniforms(pb.getGlobalScope(), 0);
+        }
+    }
+    /** Binds what {@link EnvironmentLighting.initProbeBindings} declared. @internal */ updateProbeBindGroup(bg, ctx) {
+        getProbeVolumeForDraw(ctx)?.applyBindGroup(bg);
+    }
+    /**
+   * Specular occlusion from the probe volume's sky visibility. 1 where probes
+   * do not cover the fragment or without a `worldPos` varying.
+   * @internal
+   */ getSkySpecularOcclusion(scope, normal, NoV, roughness, ctx) {
+        const pb = scope.$builder;
+        if (!getProbeVolumeForDraw(ctx)) {
+            return pb.float(1);
+        }
+        const global = pb.getGlobalScope();
+        const worldPos = global.$inputs.worldPos;
+        if (!worldPos) {
+            return pb.float(1);
+        }
+        const funcName = 'Z_envSkySpecularOcclusion';
+        pb.func(funcName, [
+            pb.vec3('n'),
+            pb.vec3('p'),
+            pb.float('NoV'),
+            pb.float('roughness')
+        ], function() {
+            this.$l.sky = sampleProbeIrradiance(this, this.p, this.n, pb.sub(this.camera.position.xyz, this.p), 'sky');
+            this.$l.vis = pb.mix(pb.float(1), this.sky.r, this.sky.a);
+            this.$l.r2 = pb.mul(this.roughness, this.roughness);
+            this.$return(pb.clamp(pb.add(pb.sub(pb.pow(pb.add(this.NoV, this.vis), this.r2), 1), this.vis), 0, 1));
+        });
+        return global[funcName](normal, worldPos, NoV, roughness);
+    }
+    /**
+   * Turns raw sky irradiance into material shading irradiance: scaled by the environment
+   * strength, then replaced by probe GI where covered (probes are not scaled again).
+   * Needs the `worldPos` varying; returns the raw irradiance without a draw context.
+   * @internal
+   */ applyProbes(scope, normal, ctx, irradiance) {
+        const pb = scope.$builder;
+        if (!ctx) {
+            return irradiance;
+        }
+        // The light uniforms of the material's light pass; see ShaderHelper.getEnvLightStrength
+        const sky = pb.mul(irradiance, scope.light.envLightStrength);
+        if (!getProbeVolumeForDraw(ctx)) {
+            return sky;
+        }
+        const global = pb.getGlobalScope();
+        const worldPos = global.$inputs.worldPos;
+        if (!worldPos) {
+            return sky;
+        }
+        const funcName = 'Z_envIrradianceWithProbes';
+        pb.func(funcName, [
+            pb.vec3('n'),
+            pb.vec3('p'),
+            pb.vec3('env')
+        ], function() {
+            this.$l.probe = sampleProbeIrradiance(this, this.p, this.n, pb.sub(this.camera.position.xyz, this.p));
+            this.$return(pb.mix(this.env, this.probe.rgb, this.probe.a));
+        });
+        return global[funcName](normal, worldPos, sky);
+    }
 }
 /**
  * IBL with SH based environment lighting
@@ -76,9 +125,7 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
     /** @internal */ static UNIFORM_NAME_SSGI_TARGET_SIZE = 'zSSGITargetSize';
     /** @internal */ static UNIFORM_NAME_SSGI_REPROJECTION = 'zSSGIReprojection';
     /**
-   * Transforms a current-frame view-space position into previous-frame clip
-   * space, so the reprojected depth can be compared against the surface history
-   * in the frame that history was written in. @internal
+   * Current view space -> previous-frame clip space. @internal
    */ static UNIFORM_NAME_SSGI_VIEW_TO_PREV_CLIP = 'zSSGIViewToPrevClip';
     /** Unprojects a screen-space sample back into current view space. @internal */ static UNIFORM_NAME_SSGI_INV_PROJECTION = 'zSSGIInvProjection';
     /** Scratch for the view -> previous clip composition. @internal */ static _viewToPrevClip = new Matrix4x4();
@@ -163,8 +210,7 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
                 pb.getGlobalScope()[EnvShIBL.UNIFORM_NAME_IBL_IRRADIANCE_WINDOW] = pb.vec3().uniform(0);
             }
             if (EnvShIBL.hasSSGIHistory(ctx)) {
-                const irradianceSampler = pb.getDevice().type === 'webgl' ? 'clamp_nearest_nomip' : 'clamp_linear_nomip';
-                pb.getGlobalScope()[EnvShIBL.UNIFORM_NAME_SSGI_IRRADIANCE] = pb.tex2D().uniform(0).withSampler(getSamplerOptions(irradianceSampler));
+                pb.getGlobalScope()[EnvShIBL.UNIFORM_NAME_SSGI_IRRADIANCE] = pb.tex2D().uniform(0).withSampler(getSamplerOptions('clamp_linear_nomip'));
                 pb.getGlobalScope()[EnvShIBL.UNIFORM_NAME_SSGI_SURFACE] = pb.tex2D().uniform(0).withSampler(getSamplerOptions('clamp_nearest_nomip'));
                 pb.getGlobalScope()[EnvShIBL.UNIFORM_NAME_SSGI_CURRENT_DEPTH] = pb.tex2D().uniform(0).withSampler(getSamplerOptions('clamp_nearest_nomip'));
                 if (ctx?.motionVectorTexture) {
@@ -175,6 +221,7 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
                 pb.getGlobalScope()[EnvShIBL.UNIFORM_NAME_SSGI_VIEW_TO_PREV_CLIP] = pb.mat4().uniform(0);
                 pb.getGlobalScope()[EnvShIBL.UNIFORM_NAME_SSGI_INV_PROJECTION] = pb.mat4().uniform(0);
             }
+            this.initProbeBindings(pb, ctx);
         }
     }
     /**
@@ -196,7 +243,7 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
             bg.setValue(EnvShIBL.UNIFORM_NAME_IBL_IRRADIANCE_WINDOW, this.irradianceWindow);
         }
         if (EnvShIBL.hasSSGIHistory(ctx)) {
-            bg.setTexture(EnvShIBL.UNIFORM_NAME_SSGI_IRRADIANCE, ctx.SSGIIrradianceHistoryTexture, fetchSampler(ctx.device.type === 'webgl' ? 'clamp_nearest_nomip' : 'clamp_linear_nomip'));
+            bg.setTexture(EnvShIBL.UNIFORM_NAME_SSGI_IRRADIANCE, ctx.SSGIIrradianceHistoryTexture, fetchSampler('clamp_linear_nomip'));
             bg.setTexture(EnvShIBL.UNIFORM_NAME_SSGI_SURFACE, ctx.SSGISurfaceHistoryTexture, fetchSampler('clamp_nearest_nomip'));
             bg.setTexture(EnvShIBL.UNIFORM_NAME_SSGI_CURRENT_DEPTH, ctx.linearDepthTexture, fetchSampler('clamp_nearest_nomip'));
             if (ctx.motionVectorTexture) {
@@ -204,15 +251,13 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
             }
             bg.setValue(EnvShIBL.UNIFORM_NAME_SSGI_TARGET_SIZE, new Vector2(ctx.renderWidth, ctx.renderHeight));
             bg.setValue(EnvShIBL.UNIFORM_NAME_SSGI_REPROJECTION, new Vector4(ctx.camera.ssgiDepthReject, ctx.camera.ssgiNormalReject, ctx.camera.getFarPlane(), ctx.camera.getNearPlane()));
-            // View -> world -> previous clip. `prevVPMatrix` is null on the first frame
-            // after a history reset; falling back to the current VP makes the expected
-            // previous depth equal the current one, so the depth term is a no-op until
-            // a real previous frame exists.
+            // View -> world -> previous clip; without a previous VP the current one makes the depth term a no-op.
             const prevVP = ctx.camera.prevVPMatrix ?? ctx.camera.viewProjectionMatrix;
             Matrix4x4.multiply(prevVP, ctx.camera.worldMatrix, EnvShIBL._viewToPrevClip);
             bg.setValue(EnvShIBL.UNIFORM_NAME_SSGI_VIEW_TO_PREV_CLIP, EnvShIBL._viewToPrevClip);
             bg.setValue(EnvShIBL.UNIFORM_NAME_SSGI_INV_PROJECTION, ctx.camera.getInvProjectionMatrix());
         }
+        this.updateProbeBindGroup(bg, ctx);
     }
     /**
    * {@inheritDoc EnvironmentLighting.getRadiance}
@@ -306,7 +351,7 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
             }
             this.$return(this.c);
         });
-        const iblIrradiance = pb.getGlobalScope().Z_sh_eval(normal);
+        const iblIrradiance = this.applyProbes(scope, normal, ctx ?? null, pb.getGlobalScope().Z_sh_eval(normal));
         if (!EnvShIBL.hasSSGIHistory(ctx)) {
             return iblIrradiance;
         }
@@ -325,7 +370,8 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
                 this.$l.motionValid = pb.bool(true);
             }
             this.$l.params = this[EnvShIBL.UNIFORM_NAME_SSGI_REPROJECTION];
-            this.$l.fallback = pb.mul(this.ibl, this.light.envLightStrength);
+            // Already in the history's units: scaled by the environment strength, probes in place
+            this.$l.fallback = this.ibl;
             this.$l.normalizedCurrentNormal = pb.normalize(this.currentNormal);
             this.$l.depthTolerance = pb.max(this.params.x, 1e-4);
             this.$l.texelSize = pb.div(pb.vec2(1), this[EnvShIBL.UNIFORM_NAME_SSGI_TARGET_SIZE]);
@@ -336,22 +382,12 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
             this.$l.previousSurface = pb.textureSampleLevel(this[EnvShIBL.UNIFORM_NAME_SSGI_SURFACE], this.previousSampleUV, 0);
             this.$l.previousNormal = pb.normalize(pb.sub(pb.mul(this.previousSurface.rgb, 2), pb.vec3(1)));
             this.$l.currentDepthSample = pb.textureSampleLevel(this[EnvShIBL.UNIFORM_NAME_SSGI_CURRENT_DEPTH], this.uv, 0);
-            this.$l.currentDepth = pb.mul(pb.getDevice().type === 'webgl' ? decodeNormalizedFloatFromRGBA(this, this.currentDepthSample) : this.currentDepthSample.r, this.params.z);
-            // The surface history holds a Z measured in the *previous* frame's view
-            // space, so the current Z cannot be compared against it directly: under
-            // camera rotation a static, correctly reprojected point has
-            // `dz ~ r * sin(theta) * dphi`, which crosses any fixed threshold at the
-            // screen edges and drops history in the exact staircase pattern that
-            // nearest-neighbour sampling of the reprojected UV produces. Rebuild the
-            // current view-space position and push it through `view -> previous clip`
-            // instead; `clip.w` is `-view.z`, i.e. the same positive view-space
-            // distance the history stores.
+            this.$l.currentDepth = pb.mul(this.currentDepthSample.r, this.params.z);
+            // History Z is in the previous frame's view space; compare via view -> previous
+            // clip (`clip.w` = positive view distance) to avoid edge staircases under rotation.
             this.$l.ndc = pb.sub(pb.mul(this.uv, 2), pb.vec2(1));
             this.$l.nearPlaneRay = pb.mul(this[EnvShIBL.UNIFORM_NAME_SSGI_INV_PROJECTION], pb.vec4(this.ndc, REVERSE_Z ? 1 : -1, 1));
-            // Perspective unprojection of the near-plane NDC depth (GL -1, reverse
-            // ZO 1) lands on the near plane, where view z is exactly -near; scaling
-            // that ray by depth/near walks it out to the sample without a
-            // non-linear depth round trip.
+            // Unprojecting near-plane NDC depth lands at view z = -near; scale by depth/near.
             this.$l.viewPos = pb.mul(pb.div(this.nearPlaneRay.xyz, this.nearPlaneRay.w), pb.div(this.currentDepth, pb.max(this.params.w, 1e-6)));
             this.$l.expectedPreviousDepth = pb.mul(this[EnvShIBL.UNIFORM_NAME_SSGI_VIEW_TO_PREV_CLIP], pb.vec4(this.viewPos, 1)).w;
             this.$l.depthDelta = pb.abs(pb.sub(this.previousSurface.a, this.expectedPreviousDepth));
@@ -364,44 +400,27 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
             this.$l.previousAlpha = pb.clamp(this.previousIrradiance.a, 0, 1);
             this.$l.exactHistoryValid = pb.and(this.previousUVInBounds, this.depthValid, this.normalValid, pb.greaterThan(this.previousAlpha, 1e-4));
             this.$if(this.exactHistoryValid, function() {
-                // Weighting confidence by the depth term keeps the gate boundary a ramp
-                // rather than a step, so residual reprojection error on moving geometry
-                // and grazing surfaces fades out instead of outlining itself.
+                // Depth-weighted confidence ramps the gate boundary instead of stepping it.
                 this.$l.exactConfidence = pb.mul(this.previousAlpha, this.depthWeight);
                 this.$if(pb.greaterThan(this.exactConfidence, 1e-4), function() {
                     this.$return(pb.mix(this.fallback, this.previousIrradiance.rgb, this.exactConfidence));
                 });
             });
-            // Repair disoccluded and off-screen history from nearby samples before
-            // falling back to IBL. Sampling around the clamped reprojected position
-            // fills camera-edge holes, while current UV provides a conservative
-            // screen-stationary candidate for invalid motion vectors.
+            // Repair disoccluded/off-screen history from nearby samples before falling back to
+            // IBL: taps around the clamped reprojection, plus current UV for invalid motion.
             this.$l.repairCenter = this.$choice(this.motionValid, this.previousSampleUV, pb.clamp(this.uv, this.halfTexel, this.maxUV));
-            // How far the reprojection had to be clamped to land back on screen. For a
-            // hole in the interior this is zero and the taps really are neighbours of
-            // the reprojected point, but for geometry rotating in from off screen the
-            // clamp can travel hundreds of pixels -- and the depth and normal terms
-            // cannot catch that, because the edge texel it lands on is usually the same
-            // continuous surface (same normal, similar depth) merely sampled somewhere
-            // spatially unrelated. Its irradiance therefore belongs to a different part
-            // of the surface, so reading it as a point sample smears into streaks along
-            // the direction of travel. Drive the tap radius with it instead, trading
-            // that structure for a blur.
+            // Clamp travel back onto the screen: zero for interior holes, large for geometry
+            // rotating in, where the edge texel is the same surface but unrelated irradiance.
+            // It drives the tap radius, trading streaks for blur.
             this.$l.repairClampTexels = pb.div(pb.length(pb.sub(this.previousSampleUV, this.previousUV)), pb.max(pb.min(this.texelSize.x, this.texelSize.y), 1e-8));
-            // Widen the taps as the clamp travel grows. Only meaningful while the motion
-            // vector is usable: without one the centre is already the current UV by
-            // construction, so there is no travel to react to.
+            // Widen taps with clamp travel; only while motion vectors are usable.
             this.$l.repairRadius = pb.mix(pb.float(SSGI_REPAIR_MIN_RADIUS_TEXELS), pb.float(SSGI_REPAIR_MAX_RADIUS_TEXELS), this.$choice(this.motionValid, pb.smoothStep(0, SSGI_REPAIR_WIDE_CLAMP_TEXELS, this.repairClampTexels), pb.float(0)));
-            // Taps this far apart straddle real depth variation across the surface, so a
-            // gate tuned for immediate neighbours would reject most of them and bring
-            // the dark band back. Loosen it with the radius and lean on the normal term,
-            // which stays strict, to keep the average on one surface.
+            // Wide taps straddle real depth variation: loosen the depth gate with the radius
+            // and rely on the strict normal term.
             this.$l.repairDepthTolerance = pb.mul(this.scaledDepthTolerance, SSGI_DEPTH_GATE_SCALE, pb.add(1, this.repairRadius));
             this.$l.repairSum = pb.vec3(0);
             this.$l.repairWeight = pb.float(0);
-            // A full ring rather than a cross: at the wide end four taps are not an
-            // average but four distant point copies, and their axis alignment paints
-            // directional artifacts of its own.
+            // Full ring: four wide axis-aligned taps paint directional artifacts.
             const repairSamples = [
                 {
                     currentUV: false,
@@ -471,21 +490,16 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
                 this.$l[`repairUVValid${i}`] = pb.and(pb.all(pb.greaterThanEqual(this[`repairUV${i}`], this.halfTexel)), pb.all(pb.lessThanEqual(this[`repairUV${i}`], this.maxUV)));
                 this.$l[`repairSurface${i}`] = pb.textureSampleLevel(this[EnvShIBL.UNIFORM_NAME_SSGI_SURFACE], pb.clamp(this[`repairUV${i}`], this.halfTexel, this.maxUV), 0);
                 this.$l[`repairNormal${i}`] = pb.normalize(pb.sub(pb.mul(this[`repairSurface${i}`].rgb, 2), pb.vec3(1)));
-                // Compared against the reprojected depth, not the current one: the taps
-                // are samples of the previous frame's surface, so they live in the same
-                // space as `expectedPreviousDepth`.
+                // Compared against the reprojected depth: taps sample the previous frame's surface.
                 this.$l[`repairDepthDelta${i}`] = pb.abs(pb.sub(this[`repairSurface${i}`].a, this.expectedPreviousDepth));
                 this.$l[`repairNormalDot${i}`] = pb.dot(this.normalizedCurrentNormal, this[`repairNormal${i}`]);
                 this.$l[`repairSurfaceValid${i}`] = pb.and(this[`repairUVValid${i}`], pb.lessThanEqual(this[`repairDepthDelta${i}`], this.repairDepthTolerance), pb.greaterThanEqual(this[`repairNormalDot${i}`], this.params.y));
                 this.$l[`repairIrradiance${i}`] = pb.textureSampleLevel(this[EnvShIBL.UNIFORM_NAME_SSGI_IRRADIANCE], pb.clamp(this[`repairUV${i}`], this.halfTexel, this.maxUV), 0);
-                // Same widening as the hard gate above: a falloff tuned for immediate
-                // neighbours decays to nothing across a wide tap and starves the average.
+                // Same widening as the hard gate above.
                 this.$l[`repairDepthWeight${i}`] = pb.exp(pb.neg(pb.div(this[`repairDepthDelta${i}`], this.repairDepthTolerance)));
                 this.$l[`repairNormalWeight${i}`] = pb.pow(pb.max(0, this[`repairNormalDot${i}`]), 8);
-                this.$l[`repairSampleWeight${i}`] = pb.mul(pb.float(this[`repairSurfaceValid${i}`]), pb.clamp(this[`repairIrradiance${i}`].a, 0, 1), this[`repairDepthWeight${i}`], this[`repairNormalWeight${i}`], // The screen-stationary tap only exists to cover unusable motion
-                // vectors; while motion is valid it is a history read at the wrong world
-                // point, which survives the depth term on any flat surface and leaves a
-                // stationary ghost.
+                this.$l[`repairSampleWeight${i}`] = pb.mul(pb.float(this[`repairSurfaceValid${i}`]), pb.clamp(this[`repairIrradiance${i}`].a, 0, 1), this[`repairDepthWeight${i}`], this[`repairNormalWeight${i}`], // The screen-stationary tap only covers unusable motion vectors; otherwise it
+                // leaves a stationary ghost.
                 sample.currentUV ? pb.float(pb.not(this.motionValid)) : pb.float(1), sample.kernel);
                 this.repairSum = pb.add(this.repairSum, pb.mul(this[`repairIrradiance${i}`].rgb, this[`repairSampleWeight${i}`]));
                 this.repairWeight = pb.add(this.repairWeight, this[`repairSampleWeight${i}`]);
@@ -502,7 +516,7 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
         return scope.Z_ssgi_reprojectIrradiance(normal, iblIrradiance);
     }
     /** Whether all textures required by the lighting reprojection are scoped. @internal */ static hasSSGIHistory(ctx) {
-        return !!(ctx?.SSGI && ctx.SSGIIrradianceHistoryTexture && ctx.SSGISurfaceHistoryTexture && (ctx.device.type === 'webgl' || ctx.motionVectorTexture) && ctx.linearDepthTexture);
+        return !!(ctx?.SSGI && ctx.SSGIIrradianceHistoryTexture && ctx.SSGISurfaceHistoryTexture && ctx.motionVectorTexture && ctx.linearDepthTexture);
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasRadiance}
@@ -563,46 +577,52 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
     /**
    * {@inheritDoc EnvironmentLighting.initShaderBindings}
    * @override
-   */ initShaderBindings(pb) {
+   */ initShaderBindings(pb, ctx) {
         if (pb.shaderKind === 'fragment') {
             pb.getGlobalScope()[EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT] = pb.vec4().uniform(0);
+            this.initProbeBindings(pb, ctx);
         }
     }
     /**
    * {@inheritDoc EnvironmentLighting.updateBindGroup}
    * @override
-   */ updateBindGroup(bg) {
+   */ updateBindGroup(bg, ctx) {
         bg.setValue(EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT, this._ambientColor);
+        this.updateProbeBindGroup(bg, ctx);
     }
     /**
    * {@inheritDoc EnvironmentLighting.getRadiance}
    * @override
-   */ getRadiance(_scope, _refl, _roughness) {
-        return null;
+   *
+   * @remarks
+   * A uniform environment prefilters to itself, so radiance is the ambient color. It
+   * must be present: at grazing angles specular takes the diffuse energy, else silhouettes go black.
+   */ getRadiance(scope, _refl, _roughness) {
+        return scope[EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT].rgb;
     }
     /**
    * {@inheritDoc EnvironmentLighting.getSheenRadiance}
    * @override
-   */ getSheenRadiance(_scope, _refl, _roughness) {
-        return null;
+   */ getSheenRadiance(scope, refl, roughness) {
+        return this.getRadiance(scope, refl, roughness);
     }
     /**
    * {@inheritDoc EnvironmentLighting.getIrradiance}
    * @override
-   */ getIrradiance(scope, _normal) {
-        return scope[EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT].rgb;
+   */ getIrradiance(scope, normal, ctx) {
+        return this.applyProbes(scope, normal, ctx ?? null, scope[EnvConstantAmbient.UNIFORM_NAME_CONSTANT_AMBIENT].rgb);
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasRadiance}
    * @override
    */ hasRadiance() {
-        return false;
+        return true;
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasSheenRadiance}
    * @override
    */ hasSheenRadiance() {
-        return false;
+        return true;
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasIrradiance}
@@ -653,18 +673,20 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
     /**
    * {@inheritDoc EnvironmentLighting.initShaderBindings}
    * @override
-   */ initShaderBindings(pb) {
+   */ initShaderBindings(pb, ctx) {
         if (pb.shaderKind === 'fragment') {
             pb.getGlobalScope()[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP] = pb.vec4().uniform(0);
             pb.getGlobalScope()[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN] = pb.vec4().uniform(0);
+            this.initProbeBindings(pb, ctx);
         }
     }
     /**
    * {@inheritDoc EnvironmentLighting.updateBindGroup}
    * @override
-   */ updateBindGroup(bg) {
+   */ updateBindGroup(bg, ctx) {
         bg.setValue(EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP, this._ambientUp);
         bg.setValue(EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN, this._ambientDown);
+        this.updateProbeBindGroup(bg, ctx);
     }
     /**
    * {@inheritDoc EnvironmentLighting.getRadiance}
@@ -683,10 +705,10 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
     /**
    * {@inheritDoc EnvironmentLighting.getIrradiance}
    * @override
-   */ getIrradiance(scope, normal) {
+   */ getIrradiance(scope, normal, ctx) {
         const pb = scope.$builder;
         const factor = pb.add(pb.mul(normal.y, 0.5), 0.5);
-        return pb.mix(scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN], scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP], factor).rgb;
+        return this.applyProbes(scope, normal, ctx ?? null, pb.mix(scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_DOWN], scope[EnvHemisphericAmbient.UNIFORM_NAME_AMBIENT_UP], factor).rgb);
     }
     /**
    * {@inheritDoc EnvironmentLighting.hasRadiance}
@@ -707,6 +729,67 @@ const SSGI_REPAIR_MAX_RADIUS_TEXELS = 16;
         return true;
     }
 }
+/**
+ * Environment lighting for type `none`: no sky, only probe-volume GI over black,
+ * since bounced scene light does not depend on the environment. Used only while
+ * the probe volume is ready.
+ * @internal
+ */ class EnvProbesOnly extends EnvironmentLighting {
+    /**
+   * {@inheritDoc EnvironmentLighting.getType}
+   * @override
+   */ getType() {
+        return 'none';
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.initShaderBindings}
+   * @override
+   */ initShaderBindings(pb, ctx) {
+        this.initProbeBindings(pb, ctx);
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.updateBindGroup}
+   * @override
+   */ updateBindGroup(bg, ctx) {
+        this.updateProbeBindGroup(bg, ctx);
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getRadiance}
+   * @override
+   */ getRadiance(_scope, _refl, _roughness) {
+        return null;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getSheenRadiance}
+   * @override
+   */ getSheenRadiance(_scope, _refl, _roughness) {
+        return null;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.getIrradiance}
+   * @override
+   */ getIrradiance(scope, normal, ctx) {
+        return this.applyProbes(scope, normal, ctx ?? null, scope.$builder.vec3(0));
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasRadiance}
+   * @override
+   */ hasRadiance() {
+        return false;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasSheenRadiance}
+   * @override
+   */ hasSheenRadiance() {
+        return false;
+    }
+    /**
+   * {@inheritDoc EnvironmentLighting.hasIrradiance}
+   * @override
+   */ hasIrradiance() {
+        return true;
+    }
+}
 
-export { EnvConstantAmbient, EnvHemisphericAmbient, EnvShIBL, EnvironmentLighting };
+export { EnvConstantAmbient, EnvHemisphericAmbient, EnvProbesOnly, EnvShIBL, EnvironmentLighting };
 //# sourceMappingURL=envlight.js.map