@woosh/meep-engine 3.61.2 → 3.61.3

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
@@ -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 };
@@ -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;
     }
 
@@ -772,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,
@@ -786,7 +809,7 @@ export class GPUProbeClipmap {
      *   tone curve, a single f32, as the last frame was shown: the exposure the probes' estimators state their
      *   thresholds in
      */
-    graph_update({ graph, wants, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback, exposure }) {
+    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.isFinite(response_frames, 'response_frames');
@@ -796,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');
@@ -842,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);
 
@@ -855,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;
@@ -963,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;
@@ -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,

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

@@ -196,7 +196,7 @@ export const PROBE_RELOCATION_STEPS: number;
  */
 export const PROBE_RAY_ORIGIN_JITTER: number;
 /**
- * The stream of a ray's noise (`probe_clipmap_ray_noise`) that jitters its direction inside its texel.
+ * 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;
@@ -382,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

@@ -230,7 +230,7 @@ export const PROBE_RELOCATION_STEPS = 3;
 export const PROBE_RAY_ORIGIN_JITTER = 1 / 16;
 
 /**
- * The stream of a ray's noise (`probe_clipmap_ray_noise`) that jitters its direction inside its texel.
+ * 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;
@@ -488,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,
+};

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

@@ -16,8 +16,8 @@ export const PROBE_RAY_STRUCT: WebGPUStruct;
 /**
  * The cascades' cage windows, a {@link CLIPMAP_LEVEL_ARRAY} as a uniform, finest first: a cell of
  * cascade `c` is the cage of the eight lattice points at its corners, so its window is one short of the
- * lattice's on each axis, and `clipmap_select_finest` over it answers the finest cascade whose whole
- * cage holds a point (§8.1).
+ * lattice's on each axis. `probe_clipmap_select_in` chooses a point's cascade by boxes on the anchor that lie
+ * inside these windows (§9.1, "Selection").
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_LEVELS_RESOURCE: ShaderResourceDescriptor;
@@ -377,12 +377,10 @@ export const chunk_probe_clipmap_ray_texel: CodeChunk;
 /**
  * A ray's noise (§8.6, §8.7): a hash of the probe's slot, its update count, the ray's place among the
  * update's rays and a stream, the same in every pass that knows the ray. It never repeats over a probe's
- * updates. Uniform and guided updates alike, the trace jitters its ray inside its texel by stream
- * `PROBE_RAY_NOISE_JITTER`, and the bounce picks the probes at its hit by `PROBE_RAY_NOISE_PICK`, which is
- * independent of the jitter that placed the hit.
+ * updates. The bounce picks the probes at its hit by stream `PROBE_RAY_NOISE_PICK`, which is independent of
+ * the jitter that placed the hit (`probe_clipmap_ray_jitter`).
  *
- * This is white noise. Nothing stratifies it across texels, across updates, or across a texel's rays,
- * which may clump. Each component lies inside (0, 1), at the centre of one of 2^23 bins, so a weighted
+ * This is white noise. Each component lies inside (0, 1), at the centre of one of 2^23 bins, so a weighted
  * draw by it never meets either end.
  *
  * ```wgsl
@@ -392,6 +390,22 @@ export const chunk_probe_clipmap_ray_texel: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_ray_noise: CodeChunk;
+/**
+ * Where a ray lands inside its octahedral texel (§8.6), as a point of the texel's square in [0, 1)²: point
+ * `index` of the texel's jitter sequence `sequence`, a shuffled, Owen-scrambled Sobol (0, 2)-sequence
+ * (`sample_sobol_2d`) seeded by the probe's slot, the texel and the sequence. Which sequence and index a ray
+ * takes is `probe_clipmap_ray_visit`'s.
+ *
+ * The points of an aligned run of 2^m indices of one sequence put one in each dyadic cell of area 2^-m of the
+ * texel. Different slots, texels and sequences draw independent sequences.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, sequence: u32, index: u32) -> vec2<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_jitter: CodeChunk;
 /**
  * Where a ray of an update starts (§8.6): a point of the ball of `PROBE_RAY_ORIGIN_JITTER` of the spacing
  * around the probe, uniform in its volume, as Brick4's bake jitters its probes. The point is drawn from the
@@ -453,6 +467,29 @@ export const PROBE_GUIDE_READ_RESOURCE: ShaderResourceDescriptor;
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_guide: CodeChunk;
+/**
+ * Which of its texel's jitter sequences a ray of an update takes, and its index there (`.x`, `.y`), for
+ * `probe_clipmap_ray_jitter` (§8.6). A texel has a sequence for each round (the ray's place among the
+ * texel's rays in the update, from 0) and each kind of update: uniform, guided, and a DEAD probe's. The index
+ * counts the texel's earlier visits of that kind:
+ * - uniform: the probe's uniform updates before this one (its first n_r²/R, then every `period`-th), over
+ *   the uniform updates between two of the texel's rays below R = n_r², n_r²/R;
+ * - guided: the probe's guided updates before this one;
+ * - DEAD: its updates before this one, over n_r²/R where its rays are fewer than the texels.
+ *
+ * So a texel that takes a ray of a round on every update of a kind has that round's rays of the kind
+ * stratified inside it, whichever other updates it takes rays on: those of an aligned run of 2^m indices
+ * put one in each dyadic cell of area 2^-m. A texel passed over on some guided updates takes a subset of
+ * such a run. The indices of a kind only grow, so no sequence gives a texel a point twice until the 30-bit
+ * update count wraps.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_visit(state: u32, round: u32, rays: u32, texels: u32, period: u32, rays_per_probe: u32) -> vec2<u32> // state: the first word; rays: the update's
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_visit: CodeChunk;
 /**
  * The rays a guided update gives a radiance texel, `R·(w + e)/W`, from the probe's guide (§8.6), whose words start
  * at `base`; nothing for a guide the guide passes never wrote.

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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"}