@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.js

@@ -0,0 +1,176 @@
+import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
+import { MESH_SDF_BRICK_TEXEL_COUNT } from "../../../geometry/sdf/MESH_SDF.js";
+import {
+    MESH_SDF_ATLAS_RESOURCE,
+    MESH_SDF_HEADERS_RESOURCE,
+    MESH_SDF_INDIRECTION_RESOURCE,
+    MESH_SDF_SAMPLER_RESOURCE
+} from "../../../geometry/sdf/MESH_SDF_RESOURCES.js";
+import { chunk_mesh_surface_sample } from "../../../geometry/sdf/surface/chunk_mesh_surface_sample.js";
+import {
+    MESH_SURFACE_DATA_RESOURCE,
+    MESH_SURFACE_RECORDS_RESOURCE,
+    MESH_SURFACE_ROWS_RESOURCE
+} from "../../../geometry/sdf/surface/MESH_SURFACE_RESOURCES.js";
+import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { BRICK_THREAD_WORKGROUP_SIZE } from "../brick/BRICK_CLIPMAP.js";
+import { BRICK_RING_RESOURCE, BRICK_TAKE_RESOURCE } from "../brick/chunk_brick_clipmap.js";
+import {
+    BRICK_ATLAS_TEXTURE_RESOURCE,
+    BRICK_LEVELS_RESOURCE,
+    BRICK_MAP_TEXTURE_RESOURCE,
+    BRICK_SAMPLER_RESOURCE,
+    BRICK_TRACE_HIT_VOXELS,
+    chunk_brick_clipmap_sample
+} from "../brick/chunk_brick_clipmap_trace.js";
+import { chunk_brick_provider } from "../brick/chunk_brick_provider.js";
+import { chunk_mesh_brick_instance } from "../brick/mesh/chunk_mesh_brick_instance.js";
+import { chunk_brick_material_cell, chunk_brick_material_texel } from "./chunk_brick_material_cell.js";
+import {
+    BRICK_MATERIAL_ALBEDO_STORE_RESOURCE,
+    BRICK_MATERIAL_EMISSIVE_STORE_RESOURCE,
+    BRICK_MATERIAL_METAL_ROUGH_STORE_RESOURCE,
+    chunk_brick_material_store
+} from "./chunk_brick_material_store.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const BRICK_MATERIAL_GATHER_SETTINGS = WebGPUStruct.from({
+    /** keys `brick_ring` holds, a power of two */
+    ring_capacity: u32,
+    /** cells a cascade's window has a side */
+    resolution: u32,
+}, "BrickMaterialGatherSettings");
+
+/**
+ * The taken cells' staging as the gather reads it, after the providers and the store
+ * (`BRICK_STAGING_RESOURCE`).
+ * @type {ShaderResourceDescriptor}
+ */
+const BRICK_STAGING_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_staging", WebGPUArray.u32);
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", BRICK_MATERIAL_GATHER_SETTINGS);
+
+resources.createGroup()
+    .add(BRICK_LEVELS_RESOURCE)
+    .add(BRICK_MAP_TEXTURE_RESOURCE)
+    .add(BRICK_ATLAS_TEXTURE_RESOURCE)
+    .add(BRICK_SAMPLER_RESOURCE)
+    .add(BRICK_TAKE_RESOURCE)
+    .add(BRICK_RING_RESOURCE)
+    .add(BRICK_STAGING_READ_RESOURCE)
+    .add(BRICK_MATERIAL_ALBEDO_STORE_RESOURCE)
+    .add(BRICK_MATERIAL_METAL_ROUGH_STORE_RESOURCE)
+    .add(BRICK_MATERIAL_EMISSIVE_STORE_RESOURCE);
+
+resources.createGroup()
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_SDF_ATLAS_RESOURCE)
+    .add(MESH_SDF_SAMPLER_RESOURCE)
+    .add(MESH_SURFACE_RECORDS_RESOURCE)
+    .add(MESH_SURFACE_ROWS_RESOURCE)
+    .add(MESH_SURFACE_DATA_RESOURCE);
+
+/**
+ * The brick material of the frame's taken cells, gathered from the Model Surface Caches: a thread a
+ * texel, dispatched through `BRICK_TAKE_TEXEL_DISPATCH` after store and the providers' merge. A cell
+ * store left without a slot does nothing.
+ *
+ * Every texel of a cell with a slot is cleared to no material, since the slot may have held another
+ * cell's. A texel whose nearest surface point is under its tent, |d|·|n|∞ < 1 voxel of the field's
+ * distance d and normal n there, takes its material from the surface it holds: the `meshes` row the
+ * providers left it (`BRICK_STAGING_SURFACE_WORDS`, contract 8), that row's (geometry, material) pair's
+ * cache (`mesh_surface_rows`), read at the texel moved into the geometry's space, at the level of its
+ * field the mesh provider sampled its distance from (`mesh_brick_instance`), surfaces within
+ * {@link BRICK_TRACE_HIT_VOXELS} of the nearest one blended (`mesh_surface_sample`). A row with no cache
+ * resident, and a point the cache holds nothing at, leave the texel without material.
+ *
+ * Reads the caches, the fields and the scene's transforms: no ray, no BLAS, no material table.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_brick_material_gather = ComputeShader.from({
+    label: "Brick Material Gather",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${BRICK_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = folded_workgroup_index(workgroup_id) * ${BRICK_THREAD_WORKGROUP_SIZE}u + lane;
+    let build = thread / ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+    let index = thread % ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+
+    if (build >= brick_take[BRICK_TAKE_COUNT]) {
+        return;
+    }
+
+    let taken = brick_material_cell_entry(build, settings.ring_capacity, settings.resolution);
+
+    if (!brick_clipmap_entry_holds_slot(taken.entry)) {
+        return;
+    }
+
+    let t = brick_material_texel(index);
+    let at = brick_material_atlas_texel(taken.entry, t);
+
+    brick_material_clear(at);
+
+    // in voxels: a voxel of 1
+    let local = vec3<f32>(t);
+    let d = brick_clipmap_sample(taken.entry, local, 1.0);
+    let n = brick_clipmap_normal(taken.entry, local);
+
+    if (!(any(n != vec3<f32>(0.0)) && abs(d) * max(max(abs(n.x), abs(n.y)), abs(n.z)) < 1.0)) {
+        return;
+    }
+
+    let row = brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_SURFACE_WORDS + index];
+
+    if (row == 0u) {
+        return;
+    }
+
+    let cache = mesh_surface_rows[row];
+
+    if (cache == ${GPU_DATABASE_NULL}u) {
+        return;
+    }
+
+    let cell = brick_provider_cell(taken.key, settings.resolution);
+    let p = vec4<f32>(cell.corner + local * cell.voxel, 1.0);
+    let instance = mesh_brick_instance(row, cell.voxel);
+    let q = vec3<f32>(dot(instance.to_local_0, p), dot(instance.to_local_1, p), dot(instance.to_local_2, p));
+
+    let seen = mesh_surface_sample(mesh_surface_records[cache], mesh_sdf_headers[instance.geometry], instance.level, q, ${BRICK_TRACE_HIT_VOXELS});
+
+    if (seen.found) {
+        brick_material_store(at, SurfaceMaterialFitted(true, seen.albedo, seen.metal_rough, seen.emissive));
+    }
+}
+`, [
+            chunk_folded_workgroup_index,
+            chunk_brick_material_cell,
+            chunk_brick_material_texel,
+            chunk_brick_material_store,
+            chunk_brick_clipmap_sample,
+            chunk_brick_provider,
+            chunk_mesh_brick_instance,
+            chunk_mesh_surface_sample,
+        ]),
+});

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

@@ -23,7 +23,10 @@
  *   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
@@ -58,7 +61,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
@@ -186,8 +191,8 @@ export class GPUProbeClipmap {
      */
     built_for(settings: ProbeClipmapSettings): boolean;
     /**
-     * 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
@@ -198,7 +203,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
      */
