@woosh/meep-engine 3.57.0 → 3.59.0

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 "__#200@#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,3 +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_probe_clipmap);

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

@@ -14,9 +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}):
+ * 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;;;;;;;;;GASG;AACH,wCAFU,eAAe,CAEwD;0BAxDvD,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,9 +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}):
+ * 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
@@ -64,3 +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_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"}

package/src/shade/renderer/postprocess/taa/TAA.js

@@ -1,6 +1,7 @@
 //
 
 
+import { assert } from "../../../../core/assert.js";
 import { TemporalJitterSequence } from "../TemporalJitterSequence.js";
 import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { shader_taa } from "./shader_taa.js";
@@ -86,7 +87,8 @@ 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,
@@ -95,7 +97,9 @@ export class TAA {
                    texture_color_history = -1,
                    texture_output,
                    texture_occlusion = -1,
+                   output_resolution,
                }) {
+        assert.isArrayLike(output_resolution, 'output_resolution');
 
         const history_validity = this.reset_history ? 0.0 : 1.0;
 
@@ -112,6 +116,7 @@ export class TAA {
                 tOcclusion: texture_occlusion,
                 settings: {
                     jitter: this.Jitter,
+                    output_resolution,
                     history_validity,
                 }
             },

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_fsr2_compute_depth_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAFU,SAAS,CA6FjB;0BAzHwB,oCAAoC"}
+{"version":3,"file":"chunk_fsr2_compute_depth_clip.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAFU,SAAS,CAkGjB;0BA9HwB,oCAAoC"}

package/src/shade/renderer/postprocess/taa/chunk_fsr2_compute_depth_clip.js

@@ -42,11 +42,16 @@ fn fsr2_compute_depth_clip(
     render_size: vec2<i32>
 ) -> f32 {
     let fCurrentDepthViewSpace = get_view_space_depth(current_depth_sample, camera_current);
-    
+
+    // previous_coord is in this frame's pixels, and the previous depth keeps the size it was drawn
+    // at across a resolution change, so carry the position into its grid. Equal sizes scale by 1.
+    let previous_size = vec2<i32>(textureDimensions(PrevDepthBuffer));
+    let previous_st = previous_coord * vec2<f32>(previous_size) / vec2<f32>(render_size);
+
     // matches FSR2's GetBilinearSamplingData: iBasePos = floor(prev_coord - 0.5).
     // floor (not truncate) so the bilinear footprint stays correct for negative coords.
-    let sample_coord_fract = fract(previous_coord + 0.5);
-    let sample_coord_i = vec2<i32>(floor(previous_coord - 0.5));
+    let sample_coord_fract = fract(previous_st + 0.5);
+    let sample_coord_i = vec2<i32>(floor(previous_st - 0.5));
     let bilinear_weights = get_bilinear_weights(sample_coord_fract);
 
     var fDilatedSum = 0.0f;
@@ -68,14 +73,14 @@ fn fsr2_compute_depth_clip(
         let iOffset = offsets[iSampleIndex];
         let iSamplePos = sample_coord_i + iOffset;
 
-        if (is_on_screen_i32(iSamplePos, render_size)) {
+        if (is_on_screen_i32(iSamplePos, previous_size)) {
             let fWeight = bilinear_weights[iSampleIndex];
             
             if (fWeight > fReconstructedDepthBilinearWeightThreshold) {
 
                 // 2x2 min-gather of raw prev depth picks the FARTHEST in inverted
                 // depth — see the file docstring for why this is intentional.
-                let fPrevDepthSample = texture_sample_red_min_st(PrevDepthBuffer, previous_coord + vec2<f32>(iOffset) - 0.5, 0);
+                let fPrevDepthSample = texture_sample_red_min_st(PrevDepthBuffer, previous_st + vec2<f32>(iOffset) - 0.5, 0);
                 let fPrevNearestDepthViewSpace = get_view_space_depth(fPrevDepthSample, camera_previous);
 
                 let fDepthDiff = fCurrentDepthViewSpace - fPrevNearestDepthViewSpace;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AAwCA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA+LF,qCAaG;0BAhRuB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_taa.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/taa/shader_taa.js"],"names":[],"mappings":"AA6CA,+CAAgD;AAGhD;;;GAGG;AACH,4CAFU,SAAS,CASjB;AAEF;;;;GAIG;AACH,gDAFU,SAAS,CAgBjB;AA6LF,qCAaG;0BAnRuB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/postprocess/taa/shader_taa.js

@@ -1,6 +1,6 @@
 import { f32, vec2f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
+import { chunk_aabb3_normalized_dist } from "../../shader/chunk/geometry/aabb3/chunk_line_aabb3_clipping_distance.js";
 import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
 import {
     chunk_texture_sample_catmullrom_hardware_5tap_uv
@@ -18,6 +18,11 @@ import { chunk_taa_history_color_bounding_box_YCoCg } from "./chunk_taa_history_
 
 const TAA_SETTINGS_STRUCT = WebGPUStruct.from({
     jitter: vec2f,
+    /**
+     * Size of the target this pass resolves into, in pixels. Not the history's: across a resize the
+     * history keeps the size it was resolved at, and is read by uv.
+     */
+    output_resolution: vec2f,
     /**
      * Used to reset history, should be 1.0 except when reset is required
      */
@@ -26,12 +31,12 @@ const TAA_SETTINGS_STRUCT = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// per-pass, 16 bytes, read-only: immediate data rather than a uniform buffer.
+// per-pass, 24 bytes, read-only: immediate data rather than a uniform buffer.
 resources.setImmediate("settings", TAA_SETTINGS_STRUCT);
 resources.createGroup()
     .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
     .addTexture("VelocityBuffer", "float") // raw velocity, in internal pixels
-    .addTexture("HistoryTexture", "float") // previous resolved frame, at output resolution.
+    .addTexture("HistoryTexture", "float") // previous resolved frame, at the output resolution it was resolved at.
     .addTexture("ColourTexture", "float") // incoming frame, drawn at internal resolution. Typically lower than output.
     .addTexture("tOcclusion", "float") // depth-clip pass output at internal resolution: r confidence, g nearest-depth offset
 ;
@@ -87,9 +92,7 @@ const body = CodeChunk.from(
 //language=WGSL
     `
 fn uv_within_screen( pixel:vec2<f32> ) -> f32{
-    let render_size = textureDimensions(HistoryTexture);
-
-    if(  all( pixel >= vec2( 0.f, 0.f ) ) && all( pixel < vec2f( render_size ) )  ){ 
+    if(  all( pixel >= vec2( 0.f, 0.f ) ) && all( pixel < settings.output_resolution )  ){ 
         return 1.0f;
     } else{
         return  0.f;
@@ -102,10 +105,10 @@ fn main(
     @location(0) uv: vec2<f32>,
 ) -> @location(0) vec4<f32> {
     let resolution_internal = textureDimensions(ColourTexture).xy;
-    let resolution_output = textureDimensions(HistoryTexture).xy;
+    let resolution_output = settings.output_resolution;
     
-    let resolution_ratio = vec2<f32>(resolution_internal.xy) / vec2<f32>(resolution_output.xy);
-    let upscale_ratio = f32(resolution_output.x) / f32(resolution_internal.x);
+    let resolution_ratio = vec2<f32>(resolution_internal.xy) / resolution_output;
+    let upscale_ratio = resolution_output.x / f32(resolution_internal.x);
 
     // positive jitter shifts rendered content right/down by settings.jitter internal pixels (see
     // GPUCameraContext), so the un-jittered content of this output pixel sits at uv + jitter / resolution
@@ -145,14 +148,14 @@ fn main(
         ColourTexture,
         sLinear,
         jittered_uv, 
-    ).rgb;
+    ).rgb;
     let color_current_raw = select(vec3(0.0), clamp(color_current_sample, vec3(0.0), vec3(F16_MAX)), color_current_sample == color_current_sample);
 
     var final_colour:vec4<f32>;
     
     if ( true == hasValidHistory ) {
         
-        let prev_uv = (prevFrameScreenST) / vec2<f32>(resolution_output);
+        let prev_uv = prevFrameScreenST / resolution_output;
     
         // sample history
         var color_history_raw = texture_sample_catmullrom_hardware_5tap_uv( HistoryTexture, sLinear, prev_uv );    
@@ -251,7 +254,7 @@ fn main(
     return final_colour.rgba;
 }
 `, [
-        F16_MAX_DEFINITION,
+        F16_MAX_DEFINITION,
         chunk_taa_decode_color,
         chunk_taa_encode_color,
         chunk_taa_history_color_bounding_box_YCoCg,

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA0QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAjB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,gBAAgB,EAA7B,MAAM;IACO,oBAAoB,EAAjC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACV,aAAa,GAA5B,OAAO;IACL,MAAM,CAgFlB;8BA5WY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AAmRA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAjB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,gBAAgB,EAA7B,MAAM;IACO,oBAAoB,EAAjC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACV,aAAa,GAA5B,OAAO;IACL,MAAM,CAgFlB;8BArXY,OAAO,6CAA6C,EAAE,eAAe"}