@woosh/meep-engine 3.60.3 → 3.60.5

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA1mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;8BAC1F,OAAO,0BAA0B,EAAE,eAAe"}
+{"version":3,"file":"ProbeClipmapSceneHolds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAwEI;;;OAGG;IACH,mBAHW,eAAe,YACf,eAAe,EASzB;IAED;;OAEG;IACH,sEAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED,0BAEC;IAED;;;;;;OAMG;IACH,oBAJW,mBAAmB,YACnB,aAAa,GACX,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,6BAIC;IAED,eAiBC;IAED,eAuCC;IAED;;OAEG;IACH,cAiBC;;CA4TJ;8BA1mBY,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;4BACnE,OAAO,iCAAiC,EAAE,aAAa;iCACvD,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,0BAA0B,EAAE,eAAe"}

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSceneHolds.js

@@ -10,7 +10,7 @@ import { row_of_entity } from "../../scene/rows/GPUSceneRows.js";
  * @typedef {import("../../geometry/MeshletGeometry.js").MeshletGeometry} MeshletGeometry
  * @typedef {import("../../geometry/GPUGeometryMetadata.js").GPUGeometryMetadata} GPUGeometryMetadata
  * @typedef {import("../../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
- * @typedef {import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} GPUResidentMaterialContext
+ * @typedef {import("../../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
  * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
  */
 
@@ -71,8 +71,8 @@ class Pair {
  * its hold and its pair, the new ones taken before the old ones go, so a cache or card set a row keeps
  * drawing is never let go in between.
  *
- * When the resident material context repacks a material whose version moved, each of that
- * material's pairs is recaptured (§6.5), and the holds of its rows move to the side it draws now.
+ * When the material manager restages a material whose version moved, each of that material's pairs
+ * is recaptured (§6.5), and the holds of its rows move to the side it draws now.
  *
  * {@link attach} subscribes and walks the rows already there; {@link detach} gives every hold and card
  * set back. Neither trims: a cache with no holder stays until its user trims, so leaving the mode keeps
@@ -86,7 +86,7 @@ export class ProbeClipmapSceneHolds {
     #scene;
 
     /**
-     * @type {GPUResidentMaterialContext}
+     * @type {GPUMaterialManager}
      */
     #materials;
 
@@ -152,14 +152,14 @@ export class ProbeClipmapSceneHolds {
 
     /**
      * @param {GPUSceneContext} scene
-     * @param {GraphicsContext} graphics whose resident materials' repacks recapture the pairs of the material
+     * @param {GraphicsContext} graphics whose material manager's restages recapture the pairs of the material
      */
     constructor(scene, graphics) {
         assert.defined(scene, 'scene');
         assert.defined(graphics, 'graphics');
 
         this.#scene = scene;
-        this.#materials = graphics.materials_resident;
+        this.#materials = graphics.materials;
         this.#device = graphics.device;
     }
 
@@ -187,7 +187,7 @@ export class ProbeClipmapSceneHolds {
     }
 
     /**
-     * Recaptures asked for, a pair each time its material was repacked.
+     * Recaptures asked for, a pair each time its material was restaged.
      * @returns {number}
      */
     get recaptures_requested() {
@@ -241,7 +241,7 @@ export class ProbeClipmapSceneHolds {
         this.#scene.geometries.sdf.onBaked.add(this.#baked, this);
         cards.onResident.add(this.#card_set_resident, this);
         cards.onWithdrawn.add(this.#card_set_withdrawn, this);
-        this.#materials.onMaterialRepacked.add(this.#repacked, this);
+        this.#materials.onMaterialRestaged.add(this.#restaged, this);
 
         // a row not yet written is taken now, and moved when it is
         rows.for_each_mesh((entity, geometry, material, skinned, flags) => this.#written(entity, geometry, material, flags));
@@ -263,7 +263,7 @@ export class ProbeClipmapSceneHolds {
         sdf.onBaked.remove(this.#baked, this);
         cards.onResident.remove(this.#card_set_resident, this);
         cards.onWithdrawn.remove(this.#card_set_withdrawn, this);
-        this.#materials.onMaterialRepacked.remove(this.#repacked, this);
+        this.#materials.onMaterialRestaged.remove(this.#restaged, this);
 
         for (const [entity, record] of this.#held) {
             sdf.release(record, this.#pair_of.get(entity).two_sided);
@@ -524,7 +524,7 @@ export class ProbeClipmapSceneHolds {
     /**
      * @param {ShadeMaterial} material
      */
-    #repacked(material) {
+    #restaged(material) {
         const of_material = this.#pairs_of_material.get(material.id);
 
         if (of_material === undefined) {

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.d.ts

@@ -274,6 +274,18 @@ export class ProbeClipmapSettings {
      * @returns {number}
      */
     get response_frames(): number;
+    /**
+     * @param {boolean} v
+     */
+    set resampling(v: boolean);
+    /**
+     * Whether each probe update also re-samples its neighbours: every radiance texel takes what four of the
+     * probe's 26 neighbours in its cascade have already seen of the point it sees, where their depth says
+     * they can see it, each a ray's worth beside its own rays. It traces nothing, and buys convergence for
+     * some spatial blur. Off, the update's pass is not recorded. Takes effect the next frame.
+     * @returns {boolean}
+     */
+    get resampling(): boolean;
     /**
      * @param {ProbeClipmapDebugView} v
      */

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,gDAFU,cAAc,MAAM,CAAC,CAE8C;AAE7E;;;GAGG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;GAEG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;GAGG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;;;GAKG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAKC;IAjBD;;;;OAIG;IACH,iCAEC;IAwBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAOC;IAtBD;;;;;;OAMG;IACH,kCAEC;IAqCD;;;OAGG;IACH,oCAKC;IA7BD;;;;;;;;;;;;;;;OAeG;IACH,mCAEC;IA6CD;;;OAGG;IACH,mCAKC;IAvCD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kCAEC;IAoCD;;OAEG;IACH,iCAIC;IA5BD;;;;;;;;;;;;;;;;OAgBG;IACH,gCAEC;IAsBD;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAOC;IApBD;;;;OAIG;IACH,kCAEC;IA0BD;;;OAGG;IACH,gCAOC;IApBD;;;;OAIG;IACH,+BAEC;IA0BD;;;OAGG;IACH,8BAKC;IAlBD;;;;OAIG;IACH,6BAEC;IAyBD;;OAEG;IACH,0BAIC;IAjBD;;;;;OAKG;IACH,yBAEC;IAyBD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAuBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}
+{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,gDAFU,cAAc,MAAM,CAAC,CAE8C;AAE7E;;;GAGG;AACH,sDAFU,MAAM,CAEyC;AAEzD;;GAEG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;GAGG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;;;GAKG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAKC;IAjBD;;;;OAIG;IACH,iCAEC;IAwBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAOC;IAtBD;;;;;;OAMG;IACH,kCAEC;IAqCD;;;OAGG;IACH,oCAKC;IA7BD;;;;;;;;;;;;;;;OAeG;IACH,mCAEC;IA6CD;;;OAGG;IACH,mCAKC;IAvCD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kCAEC;IAoCD;;OAEG;IACH,iCAIC;IA5BD;;;;;;;;;;;;;;;;OAgBG;IACH,gCAEC;IAsBD;;OAEG;IACH,mCAKC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;OAEG;IACH,wCAIC;IAfD;;;OAGG;IACH,uCAEC;IAuBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAOC;IApBD;;;;OAIG;IACH,kCAEC;IA0BD;;;OAGG;IACH,gCAOC;IApBD;;;;OAIG;IACH,+BAEC;IA0BD;;;OAGG;IACH,8BAKC;IAlBD;;;;OAIG;IACH,6BAEC;IAyBD;;OAEG;IACH,0BAIC;IAjBD;;;;;OAKG;IACH,yBAEC;IAyBD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAyBD;;OAEG;IACH,2BAIC;IAlBD;;;;;;OAMG;IACH,0BAEC;IAsBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js

@@ -477,6 +477,28 @@ export class ProbeClipmapSettings {
         this.#response_frames = v;
     }
 
+    #resampling = false;
+
+    /**
+     * Whether each probe update also re-samples its neighbours: every radiance texel takes what four of the
+     * probe's 26 neighbours in its cascade have already seen of the point it sees, where their depth says
+     * they can see it, each a ray's worth beside its own rays. It traces nothing, and buys convergence for
+     * some spatial blur. Off, the update's pass is not recorded. Takes effect the next frame.
+     * @returns {boolean}
+     */
+    get resampling() {
+        return this.#resampling;
+    }
+
+    /**
+     * @param {boolean} v
+     */
+    set resampling(v) {
+        assert.isBoolean(v, 'resampling');
+
+        this.#resampling = v;
+    }
+
     #debug_view = ProbeClipmapDebugView.None;
 
     /**

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.d.ts

@@ -156,11 +156,11 @@ export class GPUProbeClipmap {
      *   the update orders after
      * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the scene the rays
      *   light and shade: its lights, its environment, its rows and their geometry caches' cards
-     * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
-     *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
+     *   seen to its rays (`shader_probe_clipmap_resample`)
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows }: {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, resampling }: {
         graph: FrameGraph;
         x: number;
         y: number;
@@ -176,8 +176,8 @@ export class GPUProbeClipmap {
         brick_clipmap: import("../brick/GPUBrickClipmap.js").GPUBrickClipmap;
         bricks: number;
         scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
-        materials: import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
         card_rows: GPUBuffer;
+        resampling: boolean;
     }): void;
     destroy(): void;
     #private;

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAiHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA4NI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OAmGhB;IArUD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAuSjB;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAtB+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAE4C,SAAS,EAAhH,OAAO,0DAA0D,EAAE,0BAA0B;QAE1E,SAAS;aAoOtC;IAydD,gBAcC;;CACJ;mCA1sCY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAqOI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OAmGhB;IA9UD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAgTjB;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAtB+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAExC,SAAS;QACX,UAAU,EAA3B,OAAO;aA+OjB;IAweD,gBAcC;;CACJ;mCA5uCY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js

@@ -16,6 +16,7 @@ import {
 } from "../../../gpu_primitive/slot_stack/shader_slot_stack_push_range.js";
 import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_STRUCT } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
+import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
 import { GPUTileAtlas2D } from "../../../texture/atlas/GPUTileAtlas2D.js";
 import {
     PROBE_CLIPMAP_CASCADE_COUNT_MAX,
@@ -60,6 +61,7 @@ import {
 import { shader_probe_clipmap_project, shader_probe_clipmap_project_rows } from "./shader_probe_clipmap_project.js";
 import { shader_probe_clipmap_publish } from "./shader_probe_clipmap_publish.js";
 import { shader_probe_clipmap_relocate } from "./shader_probe_clipmap_relocate.js";
+import { shader_probe_clipmap_resample } from "./shader_probe_clipmap_resample.js";
 import { shader_probe_clipmap_retire } from "./shader_probe_clipmap_retire.js";
 import { shader_probe_clipmap_schedule } from "./shader_probe_clipmap_schedule.js";
 import { shader_probe_clipmap_light } from "./shader_probe_clipmap_light.js";
@@ -74,6 +76,7 @@ import { shader_probe_clipmap_order } from "./shader_probe_clipmap_order.js";
 import { shader_probe_clipmap_trace_command } from "./shader_probe_clipmap_trace_command.js";
 import { shader_probe_clipmap_want } from "./shader_probe_clipmap_want.js";
 import { shader_probe_clipmap_want_hits } from "./shader_probe_clipmap_want_hits.js";
+import { PROBE_CLIPMAP_RESAMPLING } from "./PROBE_CLIPMAP_RESAMPLING.js";
 
 /**
  * @typedef {import("../ProbeClipmapSettings.js").ProbeClipmapSettings} ProbeClipmapSettings
@@ -251,6 +254,17 @@ export class GPUProbeClipmap {
     /** The listed probes' guides, as the guide passes write them, as many as the trace list holds. @type {GPUBuffer|null} */
     #guide = null;
 
+    /**
+     * The listed probes' re-samples of their neighbours, n_r² a probe, as the re-sample pass writes them, as many
+     * as the trace list holds. Kept whether or not the frame re-samples: accumulate's variants share their
+     * resources. @type {GPUBuffer|null}
+     */
+    #resamples = null;
+
+    /** Whether the frame's updates re-sample their neighbours, and the switches accumulate is recorded with. */
+    #resampling = false;
+    #accumulate_switches = ShaderSwitchSet.EMPTY;
+
     /** The listed probes' projected rows, n_r a probe, as many as the trace list holds. @type {GPUBuffer|null} */
     #projection = null;
 
@@ -340,6 +354,7 @@ export class GPUProbeClipmap {
     #accumulate_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0, frame: 0, response_frames: 0, uniform_period: PROBE_UNIFORM_PERIOD };
     #project_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, uniform_period: PROBE_UNIFORM_PERIOD, rays_min: 0, rays_max: 0, response_frames: 0 };
     #publish_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0 };
+    #resample_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, response_frames: 0 };
     #push_settings = { first: 0, count: 0, counter: PROBE_COUNTER_FREE };
 
     #bindings = {};
@@ -365,9 +380,6 @@ export class GPUProbeClipmap {
      */
     #scene = null;
 
-    /** The frame's resident materials, a hit's fallback. @type {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext|null} */
-    #materials = null;
-
     /** The frame's row → card set table. @type {GPUBuffer|null} */
     #card_rows = null;
 
@@ -584,11 +596,11 @@ export class GPUProbeClipmap {
      *   the update orders after
      * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the scene the rays
      *   light and shade: its lights, its environment, its rows and their geometry caches' cards
-     * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
-     *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     * @param {boolean} options.resampling whether each update re-samples its neighbours, adding what they have
+     *   seen to its rays (`shader_probe_clipmap_resample`)
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows }) {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, resampling }) {
         assert.defined(graph, 'graph');
         assert.defined(camera, 'camera');
         assert.defined(stbn, 'stbn');
@@ -599,8 +611,8 @@ export class GPUProbeClipmap {
         assert.defined(brick_clipmap, 'brick_clipmap');
         assert.isNonNegativeInteger(bricks, 'bricks');
         assert.defined(scene, 'scene');
-        assert.defined(materials, 'materials');
         assert.defined(card_rows, 'card_rows');
+        assert.isBoolean(resampling, 'resampling');
         assert.notOk(this.#destroyed, 'destroyed');
 
         if (this.#grow_pending) {
@@ -733,6 +745,17 @@ export class GPUProbeClipmap {
         this.#project_settings.rays_max = rays_max;
         this.#project_settings.response_frames = response_frames;
 
+        const resample = this.#resample_settings;
+
+        resample.trace_capacity = trace_capacity;
+        resample.radiance_resolution = this.radiance_resolution;
+        resample.depth_resolution = this.depth_resolution;
+        resample.frame = this.#frame;
+        resample.response_frames = response_frames;
+
+        this.#resampling = resampling;
+        this.#accumulate_switches = ShaderSwitchSet.EMPTY.with(PROBE_CLIPMAP_RESAMPLING, resampling);
+
         const publish = this.#publish_settings;
 
         publish.trace_capacity = trace_capacity;
@@ -743,7 +766,6 @@ export class GPUProbeClipmap {
 
         this.#brick_clipmap = brick_clipmap;
         this.#scene = scene;
-        this.#materials = materials;
         this.#card_rows = card_rows;
 
         const tiles_x = Math.ceil(resolution[0] / PROBE_WANT_TILE);
@@ -882,6 +904,7 @@ export class GPUProbeClipmap {
         this.#origins?.destroy();
         this.#maps?.destroy();
         this.#guide?.destroy();
+        this.#resamples?.destroy();
         this.#projection?.destroy();
         this.#ray_counts?.destroy();
         this.#ray_requests?.destroy();
@@ -904,6 +927,7 @@ export class GPUProbeClipmap {
         this.#origins = this.#create_buffer('probe origins', 16 * trace_capacity, 0);
         this.#maps = this.#create_buffer('probe maps', 4 * probe_clipmap_maps_words(this.radiance_resolution, this.depth_resolution) * trace_capacity, 0);
         this.#guide = this.#create_buffer('probe guide', 4 * probe_clipmap_guide_words(this.radiance_resolution) * trace_capacity, 0);
+        this.#resamples = this.#create_buffer('probe resamples', 16 * this.radiance_resolution * this.radiance_resolution * trace_capacity, 0);
         this.#projection = this.#create_buffer('probe projection', PROBE_PROJECTION_ROW_STRUCT.size * this.radiance_resolution * trace_capacity, 0);
     }
 
@@ -1182,8 +1206,6 @@ export class GPUProbeClipmap {
         b.mesh_card_sets = cards.records;
         b.mesh_card_albedo = cards.atlas.texture_at(0).obtainView();
         b.mesh_card_emissive = cards.atlas.texture_at(1).obtainView();
-        b.materials = this.#materials.buffer_materials;
-        b.texture_means = this.#materials.buffer_texture_means;
         b.tEnvironment = lights.environment.obtainView();
 
         shader_probe_clipmap_shade.dispatchIndirect({
@@ -1207,6 +1229,22 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_RAYS,
         });
 
+        // what each listed probe's neighbours have already seen, from the atlases and estimators as they were,
+        // where the frame re-samples; accumulate's variant without it reads none
+        b.probe_resamples = this.#resamples;
+        b.probe_estimators = this.#estimators;
+
+        if (this.#resampling) {
+            b.settings = this.#resample_settings;
+
+            shader_probe_clipmap_resample.dispatchIndirect({
+                encoder,
+                bindings: b,
+                command: this.#dispatch,
+                command_offset: 4 * PROBE_DISPATCH_TEXELS,
+            });
+        }
+
         // the probes' maps from their rays, against the atlases as they were; their SH and kind from the
         // maps; then the atlases from the maps
         b.probe_maps = this.#maps;
@@ -1214,10 +1252,9 @@ export class GPUProbeClipmap {
         b.probe_requests = this.#requests;
         b.probe_radiance = this.#radiance.texture_at(0).obtainView();
         b.probe_depth = this.#depth.texture_at(0).obtainView();
-        b.probe_estimators = this.#estimators;
         b.settings = this.#accumulate_settings;
 
-        shader_probe_clipmap_accumulate.dispatchIndirect({
+        shader_probe_clipmap_accumulate.variant(this.#accumulate_switches).dispatchIndirect({
             encoder,
             bindings: b,
             command: this.#dispatch,
@@ -1298,7 +1335,7 @@ export class GPUProbeClipmap {
         this.#radiance.destroy();
         this.#depth.destroy();
 
-        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#projection, this.#requests, this.#ray_counts, this.#ray_requests, this.#ray_count_sums, this.#ray_request_sums, this.#ray_sums, this.#ray_scan_spine, this.#ray_scan_command, this.#rays, this.#sampling]) {
+        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#resamples, this.#projection, this.#requests, this.#ray_counts, this.#ray_requests, this.#ray_count_sums, this.#ray_request_sums, this.#ray_sums, this.#ray_scan_spine, this.#ray_scan_command, this.#rays, this.#sampling]) {
             buffer?.destroy();
         }
     }

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.d.ts

@@ -361,4 +361,10 @@ export const PROBE_RECEIVER_BIAS: number;
  * @type {number}
  */
 export const PROBE_RECEIVER_BIAS_VIEW: number;
+/**
+ * The neighbours a radiance texel re-samples an update when the frame re-samples (`shader_probe_clipmap_resample`):
+ * distinct ones of the probe's 26 in its cascade's 3×3×3, picked afresh each update. Enshrouded's 4:1.
+ * @type {number}
+ */
+export const PROBE_RESAMPLE_NEIGHBOURS: number;
 //# sourceMappingURL=PROBE_CLIPMAP.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js

@@ -463,3 +463,10 @@ export const PROBE_RECEIVER_BIAS = 0.1;
  * @type {number}
  */
 export const PROBE_RECEIVER_BIAS_VIEW = 0.2;
+
+/**
+ * The neighbours a radiance texel re-samples an update when the frame re-samples (`shader_probe_clipmap_resample`):
+ * distinct ones of the probe's 26 in its cascade's 3×3×3, picked afresh each update. Enshrouded's 4:1.
+ * @type {number}
+ */
+export const PROBE_RESAMPLE_NEIGHBOURS = 4;

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP_RESAMPLING.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Whether the frame's updates re-sample their neighbours (`shader_probe_clipmap_resample`): accumulate
+ * then adds each radiance texel's re-samples to its rays (`chunk_probe_clipmap_resampled`). Decided by
+ * `chunk_probe_clipmap_resampled`, whose `false` alternative, the default, is the texel's own rays alone
+ * and binds nothing more, so a pass that never sets it accumulates exactly as it always did.
+ *
+ * `GPUProbeClipmap` sets it from `ProbeClipmapSettings.resampling` the frame it records the update.
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_RESAMPLING: ShaderSwitch;
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=PROBE_CLIPMAP_RESAMPLING.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP_RESAMPLING.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PROBE_CLIPMAP_RESAMPLING.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP_RESAMPLING.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,uCAFU,YAAY,CAEgE;6BAZzD,0CAA0C"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP_RESAMPLING.js

@@ -0,0 +1,13 @@
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+
+/**
+ * Whether the frame's updates re-sample their neighbours (`shader_probe_clipmap_resample`): accumulate
+ * then adds each radiance texel's re-samples to its rays (`chunk_probe_clipmap_resampled`). Decided by
+ * `chunk_probe_clipmap_resampled`, whose `false` alternative, the default, is the texel's own rays alone
+ * and binds nothing more, so a pass that never sets it accumulates exactly as it always did.
+ *
+ * `GPUProbeClipmap` sets it from `ProbeClipmapSettings.resampling` the frame it records the update.
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_RESAMPLING = ShaderSwitch.bool('probe clipmap resampling');

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.d.ts

@@ -224,6 +224,23 @@ export const PROBE_MAPS_READ_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_ESTIMATORS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Each slot's radiance estimators, as the re-sample pass reads them: how spread each texel's samples are.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ESTIMATORS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The listed probes' re-samples of their neighbours, n_r² a probe by radiance texel, in list order: the
+ * accepted re-samples' radiance, each times its weight, summed, and the weights' sum
+ * (`shader_probe_clipmap_resample`), as the re-sample pass writes them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The listed probes' re-samples, as accumulation reads them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_READ_RESOURCE: ShaderResourceDescriptor;
 /**
  * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
  * @type {WebGPUStruct}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js

@@ -375,6 +375,26 @@ export const PROBE_MAPS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("
  */
 export const PROBE_ESTIMATORS_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_estimators", WebGPUArray.from(vec4u), true);
 
+/**
+ * Each slot's radiance estimators, as the re-sample pass reads them: how spread each texel's samples are.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ESTIMATORS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_estimators", WebGPUArray.from(vec4u));
+
+/**
+ * The listed probes' re-samples of their neighbours, n_r² a probe by radiance texel, in list order: the
+ * accepted re-samples' radiance, each times its weight, summed, and the weights' sum
+ * (`shader_probe_clipmap_resample`), as the re-sample pass writes them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_resamples", WebGPUArray.from(vec4f), true);
+
+/**
+ * The listed probes' re-samples, as accumulation reads them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_resamples", WebGPUArray.from(vec4f));
+
 /**
  * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
  * @type {WebGPUStruct}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.d.ts

@@ -5,16 +5,6 @@
  * @type {number}
  */
 export const PROBE_HIT_SURFACE_TOLERANCE_VOXELS: number;
-/**
- * The resident materials' table, as the ray passes read it: `materials[mesh.material]`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_MATERIALS_RESOURCE: ShaderResourceDescriptor;
-/**
- * Each resident texture slot's mean, `GPUResidentMaterialContext.buffer_texture_means`.
- * @type {ShaderResourceDescriptor}
- */
-export const PROBE_HIT_TEXTURE_MEANS_RESOURCE: ShaderResourceDescriptor;
 /**
  * What a GI hit's surface is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6), its diffuse albedo and its
  * emissive, from the `meshes` row the hit is on:
@@ -27,15 +17,15 @@ export const PROBE_HIT_TEXTURE_MEANS_RESOURCE: ShaderResourceDescriptor;
  *   the geometry's local space through its node, the normal by the transpose of the node's linear
  *   part, and the tolerance {@link PROBE_HIT_SURFACE_TOLERANCE_VOXELS} voxels of the hit's cascade,
  *   `voxel`, in local units by the transform's mean scale, the cube root of its determinant.
- * - **The material's mean**, where no card set is resident or no card sees the hit: the colour factor
- *   × the albedo slot's mean colour × (1 − the metallic factor × the ORM slot's mean metalness), and the
- *   emissive factor × the emissive slot's mean. What a card would have held, Lumen's diffuse colour,
- *   from the means of what it is made of.
+ * - **Black**, where no card set is resident or no card sees the hit, as UE's Lumen leaves a hit no
+ *   card covers: a surface whose albedo is not known brings back no light rather than light it may not
+ *   have. The cost is energy, never invented energy: a material's colour factor is all of a flat one's
+ *   albedo but only the bound of a textured one's, and in Sponza it made the bounce-lit gallery 60%
+ *   brighter on screen (§6.6).
  * - **Row 0** names no object, the scene root never being a mesh: the hit is black.
  *
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_hit_surface: CodeChunk;
-import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_probe_clipmap_hit_surface.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_hit_surface.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,iDAFU,MAAM,CAEsC;AAEtD;;;GAGG;AACH,2CAFU,wBAAwB,CAEsF;AAExH;;;GAGG;AACH,+CAFU,wBAAwB,CAE+F;AAEjI;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8CAFU,SAAS,CAoDZ;yCA9FkC,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_hit_surface.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,iDAFU,MAAM,CAEsC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,8CAFU,SAAS,CA0CZ;0BAvEmB,uCAAuC"}