@woosh/meep-engine 3.58.0 → 3.60.0

package/src/shade/renderer/postprocess/gtao/GTAO.js

@@ -1,5 +1,5 @@
-import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
+import { graph_import_texture } from "../../shader/graph/graph_import_texture.js";
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
 import { shader_denoise_luminance_spatial } from "../denoise/fragment_shader_denoise_ao.js";
 import { ao_reproject_shader } from "./ao_reproject_shader.js";
@@ -17,6 +17,19 @@ export class GTAO {
      */
     #history = [];
 
+    /**
+     * When set, the next {@link graph_pass} takes this frame's AO alone and blends nothing of the
+     * history. For a cut the history cannot see: the camera jumped, or the scene changed.
+     * @type {boolean}
+     */
+    reset_history = true;
+
+    /**
+     * The frame the history was last written on. A frame that does not follow it — the pass was
+     * off for a while — does not blend against it.
+     * @type {number}
+     */
+    #history_frame_index = -1;
 
     /**
      *
@@ -34,16 +47,6 @@ export class GTAO {
         }
     }
 
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     */
-    resize(x, y) {
-
-        this.#history.forEach(t => t.resize(x, y));
-    }
-
     /**
      * Offer the pipelines {@link graph_pass} draws with — see {@link PipelineEnquiry}.
      *
@@ -58,26 +61,26 @@ export class GTAO {
 
     /**
      *
-     * @param {FrameGraph} graph
-     * @param {number} camera
-     * @param {number} input_depth
-     * @param {number} input_hzb
-     * @param {number} input_color
-     * @param {number} input_depth_previous
-     * @param {number} input_normal
-     * @param {number} input_velocity
-     * @param {number} input_occlusion
-     * @param {number} frame_index
-     * @param {number} output
-     * @param {number[]} resolution
-     * @returns {{occlusion:number, bent_normals:number, diffuse_indirect:number}}
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {number} options.camera this frame's camera uniform
+     * @param {number} options.input_depth this frame's depth
+     * @param {number} options.input_hzb hierarchical depth built from it
+     * @param {number} options.input_normal G-buffer normals
+     * @param {number} options.input_velocity per-pixel velocity, in this frame's pixels
+     * @param {number} options.input_occlusion depth-clip pass output: history confidence in r
+     * @param {number} options.frame_index the renderer's frame counter: drives the noise, the history
+     *   ping-pong, and whether the history follows on from the last frame drawn
+     * @param {number} options.output G-buffer albedo; AO is blended into its alpha
+     * @param {number[]} options.resolution this frame's render size
+     * @returns {{visibility:number, occlusion:number, bent_normals:number}} the accumulated visibility
+     *   moments, `output` after the composite, and the raw bent normals
      */
     graph_pass({
                    graph,
                    camera,
                    input_depth,
                    input_hzb,
-                   input_depth_previous,
                    input_normal,
                    input_velocity,
                    input_occlusion,
@@ -88,16 +91,19 @@ export class GTAO {
 
         graph.push_scope("GTAO");
 
-        this.resize(...resolution);
-
         const h0 = this.#history[frame_index % 2];
         const h1 = this.#history[(frame_index + 1) % 2];
 
-        const moments_history = graph.import_resource("ao_history", TextureResourceDescriptor.fromTexture(h0.gpu_texture), h0);
-        const moments_output = graph.import_resource("ao_output", TextureResourceDescriptor.fromTexture(h1.gpu_texture), h1);
+        // Only the texture written this frame follows the render size. The history keeps the size it
+        // was written at and is read by uv, so a resolution change resamples it once rather than
+        // throwing it away; it is resized in turn when it is written.
+        h1.resize(resolution[0], resolution[1]);
 
+        const moments_history = graph_import_texture(graph, h0, "ao_history");
+        const moments_output = graph_import_texture(graph, h1, "ao_output");
 
-        const [raw_occlusion, raw_bent_normals, raw_diffuse_gi] = graph_image_pass({
+
+        const [raw_occlusion, raw_bent_normals] = graph_image_pass({
             graph,
             shader: fragment_shader_gtao,
             output_resolution: resolution,
@@ -134,6 +140,11 @@ export class GTAO {
         });
 
 
+        const history_valid = !this.reset_history && this.#history_frame_index === frame_index - 1;
+
+        this.reset_history = false;
+        this.#history_frame_index = frame_index;
+
         [moments] = graph_image_pass({
             graph,
             shader: ao_reproject_shader,
@@ -144,6 +155,9 @@ export class GTAO {
                 tHistory: moments_history,
                 tVelocity: input_velocity,
                 tOcclusion: input_occlusion,
+                settings: {
+                    history_validity: history_valid ? 1 : 0,
+                },
             }
         });
 

package/src/shade/renderer/postprocess/gtao/ao_reproject_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AA8JA,8CAaE;4BArK0B,6BAA6B"}
+{"version":3,"file":"ao_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/ao_reproject_shader.js"],"names":[],"mappings":"AA4KA,8CAaE;4BAnL0B,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/ao_reproject_shader.js

@@ -8,11 +8,23 @@ import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { chunk_taa_velocity_confidence } from "../taa/shader_taa.js";
 import { chunk_taa_get_velocity } from "../velocity/chunk_taa_get_velocity.js";
 
+const AO_REPROJECT_SETTINGS_STRUCT = WebGPUStruct.from({
+    /**
+     * 1 to blend against the history, 0 to take this frame's moments alone: the first frame, a reset,
+     * or a frame that does not follow the one the history was written on.
+     */
+    history_validity: f32,
+});
+
 const resources = new ShaderResourceSetDescriptor();
 
+// per-pass, 4 bytes, read-only: immediate data rather than a uniform buffer.
+resources.setImmediate("settings", AO_REPROJECT_SETTINGS_STRUCT);
 resources.createGroup()
     .addTexture("tInput")
     .addTexture("tVelocity")
@@ -88,7 +100,7 @@ fn main(
     let history_within_screen = all( prevFrameScreenST >= vec2(0.0) ) && all( prevFrameScreenST < vec2f(resolution )) ;
     
     
-    let confidence = velocity_confidence * occlusion_confidence * select(0.0, 1.0,history_within_screen);
+    let confidence = velocity_confidence * occlusion_confidence * select(0.0, 1.0,history_within_screen) * settings.history_validity;
 
     
     var output: vec2<f32>;
@@ -99,7 +111,9 @@ fn main(
          output = current_moments;
     }else{
 
-        let prev_uv = prevFrameScreenST / vec2<f32>(textureDimensions(tHistory));
+        // a uv over this frame's size: the history keeps the size it was written at across a
+        // resolution change, so its own dimensions do not say where this frame's pixel was
+        let prev_uv = prevFrameScreenST / vec2<f32>(resolution);
 
         let history = texture_sample_catmullrom_hardware_5tap_uv(tHistory, sLinear, prev_uv);
         let history_moments = history.rg;

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#209@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#210@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/nss/NSS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NSS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS.js"],"names":[],"mappings":"AAgCA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAsaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IAuCD,uGAQC;IAzRD;;OAEG;IACH,sBAFW,eAAe,EAwCzB;IAhOD;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,eAFU,OAAO,CAEI;IAErB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;OAWG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,gBAFU,MAAM,CAEK;IAErB;;;;;;OAMG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEI;IACpB,wCAAwC;IACxC,eAD8B,MAAM,CAChB;IAkKpB;;;;;OAKG;IACH,+BAyHC;IAED,wCAAwC;IACxC,0BAEC;IArKD;;OAEG;IACH,gBA4BC;IAwID;;OAEG;IACH,uCAEC;IAED;;OAEG;IACH,mCAEC;IAcD;;OAEG;IACH,2BAEC;IA4CD,2BAAkF;IAClF,0BAA+C;IAE/C;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAf4B,KAAK,EAAtB,UAAU;QACG,qBAAqB,EAAlC,MAAM;QACO,qBAAqB,EAAlC,MAAM;QACO,gBAAgB,EAA7B,MAAM;QACO,+BAA+B,EAA5C,MAAM;QAKO,qBAAqB,EAAlC,MAAM;QACO,cAAc,EAA3B,MAAM;QACS,iBAAiB,EAAhC,MAAM,EAAE;QACO,iBAAiB,EAAhC,MAAM,EAAE;QACN,MAAM,CA0NlB;;CACJ;yBAhwBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;2BATpC,iBAAiB;0CAvBF,oDAAoD"}
+{"version":3,"file":"NSS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS.js"],"names":[],"mappings":"AAgCA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAsaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IAsCD,uGAQC;IAxRD;;OAEG;IACH,sBAFW,eAAe,EAwCzB;IAhOD;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,eAFU,OAAO,CAEI;IAErB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;OAWG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,gBAFU,MAAM,CAEK;IAErB;;;;;;OAMG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEI;IACpB,wCAAwC;IACxC,eAD8B,MAAM,CAChB;IAkKpB;;;;;OAKG;IACH,+BAyHC;IAED,wCAAwC;IACxC,0BAEC;IArKD;;OAEG;IACH,gBA4BC;IAwID;;OAEG;IACH,uCAEC;IAED;;OAEG;IACH,mCAEC;IAcD;;OAEG;IACH,2BAEC;IA2CD,2BAAkF;IAClF,0BAA+C;IAE/C;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAf4B,KAAK,EAAtB,UAAU;QACG,qBAAqB,EAAlC,MAAM;QACO,qBAAqB,EAAlC,MAAM;QACO,gBAAgB,EAA7B,MAAM;QACO,+BAA+B,EAA5C,MAAM;QAKO,qBAAqB,EAAlC,MAAM;QACO,cAAc,EAA3B,MAAM;QACS,iBAAiB,EAAhC,MAAM,EAAE;QACO,iBAAiB,EAAhC,MAAM,EAAE;QACN,MAAM,CA4NlB;;CACJ;yBAjwBY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;2BATpC,iBAAiB;0CAvBF,oDAAoD"}

package/src/shade/renderer/postprocess/nss/NSS.js

@@ -543,9 +543,8 @@ export class NSS {
         this.#pre_output_texture.resize(render_w, render_h, groups(NSS_HEAD_INPUT_CHANNELS));
         this.#network_output_texture.resize(render_w, render_h, groups(NSS_NETWORK_OUTPUT_CHANNELS));
 
-        for (const t of this.#feedback_textures) {
-            t.resize(render_w, render_h);
-        }
+        // The feedback is not resized here: it is history, read by uv, so it keeps the size it was
+        // written at and only the texture written this frame follows the render size (graph_pass).
     }
 
     static #preprocess_tensor_descriptor(render_w, render_h) {
@@ -607,6 +606,8 @@ export class NSS {
         const fb_idx_in = this.#frame_count % 2;
         const fb_idx_out = (this.#frame_count + 1) % 2;
 
+        this.#feedback_textures[fb_idx_out].resize(render_w, render_h);
+
         const gr_feedback_in = graph_import_texture(graph, this.#feedback_textures[fb_idx_in], "nss_feedback_in");
         const gr_feedback_out = graph_import_texture(graph, this.#feedback_textures[fb_idx_out], "nss_feedback_out");
 

package/src/shade/renderer/postprocess/ssr/SSR.d.ts

@@ -54,12 +54,16 @@ export class SSR {
      *   while Brick4 runs
      * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
      *   scene's, while LPV runs. A source not given is the resolve's default, for a variant that does not read it
+     * @param {number} [options.input_indirect_diffuse] the deferred pass's indirect diffuse, irradiance with AO in,
+     *   while the probe clipmap runs: its bounce at a hit reads the hit's texel. Recorded before this pass
+     * @param {import("../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} options.probes
+     *   the renderer's probe clipmap GI, bound in every mode: a clipmap of no cascade while it has no probes
      * @param {import("../../view/GPUViewContext.js").GPUViewContext} [options.view_ctx]
      * @param {ArrayLike<number>} [options.jitter] Raster jitter in internal pixels
      * @param {number} [options.mip] Higher mip = lower resolution trace
      * @returns {{final:number, trace:number, reflections:number, denoised:number, denoised_1:number, denoise_tiles:number}}
      */
-    graph_pass({ graph, input_depth, input_depth_previous, view_ctx, jitter, input_hzb, input_scene_color, input_pbr, input_normal, input_velocity, input_occlusion, input_albedo, resolution, camera_current, camera_previous, input_environment, shader_switches, lpv, brick4, mip, }: {
+    graph_pass({ graph, input_depth, input_depth_previous, view_ctx, jitter, input_hzb, input_scene_color, input_pbr, input_normal, input_velocity, input_occlusion, input_albedo, resolution, camera_current, camera_previous, input_environment, shader_switches, lpv, brick4, input_indirect_diffuse, probes, mip, }: {
         graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
         input_depth: number;
         input_depth_previous?: number;
@@ -77,6 +81,8 @@ export class SSR {
         shader_switches?: ShaderSwitchSet;
         brick4?: import("../../global_illumination/brick4/Brick4LightMap.js").Brick4LightMap;
         lpv?: import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume;
+        input_indirect_diffuse?: number;
+        probes: import("../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI;
         view_ctx?: import("../../view/GPUViewContext.js").GPUViewContext;
         jitter?: ArrayLike<number>;
         mip?: number;

package/src/shade/renderer/postprocess/ssr/SSR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IA6EI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA1ED,oBAAgB;IAWhB,2CAMC;IAZD;;;;OAIG;IACH,sCAAqE;IAoCrE,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAxBnD,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IAY3E,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAzBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QAEuE,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QAEkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAElB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,aAAa,EAAC,MAAM,CAAA;KAAC,CAsQtH;;CACJ;gCApa+B,0CAA0C"}
+{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IA6EI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA1ED,oBAAgB;IAWhB,2CAMC;IAZD;;;;OAIG;IACH,sCAAqE;IAoCrE,kCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAxBnD,8CAOC;IATD,iGAAiG;IACjG,yCAA2E;IAY3E,qCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH;QA7BsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QAEuE,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QAEkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAEjE,sBAAsB,GAAvC,MAAM;QAE4F,MAAM,EAAxG,OAAO,8DAA8D,EAAE,iBAAiB;QAExB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;QACJ;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,QAAQ,EAAC,MAAM,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,aAAa,EAAC,MAAM,CAAA;KAAC,CAkRtH;;CACJ;gCApb+B,0CAA0C"}

package/src/shade/renderer/postprocess/ssr/SSR.js

@@ -152,6 +152,10 @@ export class SSR {
      *   while Brick4 runs
      * @param {import("../../global_illumination/lpv/GPULightProbeVolume.js").GPULightProbeVolume} [options.lpv] the
      *   scene's, while LPV runs. A source not given is the resolve's default, for a variant that does not read it
+     * @param {number} [options.input_indirect_diffuse] the deferred pass's indirect diffuse, irradiance with AO in,
+     *   while the probe clipmap runs: its bounce at a hit reads the hit's texel. Recorded before this pass
+     * @param {import("../../global_illumination/probe_clipmap/GPUProbeClipmapGI.js").GPUProbeClipmapGI} options.probes
+     *   the renderer's probe clipmap GI, bound in every mode: a clipmap of no cascade while it has no probes
      * @param {import("../../view/GPUViewContext.js").GPUViewContext} [options.view_ctx]
      * @param {ArrayLike<number>} [options.jitter] Raster jitter in internal pixels
      * @param {number} [options.mip] Higher mip = lower resolution trace
@@ -177,11 +181,14 @@ export class SSR {
                    shader_switches = ShaderSwitchSet.EMPTY,
                    lpv,
                    brick4,
+                   input_indirect_diffuse,
+                   probes,
                    mip = 0,
                }) {
 
         assert.defined(camera_current, 'camera');
         assert.isNonNegativeInteger(input_environment, 'input_environment');
+        assert.defined(probes, 'probes');
 
         const resolve_shader = ssr_resolve_shader.variant(shader_switches);
 
@@ -288,6 +295,15 @@ export class SSR {
             resolve_inputs.lpv_atlas_depth = lpv.atlas.texture_depth;
         }
 
+        if (input_indirect_diffuse !== undefined) {
+            assert.isNonNegativeInteger(input_indirect_diffuse, 'input_indirect_diffuse');
+
+            resolve_inputs.tIndirectDiffuse = input_indirect_diffuse;
+        }
+
+        // the probes in every mode, having no default: no cascade but while the probe clipmap runs
+        probes.write_sampling_bindings(resolve_inputs);
+
         const [reflections, reflection_metadata] = graph_image_pass({
             graph,
             shader: resolve_shader,

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.d.ts

@@ -1,3 +1,10 @@
+/**
+ * The deferred pass's indirect diffuse, irradiance E with AO multiplied in, as `shader_resolve_indirect_lighting`
+ * takes it, which {@link chunk_ssr_add_hit_irradiance_probe_clipmap} reads at the hit. Black by default, for the
+ * modes that hand the resolve none.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SSR_INDIRECT_DIFFUSE_RESOURCE: ShaderResourceDescriptor;
 /**
  * {@link chunk_ssr_add_hit_irradiance} for a mode that adds nothing: the call is empty.
  * @type {CodeChunk}
@@ -10,10 +17,20 @@ export const chunk_ssr_add_hit_irradiance_none: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_ssr_add_hit_irradiance_lpv: CodeChunk;
+/**
+ * {@link chunk_ssr_add_hit_irradiance} from the probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): the
+ * light the deferred pass gave the hit's own texel, reflected by its albedo, so a reflection shows the
+ * indirect diffuse the surface it hits shows, its AO and its fallback included. The deferred pass has already
+ * picked the probes at every texel. Picking them again at the hit cost 41% of the resolve on an RDNA2 iGPU
+ * for the 1% of texels that hit, because a wave pays the whole pick for a few scattered lanes; this texel
+ * load costs 1.4%. Reads `tIndirectDiffuse` and `tAlbedoAO`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_probe_clipmap: CodeChunk;
 /**
  * The indirect light SSR's resolve adds to an on-screen hit, by the renderer's indirect lighting mode
- * ({@link INDIRECT_LIGHTING}): one diffuse bounce from the light probe volume under LPV, nothing under
- * the others.
+ * ({@link INDIRECT_LIGHTING}): one diffuse bounce, from the light probe volume under LPV and from the
+ * deferred pass's indirect diffuse at the hit under the probe clipmap; nothing under the others.
  *
  * ```wgsl
  * fn ssr_add_hit_irradiance(result: ptr<function, vec3f>, confidence, position_ws, hit_position_vs,
@@ -23,6 +40,7 @@ export const chunk_ssr_add_hit_irradiance_lpv: CodeChunk;
  * @type {CodeChunkChoice}
  */
 export const chunk_ssr_add_hit_irradiance: CodeChunkChoice;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
 //# sourceMappingURL=chunk_ssr_add_hit_irradiance.d.ts.map

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_add_hit_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH,gDAFU,SAAS,CAcR;AAEX;;;;;GAKG;AACH,+CAFU,SAAS,CAyBZ;AAKP;;;;;;;;;;;GAWG;AACH,2CAFU,eAAe,CAE2D;0BArE1D,uCAAuC;gCACjC,6CAA6C"}
+{"version":3,"file":"chunk_ssr_add_hit_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,4CAFU,wBAAwB,CAQhC;AAEF;;;GAGG;AACH,gDAFU,SAAS,CAcR;AAEX;;;;;GAKG;AACH,+CAFU,SAAS,CAyBZ;AAKP;;;;;;;;GAQG;AACH,yDAFU,SAAS,CAsBZ;AAKP;;;;;;;;;;;GAWG;AACH,2CAFU,eAAe,CAE2D;yCAnH3C,sDAAsD;0BAJrE,uCAAuC;gCACjC,6CAA6C"}

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js

@@ -7,6 +7,22 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
 import { CAMERA_RESOURCE } from "../../../camera/CAMERA_RESOURCE.js";
 import { GBUFFER_ALBEDO_AO_RESOURCE } from "../../../deferred/GBUFFER_RESOURCES.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { BLACK_PIXEL_TEXTURE } from "../../../texture/util/BLACK_PIXEL_TEXTURE.js";
+
+/**
+ * The deferred pass's indirect diffuse, irradiance E with AO multiplied in, as `shader_resolve_indirect_lighting`
+ * takes it, which {@link chunk_ssr_add_hit_irradiance_probe_clipmap} reads at the hit. Black by default, for the
+ * modes that hand the resolve none.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SSR_INDIRECT_DIFFUSE_RESOURCE = ShaderResourceDescriptor.texture(
+    "tIndirectDiffuse",
+    "unfilterable-float",
+    "2d",
+    false,
+    BLACK_PIXEL_TEXTURE
+);
 
 /**
  * {@link chunk_ssr_add_hit_irradiance} for a mode that adds nothing: the call is empty.
@@ -60,10 +76,44 @@ fn ssr_add_hit_irradiance(
 chunk_ssr_add_hit_irradiance_lpv.requireResource(CAMERA_RESOURCE);
 chunk_ssr_add_hit_irradiance_lpv.requireResource(GBUFFER_ALBEDO_AO_RESOURCE);
 
+/**
+ * {@link chunk_ssr_add_hit_irradiance} from the probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): the
+ * light the deferred pass gave the hit's own texel, reflected by its albedo, so a reflection shows the
+ * indirect diffuse the surface it hits shows, its AO and its fallback included. The deferred pass has already
+ * picked the probes at every texel. Picking them again at the hit cost 41% of the resolve on an RDNA2 iGPU
+ * for the 1% of texels that hit, because a wave pays the whole pick for a few scattered lanes; this texel
+ * load costs 1.4%. Reads `tIndirectDiffuse` and `tAlbedoAO`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_add_hit_irradiance_probe_clipmap = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_add_hit_irradiance(
+    result: ptr<function, vec3f>,
+    confidence: f32,
+    position_ws: vec3f,
+    hit_position_vs: vec3f,
+    hit_normal_ws: vec3f,
+    hit_coord: vec2u,
+) {
+    if (confidence > 0.05) {
+        let hit_irradiance = textureLoad(tIndirectDiffuse, hit_coord, 0).rgb;
+        let hit_albedo = textureLoad(tAlbedoAO, hit_coord, 0).rgb;
+
+        *result += hit_albedo * hit_irradiance * RECIPROCAL_PI;
+    }
+}
+    `, [
+        RECIPROCAL_PI_DECLARATION,
+    ]);
+
+chunk_ssr_add_hit_irradiance_probe_clipmap.requireResource(SSR_INDIRECT_DIFFUSE_RESOURCE);
+chunk_ssr_add_hit_irradiance_probe_clipmap.requireResource(GBUFFER_ALBEDO_AO_RESOURCE);
+
 /**
  * The indirect light SSR's resolve adds to an on-screen hit, by the renderer's indirect lighting mode
- * ({@link INDIRECT_LIGHTING}): one diffuse bounce from the light probe volume under LPV, nothing under
- * the others.
+ * ({@link INDIRECT_LIGHTING}): one diffuse bounce, from the light probe volume under LPV and from the
+ * deferred pass's indirect diffuse at the hit under the probe clipmap; nothing under the others.
  *
  * ```wgsl
  * fn ssr_add_hit_irradiance(result: ptr<function, vec3f>, confidence, position_ws, hit_position_vs,
@@ -77,4 +127,4 @@ export const chunk_ssr_add_hit_irradiance = CodeChunkChoice.from(INDIRECT_LIGHTI
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_add_hit_irradiance_none);
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_add_hit_irradiance_none);
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_add_hit_irradiance_lpv);
-chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_add_hit_irradiance_none);
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_add_hit_irradiance_probe_clipmap);

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.d.ts

@@ -14,10 +14,18 @@ export const chunk_ssr_sample_radiance_brick4: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_ssr_sample_radiance_lpv: CodeChunk;
+/**
+ * {@link chunk_ssr_sample_radiance} from the probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): the probes'
+ * specular at the point, picked by its normal and view with STBN at the pixel and the resolve's frame index, as
+ * Brick4's is; the environment's where no probe weighs anything. Reads the probes' group, `tSTBN_vec2`, the
+ * resolve's `settings.frame_index` and `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_probe_clipmap: CodeChunk;
 /**
  * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
- * lighting mode ({@link INDIRECT_LIGHTING}). The probe clipmap falls back to the environment map until
- * it samples its own probes.
+ * lighting mode ({@link INDIRECT_LIGHTING}). The probe clipmap falls back to its probes' specular, and to
+ * the environment map where they find nothing.
  *
  * ```wgsl
  * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,4CAFU,SAAS,CAUc;AAEjC;;;;GAIG;AACH,+CAFU,SAAS,CAUoB;AAEvC;;;GAGG;AACH,4CAFU,SAAS,CAUiB;AAEpC;;;;;;;;;;GAUG;AACH,wCAFU,eAAe,CAEwD;0BAzDvD,uCAAuC;gCACjC,6CAA6C"}
+{"version":3,"file":"chunk_ssr_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,4CAFU,SAAS,CAUc;AAEjC;;;;GAIG;AACH,+CAFU,SAAS,CAUoB;AAEvC;;;GAGG;AACH,4CAFU,SAAS,CAUiB;AAEpC;;;;;;GAMG;AACH,sDAFU,SAAS,CAiB2E;AAE9F;;;;;;;;;;GAUG;AACH,wCAFU,eAAe,CAEwD;0BAjFvD,uCAAuC;gCACjC,6CAA6C"}

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js

@@ -1,8 +1,12 @@
 import { chunk_get_ibl_radiance } from "../../../deferred/indirect/chunk_get_ibl_radiance.js";
 import { chunk_brick4_sample_specular } from "../../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_specular.js";
+import {
+    chunk_probe_clipmap_sample_radiance
+} from "../../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
 import { INDIRECT_LIGHTING } from "../../../INDIRECT_LIGHTING.js";
 import { ShadeIndirectLightingMode } from "../../../ShadeIndirectLightingMode.js";
 import { chunk_lpv_sample_radiance } from "../../../shader/chunk/light/lpv/chunk_lpv_sample_radiance.js";
+import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
 
@@ -49,10 +53,34 @@ fn ssr_sample_radiance(
 }
     `, [chunk_lpv_sample_radiance]);
 
+/**
+ * {@link chunk_ssr_sample_radiance} from the probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): the probes'
+ * specular at the point, picked by its normal and view with STBN at the pixel and the resolve's frame index, as
+ * Brick4's is; the environment's where no probe weighs anything. Reads the probes' group, `tSTBN_vec2`, the
+ * resolve's `settings.frame_index` and `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_ssr_sample_radiance_probe_clipmap = CodeChunk.from(
+    //language=WGSL
+    `
+fn ssr_sample_radiance(
+    position_ws: vec3f, normal_ws: vec3f, view_direction_ws: vec3f, roughness: f32, coord: vec2u,
+) -> vec3f {
+    let noise = stbn_sample_vec2(vec3u(coord, settings.frame_index));
+    let probes = probe_clipmap_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, noise);
+
+    if (probes.found) {
+        return probes.radiance;
+    }
+
+    return get_ibl_radiance(view_direction_ws, normal_ws, roughness);
+}
+    `, [chunk_probe_clipmap_sample_radiance, chunk_stbn_sample_vec2, chunk_get_ibl_radiance]);
+
 /**
  * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
- * lighting mode ({@link INDIRECT_LIGHTING}). The probe clipmap falls back to the environment map until
- * it samples its own probes.
+ * lighting mode ({@link INDIRECT_LIGHTING}). The probe clipmap falls back to its probes' specular, and to
+ * the environment map where they find nothing.
  *
  * ```wgsl
  * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f
@@ -65,4 +93,4 @@ export const chunk_ssr_sample_radiance = CodeChunkChoice.from(INDIRECT_LIGHTING)
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_sample_radiance_ibl);
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_sample_radiance_brick4);
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_sample_radiance_lpv);
-chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_sample_radiance_ibl);
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_sample_radiance_probe_clipmap);

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AAsWA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BAxWyB,gCAAgC"}
+{"version":3,"file":"ssr_resolve_shader.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js"],"names":[],"mappings":"AA4WA;;;;;;;GAOG;AACH,iCAFU,WAAW,CAgBlB;4BA9WyB,gCAAgC"}

package/src/shade/renderer/postprocess/ssr/resolve/ssr_resolve_shader.js

@@ -13,7 +13,7 @@ import { chunk_rgb_to_YCoCg } from "../../../shader/chunk/color/YCoCg/chunk_rgb_
 import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
 import { chunk_v3_matrix4_project } from "../../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
 import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
-import { F16_MAX_DEFINITION } from "../../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { F16_MAX_DEFINITION } from "../../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
 import { chunk_murmur3_vec3u } from "../../../shader/chunk/random/murmur/chunk_murmur3_vec3u.js";
 import { chunk_texel_coordinate_to_uv } from "../../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
@@ -26,11 +26,12 @@ import { chunk_get_neighbour_weight } from "./chunk_get_neighbour_weight.js";
 import { chunk_get_ray_mip_level } from "./chunk_get_ray_mip_level.js";
 import { chunk_reconstruct_pdf } from "./chunk_reconstruct_pdf.js";
 import { BRICK4_DATA_STRUCT } from "../../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS } from "../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { BLACK_PIXEL_TEXTURE } from "../../../texture/util/BLACK_PIXEL_TEXTURE.js";
 import { ZERO_UINT_PIXEL_TEXTURE } from "../../../texture/util/ZERO_UINT_PIXEL_TEXTURE.js";
-import { chunk_ssr_add_hit_irradiance } from "./chunk_ssr_add_hit_irradiance.js";
+import { chunk_ssr_add_hit_irradiance, SSR_INDIRECT_DIFFUSE_RESOURCE } from "./chunk_ssr_add_hit_irradiance.js";
 import { chunk_ssr_sample_radiance } from "./chunk_ssr_sample_radiance.js";
 import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
 
@@ -40,17 +41,19 @@ const RESOLVE_UNIFORMS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// What every indirect lighting mode samples where the trace found nothing, whichever the variant
-// reads (chunk_ssr_sample_radiance, chunk_ssr_add_hit_irradiance): the environment, Brick4's probes and
-// the noise that jitters them, and the light probe volume. The pass binds only the running mode's, and each
-// mode's source has a default for the others: black textures, transient buffers, a volume of no probes.
+// What every indirect lighting mode samples where the trace found nothing, or adds at a hit, whichever the
+// variant reads (chunk_ssr_sample_radiance, chunk_ssr_add_hit_irradiance): the environment, Brick4's probes
+// and the noise that jitters them, the light probe volume, and the deferred pass's indirect diffuse, which
+// the probe clipmap's bounce reads. The pass binds only the running mode's, and each mode's source has a
+// default for the others: black textures, transient buffers, a volume of no probes.
 resources.createGroup()
     .addTexture("tEnvironment", "float")
     .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE)
     .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
     .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
     .addTexture("lpv_atlas_radiance", "uint", "2d", false, ZERO_UINT_PIXEL_TEXTURE)
-    .addTexture("lpv_atlas_depth", "float", "2d", false, BLACK_PIXEL_TEXTURE);
+    .addTexture("lpv_atlas_depth", "float", "2d", false, BLACK_PIXEL_TEXTURE)
+    .add(SSR_INDIRECT_DIFFUSE_RESOURCE);
 // the light probe volume
 resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
 
@@ -63,9 +66,9 @@ resources.createGroup()
     .addTexture("tNormal", "uint")
     .addTexture("tColor", "float")
     .addTexture("tAlbedoAO", "unfilterable-float")
-    .addSampler("sLinear", "filtering", SAMPLER_TRILINEAR_CLAMP)
+    .addSampler("sLinear", "filtering", SAMPLER_TRILINEAR_CLAMP)
+
 
-
 
 
 
@@ -74,6 +77,9 @@ resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
 ;
 
+// the probe clipmap's probes, which its owner binds in every mode: a clipmap of no cascade out of the mode
+resources.addGroup(PROBE_CLIPMAP_SAMPLING_GROUP);
+
 const body = CodeChunk.from(
     //language=WGSL
     `
@@ -323,7 +329,7 @@ fn main(
 
     // compute variance
     let luma = rgb_to_luminance(result);
-    let raw_variance = result_luma_moment2 - luma*luma;
+    let raw_variance = result_luma_moment2 - luma*luma;
     let variance = select(0.0, clamp(raw_variance, 0.0, F16_MAX), raw_variance == raw_variance);
 
     var output: SSRResolveOutput;
@@ -350,7 +356,7 @@ fn main(
         chunk_get_ray_mip_level,
         chunk_project_view_position_from_depth,
         chunk_v3_matrix4_project,
-        F16_MAX_DEFINITION,
+        F16_MAX_DEFINITION,
         RECIPROCAL_PI_DECLARATION,
         chunk_rgb_to_luminance,
     ]

package/src/shade/renderer/postprocess/taa/TAA.d.ts

@@ -47,15 +47,17 @@ export class TAA {
      * @param {number} options.texture_color_history
      * @param {number} options.texture_output
      * @param {number} options.texture_occlusion depth-clip pass output: confidence in r, nearest-depth offset in g
-     * @param view
+     * @param {ArrayLike<number>} options.output_resolution size of `texture_output`; the history keeps
+     *   the size it was resolved at across a resize
      */
-    graph_pass({ graph, texture_velocity, texture_color_current, texture_color_history, texture_output, texture_occlusion, }: {
+    graph_pass({ graph, texture_velocity, texture_color_current, texture_color_history, texture_output, texture_occlusion, output_resolution, }: {
         graph: FrameGraph;
         texture_velocity: number;
         texture_color_current: number;
         texture_color_history: number;
         texture_output: number;
         texture_occlusion: number;
+        output_resolution: ArrayLike<number>;
     }): number;
     #private;
 }

package/src/shade/renderer/postprocess/taa/TAA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH;IAEI;;;;OAIG;IACH,eAFU,OAAO,CAEK;IAatB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;OAEG;IACH,uCAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,0BAHW,eAAe,0CAKzB;IAED;;;;;;;;;;OAUG;IACH;QAR+B,KAAK;QACT,gBAAgB,EAAhC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,iBAAiB,EAAjC,MAAM;eAkChB;;CACJ;8BAlHY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"TAA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/TAA.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAEI;;;;OAIG;IACH,eAFU,OAAO,CAEK;IAatB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;OAEG;IACH,uCAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,0BAHW,eAAe,0CAKzB;IAED;;;;;;;;;;;OAWG;IACH;QAT+B,KAAK;QACT,gBAAgB,EAAhC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,qBAAqB,EAArC,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACqB,iBAAiB,EAA5C,UAAU,MAAM,CAAC;eAqC3B;;CACJ;8BAtHY,OAAO,6CAA6C,EAAE,eAAe"}