@@ -219,8 +225,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,
@@ -233,7 +240,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 }: {
         graph: FrameGraph;
         wants: ProbeClipmapWants;
         response_frames: number;
@@ -242,7 +249,9 @@ export class GPUProbeClipmap {
         brick_clipmap: import("../brick/GPUBrickClipmap.js").GPUBrickClipmap;
         bricks: number;
         scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
-        card_rows: GPUBuffer;
+        material: {
+            write_bindings: (arg0: any) => any;
+        };
         history_resampling: boolean;
         ray_resampling: boolean;
         clusters: {

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;QAxB+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;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;QACC,QAAQ,EAAxB,MAAM;aAmOhB;IAqhBD,gBAcC;;CACJ;mCA17CY,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;IA2RI;;;;;;;;;;;;;;;;;;;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;IA9ZD;;;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;IAiXN;;;;;;;;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;aA0OhB;IA6gBD,gBAcC;;CACJ;mCAn9CY,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
@@ -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;
 
@@ -374,6 +382,12 @@ export class GPUProbeClipmap {
     #starved = 0;
     #grow_pending = false;
 
+    /**
+     * The frame the capacity last grew in. A reading recorded before it asked for what that growth gave, so
+     * only a count that moved in a frame at or after it grows the capacity again.
+     */
+    #grown_frame = -1;
+
     /** Frames recorded: the clock the records keep. */
     #frame = 0;
 
@@ -391,7 +405,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 +453,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 +465,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 +487,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 +703,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 +718,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 +736,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 +748,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 +777,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 +800,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 +815,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 +825,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');
@@ -811,6 +840,7 @@ export class GPUProbeClipmap {
         if (this.#grow_pending) {
             this.#grow_pending = false;
             this.#grow();
+            this.#grown_frame = this.#frame;
         }
 
         const trace_capacity = Math.floor(ray_budget / rays_per_probe);
@@ -842,6 +872,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 +887,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 +997,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;
@@ -991,6 +1025,8 @@ export class GPUProbeClipmap {
         update.make_side_effect();
 
         // an admission the free list could not serve grows the capacity, from a later frame
+        const read_frame = this.#frame;
+
         graph_read_buffer({ graph, buffer: update_data.counters, offset: 4 * PROBE_COUNTER_STARVED, size: 4 })
             .then(reference => {
                 try {
@@ -998,7 +1034,7 @@ export class GPUProbeClipmap {
 
                     if (!this.#destroyed && starved !== this.#starved) {
                         this.#starved = starved;
-                        this.#grow_pending = true;
+                        this.#grow_pending ||= read_frame >= this.#grown_frame;
                     }
                 } finally {
                     reference.release();
@@ -1353,19 +1389,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.