@woosh/meep-engine 3.61.1 → 3.61.3

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":"AAiIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IA4QI;;;;;;;;;;;;;;;;;OAiBG;IACH;QAf2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAGU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OA8GhB;IAxYD;;;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;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IA2VN;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;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;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QA6BhB;IAED;;;;;;;OAOG;IACH,sBAFW,eAAe,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAtB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;QACN,IAAI;QACC,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,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;aAiOzB;IAshBD,gBAcC;;CACJ;mCAz7CY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AA0HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IAqRI;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAKU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OAmHhB;IAxZD;;;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;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IA2WN;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;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;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QAkChB;IAED;;;;;;;;OAQG;IACH,sBAFW,eAAe,QA+BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH;QAzB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;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;QAEP,QAAQ,EAA5D;YAAC,cAAc,qBAA0B;SAAC;QAEzB,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;QACC,QAAQ,EAAxB,MAAM;aAuOhB;IA6gBD,gBAcC;;CACJ;mCA18CY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}

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

@@ -40,6 +40,8 @@ import { PROBE_SAMPLING_STRUCT } from "./chunk_probe_clipmap_pick.js";
 import {
     probe_clipmap_guide_words,
     probe_clipmap_maps_words,
+    PROBE_CASCADE_HYSTERESIS,
+    PROBE_CASCADE_STEP,
     PROBE_COUNTER_FREE,
     PROBE_COUNTER_STARVED,
     PROBE_COUNTER_WORDS,
@@ -57,6 +59,7 @@ import {
     PROBE_RAYS_PER_TEXEL_MAX,
     PROBE_RAYS_PER_TEXEL_MIN,
     PROBE_RECORD_CASCADE_SHIFT,
+    PROBE_SELECTION_INSET,
     PROBE_THREAD_WORKGROUP_SIZE,
     PROBE_UNIFORM_PERIOD
 } from "./PROBE_CLIPMAP.js";
@@ -97,20 +100,7 @@ import { shader_probe_clipmap_trace_command } from "./shader_probe_clipmap_trace
  */
 
 /**
- * Corner steps of a probe cascade's window: one lattice cell, as the bricks' (§8.1).
- * @type {number}
- */
-const PROBE_CASCADE_STEP = 1;
-
-/**
- * Cells past half a step the anchor goes from a window's centre before it moves: the bricks' value.
- * @type {number}
- */
-const PROBE_CASCADE_HYSTERESIS = 0.1;
-
-/**
- * Parent cells every cascade's window keeps inside its parent's, so that a cage in a cascade's blend
- * skirt is inside the next cascade's cage window.
+ * Parent cells every cascade's window keeps inside its parent's (§8.1).
  * @type {number}
  */
 const PROBE_CASCADE_NEST_MARGIN = 1;
@@ -126,6 +116,9 @@ const SAMPLING_RADIANCE_RESOLUTION = PROBE_SAMPLING_STRUCT.get("radiance_resolut
 const SAMPLING_RADIANCE_TILES_PER_ROW = PROBE_SAMPLING_STRUCT.get("radiance_tiles_per_row").offset >>> 2;
 const SAMPLING_RADIANCE_TEXEL = PROBE_SAMPLING_STRUCT.get("radiance_texel").offset >>> 2;
 const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("radiance_tiles_per_row_reciprocal").offset >>> 2;
+// word offsets of the selection boxes in PROBE_SAMPLING_STRUCT
+const SAMPLING_ANCHOR = PROBE_SAMPLING_STRUCT.get("anchor").offset >>> 2;
+const SAMPLING_SELECT_HALF = PROBE_SAMPLING_STRUCT.get("select_half").offset >>> 2;
 
 /**
  * What shading samples (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8): {@link cascade_count} cascades of
@@ -142,7 +135,7 @@ const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("ra
  *   stacked along z: the slot of the point's probe, or none. Allocated whole, since the lattice follows
  *   from the structure alone.
  * - a slot each: a state of two words, the kind and updates and then where relocation moved it
- *   (`PROBE_CLIPMAP.js`), a 48-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
+ *   (`PROBE_CLIPMAP.js`), a 64-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
  *   {@link radiance_resolution}² texels and a depth-moment tile of {@link depth_resolution}², in two 2-D
  *   tile atlases. The depth tile has a one-texel skirt, which the pick's bilinear tap reads; the radiance
  *   tile has one where {@link radiance_skirt}, for the specular's tap, and none where nothing samples it.
@@ -152,7 +145,10 @@ const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("ra
  *   of the frame's updates, at most U = ⌊ray_budget / rays_per_probe⌋.
  *
  * **A frame's windows** ({@link place}, {@link place_within}): around the anchor, coarsest first, each a
- * parent cell inside its parent; or another clipmap's.
+ * parent cell inside its parent; or another clipmap's. Readers and wants choose a point's cascade by
+ * selection boxes centred on the anchor itself, `PROBE_SELECTION_INSET` short of half a window (§9.1,
+ * "Selection"): the windows move a step at a time, the boxes with the anchor, so the blend between
+ * cascades moves as the anchor does.
  *
  * **A frame's lifetime** ({@link graph_update}, §8.3, §8.5): retire frees the probes whose points left
  * their windows and those the last frame's schedule evicted, the wants mark the cages they read, admit
@@ -238,6 +234,12 @@ export class GPUProbeClipmap {
     /** The frame {@link place} or {@link place_within} last placed the windows in, of {@link graph_update}'s count. */
     #placed_frame = -1;
 
+    /** Where {@link place} or {@link place_within} last placed the windows around, world metres: the selection boxes' centre. */
+    #anchor = new Float32Array(3);
+
+    /** A selection box's half side, in this clipmap's cells, as the windows were last placed. */
+    #select_half = 0;
+
     /** @type {GPUTexture} */
     #indirection;
 
@@ -315,6 +317,12 @@ export class GPUProbeClipmap {
     #ray_resampling = false;
     #accumulate_switches = ShaderSwitchSet.EMPTY;
 
+    /**
+     * What binds the brick material's planes for the shade, as the frame's update was given it.
+     * @type {{write_bindings: function(Object): Object}|null}
+     */
+    #material = null;
+
     /** The listed probes' projected rows, n_r a probe, as many as the trace list holds. @type {GPUBuffer|null} */
     #projection = null;
 
@@ -391,7 +399,7 @@ export class GPUProbeClipmap {
     #levels_f32 = new Float32Array(this.#levels_data);
 
     #retire_settings = { capacity: 0, resolution: 0, frame: 0 };
-    #want_settings = { cascade_count: 0, resolution: 0, frame: 0, wanted_capacity: 0 };
+    #want_settings = { cascade_count: 0, resolution: 0, frame: 0, wanted_capacity: 0, anchor: new Float32Array(3), select_half: 0 };
     #admit_command_settings = { wanted_capacity: 0 };
     #admit_settings = { capacity: 0, resolution: 0, wanted_capacity: 0, frame: 0 };
     #schedule_settings = { capacity: 0, wanted_capacity: 0, trace_capacity: 0, slack: 0 };
@@ -422,9 +430,9 @@ export class GPUProbeClipmap {
     /** The ray counts' scan's, which names its buffers its own way. */
     #ray_scan_bindings = { scan_in: null, scan_out: null, spine: null, command: null };
 
-    #lifetime_data = { counters: -1, stbn: -1, want_depth: -1, want_normal: -1 };
+    #lifetime_data = { counters: -1, want_depth: -1, want_normal: -1 };
 
-    #update_data = { counters: -1, bricks: -1, world_cluster_lookup: -1, world_cluster_data: -1 };
+    #update_data = { counters: -1, bricks: -1, world_cluster_lookup: -1, world_cluster_data: -1, exposure: -1 };
 
     /** The frame's wants. @type {ProbeClipmapWants|null} */
     #wants = null;
@@ -439,14 +447,11 @@ export class GPUProbeClipmap {
 
     /**
      * The frame's scene: its light database, the suns the rays' hits trace shadows toward; its environment,
-     * what a miss sees; its rows and geometry caches, what a hit is on.
+     * what a miss sees.
      * @type {import("../../../scene/GPUSceneContext.js").GPUSceneContext|null}
      */
     #scene = null;
 
-    /** The frame's row → card set table. @type {GPUBuffer|null} */
-    #card_rows = null;
-
     /**
      * @param {GPUDevice} device
      * @param {object} options
@@ -454,7 +459,9 @@ export class GPUProbeClipmap {
      *        the record's cascade field, {@link PROBE_RECORD_CASCADE_SHIFT}
      * @param {number} options.resolution a power of two, at most 1024: the order's Morton code takes 10 bits
      *        an axis; the indirection's height, resolution · cascade_count, at most the device's
-     *        `maxTextureDimension3D`
+     *        `maxTextureDimension3D`; past twice {@link PROBE_SELECTION_INSET}, so a selection box holds points;
+     *        and with more than one cascade, from 8, so the nesting never holds a window further from the anchor
+     *        than the inset allows (§9.1, "Selection")
      * @param {number} options.spacing metres
      * @param {number} options.radiance_resolution a power of two from 2, which the update's bit-reversed
      *        walk of the texels needs
@@ -474,6 +481,11 @@ export class GPUProbeClipmap {
         // the order's key: the cascade above the Morton code of a lattice point in its window
         assert.lessThanOrEqual(3 * ceil_log2(resolution) + ceil_log2(cascade_count), 32, 'the order key fits a word');
         assert.lessThanOrEqual(resolution * cascade_count, device.limits.maxTextureDimension3D, "resolution · cascade_count, the indirection's height, past maxTextureDimension3D");
+        assert.greaterThan(resolution / 2, PROBE_SELECTION_INSET, 'resolution: a selection box, N/2 less PROBE_SELECTION_INSET cells a side, holds no point');
+        // a child's centre may sit N/2 less the nest margin from its parent's; the child lags the anchor by up to
+        // half a step and the hysteresis, the parent by twice that in child cells
+        assert.ok(cascade_count === 1 || resolution / 2 - 2 * PROBE_CASCADE_NEST_MARGIN >= 3 * (PROBE_CASCADE_STEP / 2 + PROBE_CASCADE_HYSTERESIS),
+            'resolution: the nesting would hold a window further from the anchor than PROBE_SELECTION_INSET allows');
         assert.isFinite(spacing, 'spacing');
         assert.greaterThan(spacing, 0, 'spacing');
         assert.isPositiveInteger(radiance_resolution, 'radiance_resolution');
@@ -685,8 +697,8 @@ export class GPUProbeClipmap {
     }
 
     /**
-     * Place the windows around the anchor, coarsest first, each a parent cell inside its parent, for the
-     * frame's {@link graph_update}.
+     * Place the windows around the anchor, coarsest first, each a parent cell inside its parent, and the
+     * selection boxes on the anchor, for the frame's {@link graph_update}.
      *
      * @param {number} x the anchor, world metres
      * @param {number} y
@@ -700,11 +712,11 @@ export class GPUProbeClipmap {
         const placement = this.#placement;
         const n = this.resolution;
 
+        // the whole stack each frame: every window by the hysteretic rule, each clamped into its parent's new
+        // window alone, so none is held by a child's last one and each stays within the hysteresis of the anchor,
+        // which the selection boxes' inset takes
         placement.begin();
-
-        for (let c = this.cascade_count - 1; c >= 0; c--) {
-            placement.place(c, x, y, z);
-        }
+        placement.place_all(x, y, z);
 
         for (let c = 0; c < this.cascade_count; c++) {
             const level = (c * CLIPMAP_LEVEL_STRUCT.aligned_size) >>> 2;
@@ -718,6 +730,11 @@ export class GPUProbeClipmap {
             this.#levels_f32[level + 3] = placement.cell_size(c);
         }
 
+        this.#anchor[0] = x;
+        this.#anchor[1] = y;
+        this.#anchor[2] = z;
+        this.#select_half = n / 2 - PROBE_SELECTION_INSET;
+
         this.#placed_frame = this.#frame;
     }
 
@@ -725,7 +742,8 @@ export class GPUProbeClipmap {
      * Take another clipmap's windows, as {@link place} last placed them, at 2^k this clipmap's lattice
      * (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.2): the same cascades, each the other's window and spacing over
      * 2^k, its corner 2^k the other's, so every point of the other's lattice is one of this clipmap's and the
-     * two scroll together. k is the ratio of the resolutions, a power of two from 2.
+     * two scroll together. k is the ratio of the resolutions, a power of two from 2. The selection boxes are the
+     * other's too: the same anchor, the same half side in metres.
      *
      * @param {GPUProbeClipmap} clipmap placed this frame
      */
@@ -753,6 +771,10 @@ export class GPUProbeClipmap {
             this.#levels_f32[level + 3] = this.cell_size(c);
         }
 
+        // the other's boxes, in this clipmap's cells
+        this.#anchor.set(clipmap.#anchor);
+        this.#select_half = clipmap.#select_half * ratio;
+
         this.#placed_frame = this.#frame;
     }
 
@@ -764,7 +786,6 @@ export class GPUProbeClipmap {
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {ProbeClipmapWants} options.wants who wants the frame's probes
-     * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
      * @param {number} options.response_frames frames over which a re-sampled neighbour's history goes stale, τ
      * @param {number} options.ray_budget rays a frame
      * @param {number} options.rays_per_probe rays an update, R: the frame updates ⌊ray_budget / R⌋ probes at most
@@ -773,8 +794,9 @@ export class GPUProbeClipmap {
      * @param {number} options.bricks the graph handle of the brick clipmap's last write this frame, which
      *   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 {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     *   light: its lights and its environment
+     * @param {{write_bindings: function(Object): Object}} options.material what binds the brick material's planes
+     *   for the shade (`GPUBrickMaterial#write_bindings`): the material the bricks carry
      * @param {boolean} options.history_resampling whether each update re-samples its neighbours' histories, adding
      *   what they have seen to its rays (`shader_probe_clipmap_resample`); never where the radiance has no skirt
      * @param {boolean} options.ray_resampling whether each update re-samples one neighbour's rays of the frame,
@@ -783,11 +805,13 @@ export class GPUProbeClipmap {
      *   bricks' cascades, which the hits' local lights come from
      * @param {GPUProbeClipmap} options.bounce_first the clipmap a hit takes its next bounce from first
      * @param {GPUProbeClipmap} options.bounce_fallback the clipmap it takes it from where the first has no probe
+     * @param {number} options.exposure the graph handle of the factor the display multiplies radiance by ahead of its
+     *   tone curve, a single f32, as the last frame was shown: the exposure the probes' estimators state their
+     *   thresholds in
      */
-    graph_update({ graph, wants, stbn, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback }) {
+    graph_update({ graph, wants, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, material, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback, exposure }) {
         assert.defined(graph, 'graph');
         assert.defined(wants, 'wants');
-        assert.defined(stbn, 'stbn');
         assert.isFinite(response_frames, 'response_frames');
         assert.greaterThan(response_frames, 0, 'response_frames');
         assert.isPositiveInteger(rays_per_probe, 'rays_per_probe');
@@ -795,7 +819,7 @@ export class GPUProbeClipmap {
         assert.defined(brick_clipmap, 'brick_clipmap');
         assert.isNonNegativeInteger(bricks, 'bricks');
         assert.defined(scene, 'scene');
-        assert.defined(card_rows, 'card_rows');
+        assert.isFunction(material?.write_bindings, 'material.write_bindings');
         assert.isBoolean(history_resampling, 'history_resampling');
         assert.ok(!history_resampling || this.radiance_skirt, 'history_resampling taps the neighbours\' radiance, which a clipmap without a skirt cannot');
         assert.isBoolean(ray_resampling, 'ray_resampling');
@@ -803,6 +827,7 @@ export class GPUProbeClipmap {
         assert.isNonNegativeInteger(clusters.data, 'clusters.data');
         assert.defined(bounce_first, 'bounce_first');
         assert.defined(bounce_fallback, 'bounce_fallback');
+        assert.isNonNegativeInteger(exposure, 'exposure');
         assert.equal(this.#placed_frame, this.#frame, 'windows placed this frame: place() or place_within() first');
         assert.notOk(this.#destroyed, 'destroyed');
 
@@ -840,6 +865,8 @@ export class GPUProbeClipmap {
         this.#sampling_f32[SAMPLING_RADIANCE_TEXEL] = 1 / radiance_texture.width;
         this.#sampling_f32[SAMPLING_RADIANCE_TEXEL + 1] = 1 / radiance_texture.height;
         this.#sampling_f32[SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL] = 1 / this.#radiance.tiles_per_row;
+        this.#sampling_f32.set(this.#anchor, SAMPLING_ANCHOR);
+        this.#sampling_f32[SAMPLING_SELECT_HALF] = this.#select_half;
 
         this.#device.queue.writeBuffer(this.#sampling, 0, this.#sampling_data);
 
@@ -853,6 +880,8 @@ export class GPUProbeClipmap {
         this.#ensure_wanted(Math.min(this.#key_count, wants.wanted_bound()));
 
         this.#want_settings.wanted_capacity = this.#wanted_capacity;
+        this.#want_settings.anchor.set(this.#anchor);
+        this.#want_settings.select_half = this.#select_half;
 
 
         this.#admit_command_settings.wanted_capacity = this.#wanted_capacity;
@@ -961,7 +990,7 @@ export class GPUProbeClipmap {
 
         this.#brick_clipmap = brick_clipmap;
         this.#scene = scene;
-        this.#card_rows = card_rows;
+        this.#material = material;
 
         this.#wants = wants;
         this.#bounce_first = bounce_first;
@@ -971,7 +1000,6 @@ export class GPUProbeClipmap {
         const pass = graph.add(`${this.label} Lifetime`, data, this.#execute_lifetime);
 
         data.counters = pass.write(graph_import_buffer(graph, this.#counters, `${this.label} counters`));
-        data.stbn = stbn;
 
         wants.graph_declare(pass, data);
 
@@ -985,6 +1013,7 @@ export class GPUProbeClipmap {
         update_data.bricks = update.read(bricks);
         update_data.world_cluster_lookup = update.read(clusters.lookup);
         update_data.world_cluster_data = update.read(clusters.data);
+        update_data.exposure = update.read(exposure);
 
         update.make_side_effect();
 
@@ -1191,8 +1220,6 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_ACTIVE,
         });
 
-        b.tSTBN_vec2 = data.stbn;
-
         // the frame's wants, into the wanted bits and list
         const want = this.#want_bindings;
 
@@ -1353,19 +1380,11 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_RAYS,
         });
 
-        // what each ray brings back: the buffers taken now, since a table may have been replaced as it grew
-        const sdf = scene.geometries.sdf;
-        const cards = sdf.cards;
-
-        sdf.write_bindings(b);
-
-        b.scene_database = scene.scene_database_buffer;
-        b.mesh_card_rows = this.#card_rows;
-        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();
+        // what each ray brings back: the material planes taken now, since they are replaced as they grow
         b.tEnvironment = lights.environment.obtainView();
 
+        this.#material.write_bindings(b);
+
         shader_probe_clipmap_shade.dispatchIndirect({
             encoder,
             bindings: b,
@@ -1420,6 +1439,7 @@ export class GPUProbeClipmap {
         this.write_sampling_bindings(b);
         b.probe_resamples = this.#resamples;
         b.probe_estimators = this.#estimators;
+        b.probe_exposure = resources.get(data.exposure);
 
         if (this.#history_resampling) {
             b.settings = this.#resample_settings;

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

@@ -195,6 +195,18 @@ export const PROBE_RELOCATION_STEPS: number;
  * @type {number}
  */
 export const PROBE_RAY_ORIGIN_JITTER: number;
+/**
+ * The stream that seeds a texel's jitter sequences (`probe_clipmap_ray_jitter`), which place its rays inside it.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_JITTER: number;
+/**
+ * The stream of a ray's noise that picks the probes at its hit for the next bounce. It is drawn apart from
+ * the jitter, which places the hit: a weighted pick is unbiased only when its noise is independent of the
+ * weights.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_PICK: number;
 /**
  * A miss's depth sample, and the most any sample is, in spacings: the farthest a cage tests a probe's depth,
  * (1 + {@link PROBE_RELOCATION_LIMIT})·√3 (D9). A biased point lies within a spacing of the corner's lattice
@@ -370,6 +382,26 @@ export const PROBE_RECEIVER_BIAS: number;
  * @type {number}
  */
 export const PROBE_RECEIVER_BIAS_VIEW: number;
+/**
+ * Corner steps of a probe cascade's window: one lattice cell, as the bricks' (§8.1).
+ * @type {number}
+ */
+export const PROBE_CASCADE_STEP: number;
+/**
+ * Cells past half a step the anchor goes from a window's centre before it moves: the bricks' value.
+ * @type {number}
+ */
+export const PROBE_CASCADE_HYSTERESIS: number;
+/**
+ * Cells a cascade's selection box keeps inside half its window's N lattice points, measured from the anchor
+ * (§9.1, "Selection"): the cage window's far face sits one cell short of N/2 past the window's centre, the
+ * window's centre lags the anchor by up to half a step and the hysteresis, and the receiver bias moves a
+ * point up to its length. A box of N/2 less this around the anchor holds every point whose biased cage is in
+ * the window, as `GPUProbeClipmap` places the whole stack each frame and so holds every window within the
+ * hysteresis of the anchor.
+ * @type {number}
+ */
+export const PROBE_SELECTION_INSET: 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.

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

@@ -229,6 +229,20 @@ export const PROBE_RELOCATION_STEPS = 3;
  */
 export const PROBE_RAY_ORIGIN_JITTER = 1 / 16;
 
+/**
+ * The stream that seeds a texel's jitter sequences (`probe_clipmap_ray_jitter`), which place its rays inside it.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_JITTER = 0x510E527F;
+
+/**
+ * The stream of a ray's noise that picks the probes at its hit for the next bounce. It is drawn apart from
+ * the jitter, which places the hit: a weighted pick is unbiased only when its noise is independent of the
+ * weights.
+ * @type {number}
+ */
+export const PROBE_RAY_NOISE_PICK = 0x9B05688C;
+
 /**
  * A miss's depth sample, and the most any sample is, in spacings: the farthest a cage tests a probe's depth,
  * (1 + {@link PROBE_RELOCATION_LIMIT})·√3 (D9). A biased point lies within a spacing of the corner's lattice
@@ -474,6 +488,29 @@ export const PROBE_RECEIVER_BIAS = 0.1;
  */
 export const PROBE_RECEIVER_BIAS_VIEW = 0.2;
 
+/**
+ * Corner steps of a probe cascade's window: one lattice cell, as the bricks' (§8.1).
+ * @type {number}
+ */
+export const PROBE_CASCADE_STEP = 1;
+
+/**
+ * Cells past half a step the anchor goes from a window's centre before it moves: the bricks' value.
+ * @type {number}
+ */
+export const PROBE_CASCADE_HYSTERESIS = 0.1;
+
+/**
+ * Cells a cascade's selection box keeps inside half its window's N lattice points, measured from the anchor
+ * (§9.1, "Selection"): the cage window's far face sits one cell short of N/2 past the window's centre, the
+ * window's centre lags the anchor by up to half a step and the hysteresis, and the receiver bias moves a
+ * point up to its length. A box of N/2 less this around the anchor holds every point whose biased cage is in
+ * the window, as `GPUProbeClipmap` places the whole stack each frame and so holds every window within the
+ * hysteresis of the anchor.
+ * @type {number}
+ */
+export const PROBE_SELECTION_INSET = 1 + PROBE_CASCADE_STEP / 2 + PROBE_CASCADE_HYSTERESIS + PROBE_RECEIVER_BIAS;
+
 /**
  * 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.

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

@@ -0,0 +1,10 @@
+/**
+ * Which of a pixel's two lobes the fused indirect pass writes (`chunk_probe_clipmap_indirect_lobe`): both, the
+ * frame's, by default; one alone for the mode's indirect debug views (`ProbeClipmapDebugView.IndirectDiffuse`,
+ * `ProbeClipmapDebugView.IndirectSpecular`).
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_INDIRECT_LOBE: ShaderSwitch;
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=PROBE_CLIPMAP_INDIRECT_LOBE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PROBE_CLIPMAP_INDIRECT_LOBE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP_INDIRECT_LOBE.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,0CAFU,YAAY,CAEgG;6BAVzF,0CAA0C"}

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

@@ -0,0 +1,11 @@
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+import { ProbeClipmapIndirectLobe } from "./ProbeClipmapIndirectLobe.js";
+
+/**
+ * Which of a pixel's two lobes the fused indirect pass writes (`chunk_probe_clipmap_indirect_lobe`): both, the
+ * frame's, by default; one alone for the mode's indirect debug views (`ProbeClipmapDebugView.IndirectDiffuse`,
+ * `ProbeClipmapDebugView.IndirectSpecular`).
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_INDIRECT_LOBE = ShaderSwitch.enum('probe clipmap indirect lobe', ProbeClipmapIndirectLobe);

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

@@ -0,0 +1,11 @@
+/**
+ * What the probe clipmap's fused indirect pass (`shader_probe_clipmap_indirect_lighting`) writes of a pixel's
+ * two lobes, by {@link PROBE_CLIPMAP_INDIRECT_LOBE }.
+ */
+export type ProbeClipmapIndirectLobe = number;
+export namespace ProbeClipmapIndirectLobe {
+    let Both: number;
+    let Diffuse: number;
+    let Specular: number;
+}
+//# sourceMappingURL=ProbeClipmapIndirectLobe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProbeClipmapIndirectLobe.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/ProbeClipmapIndirectLobe.js"],"names":[],"mappings":";;;;uCAKU,MAAM"}

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

@@ -0,0 +1,15 @@
+/**
+ * What the probe clipmap's fused indirect pass (`shader_probe_clipmap_indirect_lighting`) writes of a pixel's
+ * two lobes, by {@link PROBE_CLIPMAP_INDIRECT_LOBE}.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const ProbeClipmapIndirectLobe = {
+    /** the diffuse and the specular summed: what the frame adds */
+    Both: 0,
+    /** the probes' irradiance at the bent normal over π, before the surface's albedo, metalness and occlusion */
+    Diffuse: 1,
+    /** the probes' radiance along the surface's lobe, before its split-sum reflectance and occlusion */
+    Specular: 2,
+};