@zephyr3d/scene 0.9.20 → 0.9.22

package/dist/posteffect/ssgi.js

@@ -0,0 +1,644 @@
+import { AbstractPostEffect, PostEffectLayer } from './posteffect.js';
+import { linearToGamma } from '../shaders/misc.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';
+import '../material/unlit.js';
+import '../material/particle.js';
+import '../material/subsurfaceprofile.js';
+import '../material/skin.js';
+import '@zephyr3d/device';
+import '../values.js';
+import '../material/meshmaterial.js';
+import '../material/grassmaterial.js';
+import '../material/terrain-cm.js';
+import '../material/pbrmr.js';
+import '../material/pbrsg.js';
+import '../material/mtoon.js';
+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';
+
+/**
+ * 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
+ */ 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(){
+        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.requireMotionVectorTexture} */ requireMotionVectorTexture(ctx) {
+        return !!ctx.camera.ssgiTemporal;
+    }
+    /**
+   * 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)) {
+            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',
+            sizeMode: 'absolute',
+            width: traceWidth,
+            height: traceHeight
+        };
+        const readCommon = (builder)=>{
+            if (linearDepthHandle) {
+                builder.read(linearDepthHandle);
+            }
+            // 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);
+            const out = builder.createTexture({
+                ...texDesc,
+                label: 'SSGI:trace'
+            });
+            const fb = builder.createFramebuffer({
+                label: 'SSGI:traceFB',
+                width: traceWidth,
+                height: traceHeight,
+                colorAttachments: out,
+                depthAttachment: null,
+                ignoreDepthStencil: true
+            });
+            builder.setExecute((rg)=>{
+                const device = ctx.device;
+                device.pushDeviceStates();
+                try {
+                    device.setFramebuffer(rg.getFramebuffer(fb));
+                    this.trace(ctx, rg.getTexture(s.input), getLinearDepth(rg));
+                } 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 out = builder.createTexture({
+                    ...texDesc,
+                    label: 'SSGI:temporal'
+                });
+                const fb = builder.createFramebuffer({
+                    label: 'SSGI:temporalFB',
+                    width: traceWidth,
+                    height: traceHeight,
+                    colorAttachments: out,
+                    depthAttachment: null,
+                    ignoreDepthStencil: true
+                });
+                builder.setExecute((rg)=>{
+                    const device = ctx.device;
+                    device.pushDeviceStates();
+                    try {
+                        this.temporal(ctx, rg.getTexture(traceHandle), rg.getTexture(prevRadianceHandle), rg.getTexture(prevMotionVectorHandle), rg.getFramebuffer(fb));
+                    } finally{
+                        device.popDeviceStates();
+                    }
+                });
+                return out;
+            });
+        }
+        // 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'
+                });
+                const out = builder.createTexture({
+                    ...texDesc,
+                    label: 'SSGI:blur'
+                });
+                const middleFB = builder.createFramebuffer({
+                    label: 'SSGI:blurHFB',
+                    width: traceWidth,
+                    height: traceHeight,
+                    colorAttachments: middle,
+                    depthAttachment: null,
+                    ignoreDepthStencil: true
+                });
+                const outFB = builder.createFramebuffer({
+                    label: 'SSGI:blurFB',
+                    width: traceWidth,
+                    height: traceHeight,
+                    colorAttachments: out,
+                    depthAttachment: null,
+                    ignoreDepthStencil: true
+                });
+                builder.setExecute((rg)=>{
+                    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));
+                    } finally{
+                        device.popDeviceStates();
+                    }
+                });
+                return out;
+            });
+        }
+        // 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)=>{
+            builder.read(s.input);
+            builder.read(finalRadianceHandle);
+            if (accumulatedHandle !== finalRadianceHandle) {
+                builder.read(accumulatedHandle);
+            }
+            if (motionVectorHandle) {
+                builder.read(motionVectorHandle);
+            }
+            readCommon(builder);
+            const output = s.createOutput(builder, {
+                needDepthAttachment: true
+            });
+            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);
+                        }
+                    }
+                } finally{
+                    device.popDeviceStates();
+                }
+            });
+            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 */ 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;
+            }
+            program = created;
+            SSGI._tracePrograms[hash] = program;
+        }
+        let bindGroup = this._traceBindGroups[hash];
+        if (!bindGroup) {
+            bindGroup = device.createBindGroup(program.bindGroupLayouts[0]);
+            this._traceBindGroups[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('flip', this.needFlip(device) ? 1 : 0);
+        device.setProgram(program);
+        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;
+        if (!program) {
+            program = this._createTemporalProgram(ctx);
+            SSGI._temporalProgram = program;
+        }
+        if (!this._temporalBindGroup) {
+            this._temporalBindGroup = device.createBindGroup(program.bindGroupLayouts[0]);
+        }
+        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);
+        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;
+        }
+        if (!this._combineBindGroup) {
+            this._combineBindGroup = device.createBindGroup(program.bindGroupLayouts[0]);
+        }
+        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'));
+    }
+    /** @internal */ _createTraceProgram(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, 1, 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.colorTex = pb.tex2D().uniform(0);
+                this.normalTex = pb.tex2D().uniform(0);
+                this.depthTex = pb.tex2D().uniform(0);
+                this.cameraNearFar = pb.vec2().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.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.$outputs.outColor = pb.vec4();
+                pb.func('getPosition', [
+                    pb.vec2('uv'),
+                    pb.mat4('mat')
+                ], 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));
+                });
+                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.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);
+                            } 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.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));
+                            });
+                        });
+                        // 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);
+                    });
+                    // 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) {
+        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.$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.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();
+                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.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);
+                        });
+                    });
+                });
+            }
+        });
+        program.name = '@SSGI_Temporal';
+        return program;
+    }
+    /** @internal */ _createCombineProgram(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, 1, 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.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.$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);
+                    });
+                });
+            }
+        });
+        program.name = '@SSGI_Combine';
+        return program;
+    }
+}
+
+export { SSGI };
+//# sourceMappingURL=ssgi.js.map