@zephyr3d/scene 0.9.22 → 0.9.24

package/dist/posteffect/ssgi.js

@@ -1,10 +1,7 @@
-import { AbstractPostEffect, PostEffectLayer } from './posteffect.js';
-import { linearToGamma } from '../shaders/misc.js';
+import { Vector2, Matrix4x4, Vector4, DEPTH_FARTHEST } from '@zephyr3d/base';
+import { FrameResources } from '../render/rendergraph/blackboard.js';
+import { RGHistoryResources } from '../render/rendergraph/history_resources.js';
 import { screenSpaceRayTracing_HiZ, screenSpaceRayTracing_Linear2D } from '../shaders/ssr.js';
-import { SSGI_rand2, SSGI_cosineSampleHemisphere } from '../shaders/ssgi.js';
-import { Vector2, Matrix4x4, Vector4 } from '@zephyr3d/base';
-import { copyTexture, fetchSampler } from '../utility/misc.js';
-import { BilateralBlurBlitter } from '../blitter/bilateralblur.js';
 import { ShaderHelper } from '../material/shader/helper.js';
 import '../material/lambert.js';
 import '../material/blinn.js';
@@ -24,92 +21,203 @@ import '../material/pbrblueprint.js';
 import '../material/sprite.js';
 import '../material/sprite_std.js';
 import '../utility/blueprint/material/texture.js';
-import { RGHistoryResources } from '../render/rendergraph/history_resources.js';
-import { FrameResources } from '../render/rendergraph/blackboard.js';
+import { linearToGamma } from '../shaders/misc.js';
+import { fetchSampler } from '../utility/misc.js';
+import { AbstractPostEffect, PostEffectLayer } from './posteffect.js';
 
-/**
- * SSGI post effect
- *
- * @remarks
- * Screen space global illumination: gathers one-bounce indirect diffuse
- * lighting by cosine-weighted hemisphere ray marching against the scene
- * depth buffer (Hi-Z accelerated when available), then denoises the result
- * with a bilateral blur and optional temporal accumulation before adding
- * it to the scene color. Internal used in light pass.
- *
- * @internal
+const IRRADIANCE_FORMAT = 'rgba16f';
+const SURFACE_FORMAT = 'rgba16f';
+const MOMENTS_FORMAT = 'rgba16f';
+// AO is scalar; r16f is available wherever SSGI runs.
+const AO_FORMAT = 'r16f';
+const HALF_FLOAT_MAX = 65504;
+// Keep squared luminance below the rgba16f range.
+const MOMENT_LUMINANCE_MAX = 255;
+/**
+ * Screen-space diffuse global illumination.
+ *
+ * @public
  */ class SSGI extends AbstractPostEffect {
     static _tracePrograms = {};
-    static _combineProgram;
-    static _temporalProgram;
-    static _blurBlitterH = null;
-    static _blurBlitterV = null;
-    _traceBindGroups;
-    _combineBindGroup;
-    _temporalBindGroup;
-    /**
-   * Creates an instance of SSGI post effect
-   */ constructor(){
+    static _temporalPrograms = {};
+    static _atrousProgram = null;
+    static _surfaceProgram = null;
+    static _upsampleProgram = null;
+    static _compositePrograms = {};
+    _traceBindGroups = {};
+    _temporalBindGroups = {};
+    _atrousBindGroups = {};
+    _surfaceBindGroups = {};
+    _upsampleBindGroups = {};
+    _compositeBindGroups = {};
+    constructor(){
         super();
         this._layer = PostEffectLayer.opaque;
-        this._traceBindGroups = {};
-        this._combineBindGroup = null;
-        this._temporalBindGroup = null;
     }
-    /** {@inheritDoc AbstractPostEffect.requireLinearDepthTexture} */ requireLinearDepthTexture() {
-        return true;
-    }
-    /** {@inheritDoc AbstractPostEffect.requireDepthAttachment} */ requireDepthAttachment() {
-        return true;
+    /** {@inheritDoc AbstractPostEffect.requireLinearDepthTexture} */ requireLinearDepthTexture(ctx) {
+        return !!ctx.SSGI;
     }
     /** {@inheritDoc AbstractPostEffect.requireMotionVectorTexture} */ requireMotionVectorTexture(ctx) {
-        return !!ctx.camera.ssgiTemporal;
+        return !!ctx.SSGI && ctx.device.type === 'webgpu';
+    }
+    /** {@inheritDoc AbstractPostEffect.requireHiZTexture} */ requireHiZTexture(ctx) {
+        return !!ctx.SSGI && ctx.device.type === 'webgpu';
     }
-    /**
-   * Declares SSGI's internal steps (trace, optional bilateral blur, optional
-   * temporal resolve, combine) as individual render graph passes.
-   */ setup(s) {
-        const { graph, ctx, history } = s;
-        // SSGI needs the surface normal MRT and dynamic loops; neither is
-        // available on WebGL1. Pass the input through untouched in that case.
-        if (ctx.device.type === 'webgl' || !s.blackboard.get(FrameResources.SSRNormal)) {
+    /** {@inheritDoc AbstractPostEffect.requireSceneNormalTexture} */ requireSceneNormalTexture(ctx) {
+        return !!ctx.SSGI;
+    }
+    /** Build trace, temporal, denoise, upsample, history and pass-through stages. */ setup(s) {
+        const { graph, ctx, history, blackboard } = s;
+        if (!ctx.SSGI || !history) {
             return s.input;
         }
-        const camera = ctx.camera;
-        const halfRes = !!camera.ssgiHalfResolution;
-        const traceWidth = Math.max(1, halfRes ? s.width >> 1 : s.width);
-        const traceHeight = Math.max(1, halfRes ? s.height >> 1 : s.height);
-        const linearDepthHandle = s.blackboard.get(FrameResources.LinearDepth);
-        const texDesc = {
-            format: 'rgba16f',
+        const linearDepthHandle = blackboard.get(FrameResources.LinearDepth);
+        const normalHandle = blackboard.get(FrameResources.SceneNormal);
+        const motionHandle = blackboard.get(FrameResources.MotionVector);
+        const hiZHandle = blackboard.get(FrameResources.HiZ);
+        // Traced hits read this as outgoing surface radiance, so it must exclude the
+        // fog the camera ray accumulated: that fog belongs to a different path than
+        // the one being integrated, and feeding it back would brighten every bounce.
+        // Absent when the scene has no fog, in which case SceneColor is already fog
+        // free. Both the sampled color and the committed history use it, otherwise
+        // the current and previous frames would disagree and flicker.
+        const noFogHandle = blackboard.get(FrameResources.SceneColorNoFog);
+        const sampleColorHandle = noFogHandle ?? s.input;
+        if (!linearDepthHandle || !normalHandle) {
+            return s.input;
+        }
+        const settings = ctx.camera.ssgiResolvedSettings;
+        const traceWidth = settings.halfRes ? Math.max(1, Math.ceil(s.width * 0.5)) : s.width;
+        const traceHeight = settings.halfRes ? Math.max(1, Math.ceil(s.height * 0.5)) : s.height;
+        const traceSize = {
+            width: traceWidth,
+            height: traceHeight
+        };
+        const fullSize = {
+            width: s.width,
+            height: s.height
+        };
+        const traceDesc = {
+            format: IRRADIANCE_FORMAT,
             sizeMode: 'absolute',
             width: traceWidth,
             height: traceHeight
         };
-        const readCommon = (builder)=>{
-            if (linearDepthHandle) {
-                builder.read(linearDepthHandle);
+        const fullIrradianceDesc = {
+            format: IRRADIANCE_FORMAT,
+            sizeMode: 'absolute',
+            width: s.width,
+            height: s.height
+        };
+        const surfaceDesc = {
+            format: SURFACE_FORMAT,
+            sizeMode: 'absolute',
+            width: s.width,
+            height: s.height
+        };
+        const momentsDesc = {
+            format: MOMENTS_FORMAT,
+            sizeMode: 'absolute',
+            width: traceWidth,
+            height: traceHeight
+        };
+        const aoTraceDesc = {
+            format: AO_FORMAT,
+            sizeMode: 'absolute',
+            width: traceWidth,
+            height: traceHeight
+        };
+        const fullAODesc = {
+            format: AO_FORMAT,
+            sizeMode: 'absolute',
+            width: s.width,
+            height: s.height
+        };
+        const findHistoryRead = (name)=>s.historyReads.find((binding)=>binding.name === name)?.handle ?? null;
+        const previousIrradianceHandle = findHistoryRead(RGHistoryResources.SSGI_IRRADIANCE);
+        const previousSurfaceHandle = findHistoryRead(RGHistoryResources.SSGI_SURFACE);
+        const previousMomentsHandle = history.importPreviousIfCompatible(graph, RGHistoryResources.SSGI_MOMENTS, momentsDesc, traceSize);
+        // Only this effect's own temporal pass reads the AO history, so it is
+        // imported directly instead of being routed through the light pass history
+        // read bindings the way irradiance and surface are.
+        const previousAOHandle = history.importPreviousIfCompatible(graph, RGHistoryResources.SSGI_AO, aoTraceDesc, traceSize);
+        const previousSceneColorHandle = ctx.device.type === 'webgpu' ? history.importPreviousIfCompatible(graph, RGHistoryResources.SSGI_SCENE_COLOR, {
+            format: s.colorFormat,
+            sizeMode: 'absolute',
+            width: s.width,
+            height: s.height
+        }, fullSize) : null;
+        const canSampleSceneHistory = !!(previousSceneColorHandle && previousSurfaceHandle && motionHandle);
+        const readFrameInputs = (builder)=>{
+            builder.read(linearDepthHandle);
+            builder.read(normalHandle);
+            if (motionHandle) {
+                builder.read(motionHandle);
+            }
+            if (hiZHandle) {
+                builder.read(hiZHandle);
             }
-            // Normal MRT, HiZ and the scene color are reached through DrawContext
-            // fields; the dependency list carries their handles.
             for (const dep of s.dependencies){
                 builder.read(dep);
             }
         };
-        const getLinearDepth = (rg)=>linearDepthHandle ? rg.getTexture(linearDepthHandle) : ctx.linearDepthTexture;
-        // 1. Trace cosine-weighted hemisphere rays against the depth buffer and
-        // gather the radiance at the hit points.
-        const traceHandle = graph.addPass('SSGI:Trace', (builder)=>{
-            builder.read(s.input);
-            readCommon(builder);
+        // Trace one or two cosine-weighted diffuse rays. A hit prefers the previous
+        // frame through previousHitUV = hitUV - motion(hitUV) for multi-bounce
+        // feedback and falls back to the current frame when that reprojection fails.
+        const traceResult = graph.addPass('SSGI:Trace', (builder)=>{
+            builder.read(sampleColorHandle);
+            readFrameInputs(builder);
+            if (canSampleSceneHistory) {
+                builder.read(previousSceneColorHandle);
+                builder.read(previousSurfaceHandle);
+            }
             const out = builder.createTexture({
-                ...texDesc,
-                label: 'SSGI:trace'
+                ...traceDesc,
+                label: 'SSGI:rawIrradiance'
+            });
+            const ao = builder.createTexture({
+                ...aoTraceDesc,
+                label: 'SSGI:rawAO'
             });
             const fb = builder.createFramebuffer({
                 label: 'SSGI:traceFB',
                 width: traceWidth,
                 height: traceHeight,
+                colorAttachments: [
+                    out,
+                    ao
+                ],
+                depthAttachment: null,
+                ignoreDepthStencil: true
+            });
+            builder.setExecute((rg)=>{
+                const device = ctx.device;
+                device.pushDeviceStates();
+                try {
+                    device.setFramebuffer(rg.getFramebuffer(fb));
+                    this.trace(ctx, rg.getTexture(sampleColorHandle), canSampleSceneHistory ? rg.getTexture(previousSceneColorHandle) : null, rg.getTexture(linearDepthHandle), rg.getTexture(normalHandle), canSampleSceneHistory ? rg.getTexture(motionHandle) : null, canSampleSceneHistory ? rg.getTexture(previousSurfaceHandle) : null, hiZHandle ? rg.getTexture(hiZHandle) : null, traceWidth, traceHeight);
+                } finally{
+                    device.popDeviceStates();
+                }
+            });
+            return {
+                irradiance: out,
+                ao
+            };
+        });
+        // Store the current full-resolution surface independently from irradiance;
+        // no albedo MRT is needed because the next lighting pass applies the BRDF.
+        const surfaceHandle = graph.addPass('SSGI:Surface', (builder)=>{
+            builder.read(linearDepthHandle);
+            builder.read(normalHandle);
+            const out = builder.createTexture({
+                ...surfaceDesc,
+                label: 'SSGI:surface'
+            });
+            const fb = builder.createFramebuffer({
+                label: 'SSGI:surfaceFB',
+                width: s.width,
+                height: s.height,
                 colorAttachments: out,
                 depthAttachment: null,
                 ignoreDepthStencil: true
@@ -119,52 +227,97 @@ import { FrameResources } from '../render/rendergraph/blackboard.js';
                 device.pushDeviceStates();
                 try {
                     device.setFramebuffer(rg.getFramebuffer(fb));
-                    this.trace(ctx, rg.getTexture(s.input), getLinearDepth(rg));
+                    this.writeSurface(ctx, rg.getTexture(linearDepthHandle), rg.getTexture(normalHandle));
                 } finally{
                     device.popDeviceStates();
                 }
             });
             return out;
         });
-        // 2. Temporal accumulation BEFORE the spatial blur: accumulating the raw
-        // per-pixel estimate raises the effective sample count over time, and the
-        // blur then only has to clean the residual noise. (Blurring first would
-        // turn per-frame noise into large low-frequency blobs that flicker.)
-        // The history stores the pre-blur accumulated signal.
-        const wantTemporal = !!camera.ssgiTemporal;
-        const motionVectorHandle = wantTemporal ? s.blackboard.get(FrameResources.MotionVector) : null;
-        const historySize = {
-            width: traceWidth,
-            height: traceHeight
-        };
-        const prevRadianceHandle = wantTemporal && history && motionVectorHandle ? history.importPreviousIfCompatible(graph, RGHistoryResources.SSGI_RADIANCE, texDesc, historySize) : null;
-        const prevMotionVectorHandle = wantTemporal && history && motionVectorHandle ? history.importPreviousIfCompatible(graph, RGHistoryResources.SSGI_MOTION_VECTOR, {
-            format: 'rgba16f',
-            sizeMode: 'absolute',
-            width: s.width,
-            height: s.height
-        }, {
-            width: s.width,
-            height: s.height
-        }) : null;
-        let radianceHandle = traceHandle;
-        const canTemporal = !!(motionVectorHandle && prevRadianceHandle && prevMotionVectorHandle);
-        if (canTemporal) {
-            radianceHandle = graph.addPass('SSGI:Temporal', (builder)=>{
-                builder.read(traceHandle);
-                builder.read(prevRadianceHandle);
-                builder.read(prevMotionVectorHandle);
-                builder.read(motionVectorHandle);
-                readCommon(builder);
+        const canTemporal = !!(ctx.device.type === 'webgpu' && ctx.camera.ssgiTemporal && motionHandle && previousIrradianceHandle && previousSurfaceHandle && previousMomentsHandle && previousAOHandle);
+        // Temporal pass always creates moments. On the first frame it simply
+        // initializes them; with valid history it rejects by depth and normal,
+        // neighborhood-clamps radiance, and accumulates first/second moments.
+        const temporalResult = graph.addPass('SSGI:Temporal', (builder)=>{
+            builder.read(traceResult.irradiance);
+            builder.read(traceResult.ao);
+            readFrameInputs(builder);
+            if (canTemporal) {
+                builder.read(previousIrradianceHandle);
+                builder.read(previousSurfaceHandle);
+                builder.read(previousMomentsHandle);
+                builder.read(previousAOHandle);
+            }
+            const irradiance = builder.createTexture({
+                ...traceDesc,
+                label: 'SSGI:temporalIrradiance'
+            });
+            const moments = builder.createTexture({
+                ...momentsDesc,
+                label: 'SSGI:moments'
+            });
+            const ao = builder.createTexture({
+                ...aoTraceDesc,
+                label: 'SSGI:temporalAO'
+            });
+            const fb = builder.createFramebuffer({
+                label: 'SSGI:temporalFB',
+                width: traceWidth,
+                height: traceHeight,
+                colorAttachments: [
+                    irradiance,
+                    moments,
+                    ao
+                ],
+                depthAttachment: null,
+                ignoreDepthStencil: true
+            });
+            builder.setExecute((rg)=>{
+                const device = ctx.device;
+                device.pushDeviceStates();
+                try {
+                    device.setFramebuffer(rg.getFramebuffer(fb));
+                    this.temporal(ctx, rg.getTexture(traceResult.irradiance), rg.getTexture(traceResult.ao), rg.getTexture(linearDepthHandle), rg.getTexture(normalHandle), canTemporal ? rg.getTexture(motionHandle) : null, canTemporal ? rg.getTexture(previousIrradianceHandle) : null, canTemporal ? rg.getTexture(previousSurfaceHandle) : null, canTemporal ? rg.getTexture(previousMomentsHandle) : null, canTemporal ? rg.getTexture(previousAOHandle) : null, traceWidth, traceHeight);
+                } finally{
+                    device.popDeviceStates();
+                }
+            });
+            return {
+                irradiance,
+                moments,
+                ao
+            };
+        });
+        // Variance-guided, cross-bilateral a-trous filtering. The increasing
+        // kernel step removes low-frequency Monte Carlo noise while depth/normal
+        // weights preserve discontinuities.
+        let filteredHandle = temporalResult.irradiance;
+        let filteredAOHandle = temporalResult.ao;
+        for(let pass = 0; pass < settings.denoisePasses; pass++){
+            const source = filteredHandle;
+            const aoSource = filteredAOHandle;
+            const filtered = graph.addPass(`SSGI:ATrous:${pass}`, (builder)=>{
+                builder.read(source);
+                builder.read(aoSource);
+                builder.read(temporalResult.moments);
+                builder.read(linearDepthHandle);
+                builder.read(normalHandle);
                 const out = builder.createTexture({
-                    ...texDesc,
-                    label: 'SSGI:temporal'
+                    ...traceDesc,
+                    label: `SSGI:atrous${pass}`
+                });
+                const ao = builder.createTexture({
+                    ...aoTraceDesc,
+                    label: `SSGI:atrousAO${pass}`
                 });
                 const fb = builder.createFramebuffer({
-                    label: 'SSGI:temporalFB',
+                    label: `SSGI:atrousFB${pass}`,
                     width: traceWidth,
                     height: traceHeight,
-                    colorAttachments: out,
+                    colorAttachments: [
+                        out,
+                        ao
+                    ],
                     depthAttachment: null,
                     ignoreDepthStencil: true
                 });
@@ -172,44 +325,48 @@ import { FrameResources } from '../render/rendergraph/blackboard.js';
                     const device = ctx.device;
                     device.pushDeviceStates();
                     try {
-                        this.temporal(ctx, rg.getTexture(traceHandle), rg.getTexture(prevRadianceHandle), rg.getTexture(prevMotionVectorHandle), rg.getFramebuffer(fb));
+                        device.setFramebuffer(rg.getFramebuffer(fb));
+                        this.atrous(ctx, rg.getTexture(source), rg.getTexture(aoSource), rg.getTexture(temporalResult.moments), rg.getTexture(linearDepthHandle), rg.getTexture(normalHandle), traceWidth, traceHeight, 1 << pass, canTemporal);
                     } finally{
                         device.popDeviceStates();
                     }
                 });
-                return out;
+                return {
+                    irradiance: out,
+                    ao
+                };
             });
+            filteredHandle = filtered.irradiance;
+            filteredAOHandle = filtered.ao;
         }
-        // The accumulated (pre-blur) signal is what feeds next frame's history.
-        const accumulatedHandle = radianceHandle;
-        // 3. Bilateral blur (horizontal + vertical) guided by scene depth cleans
-        // the residual noise left after accumulation.
-        if (camera.ssgiBlurKernelSize > 0) {
-            const blurInputHandle = radianceHandle;
-            radianceHandle = graph.addPass('SSGI:Blur', (builder)=>{
-                builder.read(blurInputHandle);
-                readCommon(builder);
-                const middle = builder.createTexture({
-                    ...texDesc,
-                    label: 'SSGI:blurH'
-                });
+        // Half-resolution presets use a joint bilateral upsample before history is
+        // consumed by full-resolution materials on the next frame.
+        let finalIrradianceHandle = filteredHandle;
+        let finalAOHandle = filteredAOHandle;
+        if (settings.halfRes) {
+            const source = filteredHandle;
+            const aoSource = filteredAOHandle;
+            const upsampled = graph.addPass('SSGI:Upsample', (builder)=>{
+                builder.read(source);
+                builder.read(aoSource);
+                builder.read(linearDepthHandle);
+                builder.read(normalHandle);
                 const out = builder.createTexture({
-                    ...texDesc,
-                    label: 'SSGI:blur'
+                    ...fullIrradianceDesc,
+                    label: 'SSGI:upsampledIrradiance'
                 });
-                const middleFB = builder.createFramebuffer({
-                    label: 'SSGI:blurHFB',
-                    width: traceWidth,
-                    height: traceHeight,
-                    colorAttachments: middle,
-                    depthAttachment: null,
-                    ignoreDepthStencil: true
+                const ao = builder.createTexture({
+                    ...fullAODesc,
+                    label: 'SSGI:upsampledAO'
                 });
-                const outFB = builder.createFramebuffer({
-                    label: 'SSGI:blurFB',
-                    width: traceWidth,
-                    height: traceHeight,
-                    colorAttachments: out,
+                const fb = builder.createFramebuffer({
+                    label: 'SSGI:upsampleFB',
+                    width: s.width,
+                    height: s.height,
+                    colorAttachments: [
+                        out,
+                        ao
+                    ],
                     depthAttachment: null,
                     ignoreDepthStencil: true
                 });
@@ -217,73 +374,68 @@ import { FrameResources } from '../render/rendergraph/blackboard.js';
                     const device = ctx.device;
                     device.pushDeviceStates();
                     try {
-                        const depthTex = getLinearDepth(rg);
-                        const blitterH = SSGI._blurBlitterH = SSGI._blurBlitterH ?? new BilateralBlurBlitter(false);
-                        this.blurPass(ctx, blitterH, depthTex, rg.getTexture(blurInputHandle), rg.getFramebuffer(middleFB));
-                        const blitterV = SSGI._blurBlitterV = SSGI._blurBlitterV ?? new BilateralBlurBlitter(true);
-                        this.blurPass(ctx, blitterV, depthTex, rg.getTexture(middle), rg.getFramebuffer(outFB));
+                        device.setFramebuffer(rg.getFramebuffer(fb));
+                        this.upsample(ctx, rg.getTexture(source), rg.getTexture(aoSource), rg.getTexture(linearDepthHandle), rg.getTexture(normalHandle));
                     } finally{
                         device.popDeviceStates();
                     }
                 });
-                return out;
+                return {
+                    irradiance: out,
+                    ao
+                };
             });
+            finalIrradianceHandle = upsampled.irradiance;
+            finalAOHandle = upsampled.ao;
         }
-        // 4. Upsample, modulate by the albedo approximation and add to the scene
-        // color; queue history commits.
-        const finalRadianceHandle = radianceHandle;
-        return graph.addPass('PostEffect:SSGI', (builder)=>{
+        // Pinned before the commit closure captures it: the a-trous loop above
+        // reassigns the handle, and the AO history has to be the trace-resolution
+        // one regardless of whether an upsample ran.
+        const traceResolutionAOHandle = filteredAOHandle;
+        // SSGI history is independent from TAA/SSR history. Commit the opaque HDR
+        // SceneColor input (before SSR/transparency/tone-map/AA), irradiance,
+        // surface and moments, then pass SceneColor through unchanged.
+        return graph.addPass('SSGI:Commit', (builder)=>{
             builder.read(s.input);
-            builder.read(finalRadianceHandle);
-            if (accumulatedHandle !== finalRadianceHandle) {
-                builder.read(accumulatedHandle);
-            }
-            if (motionVectorHandle) {
-                builder.read(motionVectorHandle);
+            if (noFogHandle) {
+                builder.read(noFogHandle);
             }
-            readCommon(builder);
-            const output = s.createOutput(builder, {
-                needDepthAttachment: true
-            });
+            builder.read(finalIrradianceHandle);
+            builder.read(finalAOHandle);
+            // The trace-resolution AO is what goes back into history, so it has to be
+            // read here too even when the upsampled one is what gets composited.
+            builder.read(traceResolutionAOHandle);
+            builder.read(surfaceHandle);
+            builder.read(temporalResult.moments);
+            const output = s.createOutput(builder);
             builder.setExecute((rg)=>{
                 const device = ctx.device;
                 device.pushDeviceStates();
                 try {
                     device.setFramebuffer(output.framebuffer ? rg.getFramebuffer(output.framebuffer) : null);
-                    const inputTex = rg.getTexture(s.input);
-                    const radianceTex = rg.getTexture(finalRadianceHandle);
-                    copyTexture(inputTex, device.getFramebuffer(), fetchSampler('clamp_nearest_nomip'), AbstractPostEffect.getDefaultRenderState(ctx, 'eq'));
-                    this.combine(ctx, inputTex, radianceTex, output.srgbOutput);
-                    // Commit history whenever temporal is wanted - even on frames where
-                    // the temporal pass could not run yet (no compatible history). This
-                    // seeds the very first frame; gating the commit on canTemporal
-                    // would deadlock: no history -> no temporal -> no commit -> no
-                    // history, forever.
-                    if (wantTemporal && history && motionVectorHandle) {
-                        // Commit the PRE-blur accumulated signal: feeding the blurred
-                        // result back would compound the blur every frame.
-                        const accumulatedTex = rg.getTexture(accumulatedHandle);
-                        history.queueRetainedCommit(RGHistoryResources.SSGI_RADIANCE, {
-                            format: accumulatedTex.format,
-                            sizeMode: 'absolute',
-                            width: accumulatedTex.width,
-                            height: accumulatedTex.height
-                        }, {
-                            width: accumulatedTex.width,
-                            height: accumulatedTex.height
-                        }, accumulatedTex);
-                        if (ctx.motionVectorTexture) {
-                            history.queueRetainedCommit(RGHistoryResources.SSGI_MOTION_VECTOR, {
-                                format: ctx.motionVectorTexture.format,
-                                sizeMode: 'absolute',
-                                width: ctx.motionVectorTexture.width,
-                                height: ctx.motionVectorTexture.height
-                            }, {
-                                width: ctx.motionVectorTexture.width,
-                                height: ctx.motionVectorTexture.height
-                            }, ctx.motionVectorTexture);
-                        }
+                    const sceneColor = rg.getTexture(s.input);
+                    const irradiance = rg.getTexture(finalIrradianceHandle);
+                    const ao = rg.getTexture(finalAOHandle);
+                    const filteredAO = rg.getTexture(traceResolutionAOHandle);
+                    const surface = rg.getTexture(surfaceHandle);
+                    const moments = rg.getTexture(temporalResult.moments);
+                    if (ctx.camera.ssgiAOIntensity > 0) {
+                        this.compositeAO(ctx, sceneColor, ao, output.srgbOutput);
+                    } else {
+                        this.passThrough(ctx, sceneColor, output.srgbOutput);
+                    }
+                    if (ctx.device.type === 'webgpu') {
+                        // Commit the same fog-free color the trace sampled, so next frame's
+                        // reprojected history is on the same footing as this frame's fallback.
+                        this.commitHistory(history, RGHistoryResources.SSGI_SCENE_COLOR, rg.getTexture(sampleColorHandle));
                     }
+                    this.commitHistory(history, RGHistoryResources.SSGI_IRRADIANCE, irradiance);
+                    this.commitHistory(history, RGHistoryResources.SSGI_SURFACE, surface);
+                    this.commitHistory(history, RGHistoryResources.SSGI_MOMENTS, moments);
+                    // Committed at trace resolution: the temporal pass that consumes it
+                    // runs before the upsample, so a full-resolution AO would fail the
+                    // descriptor compatibility check and silently disable accumulation.
+                    this.commitHistory(history, RGHistoryResources.SSGI_AO, filteredAO);
                 } finally{
                     device.popDeviceStates();
                 }
@@ -291,116 +443,180 @@ import { FrameResources } from '../render/rendergraph/blackboard.js';
             return output.color;
         });
     }
-    /** @internal */ blurPass(ctx, blitter, depthTex, srcTex, fbTo) {
-        const camera = ctx.camera;
-        blitter.kernelRadius = Math.max(1, camera.ssgiBlurKernelSize >> 0) - 1 >> 1;
-        blitter.stdDev = camera.ssgiBlurStdDev;
-        blitter.size = new Vector2(srcTex.width, srcTex.height);
-        blitter.depthTex = depthTex;
-        blitter.depthCutoff = camera.ssgiBlurDepthCutoff;
-        blitter.blurSizeTex = null;
-        blitter.sampler = fetchSampler('clamp_nearest_nomip');
-        blitter.cameraNearFar.setXY(camera.getNearPlane(), camera.getFarPlane());
-        blitter.srgbOut = false;
-        blitter.blit(srcTex, fbTo, fetchSampler('clamp_linear_nomip'));
+    /** @internal */ commitHistory(history, name, texture) {
+        history.queueRetainedCommit(name, {
+            format: texture.format,
+            sizeMode: 'absolute',
+            width: texture.width,
+            height: texture.height
+        }, {
+            width: texture.width,
+            height: texture.height
+        }, texture);
     }
-    /** @internal */ trace(ctx, inputColorTexture, sceneDepthTexture) {
-        const device = ctx.device;
-        const hash = `${!!ctx.HiZTexture}:${!!ctx.SSRCalcThickness}`;
-        let program = SSGI._tracePrograms[hash];
-        if (program === undefined) {
-            const created = this._createTraceProgram(ctx);
-            if (!created) {
-                return;
+    /** @internal */ trace(ctx, currentColor, previousColor, depth, normal, motion, previousSurface, hiZ, width, height) {
+        const sampleHistory = !!(previousColor && motion && previousSurface);
+        const envHash = ctx.env.light.getHash();
+        const historyHash = sampleHistory ? `${previousColor.uid}:${motion.uid}:${previousSurface.uid}` : '';
+        const hizHash = hiZ ? `${hiZ.uid}` : '';
+        const programHash = `${sampleHistory ? '1' : '0'}:${hiZ ? '1' : '0'}:${ctx.camera.ssgiResolvedSettings.raysPerPixel}:${envHash}`;
+        const bindGroupHash = `${currentColor.uid}:${depth.uid}:${normal.uid}:(${historyHash}):(${hizHash}):${ctx.camera.ssgiResolvedSettings.raysPerPixel}:${envHash}`;
+        let program = SSGI._tracePrograms[programHash];
+        if (!program) {
+            program = this.createTraceProgram(ctx, !!hiZ, sampleHistory);
+            SSGI._tracePrograms[programHash] = program;
+        }
+        const colorSampler = fetchSampler(ctx.device.type === 'webgl' ? 'clamp_nearest_nomip' : 'clamp_linear_nomip');
+        let bindGroup = this._traceBindGroups[bindGroupHash];
+        if (!bindGroup) {
+            bindGroup = ctx.device.createBindGroup(program.bindGroupLayouts[0]);
+            bindGroup.setTexture('currentColorTex', currentColor, colorSampler);
+            bindGroup.setTexture('depthTex', depth, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('normalTex', normal, fetchSampler('clamp_nearest_nomip'));
+            if (sampleHistory) {
+                bindGroup.setTexture('previousColorTex', previousColor, colorSampler);
+                bindGroup.setTexture('motionTex', motion, fetchSampler('clamp_nearest_nomip'));
+                bindGroup.setTexture('previousSurfaceTex', previousSurface, fetchSampler('clamp_nearest_nomip'));
             }
-            program = created;
-            SSGI._tracePrograms[hash] = program;
+            if (hiZ) {
+                bindGroup.setTexture('hizTex', hiZ, fetchSampler('clamp_nearest'));
+                bindGroup.setValue('depthMipLevels', hiZ.mipLevelCount);
+            }
+            this._traceBindGroups[bindGroupHash] = bindGroup;
+        }
+        if (sampleHistory) {
+            bindGroup.setValue('historyRejectParams', new Vector2(ctx.camera.ssgiDepthReject, ctx.camera.ssgiNormalReject));
         }
-        let bindGroup = this._traceBindGroups[hash];
+        bindGroup.setValue('cameraNearFar', new Vector2(ctx.camera.getNearPlane(), ctx.camera.getFarPlane()));
+        bindGroup.setValue('viewMatrix', ctx.camera.viewMatrix);
+        bindGroup.setValue('invViewMatrix', ctx.camera.worldMatrix);
+        bindGroup.setValue('projMatrix', ctx.camera.getProjectionMatrix());
+        bindGroup.setValue('invProjMatrix', Matrix4x4.invert(ctx.camera.getProjectionMatrix()));
+        bindGroup.setValue('traceParams', new Vector4(ctx.camera.ssgiMaxDistance, ctx.camera.ssgiThickness, ctx.camera.ssgiResolvedSettings.maxSteps, ctx.camera.ssgiStride));
+        bindGroup.setValue('targetSize', new Vector4(width, height, hiZ?.width ?? depth.width, hiZ?.height ?? depth.height));
+        bindGroup.setValue('radianceParams', new Vector4(ctx.camera.ssgiIntensity, ctx.camera.ssgiMaxRayIntensity, ShaderHelper.getEnvLightLuminance(ctx), ctx.device.frameInfo.frameCounter));
+        bindGroup.setValue('skyOcclusion', ctx.camera.ssgiSkyOcclusion);
+        bindGroup.setValue('flip', this.needFlip(ctx.device) ? 1 : 0);
+        ctx.env.light.envLight.updateBindGroup(bindGroup);
+        ctx.device.setProgram(program);
+        ctx.device.setBindGroup(0, bindGroup);
+        this.drawFullscreenQuad(AbstractPostEffect.getDefaultRenderState(ctx, 'always'));
+    }
+    /** @internal */ temporal(ctx, current, currentAO, depth, normal, motion, previousIrradiance, previousSurface, previousMoments, previousAO, width, height) {
+        const hasHistory = !!(motion && previousIrradiance && previousSurface && previousMoments && previousAO);
+        const hash = hasHistory ? `history:${current.uid}:${currentAO.uid}:${depth.uid}:${normal.uid}:${motion.uid}:${previousIrradiance.uid}:${previousSurface.uid}:${previousMoments.uid}:${previousAO.uid}` : `initialize:${current.uid}:${currentAO.uid}:${depth.uid}:${normal.uid}`;
+        let program = SSGI._temporalPrograms[hash];
+        if (!program) {
+            program = this.createTemporalProgram(ctx, hasHistory);
+            SSGI._temporalPrograms[hash] = program;
+        }
+        let bindGroup = this._temporalBindGroups[hash];
         if (!bindGroup) {
-            bindGroup = device.createBindGroup(program.bindGroupLayouts[0]);
-            this._traceBindGroups[hash] = bindGroup;
+            bindGroup = ctx.device.createBindGroup(program.bindGroupLayouts[0]);
+            bindGroup.setTexture('currentTex', current, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('currentAOTex', currentAO, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('depthTex', depth, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('normalTex', normal, fetchSampler('clamp_nearest_nomip'));
+            if (hasHistory) {
+                bindGroup.setTexture('motionTex', motion, fetchSampler('clamp_nearest_nomip'));
+                bindGroup.setTexture('previousIrradianceTex', previousIrradiance, fetchSampler('clamp_linear_nomip'));
+                bindGroup.setTexture('previousSurfaceTex', previousSurface, fetchSampler('clamp_nearest_nomip'));
+                bindGroup.setTexture('previousMomentsTex', previousMoments, fetchSampler('clamp_linear_nomip'));
+                // Linear is safe here: this branch only runs on WebGPU, where r16f is
+                // unconditionally filterable, and the read is at a reprojected UV.
+                bindGroup.setTexture('previousAOTex', previousAO, fetchSampler('clamp_linear_nomip'));
+            }
+            this._temporalBindGroups[hash] = bindGroup;
         }
-        const camera = ctx.camera;
-        const nearestSampler = fetchSampler('clamp_nearest');
-        const linearSampler = fetchSampler('clamp_linear');
-        const fb = device.getFramebuffer();
-        const traceWidth = fb.getWidth();
-        const traceHeight = fb.getHeight();
-        bindGroup.setTexture('colorTex', inputColorTexture, linearSampler);
-        bindGroup.setTexture('normalTex', ctx.SSRNormalTexture, nearestSampler);
-        bindGroup.setTexture('depthTex', sceneDepthTexture, nearestSampler);
-        bindGroup.setValue('cameraNearFar', new Vector2(camera.getNearPlane(), camera.getFarPlane()));
-        bindGroup.setValue('projMatrix', camera.getProjectionMatrix());
-        bindGroup.setValue('invProjMatrix', Matrix4x4.invert(camera.getProjectionMatrix()));
-        bindGroup.setValue('viewMatrix', camera.viewMatrix);
-        bindGroup.setValue('ssgiParams', new Vector4(camera.ssgiRadius, camera.ssgiMaxSteps, camera.ssgiThickness, camera.ssgiSamples));
-        // Advance the noise sequence only when the temporal resolve can converge
-        // it; a static pattern is less objectionable than unaccumulated flicker.
-        bindGroup.setValue('frameIndex', camera.ssgiTemporal ? device.frameInfo.frameCounter % 1024 : 0);
-        if (ctx.HiZTexture) {
-            bindGroup.setTexture('hizTex', ctx.HiZTexture, nearestSampler);
-            bindGroup.setValue('depthMipLevels', ctx.HiZTexture.mipLevelCount);
-            bindGroup.setValue('targetSize', new Vector4(traceWidth, traceHeight, ctx.HiZTexture.width, ctx.HiZTexture.height));
-        } else {
-            bindGroup.setValue('ssgiStride', camera.ssgiStride);
-            bindGroup.setValue('targetSize', new Vector4(traceWidth, traceHeight, sceneDepthTexture.width, sceneDepthTexture.height));
+        bindGroup.setValue('targetSize', new Vector4(width, height, depth.width, depth.height));
+        bindGroup.setValue('temporalParams', new Vector4(ctx.camera.ssgiTemporalWeight, ctx.camera.ssgiDepthReject, ctx.camera.ssgiNormalReject, ctx.camera.getFarPlane()));
+        bindGroup.setValue('flip', this.needFlip(ctx.device) ? 1 : 0);
+        ctx.device.setProgram(program);
+        ctx.device.setBindGroup(0, bindGroup);
+        this.drawFullscreenQuad(AbstractPostEffect.getDefaultRenderState(ctx, 'always'));
+    }
+    /** @internal */ atrous(ctx, source, aoSource, moments, depth, normal, width, height, step, hasTemporalHistory) {
+        let program = SSGI._atrousProgram;
+        if (!program) {
+            program = this.createAtrousProgram(ctx);
+            SSGI._atrousProgram = program;
+        }
+        const hash = `atrous:${source.uid}:${aoSource.uid}:${moments.uid}:${depth.uid}:${normal.uid}`;
+        let bindGroup = this._atrousBindGroups[hash];
+        if (!bindGroup) {
+            bindGroup = ctx.device.createBindGroup(program.bindGroupLayouts[0]);
+            bindGroup.setTexture('sourceTex', source, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('aoSourceTex', aoSource, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('momentsTex', moments, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('depthTex', depth, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('normalTex', normal, fetchSampler('clamp_nearest_nomip'));
+            this._atrousBindGroups[hash] = bindGroup;
         }
-        bindGroup.setValue('flip', this.needFlip(device) ? 1 : 0);
-        device.setProgram(program);
-        device.setBindGroup(0, bindGroup);
+        bindGroup.setValue('targetSize', new Vector4(width, height, depth.width, depth.height));
+        bindGroup.setValue('filterParams', new Vector4(step, Math.max(0.001, ctx.camera.ssgiDepthReject), Math.max(1, ctx.camera.ssgiNormalReject * 32), 4));
+        // Number of accumulated frames a pixel needs before its variance estimate is
+        // trusted. Zero disables the ramp for paths that never build history, where
+        // the stored length is pinned at 1 and would read as permanently new.
+        bindGroup.setValue('denoiseParams', new Vector4(hasTemporalHistory ? 8 : 0, 0, 0, 0));
+        bindGroup.setValue('cameraFar', ctx.camera.getFarPlane());
+        bindGroup.setValue('flip', this.needFlip(ctx.device) ? 1 : 0);
+        ctx.device.setProgram(program);
+        ctx.device.setBindGroup(0, bindGroup);
         this.drawFullscreenQuad(AbstractPostEffect.getDefaultRenderState(ctx, 'always'));
     }
-    /** @internal */ temporal(ctx, currentRadianceTex, prevRadianceTex, prevMotionVectorTex, outFramebuffer) {
-        const device = ctx.device;
-        let program = SSGI._temporalProgram;
+    /** @internal */ writeSurface(ctx, depth, normal) {
+        let program = SSGI._surfaceProgram;
         if (!program) {
-            program = this._createTemporalProgram(ctx);
-            SSGI._temporalProgram = program;
+            program = this.createSurfaceProgram(ctx);
+            SSGI._surfaceProgram = program;
         }
-        if (!this._temporalBindGroup) {
-            this._temporalBindGroup = device.createBindGroup(program.bindGroupLayouts[0]);
+        const hash = `${depth.uid}:${normal.uid}`;
+        let bindGroup = this._surfaceBindGroups[hash];
+        if (!bindGroup) {
+            bindGroup = ctx.device.createBindGroup(program.bindGroupLayouts[0]);
+            bindGroup.setTexture('depthTex', depth, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('normalTex', normal, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setValue('targetSize', new Vector2(depth.width, depth.height));
+            this._surfaceBindGroups[hash] = bindGroup;
         }
-        this._temporalBindGroup.setTexture('historyColorTex', prevRadianceTex, fetchSampler('clamp_linear_nomip'));
-        this._temporalBindGroup.setTexture('currentColorTex', currentRadianceTex, fetchSampler('clamp_nearest_nomip'));
-        this._temporalBindGroup.setTexture('motionVector', ctx.motionVectorTexture, fetchSampler('clamp_linear_nomip'));
-        this._temporalBindGroup.setTexture('prevMotionVector', prevMotionVectorTex, fetchSampler('clamp_linear_nomip'));
-        this._temporalBindGroup.setValue('flip', this.needFlip(device) ? 1 : 0);
-        this._temporalBindGroup.setValue('texSize', new Vector2(currentRadianceTex.width, currentRadianceTex.height));
-        this._temporalBindGroup.setValue('temporalWeight', ctx.camera.ssgiTemporalWeight);
-        device.setFramebuffer(outFramebuffer);
-        device.setProgram(program);
-        device.setBindGroup(0, this._temporalBindGroup);
+        bindGroup.setValue('cameraFar', ctx.camera.getFarPlane());
+        bindGroup.setValue('flip', this.needFlip(ctx.device) ? 1 : 0);
+        ctx.device.setProgram(program);
+        ctx.device.setBindGroup(0, bindGroup);
         this.drawFullscreenQuad(AbstractPostEffect.getDefaultRenderState(ctx, 'always'));
     }
-    /** @internal */ combine(ctx, inputColorTexture, radianceTex, srgbOut) {
-        const device = ctx.device;
-        let program = SSGI._combineProgram;
-        if (program === undefined) {
-            program = this._createCombineProgram(ctx);
-            SSGI._combineProgram = program;
+    /** @internal */ upsample(ctx, source, aoSource, depth, normal) {
+        let program = SSGI._upsampleProgram;
+        if (!program) {
+            program = this.createUpsampleProgram(ctx);
+            SSGI._upsampleProgram = program;
         }
-        if (!this._combineBindGroup) {
-            this._combineBindGroup = device.createBindGroup(program.bindGroupLayouts[0]);
+        const hash = `${source.uid}:${aoSource.uid}:${depth.uid}:${normal.uid}`;
+        let bindGroup = this._upsampleBindGroups[hash];
+        if (!bindGroup) {
+            bindGroup = ctx.device.createBindGroup(program.bindGroupLayouts[0]);
+            bindGroup.setTexture('sourceTex', source, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('aoSourceTex', aoSource, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('depthTex', depth, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setTexture('normalTex', normal, fetchSampler('clamp_nearest_nomip'));
+            bindGroup.setValue('targetSize', new Vector4(source.width, source.height, depth.width, depth.height));
+            this._upsampleBindGroups[hash] = bindGroup;
         }
-        this._combineBindGroup.setTexture('colorTex', inputColorTexture, fetchSampler('clamp_nearest'));
-        this._combineBindGroup.setTexture('radianceTex', radianceTex, fetchSampler('clamp_linear'));
-        this._combineBindGroup.setValue('ssgiIntensity', ctx.camera.ssgiIntensity);
-        this._combineBindGroup.setValue('targetSize', new Vector2(inputColorTexture.width, inputColorTexture.height));
-        this._combineBindGroup.setValue('flip', this.needFlip(device) ? 1 : 0);
-        this._combineBindGroup.setValue('srgbOut', srgbOut ? 1 : 0);
-        device.setProgram(program);
-        device.setBindGroup(0, this._combineBindGroup);
-        this.drawFullscreenQuad(AbstractPostEffect.getDefaultRenderState(ctx, 'gt'));
+        bindGroup.setValue('guideParams', new Vector4(Math.max(0.001, ctx.camera.ssgiDepthReject), Math.max(1, ctx.camera.ssgiNormalReject * 32), ctx.camera.getFarPlane(), 0));
+        bindGroup.setValue('flip', this.needFlip(ctx.device) ? 1 : 0);
+        ctx.device.setProgram(program);
+        ctx.device.setBindGroup(0, bindGroup);
+        this.drawFullscreenQuad(AbstractPostEffect.getDefaultRenderState(ctx, 'always'));
     }
-    /** @internal */ _createTraceProgram(ctx) {
+    /** @internal */ createTraceProgram(ctx, useHiZ, sampleHistory) {
+        const raysPerPixel = ctx.camera.ssgiResolvedSettings.raysPerPixel;
         const program = ctx.device.buildRenderProgram({
             vertex (pb) {
                 this.flip = pb.int().uniform(0);
                 this.$inputs.pos = pb.vec2().attrib('position');
                 this.$outputs.uv = pb.vec2();
                 pb.main(function() {
-                    this.$builtins.position = pb.vec4(this.$inputs.pos, 1, 1);
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, DEPTH_FARTHEST, 1);
                     this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
                     this.$if(pb.notEqual(this.flip, 0), function() {
                         this.$builtins.position.y = pb.neg(this.$builtins.position.y);
@@ -408,100 +624,208 @@ import { FrameResources } from '../render/rendergraph/blackboard.js';
                 });
             },
             fragment (pb) {
-                this.colorTex = pb.tex2D().uniform(0);
+                this.currentColorTex = pb.tex2D().uniform(0);
+                // Linear depth is r32f (or rg32f when thickness is enabled). These
+                // formats are not filterable without the optional float32-filterable
+                // feature, and all SSGI depth reads use a nearest sampler.
+                this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
                 this.normalTex = pb.tex2D().uniform(0);
-                this.depthTex = pb.tex2D().uniform(0);
+                if (sampleHistory) {
+                    this.previousColorTex = pb.tex2D().uniform(0);
+                    this.motionTex = pb.tex2D().uniform(0);
+                    this.previousSurfaceTex = pb.tex2D().uniform(0);
+                    this.historyRejectParams = pb.vec2().uniform(0);
+                }
+                if (useHiZ) {
+                    // Hi-Z is stored as r32f. It is only read with a nearest sampler,
+                    // so use the unfilterable sample type for adapters without the
+                    // optional float32-filterable feature (notably some AMD iGPUs).
+                    this.hizTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                    this.depthMipLevels = pb.int().uniform(0);
+                }
                 this.cameraNearFar = pb.vec2().uniform(0);
+                this.viewMatrix = pb.mat4().uniform(0);
+                this.invViewMatrix = pb.mat4().uniform(0);
                 this.projMatrix = pb.mat4().uniform(0);
                 this.invProjMatrix = pb.mat4().uniform(0);
-                this.viewMatrix = pb.mat4().uniform(0);
-                // (radius, maxIterations, thickness, numRays)
-                this.ssgiParams = pb.vec4().uniform(0);
-                this.frameIndex = pb.float().uniform(0);
+                this.traceParams = pb.vec4().uniform(0);
                 this.targetSize = pb.vec4().uniform(0);
-                if (ctx.HiZTexture) {
-                    this.hizTex = pb.tex2D().uniform(0);
-                    this.depthMipLevels = pb.int().uniform(0);
-                } else {
-                    this.ssgiStride = pb.float().uniform(0);
-                }
+                this.radianceParams = pb.vec4().uniform(0);
+                this.skyOcclusion = pb.float().uniform(0);
+                ctx.env.light.envLight.initShaderBindings(pb);
                 this.$outputs.outColor = pb.vec4();
-                pb.func('getPosition', [
-                    pb.vec2('uv'),
-                    pb.mat4('mat')
+                this.$outputs.outAO = pb.vec4();
+                pb.func('SSGI_getPosition', [
+                    pb.vec2('uv')
                 ], function() {
                     this.$l.linearDepth = ShaderHelper.sampleLinearDepth(this, this.depthTex, this.uv, 0);
-                    this.$l.nonLinearDepth = pb.div(pb.sub(pb.div(this.cameraNearFar.x, this.linearDepth), this.cameraNearFar.y), pb.sub(this.cameraNearFar.x, this.cameraNearFar.y));
-                    this.$l.clipSpacePos = pb.vec4(pb.sub(pb.mul(this.uv, 2), pb.vec2(1)), pb.sub(pb.mul(pb.clamp(this.nonLinearDepth, 0, 1), 2), 1), 1);
-                    this.$l.wPos = pb.mul(this.mat, this.clipSpacePos);
-                    this.$return(pb.vec4(pb.div(this.wPos.xyz, this.wPos.w), this.linearDepth));
+                    this.$l.nonLinearDepth = ShaderHelper.linearNormalizedToNonLinearDepth(this, this.linearDepth, this.cameraNearFar);
+                    this.$l.clipPos = pb.vec4(pb.sub(pb.mul(this.uv, 2), pb.vec2(1)), ShaderHelper.deviceDepthToClipZ(this, pb.clamp(this.nonLinearDepth, 0, 1)), 1);
+                    this.$l.viewPos = pb.mul(this.invProjMatrix, this.clipPos);
+                    this.$return(pb.vec4(pb.div(this.viewPos.xyz, this.viewPos.w), this.linearDepth));
+                });
+                pb.func('SSGI_hash22', [
+                    pb.vec2('p'),
+                    pb.float('seed')
+                ], function() {
+                    this.$l.q = pb.vec2(pb.dot(this.p, pb.vec2(127.1, 311.7)), pb.dot(this.p, pb.vec2(269.5, 183.3)));
+                    this.$return(pb.fract(pb.mul(pb.sin(pb.add(this.q, this.seed)), 43758.5453)));
+                });
+                pb.func('SSGI_cosineDirection', [
+                    pb.vec3('n'),
+                    pb.vec2('xi')
+                ], function() {
+                    this.$l.up = this.$choice(pb.lessThan(pb.abs(this.n.z), 0.999), pb.vec3(0, 0, 1), pb.vec3(1, 0, 0));
+                    this.$l.tangent = pb.normalize(pb.cross(this.up, this.n));
+                    this.$l.bitangent = pb.cross(this.n, this.tangent);
+                    this.$l.r = pb.sqrt(this.xi.x);
+                    this.$l.phi = pb.mul(2 * Math.PI, this.xi.y);
+                    this.$l.local = pb.vec3(pb.mul(this.r, pb.cos(this.phi)), pb.mul(this.r, pb.sin(this.phi)), pb.sqrt(pb.max(0, pb.sub(1, this.xi.x))));
+                    this.$return(pb.normalize(pb.add(pb.mul(this.tangent, this.local.x), pb.mul(this.bitangent, this.local.y), pb.mul(this.n, this.local.z))));
                 });
                 pb.main(function() {
-                    this.$l.screenUV = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.targetSize.xy);
-                    this.$l.color = pb.vec3(0);
-                    this.$l.pos = this.getPosition(this.screenUV, this.invProjMatrix);
-                    this.$if(pb.lessThan(this.pos.w, 1), function() {
-                        this.$l.viewPos = this.pos.xyz;
-                        this.$l.worldNormal = pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.screenUV, 0).rgb, 2), pb.vec3(1));
+                    this.$l.uv = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.targetSize.xy);
+                    this.$l.pos = this.SSGI_getPosition(this.uv);
+                    this.$if(pb.greaterThanEqual(this.pos.w, 1), function() {
+                        this.$outputs.outColor = pb.vec4(0);
+                        // Sky is unoccluded. Its irradiance validity is zero, so this value
+                        // is never read as a weight, but it must not be a dark texel: the
+                        // a-trous and upsample kernels reach across the silhouette.
+                        this.$outputs.outAO = pb.vec4(1);
+                    }).$else(function() {
+                        this.$l.worldNormal = pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.uv, 0).rgb, 2), pb.vec3(1)));
                         this.$l.viewNormal = pb.normalize(pb.mul(this.viewMatrix, pb.vec4(this.worldNormal, 0)).xyz);
-                        this.$l.numRays = pb.max(this.ssgiParams.w, 1);
-                        this.$l.sum = pb.vec3(0);
-                        this.$for(pb.float('ray'), 0, this.numRays, function() {
-                            this.$l.rand = SSGI_rand2(this, pb.vec2(this.$builtins.fragCoord.xy), pb.add(pb.mul(this.frameIndex, this.numRays), this.ray));
-                            this.$l.rayDir = SSGI_cosineSampleHemisphere(this, this.viewNormal, this.rand);
-                            this.$l.hitInfo = pb.vec4(0);
-                            if (ctx.HiZTexture) {
-                                this.hitInfo = screenSpaceRayTracing_HiZ(this, this.viewPos, this.rayDir, this.viewMatrix, this.projMatrix, this.invProjMatrix, this.cameraNearFar, this.depthMipLevels, this.ssgiParams.y, this.ssgiParams.x, this.ssgiParams.z, this.targetSize, this.hizTex, this.normalTex);
+                        // Use the SH-integrated diffuse IBL as an exact, noise-free
+                        // baseline. Stochastic rays only estimate the screen-space
+                        // replacement relative to the environment in the same direction.
+                        //
+                        // getIrradiance returns the cosine-convolved SH, which already
+                        // carries the 1/PI of the Lambert BRDF: materials consume it as
+                        // k_D * irradiance with no further division, matching punctual
+                        // lights that apply 1/PI explicitly. The published history is mixed
+                        // against that same value in the lighting pass, so this baseline
+                        // must stay in those units and must not be scaled by PI.
+                        this.$l.iblIrradiance = pb.mul(ctx.env.light.envLight.getIrradiance(this, this.worldNormal), this.radianceParams.z);
+                        this.$l.correctionSum = pb.vec3(0);
+                        // Rays whose outcome the depth buffer cannot resolve (they left the
+                        // screen or ran out of iterations behind geometry) are excluded from
+                        // the average instead of counted as unoccluded sky.
+                        this.$l.determinateSum = pb.float(0);
+                        this.$l.escapedSum = pb.float(0);
+                        // Ambient occlusion reuses the very same visibility measurement the
+                        // sky removal is built on, so the two can never disagree. No extra
+                        // ray march: only this accumulator is new.
+                        this.$l.occludedSum = pb.float(0);
+                        this.$for(pb.float('rayIndex'), 0, raysPerPixel, function() {
+                            this.$l.xi = this.SSGI_hash22(pb.add(pb.mul(this.uv, this.targetSize.xy), pb.vec2(this.rayIndex, pb.mul(this.rayIndex, 7))), pb.add(this.radianceParams.w, pb.mul(this.rayIndex, 17)));
+                            this.$l.worldRay = this.SSGI_cosineDirection(this.worldNormal, this.xi);
+                            this.$l.viewRay = pb.normalize(pb.mul(this.viewMatrix, pb.vec4(this.worldRay, 0)).xyz);
+                            this.$l.rayOrigin = pb.add(this.pos.xyz, pb.mul(this.viewNormal, this.traceParams.y, 0.25));
+                            // vec3(occluded, escaped, rawConfidence) - see screenSpaceRayTracing_Linear2D.
+                            this.$l.giTrace = pb.vec3(0);
+                            if (useHiZ) {
+                                // UE5 SSGI: diffuse rays march with RayRoughness = 1 (fast mip
+                                // ramp) and StepOffset = noise - 0.9. A dedicated hash keeps
+                                // the jitter decorrelated from the direction sample.
+                                this.$l.stepOffset = pb.sub(this.SSGI_hash22(pb.add(pb.mul(this.uv, this.targetSize.xy), pb.vec2(pb.mul(this.rayIndex, 23), 11)), pb.add(this.radianceParams.w, pb.mul(this.rayIndex, 29))).x, 0.9);
+                                this.$l.hit = screenSpaceRayTracing_HiZ(this, this.rayOrigin, this.viewRay, this.viewMatrix, this.projMatrix, this.invProjMatrix, this.cameraNearFar, this.depthMipLevels, this.traceParams.z, this.traceParams.x, this.traceParams.y, this.targetSize, this.hizTex, this.normalTex, this.giTrace, 1, this.stepOffset);
                             } else {
-                                this.hitInfo = screenSpaceRayTracing_Linear2D(this, this.viewPos, this.rayDir, this.viewMatrix, this.projMatrix, this.invProjMatrix, this.cameraNearFar, this.ssgiParams.x, this.ssgiParams.y, this.ssgiParams.z, this.ssgiStride, this.targetSize, this.depthTex, this.normalTex, // Backface depth is only present when the depth prepass was
-                                // built with SSR thickness computation enabled.
-                                !!ctx.SSRCalcThickness);
+                                this.$l.hit = screenSpaceRayTracing_Linear2D(this, this.rayOrigin, this.viewRay, this.viewMatrix, this.projMatrix, this.invProjMatrix, this.cameraNearFar, this.traceParams.x, this.traceParams.z, this.traceParams.y, this.traceParams.w, this.targetSize, this.depthTex, this.normalTex, false, this.giTrace);
                             }
-                            this.$l.hitAlpha = pb.clamp(this.hitInfo.w, 0, 1);
-                            // Hemisphere rays frequently graze the screen plane; the
-                            // projective ray setup can then produce Inf/NaN which would be
-                            // smeared into large blocks by the bilateral blur. NaN fails
-                            // any comparison, so this test also rejects it.
-                            this.$l.hitValid = pb.and(pb.all(pb.lessThan(pb.abs(this.hitInfo), pb.vec4(1e30))), pb.greaterThan(this.hitAlpha, 0));
-                            this.$if(this.hitValid, function() {
-                                this.$l.hitUV = pb.clamp(this.hitInfo.xy, pb.vec2(0), pb.vec2(1));
-                                // Firefly clamp: an HDR sun/sky sample can be orders of
-                                // magnitude brighter than the surroundings; unclamped it
-                                // dominates the low-spp estimate as isolated bright dots no
-                                // spatial filter can remove.
-                                this.$l.radiance = pb.min(pb.textureSampleLevel(this.colorTex, this.hitUV, 0).rgb, pb.vec3(4));
-                                this.sum = pb.add(this.sum, pb.mul(this.radiance, this.hitAlpha));
-                            });
+                            // Grazing/projectively degenerate rays can return Inf or NaN.
+                            // A zero weight is not sufficient because NaN * 0 remains NaN and
+                            // the spatial passes then spread it into a dark block.
+                            this.$l.hitFinite = pb.all(pb.lessThan(pb.abs(this.hit), pb.vec4(1e30)));
+                            // Visibility and radiance are kept apart: whether the ray was
+                            // blocked is independent of whether the blocker's outgoing
+                            // radiance can be read back from the screen. Geometric certainty
+                            // gates occlusion so a thin-object false positive cannot darken,
+                            // while the hit's screen colour is always a usable radiance
+                            // estimate because the marcher only ever stops on-screen.
+                            this.$l.occluded = pb.mul(pb.float(this.hitFinite), pb.clamp(this.giTrace.x, 0, 1), pb.clamp(this.giTrace.z, 0, 1));
+                            this.$l.escaped = pb.mul(pb.float(this.hitFinite), pb.clamp(this.giTrace.y, 0, 1));
+                            this.$l.hitUV = this.$choice(pb.greaterThan(this.occluded, 0), pb.clamp(this.hit.xy, pb.vec2(0), pb.vec2(1)), this.uv);
+                            this.$l.rawEnvRadiance = pb.mul(ctx.env.light.envLight.getRadiance(this, this.worldRay, pb.float(0)), this.radianceParams.z);
+                            this.$l.envRadiance = this.$choice(pb.all(pb.lessThan(pb.abs(this.rawEnvRadiance), pb.vec3(1e30))), this.rawEnvRadiance, pb.vec3(0));
+                            this.$l.currentRadiance = pb.textureSampleLevel(this.currentColorTex, this.hitUV, 0).rgb;
+                            if (sampleHistory) {
+                                this.$l.hitMotion = pb.textureSampleLevel(this.motionTex, this.hitUV, 0).xy;
+                                this.$l.previousHitUV = pb.sub(this.hitUV, this.hitMotion);
+                                this.$l.historyValid = pb.and(pb.all(pb.greaterThanEqual(this.previousHitUV, pb.vec2(0))), pb.all(pb.lessThanEqual(this.previousHitUV, pb.vec2(1))), pb.all(pb.lessThan(pb.abs(this.hitMotion), pb.vec2(5e4))));
+                                this.$l.historyRadiance = pb.textureSampleLevel(this.previousColorTex, pb.clamp(this.previousHitUV, pb.vec2(0), pb.vec2(1)), 0).rgb;
+                                this.$l.currentHitDepth = pb.mul(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.hitUV, 0), this.cameraNearFar.y);
+                                this.$l.currentHitNormal = pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.hitUV, 0).rgb, 2), pb.vec3(1)));
+                                this.$l.previousHitSurface = pb.textureSampleLevel(this.previousSurfaceTex, pb.clamp(this.previousHitUV, pb.vec2(0), pb.vec2(1)), 0);
+                                this.$l.previousHitNormal = pb.normalize(pb.sub(pb.mul(this.previousHitSurface.rgb, 2), pb.vec3(1)));
+                                this.historyValid = pb.and(this.historyValid, pb.lessThanEqual(pb.abs(pb.sub(this.previousHitSurface.a, this.currentHitDepth)), this.historyRejectParams.x), pb.greaterThanEqual(pb.dot(this.currentHitNormal, this.previousHitNormal), this.historyRejectParams.y));
+                                // Prefer the reprojected previous frame for multi-bounce
+                                // feedback, but fall back to this frame's already-shaded opaque
+                                // colour rather than dropping the sample. Losing one bounce of
+                                // feedback is a far smaller error than reverting to unoccluded
+                                // IBL, which is what made newly disoccluded regions flash.
+                                this.$l.screenRadiance = this.$choice(this.historyValid, this.historyRadiance, this.currentRadiance);
+                            } else {
+                                this.$l.screenRadiance = this.currentRadiance;
+                            }
+                            this.$l.screenRadianceFinite = pb.all(pb.lessThan(pb.abs(this.screenRadiance), pb.vec3(1e30)));
+                            this.screenRadiance = this.$choice(this.screenRadianceFinite, this.screenRadiance, this.envRadiance);
+                            this.$l.maxComponent = pb.max(pb.max(this.screenRadiance.r, this.screenRadiance.g), this.screenRadiance.b);
+                            this.$l.fireflyScale = this.$choice(pb.greaterThan(this.maxComponent, this.radianceParams.y), pb.div(this.radianceParams.y, pb.max(this.maxComponent, 1e-5)), pb.float(1));
+                            this.$l.clampedScreenRadiance = pb.mul(this.screenRadiance, this.fireflyScale);
+                            // Split the correction into the bounce the blocker adds and the sky
+                            // it takes away. The bounce is always kept: the hit is on-screen, so
+                            // its colour is a real measurement. Only the removal is scaled by
+                            // skyOcclusion, which lets the sky be dimmed less than physically
+                            // implied without also discarding measured bounce light.
+                            this.$l.bounceGain = pb.max(pb.sub(this.clampedScreenRadiance, this.envRadiance), pb.vec3(0));
+                            this.$l.skyLoss = pb.mul(pb.max(pb.sub(this.envRadiance, this.clampedScreenRadiance), pb.vec3(0)), this.skyOcclusion);
+                            // Cosine-weighted sampling makes the estimator of E/PI - the unit
+                            // the baseline and the lighting pass both use - the plain mean of
+                            // the sampled radiance, so no PI appears here either.
+                            this.$l.correction = pb.mul(pb.sub(this.bounceGain, this.skyLoss), this.occluded, this.radianceParams.x);
+                            this.correctionSum = pb.add(this.correctionSum, this.correction);
+                            this.determinateSum = pb.add(this.determinateSum, pb.max(this.occluded, this.escaped));
+                            this.escapedSum = pb.add(this.escapedSum, this.escaped);
+                            this.occludedSum = pb.add(this.occludedSum, this.occluded);
                         });
-                        // Cosine-weighted sampling: the irradiance estimate over the
-                        // hemisphere reduces to the plain average of the hit radiances.
-                        this.color = pb.div(this.sum, this.numRays);
+                        // Average over resolved rays only. Dividing by raysPerPixel would
+                        // implicitly treat every indeterminate ray as an unoccluded sky
+                        // sample, which is the systematic sky leak this pass has to avoid.
+                        this.$l.determinateCount = pb.max(this.determinateSum, 1);
+                        this.$l.irradiance = pb.add(this.iblIrradiance, pb.div(this.correctionSum, this.determinateCount));
+                        // radianceParams.x blends the traced estimate over the IBL baseline. A finite-ray
+                        // correction can have much higher variance than the integrated physical sky and must
+                        // not remove more than that blend permits (at the default 0.7, at least 30% remains).
+                        // That reserved share is itself scaled by measured visibility, otherwise no amount of
+                        // occlusion could ever darken an enclosed corner.
+                        this.$l.minimumIrradiance = pb.mul(this.iblIrradiance, pb.max(0, pb.sub(1, this.radianceParams.x)), pb.mix(pb.float(1), pb.div(this.escapedSum, this.determinateCount), this.skyOcclusion));
+                        // Clamp before the render-target conversion: a finite value that overflows becomes Inf
+                        // in the texture, and every a-trous pass then expands the contaminated region by its
+                        // kernel radius. Pre-exposed lighting makes this unlikely, but a bright emissive hit
+                        // amplified by a low-probability ray can still reach it.
+                        this.$l.boundedIrradiance = pb.clamp(pb.max(this.irradiance, this.minimumIrradiance), pb.vec3(0), pb.vec3(HALF_FLOAT_MAX));
+                        this.$outputs.outColor = pb.vec4(this.boundedIrradiance, 1);
+                        // Cosine-weighted sampling makes the mean of `occluded` over the
+                        // resolved rays an unbiased estimate of cosine-weighted visibility.
+                        // Averaging over the determinate set - not raysPerPixel - is what
+                        // keeps an indeterminate ray from reading as unoccluded, the same
+                        // reasoning the irradiance average uses above.
+                        this.$outputs.outAO = pb.vec4(pb.clamp(pb.sub(1, pb.div(this.occludedSum, this.determinateCount)), 0, 1));
                     });
-                    // Reinhard-compress into [0, 1) (mirrors the SSR intersect pass).
-                    // The bilateral blur weights neighbors by color distance; in linear
-                    // HDR a firefly is "far" from every neighbor and survives the blur
-                    // untouched. Compressed, bright outliers stay within blurring range
-                    // and the denoiser can actually converge them. combine() inverts
-                    // this mapping.
-                    this.color = pb.div(this.color, pb.add(this.color, pb.vec3(1)));
-                    this.$outputs.outColor = pb.vec4(this.color, 1);
                 });
             }
         });
-        if (!program) {
-            return null;
-        }
         program.name = '@SSGI_Trace';
         return program;
     }
-    /** @internal */ _createTemporalProgram(ctx) {
+    /** @internal */ createTemporalProgram(ctx, hasHistory) {
         const program = ctx.device.buildRenderProgram({
             vertex (pb) {
                 this.flip = pb.int().uniform(0);
                 this.$inputs.pos = pb.vec2().attrib('position');
                 this.$outputs.uv = pb.vec2();
                 pb.main(function() {
-                    this.$builtins.position = pb.vec4(this.$inputs.pos, 1, 1);
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, DEPTH_FARTHEST, 1);
                     this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
                     this.$if(pb.notEqual(this.flip, 0), function() {
                         this.$builtins.position.y = pb.neg(this.$builtins.position.y);
@@ -509,95 +833,279 @@ import { FrameResources } from '../render/rendergraph/blackboard.js';
                 });
             },
             fragment (pb) {
-                this.historyColorTex = pb.tex2D().uniform(0);
-                this.currentColorTex = pb.tex2D().uniform(0);
-                this.motionVector = pb.tex2D().uniform(0);
-                this.prevMotionVector = pb.tex2D().uniform(0);
-                this.texSize = pb.vec2().uniform(0);
-                this.temporalWeight = pb.float().uniform(0);
-                this.$outputs.outColor = pb.vec4();
+                this.currentTex = pb.tex2D().uniform(0);
+                this.currentAOTex = pb.tex2D().uniform(0);
+                this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                this.normalTex = pb.tex2D().uniform(0);
+                if (hasHistory) {
+                    this.motionTex = pb.tex2D().uniform(0);
+                    this.previousIrradianceTex = pb.tex2D().uniform(0);
+                    this.previousSurfaceTex = pb.tex2D().uniform(0);
+                    this.previousMomentsTex = pb.tex2D().uniform(0);
+                    this.previousAOTex = pb.tex2D().uniform(0);
+                }
+                this.targetSize = pb.vec4().uniform(0);
+                this.temporalParams = pb.vec4().uniform(0);
+                this.$outputs.outIrradiance = pb.vec4();
+                this.$outputs.outMoments = pb.vec4();
+                this.$outputs.outAO = pb.vec4();
+                pb.func('SSGI_luminance', [
+                    pb.vec3('c')
+                ], function() {
+                    this.$l.boundedLuminance = pb.clamp(pb.dot(this.c, pb.vec3(0.2126, 0.7152, 0.0722)), 0, MOMENT_LUMINANCE_MAX);
+                    this.$return(this.boundedLuminance);
+                });
                 pb.main(function() {
-                    // Sample-count adaptive accumulation with fixed-gamma variance
-                    // clipping. The accumulated frame count N rides in the alpha
-                    // channel of the radiance history: early frames blend with
-                    // 1/(N+1) (fast convergence), converged pixels blend at the
-                    // temporalWeight cap. A FIXED-weight EMA never settles - its
-                    // stationary state is a random walk inside the clip box, visible
-                    // as slowly rippling low-frequency noise after the blur. With
-                    // count-based weighting the estimator is a true running average,
-                    // so the converged value stops moving.
-                    // TAA-style box collapsing with velocity is deliberately avoided:
-                    // camera jitter alone would collapse the box and reject all
-                    // history, preventing convergence of the stochastic signal.
-                    this.$l.screenUV = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.texSize);
-                    this.$l.currentColor = pb.textureSampleLevel(this.currentColorTex, this.screenUV, 0).rgb;
-                    this.$l.velocitySample = pb.textureSampleLevel(this.motionVector, this.screenUV, 0);
-                    this.$l.velocity = this.velocitySample.xy;
-                    // Sky/unwritten motion vector sentinel: no history
-                    this.$if(pb.and(pb.greaterThanEqual(this.velocity.x, 5e4), pb.greaterThanEqual(this.velocity.y, 5e4)), function() {
-                        this.$outputs.outColor = pb.vec4(this.currentColor, 1);
-                    }).$else(function() {
-                        this.$l.reprojectedUV = pb.sub(this.screenUV, this.velocity);
-                        this.$l.offscreen = pb.or(pb.any(pb.lessThan(this.reprojectedUV, pb.vec2(0))), pb.any(pb.greaterThan(this.reprojectedUV, pb.vec2(1))));
-                        this.$if(this.offscreen, function() {
-                            this.$outputs.outColor = pb.vec4(this.currentColor, 1);
-                        }).$else(function() {
-                            this.$l.historySample = pb.textureSampleLevel(this.historyColorTex, this.reprojectedUV, 0);
-                            this.$l.historyColor = this.historySample.rgb;
-                            this.$l.historyCount = pb.max(this.historySample.a, 1);
-                            // 3x3 neighborhood statistics of the current stochastic estimate
-                            this.$l.m1 = pb.vec3(0);
-                            this.$l.m2 = pb.vec3(0);
-                            for(let i = -1; i <= 1; i++){
-                                for(let j = -1; j <= 1; j++){
-                                    const c = `c${(i + 1) * 3 + j + 1}`;
-                                    this.$l[c] = pb.textureSampleLevel(this.currentColorTex, pb.add(this.screenUV, pb.div(pb.vec2(i, j), this.texSize)), 0).rgb;
-                                    this.m1 = pb.add(this.m1, this[c]);
-                                    this.m2 = pb.add(this.m2, pb.mul(this[c], this[c]));
+                    this.$l.uv = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.targetSize.xy);
+                    this.$l.current = pb.textureSampleLevel(this.currentTex, this.uv, 0);
+                    this.$l.currentAO = pb.textureSampleLevel(this.currentAOTex, this.uv, 0).r;
+                    this.$l.result = this.current.rgb;
+                    this.$l.resultAO = this.currentAO;
+                    this.$l.luminance = this.SSGI_luminance(this.current.rgb);
+                    this.$l.moment = pb.vec4(this.luminance, pb.mul(this.luminance, this.luminance), 1, 0);
+                    if (hasHistory) {
+                        this.$l.motion = pb.textureSampleLevel(this.motionTex, this.uv, 0).xy;
+                        this.$l.previousUV = pb.sub(this.uv, this.motion);
+                        this.$l.validUV = pb.and(pb.all(pb.greaterThanEqual(this.previousUV, pb.vec2(0))), pb.all(pb.lessThanEqual(this.previousUV, pb.vec2(1))), pb.all(pb.lessThan(pb.abs(this.motion), pb.vec2(5e4))));
+                        this.$l.currentDepth = pb.mul(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.uv, 0), this.temporalParams.w);
+                        this.$l.currentNormal = pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.uv, 0).rgb, 2), pb.vec3(1)));
+                        this.$l.previousSurface = pb.textureSampleLevel(this.previousSurfaceTex, pb.clamp(this.previousUV, pb.vec2(0), pb.vec2(1)), 0);
+                        this.$l.previousNormal = pb.normalize(pb.sub(pb.mul(this.previousSurface.rgb, 2), pb.vec3(1)));
+                        this.$l.surfaceValid = pb.and(pb.lessThanEqual(pb.abs(pb.sub(this.previousSurface.a, this.currentDepth)), this.temporalParams.y), pb.greaterThanEqual(pb.dot(this.currentNormal, this.previousNormal), this.temporalParams.z));
+                        this.$l.neighborhoodMin = this.current.rgb;
+                        this.$l.neighborhoodMax = this.current.rgb;
+                        this.$l.aoNeighborhoodMin = this.currentAO;
+                        this.$l.aoNeighborhoodMax = this.currentAO;
+                        for(let y = -1; y <= 1; y++){
+                            for(let x = -1; x <= 1; x++){
+                                if (x === 0 && y === 0) {
+                                    continue;
                                 }
+                                this.$l.neighborUV = pb.add(this.uv, pb.div(pb.vec2(x, y), this.targetSize.xy));
+                                this.$l.neighbor = pb.textureSampleLevel(this.currentTex, this.neighborUV, 0).rgb;
+                                this.neighborhoodMin = pb.min(this.neighborhoodMin, this.neighbor);
+                                this.neighborhoodMax = pb.max(this.neighborhoodMax, this.neighbor);
+                                this.$l.aoNeighbor = pb.textureSampleLevel(this.currentAOTex, this.neighborUV, 0).r;
+                                this.aoNeighborhoodMin = pb.min(this.aoNeighborhoodMin, this.aoNeighbor);
+                                this.aoNeighborhoodMax = pb.max(this.aoNeighborhoodMax, this.aoNeighbor);
                             }
-                            this.m1 = pb.div(this.m1, 9);
-                            this.m2 = pb.div(this.m2, 9);
-                            this.$l.sigma = pb.sqrt(pb.max(pb.sub(this.m2, pb.mul(this.m1, this.m1)), pb.vec3(0)));
-                            // gamma = 2 with a small absolute slack: tolerant to the noise a
-                            // converged history legitimately sits in (compressed-space values).
-                            this.$l.halfExtent = pb.add(pb.mul(this.sigma, 2), pb.vec3(0.03));
-                            this.$l.clampedHistory = pb.clamp(this.historyColor, pb.sub(this.m1, this.halfExtent), pb.add(this.m1, this.halfExtent));
-                            // How much the clip moved the history signals stale data;
-                            // knock the effective count down so recovery is fast.
-                            this.$l.clipAmount = pb.length(pb.sub(this.clampedHistory, this.historyColor));
-                            this.$l.clipReset = pb.clamp(pb.mul(this.clipAmount, 8), 0, 1);
-                            // Disocclusion: previous frame's motion at the reprojected point
-                            // should agree with the current motion; a large mismatch means the
-                            // surface was not visible last frame.
-                            this.$l.prevVelocity = pb.textureSampleLevel(this.prevMotionVector, this.reprojectedUV, 0).xy;
-                            this.$l.velocityDiff = pb.length(pb.mul(pb.sub(this.velocity, this.prevVelocity), this.texSize));
-                            this.$l.disocclusion = pb.clamp(pb.mul(pb.sub(this.velocityDiff, 2.5), 0.1), 0, 1);
-                            this.$l.confidence = pb.mul(pb.sub(1, this.disocclusion), pb.sub(1, this.clipReset));
-                            this.$l.effectiveCount = pb.max(pb.mul(this.historyCount, this.confidence), 0);
-                            // Count-based blend weight, capped by temporalWeight:
-                            // maxCount = w/(1-w) so the cap and the weight limit agree.
-                            this.$l.wMax = pb.clamp(this.temporalWeight, 0, 0.99);
-                            this.$l.maxCount = pb.div(this.wMax, pb.sub(1, this.wMax));
-                            this.$l.w = pb.min(this.wMax, pb.div(this.effectiveCount, pb.add(this.effectiveCount, 1)));
-                            this.$l.newCount = pb.min(pb.add(this.effectiveCount, 1), this.maxCount);
-                            this.$outputs.outColor = pb.vec4(pb.mix(this.currentColor, this.clampedHistory, this.w), this.newCount);
-                        });
+                        }
+                        this.$l.previous = pb.textureSampleLevel(this.previousIrradianceTex, pb.clamp(this.previousUV, pb.vec2(0), pb.vec2(1)), 0);
+                        this.$l.previousClamped = pb.clamp(this.previous.rgb, this.neighborhoodMin, this.neighborhoodMax);
+                        this.$l.previousMoment = pb.textureSampleLevel(this.previousMomentsTex, pb.clamp(this.previousUV, pb.vec2(0), pb.vec2(1)), 0);
+                        this.$l.validity = pb.mul(pb.float(pb.and(this.validUV, this.surfaceValid)), pb.clamp(this.previous.a, 0, 1));
+                        // Start new histories as a running average, then cap their weight
+                        // at the configured value once enough samples have accumulated.
+                        this.$l.runningAverageWeight = pb.div(this.previousMoment.z, pb.add(this.previousMoment.z, 1));
+                        this.$l.historyWeight = pb.min(this.temporalParams.x, this.runningAverageWeight);
+                        this.$l.weight = pb.mul(this.historyWeight, this.validity);
+                        this.result = pb.mix(this.current.rgb, this.previousClamped, this.weight);
+                        // AO accumulates on exactly the same validity and weight as the
+                        // irradiance: it was measured by the same rays against the same
+                        // surface, so any disagreement between the two would be an artifact.
+                        this.$l.previousAO = pb.textureSampleLevel(this.previousAOTex, pb.clamp(this.previousUV, pb.vec2(0), pb.vec2(1)), 0).r;
+                        this.$l.previousAOClamped = pb.clamp(this.previousAO, this.aoNeighborhoodMin, this.aoNeighborhoodMax);
+                        this.resultAO = pb.mix(this.currentAO, this.previousAOClamped, this.weight);
+                        this.$l.momentXY = pb.mix(this.moment.xy, this.previousMoment.xy, this.weight);
+                        this.$l.historyLength = pb.mix(pb.float(1), pb.min(32, pb.add(this.previousMoment.z, 1)), this.validity);
+                        this.$l.variance = pb.max(0, pb.sub(this.momentXY.y, pb.mul(this.momentXY.x, this.momentXY.x)));
+                        this.moment = pb.vec4(this.momentXY, this.historyLength, this.variance);
+                    } else {
+                        // The WebGL fallback has no motion-vector temporal resolve. Seed
+                        // a-trous with spatial variance so its luminance weighting can
+                        // still remove Monte Carlo noise instead of treating it as an edge.
+                        this.$l.spatialLum = pb.float(0);
+                        this.$l.spatialLum2 = pb.float(0);
+                        for(let y = -1; y <= 1; y++){
+                            for(let x = -1; x <= 1; x++){
+                                this.$l.neighborLum = this.SSGI_luminance(pb.textureSampleLevel(this.currentTex, pb.add(this.uv, pb.div(pb.vec2(x, y), this.targetSize.xy)), 0).rgb);
+                                this.spatialLum = pb.add(this.spatialLum, this.neighborLum);
+                                this.spatialLum2 = pb.add(this.spatialLum2, pb.mul(this.neighborLum, this.neighborLum));
+                            }
+                        }
+                        this.spatialLum = pb.div(this.spatialLum, 9);
+                        this.spatialLum2 = pb.div(this.spatialLum2, 9);
+                        this.$l.spatialVariance = pb.max(0, pb.sub(this.spatialLum2, pb.mul(this.spatialLum, this.spatialLum)));
+                        this.moment = pb.vec4(this.moment.xyz, this.spatialVariance);
+                    }
+                    this.$outputs.outIrradiance = pb.vec4(this.result, this.current.a);
+                    this.$outputs.outMoments = this.moment;
+                    this.$outputs.outAO = pb.vec4(pb.clamp(this.resultAO, 0, 1));
+                });
+            }
+        });
+        program.name = hasHistory ? '@SSGI_Temporal' : '@SSGI_TemporalInitialize';
+        return program;
+    }
+    /** @internal */ createAtrousProgram(ctx) {
+        const program = ctx.device.buildRenderProgram({
+            vertex (pb) {
+                this.flip = pb.int().uniform(0);
+                this.$inputs.pos = pb.vec2().attrib('position');
+                this.$outputs.uv = pb.vec2();
+                pb.main(function() {
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, DEPTH_FARTHEST, 1);
+                    this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                    this.$if(pb.notEqual(this.flip, 0), function() {
+                        this.$builtins.position.y = pb.neg(this.$builtins.position.y);
+                    });
+                });
+            },
+            fragment (pb) {
+                this.sourceTex = pb.tex2D().uniform(0);
+                this.aoSourceTex = pb.tex2D().uniform(0);
+                this.momentsTex = pb.tex2D().uniform(0);
+                this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                this.normalTex = pb.tex2D().uniform(0);
+                this.targetSize = pb.vec4().uniform(0);
+                this.filterParams = pb.vec4().uniform(0);
+                this.denoiseParams = pb.vec4().uniform(0);
+                this.cameraFar = pb.float().uniform(0);
+                this.$outputs.outColor = pb.vec4();
+                this.$outputs.outAO = pb.vec4();
+                pb.func('SSGI_luminance', [
+                    pb.vec3('c')
+                ], function() {
+                    this.$return(pb.max(0, pb.dot(this.c, pb.vec3(0.2126, 0.7152, 0.0722))));
+                });
+                pb.main(function() {
+                    this.$l.uv = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.targetSize.xy);
+                    this.$l.center = pb.textureSampleLevel(this.sourceTex, this.uv, 0);
+                    this.$l.centerDepth = pb.mul(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.uv, 0), this.cameraFar);
+                    this.$l.centerNormal = pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.uv, 0).rgb, 2), pb.vec3(1)));
+                    this.$l.centerLum = this.SSGI_luminance(this.center.rgb);
+                    this.$l.moments = pb.textureSampleLevel(this.momentsTex, this.uv, 0);
+                    // A pixel with little accumulated history has an unreliable variance
+                    // estimate, so the edge-stopping functions would preserve Monte Carlo
+                    // noise as if it were detail. Widen the kernel and relax the luminance
+                    // and normal tests until enough frames have converged, then hand back
+                    // to the sharp weights (standard SVGF history-driven ramp).
+                    //
+                    // A path that never accumulates history (no temporal resolve, so
+                    // moments.z is pinned at 1) is permanently unconverged, not converged:
+                    // it is the noisiest input this filter ever sees. Sending it to the
+                    // relaxed end is the whole point of the ramp - the sharp end would give
+                    // it the narrowest kernel and one eighth the luminance tolerance.
+                    this.$l.historyConfidence = this.$choice(pb.greaterThan(this.denoiseParams.x, 0), pb.clamp(pb.div(this.moments.z, this.denoiseParams.x), 0, 1), pb.float(0));
+                    this.$l.stepScale = pb.mix(pb.float(2), pb.float(1), this.historyConfidence);
+                    this.$l.effStep = pb.mul(this.filterParams.x, this.stepScale);
+                    this.$l.normalPower = pb.mix(pb.max(1, pb.mul(this.filterParams.z, 0.25)), this.filterParams.z, this.historyConfidence);
+                    this.$l.sigmaScale = pb.mix(pb.float(8), pb.float(1), this.historyConfidence);
+                    this.$l.sigma = pb.mul(pb.add(pb.sqrt(pb.max(this.moments.w, 0)), 0.02), this.sigmaScale);
+                    this.$l.centerAO = pb.textureSampleLevel(this.aoSourceTex, this.uv, 0).r;
+                    this.$l.sum = pb.vec3(0);
+                    this.$l.weightSum = pb.float(0);
+                    this.$l.aoSum = pb.float(0);
+                    this.$l.aoWeightSum = pb.float(0);
+                    const kernel = [
+                        1,
+                        2 / 3,
+                        1 / 6
+                    ];
+                    for(let y = -2; y <= 2; y++){
+                        for(let x = -2; x <= 2; x++){
+                            const kernelWeight = kernel[Math.abs(x)] * kernel[Math.abs(y)];
+                            this.$l.sampleUV = pb.add(this.uv, pb.mul(pb.div(pb.vec2(x, y), this.targetSize.xy), this.effStep));
+                            this.$l.sampleValue = pb.textureSampleLevel(this.sourceTex, this.sampleUV, 0);
+                            this.$l.sampleDepth = pb.mul(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.sampleUV, 0), this.cameraFar);
+                            this.$l.sampleNormal = pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.sampleUV, 0).rgb, 2), pb.vec3(1)));
+                            this.$l.depthWeight = pb.exp(pb.neg(pb.div(pb.abs(pb.sub(this.sampleDepth, this.centerDepth)), pb.mul(this.filterParams.y, this.effStep))));
+                            this.$l.normalWeight = pb.pow(pb.max(0, pb.dot(this.centerNormal, this.sampleNormal)), this.normalPower);
+                            this.$l.colorWeight = pb.exp(pb.neg(pb.div(pb.abs(pb.sub(this.SSGI_luminance(this.sampleValue.rgb), this.centerLum)), pb.mul(this.sigma, this.filterParams.w))));
+                            this.$l.weight = pb.mul(kernelWeight, this.depthWeight, this.normalWeight, this.colorWeight, this.sampleValue.a);
+                            this.sum = pb.add(this.sum, pb.mul(this.sampleValue.rgb, this.weight));
+                            this.weightSum = pb.add(this.weightSum, this.weight);
+                            // AO deliberately drops colorWeight: that term is driven by the
+                            // moments' luminance variance, which describes the irradiance and
+                            // says nothing about AO. Leaving it out is a stronger smoothing,
+                            // which is what a per-ray binary quantity needs - with 1-2 rays per
+                            // pixel, single-frame AO is close to binary.
+                            this.$l.aoWeight = pb.mul(kernelWeight, this.depthWeight, this.normalWeight, this.sampleValue.a);
+                            this.$l.sampleAO = pb.textureSampleLevel(this.aoSourceTex, this.sampleUV, 0).r;
+                            this.aoSum = pb.add(this.aoSum, pb.mul(this.sampleAO, this.aoWeight));
+                            this.aoWeightSum = pb.add(this.aoWeightSum, this.aoWeight);
+                        }
+                    }
+                    this.$l.filtered = this.$choice(pb.greaterThan(this.weightSum, 1e-5), pb.div(this.sum, this.weightSum), this.center.rgb);
+                    this.$l.filteredAO = this.$choice(pb.greaterThan(this.aoWeightSum, 1e-5), pb.div(this.aoSum, this.aoWeightSum), this.centerAO);
+                    this.$outputs.outColor = pb.vec4(this.filtered, this.center.a);
+                    this.$outputs.outAO = pb.vec4(pb.clamp(this.filteredAO, 0, 1));
+                });
+            }
+        });
+        program.name = '@SSGI_ATrous';
+        return program;
+    }
+    /** @internal */ createSurfaceProgram(ctx) {
+        const program = ctx.device.buildRenderProgram({
+            vertex (pb) {
+                this.flip = pb.int().uniform(0);
+                this.$inputs.pos = pb.vec2().attrib('position');
+                this.$outputs.uv = pb.vec2();
+                pb.main(function() {
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, DEPTH_FARTHEST, 1);
+                    this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                    this.$if(pb.notEqual(this.flip, 0), function() {
+                        this.$builtins.position.y = pb.neg(this.$builtins.position.y);
                     });
                 });
+            },
+            fragment (pb) {
+                this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                this.normalTex = pb.tex2D().uniform(0);
+                this.targetSize = pb.vec2().uniform(0);
+                this.cameraFar = pb.float().uniform(0);
+                this.$outputs.outColor = pb.vec4();
+                pb.main(function() {
+                    this.$l.uv = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.targetSize);
+                    this.$l.normal = pb.textureSampleLevel(this.normalTex, this.uv, 0).rgb;
+                    this.$l.depth = pb.mul(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.uv, 0), this.cameraFar);
+                    this.$outputs.outColor = pb.vec4(this.normal, this.depth);
+                });
             }
         });
-        program.name = '@SSGI_Temporal';
+        program.name = '@SSGI_Surface';
         return program;
     }
-    /** @internal */ _createCombineProgram(ctx) {
+    /**
+   * Multiply the traced ambient occlusion into the scene color.
+   *
+   * This is the same multiply-into-final-color semantics the standalone SAO post
+   * effect applies, so enabling both double darkens.
+   *
+   * @internal
+   */ compositeAO(ctx, sceneColor, ao, srgbOutput) {
+        const key = srgbOutput ? 'srgb' : 'linear';
+        let program = SSGI._compositePrograms[key];
+        if (!program) {
+            program = this.createCompositeProgram(ctx, srgbOutput);
+            SSGI._compositePrograms[key] = program;
+        }
+        const hash = `${key}:${sceneColor.uid}:${ao.uid}`;
+        let bindGroup = this._compositeBindGroups[hash];
+        if (!bindGroup) {
+            bindGroup = ctx.device.createBindGroup(program.bindGroupLayouts[0]);
+            bindGroup.setTexture('colorTex', sceneColor, fetchSampler('clamp_nearest_nomip'));
+            // Nearest, not linear: the AO handed to this pass is already at full
+            // resolution, so filtering would only add a dependency on the WebGL
+            // half-float linear filtering cap for no gain.
+            bindGroup.setTexture('aoTex', ao, fetchSampler('clamp_nearest_nomip'));
+            this._compositeBindGroups[hash] = bindGroup;
+        }
+        bindGroup.setValue('aoParams', new Vector2(ctx.camera.ssgiAOIntensity, Math.max(1e-3, ctx.camera.ssgiAOPower)));
+        bindGroup.setValue('flip', this.needFlip(ctx.device) ? 1 : 0);
+        ctx.device.setProgram(program);
+        ctx.device.setBindGroup(0, bindGroup);
+        this.drawFullscreenQuad(AbstractPostEffect.getDefaultRenderState(ctx, 'always'));
+    }
+    /** @internal */ createCompositeProgram(ctx, srgbOutput) {
         const program = ctx.device.buildRenderProgram({
             vertex (pb) {
                 this.flip = pb.int().uniform(0);
                 this.$inputs.pos = pb.vec2().attrib('position');
                 this.$outputs.uv = pb.vec2();
                 pb.main(function() {
-                    this.$builtins.position = pb.vec4(this.$inputs.pos, 1, 1);
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, DEPTH_FARTHEST, 1);
                     this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
                     this.$if(pb.notEqual(this.flip, 0), function() {
                         this.$builtins.position.y = pb.neg(this.$builtins.position.y);
@@ -606,36 +1114,80 @@ import { FrameResources } from '../render/rendergraph/blackboard.js';
             },
             fragment (pb) {
                 this.colorTex = pb.tex2D().uniform(0);
-                this.radianceTex = pb.tex2D().uniform(0);
-                this.targetSize = pb.vec2().uniform(0);
-                this.ssgiIntensity = pb.float().uniform(0);
-                this.srgbOut = pb.int().uniform(0);
+                this.aoTex = pb.tex2D().uniform(0);
+                this.aoParams = pb.vec2().uniform(0);
                 this.$outputs.outColor = pb.vec4();
                 pb.main(function() {
-                    this.$l.screenUV = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.targetSize);
-                    this.$l.sceneColor = pb.textureSampleLevel(this.colorTex, this.screenUV, 0).rgb;
-                    // Invert the Reinhard compression applied by the trace pass
-                    // (x/(1+x) -> y/(1-y)); the clamp bounds the expansion so a fully
-                    // saturated texel cannot blow up to infinity.
-                    this.$l.compressed = pb.clamp(pb.textureSampleLevel(this.radianceTex, this.screenUV, 0).rgb, pb.vec3(0), pb.vec3(0.98));
-                    this.$l.radiance = pb.div(this.compressed, pb.sub(pb.vec3(1), this.compressed));
-                    // The forward pipeline keeps no albedo GBuffer; approximate the
-                    // surface reflectance by the chromaticity of the lit scene color
-                    // (hue preserved, luminance normalized). Unlike scaling by the
-                    // scene color itself this keeps indirect light visible in shadowed
-                    // areas - exactly where GI matters.
-                    this.$l.luma = pb.dot(this.sceneColor, pb.vec3(0.2126, 0.7152, 0.0722));
-                    this.$l.albedoApprox = pb.clamp(pb.div(this.sceneColor, pb.vec3(pb.add(this.luma, 1e-3))), pb.vec3(0), pb.vec3(1));
-                    this.$l.combined = pb.add(this.sceneColor, pb.mul(this.radiance, this.albedoApprox, this.ssgiIntensity));
-                    this.$if(pb.equal(this.srgbOut, 0), function() {
-                        this.$outputs.outColor = pb.vec4(this.combined, 1);
-                    }).$else(function() {
-                        this.$outputs.outColor = pb.vec4(linearToGamma(this, this.combined), 1);
+                    this.$l.color = pb.textureSampleLevel(this.colorTex, this.$inputs.uv, 0);
+                    this.$l.ao = pb.clamp(pb.textureSampleLevel(this.aoTex, this.$inputs.uv, 0).r, 0, 1);
+                    // mix() toward 1 rather than a plain multiply: intensity then doubles as
+                    // the fallback for noisy or unresolved texels, which matters most on the
+                    // WebGL path where there is no temporal accumulation to converge them.
+                    this.$l.shapedAO = pb.pow(this.ao, this.aoParams.y);
+                    this.$l.finalAO = pb.mix(pb.float(1), this.shapedAO, this.aoParams.x);
+                    this.$l.occludedColor = pb.mul(this.color.rgb, this.finalAO);
+                    this.$outputs.outColor = pb.vec4(srgbOutput ? linearToGamma(this, this.occludedColor) : this.occludedColor, this.color.a);
+                });
+            }
+        });
+        program.name = srgbOutput ? '@SSGI_CompositeAO_sRGB' : '@SSGI_CompositeAO';
+        return program;
+    }
+    /** @internal */ createUpsampleProgram(ctx) {
+        const program = ctx.device.buildRenderProgram({
+            vertex (pb) {
+                this.flip = pb.int().uniform(0);
+                this.$inputs.pos = pb.vec2().attrib('position');
+                this.$outputs.uv = pb.vec2();
+                pb.main(function() {
+                    this.$builtins.position = pb.vec4(this.$inputs.pos, DEPTH_FARTHEST, 1);
+                    this.$outputs.uv = pb.add(pb.mul(this.$inputs.pos.xy, 0.5), pb.vec2(0.5));
+                    this.$if(pb.notEqual(this.flip, 0), function() {
+                        this.$builtins.position.y = pb.neg(this.$builtins.position.y);
                     });
                 });
+            },
+            fragment (pb) {
+                this.sourceTex = pb.tex2D().uniform(0);
+                this.aoSourceTex = pb.tex2D().uniform(0);
+                this.depthTex = pb.tex2D().sampleType('unfilterable-float').uniform(0);
+                this.normalTex = pb.tex2D().uniform(0);
+                this.targetSize = pb.vec4().uniform(0);
+                this.guideParams = pb.vec4().uniform(0);
+                this.$outputs.outColor = pb.vec4();
+                this.$outputs.outAO = pb.vec4();
+                pb.main(function() {
+                    this.$l.uv = pb.div(pb.vec2(this.$builtins.fragCoord.xy), this.targetSize.zw);
+                    this.$l.centerDepth = pb.mul(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.uv, 0), this.guideParams.z);
+                    this.$l.centerNormal = pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.uv, 0).rgb, 2), pb.vec3(1)));
+                    this.$l.sum = pb.vec3(0);
+                    this.$l.weightSum = pb.float(0);
+                    this.$l.aoSum = pb.float(0);
+                    for(let y = -1; y <= 1; y++){
+                        for(let x = -1; x <= 1; x++){
+                            this.$l.sampleUV = pb.add(this.uv, pb.div(pb.vec2(x, y), this.targetSize.xy));
+                            this.$l.sampleValue = pb.textureSampleLevel(this.sourceTex, this.sampleUV, 0);
+                            this.$l.sampleAO = pb.textureSampleLevel(this.aoSourceTex, this.sampleUV, 0).r;
+                            this.$l.sampleDepth = pb.mul(ShaderHelper.sampleLinearDepth(this, this.depthTex, this.sampleUV, 0), this.guideParams.z);
+                            this.$l.sampleNormal = pb.normalize(pb.sub(pb.mul(pb.textureSampleLevel(this.normalTex, this.sampleUV, 0).rgb, 2), pb.vec3(1)));
+                            this.$l.depthWeight = pb.exp(pb.neg(pb.div(pb.abs(pb.sub(this.sampleDepth, this.centerDepth)), this.guideParams.x)));
+                            this.$l.normalWeight = pb.pow(pb.max(0, pb.dot(this.centerNormal, this.sampleNormal)), this.guideParams.y);
+                            this.$l.weight = pb.mul(this.depthWeight, this.normalWeight, this.sampleValue.a);
+                            this.sum = pb.add(this.sum, pb.mul(this.sampleValue.rgb, this.weight));
+                            this.weightSum = pb.add(this.weightSum, this.weight);
+                            // Same joint bilateral weights as the irradiance, so the upsampled
+                            // AO cannot cross a depth or normal edge the irradiance respects.
+                            this.aoSum = pb.add(this.aoSum, pb.mul(this.sampleAO, this.weight));
+                        }
+                    }
+                    this.$l.result = this.$choice(pb.greaterThan(this.weightSum, 1e-5), pb.div(this.sum, this.weightSum), pb.textureSampleLevel(this.sourceTex, this.uv, 0).rgb);
+                    this.$l.resultAO = this.$choice(pb.greaterThan(this.weightSum, 1e-5), pb.div(this.aoSum, this.weightSum), pb.textureSampleLevel(this.aoSourceTex, this.uv, 0).r);
+                    this.$outputs.outColor = pb.vec4(this.result, pb.float(pb.greaterThan(this.weightSum, 1e-5)));
+                    this.$outputs.outAO = pb.vec4(pb.clamp(this.resultAO, 0, 1));
+                });
             }
         });
-        program.name = '@SSGI_Combine';
+        program.name = '@SSGI_Upsample';
         return program;
     }
 }