@woosh/meep-engine 3.61.1 → 3.61.3

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

@@ -1,13 +1,4 @@
-import {
-    MESH_CARD_ALBEDO_RESOURCE,
-    MESH_CARD_EMISSIVE_RESOURCE,
-    MESH_CARD_ROWS_RESOURCE,
-    MESH_CARD_SETS_RESOURCE
-} from "../../../geometry/sdf/cards/MESH_CARD_RESOURCES.js";
-import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
-import { MESH_SDF_HEADERS_RESOURCE, MESH_SDF_INDIRECTION_RESOURCE } from "../../../geometry/sdf/MESH_SDF_RESOURCES.js";
 import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
-import { SCENE_DATABASE_RESOURCE } from "../../../scene/SCENE_DATABASE_RESOURCE.js";
 import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
 import {
@@ -15,12 +6,20 @@ import {
 } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
+import { chunk_pcg4d } from "../../../shader/chunk/random/pcg/chunk_pcg4d.js";
 import { chunk_sample_environment_map } from "../../../shader/chunk/texture/sample/chunk_sample_environment_map.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { BRICK_TRACE_HIT, BRICK_TRACE_MISS } from "../brick/BRICK_CLIPMAP.js";
-import { BRICK_LEVELS_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
+import {
+    BRICK_ATLAS_TEXTURE_RESOURCE,
+    BRICK_LEVELS_RESOURCE,
+    BRICK_MAP_TEXTURE_RESOURCE,
+    BRICK_SAMPLER_RESOURCE
+} from "../brick/chunk_brick_clipmap_trace.js";
+import { BRICK_MATERIAL_ALBEDO_RESOURCE, BRICK_MATERIAL_EMISSIVE_RESOURCE } from "../material/chunk_brick_material.js";
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_ray_origin,
@@ -28,7 +27,7 @@ import {
     PROBE_RAYS_WRITE_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import { chunk_probe_clipmap_hit_surface } from "./chunk_probe_clipmap_hit_surface.js";
+import { chunk_probe_clipmap_hit_material_pick } from "./chunk_probe_clipmap_hit_material.js";
 import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 import { PROBE_TRACE_SETTINGS } from "./shader_probe_clipmap_trace.js";
 
@@ -44,14 +43,13 @@ resources.createGroup()
     .addTexture("tEnvironment", "float", "2d")
     .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE);
 
+// what the brick material's read takes
 resources.createGroup()
-    .add(SCENE_DATABASE_RESOURCE)
-    .add(MESH_CARD_ROWS_RESOURCE)
-    .add(MESH_SDF_HEADERS_RESOURCE)
-    .add(MESH_SDF_INDIRECTION_RESOURCE)
-    .add(MESH_CARD_SETS_RESOURCE)
-    .add(MESH_CARD_ALBEDO_RESOURCE)
-    .add(MESH_CARD_EMISSIVE_RESOURCE);
+    .add(BRICK_MAP_TEXTURE_RESOURCE)
+    .add(BRICK_ATLAS_TEXTURE_RESOURCE)
+    .add(BRICK_SAMPLER_RESOURCE)
+    .add(BRICK_MATERIAL_ALBEDO_RESOURCE)
+    .add(BRICK_MATERIAL_EMISSIVE_RESOURCE);
 
 /**
  * Shade (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a thread a ray of the frame's updates, dispatched
@@ -65,13 +63,16 @@ resources.createGroup()
  *   4πm²·(1 − (1 − e^(−k))/k), k = 2/m²: m = 1/n_r to 0.2% at n_r = 16, so the roughness is 1/√n_r. A sun
  *   a few texels wide at level 0 is then a lobe a texel wide, which a texel's jittered rays all see,
  *   rather than a point that only some probes' jitter ever lands on;
- * - a **front-face hit** is `emissive + ρ_d·E_dir/π` (D7), its surface from `probe_clipmap_hit_surface`
- *   at the hit's position, the probe's origin plus t along the ray, with the hit's normal, at its
- *   cascade's voxel; E_dir is what trace left in the light;
+ * - a **front-face hit** is `emissive + ρ_d·E_dir/π` (D7), its surface from
+ *   `probe_clipmap_hit_material_pick` at the hit's position, the probe's origin plus t along the ray,
+ *   with the hit's normal, in its cascade: one texel of the brick material there, drawn from the ray's
+ *   slot and direction, fresh every update and apart from the light pass's draws, in proportion to its
+ *   weight in the texels' blend, which the probe's blend of its rays so takes on average; E_dir is what
+ *   trace left in the light;
  * - an **unresolved** ray and a **back face** bring nothing back: accumulation discards the one and
  *   counts the other (§8.4, §8.8).
  *
- * A front-face hit's diffuse albedo goes over its `row`, `pack4x8unorm`, and every other ray's row to
+ * A front-face hit's diffuse albedo goes into its `albedo`, `pack4x8unorm`, and every other ray's to
  * zero: the light pass adds ρ_d·(E_loc + E_ind)/π after it (S5).
  *
  * @type {ComputeShader}
@@ -106,9 +107,10 @@ fn main(
         let origin = probe_clipmap_ray_origin(probe_origins[k], probe_trace.elements[k], record.direction);
         let position = origin + record.t * direction;
         let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
-        let voxel = brick_levels[(record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
+        let cascade = (record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK;
 
-        let surface = probe_clipmap_hit_surface(record.row, position, normal, voxel);
+        let draw = hash_to_float01(pcg4d(vec4<u32>(probe_trace.elements[k], record.direction, 0x510E527Fu, 0u)).x);
+        let surface = probe_clipmap_hit_material_pick(position, normal, cascade, draw);
         let direct = rgbe9995_decode(record.light);
 
         radiance = surface.emissive + surface.albedo * direct * RECIPROCAL_PI;
@@ -118,7 +120,7 @@ fn main(
     // held to RGB9E5's largest value, which the half-float atlas also holds: an infinity there times a
     // zero weight would be a NaN in every sum it reaches
     probe_rays[ray].light = rgbe9995_encode(radiance);
-    probe_rays[ray].row = pack4x8unorm(vec4<f32>(albedo, 0.0));
+    probe_rays[ray].albedo = pack4x8unorm(vec4<f32>(albedo, 0.0));
 }
 `, [
             chunk_probe_clipmap,
@@ -126,7 +128,9 @@ fn main(
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
             chunk_sample_environment_map,
-            chunk_probe_clipmap_hit_surface,
+            chunk_probe_clipmap_hit_material_pick,
+            chunk_pcg4d,
+            chunk_hash_to_float01,
             chunk_rgbe9995_decode,
             chunk_rgbe9995_encode,
             RECIPROCAL_PI_DECLARATION,

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

@@ -12,10 +12,10 @@ export const PROBE_TRACE_SETTINGS: WebGPUStruct;
  *   or a spread subset below R = n_r². On a guided one, the walk position whose rays the ray is among
  *   in the probe's guide (`chunk_probe_clipmap_guide`), found by bisecting the first rays. A texel's rays
  *   then follow one another, in the walk's order.
- * - **Direction**: the texel's octahedral square, jittered by STBN at the texel, moved by the slot's
- *   hash so that neighbouring probes do not jitter alike, and at the update count: one stratified,
- *   jittered ray a texel, LPV's own pattern. A guided texel's later rays rotate that jitter by R2
- *   (`probe_clipmap_guided_ray_jitter`).
+ * - **Direction**: the texel's octahedral square, jittered by a point of one of the texel's Sobol sequences
+ *   (`probe_clipmap_ray_jitter`): the sequence of the ray's round among the texel's rays and of the kind of
+ *   update, at the count of the probe's earlier updates of that kind (`probe_clipmap_ray_visit`). A texel's
+ *   rays of a round and kind are stratified inside it over the updates of that kind it takes them on.
  * - **Origin**: a point of a small ball around the probe where relocation left it, `probe_origins`, one a
  *   ray (`probe_clipmap_ray_origin`); t_min one voxel of the brick cascade there.
  * - **Direct light**: a hit off a front face takes E_dir = Σ colour·max(0, n·l)·visibility over the
@@ -29,8 +29,8 @@ export const PROBE_TRACE_SETTINGS: WebGPUStruct;
  *   surface turned from a light traces no ray toward it, since the light gives it nothing.
  * - **Back face**: a hit whose field's gradient is along the ray, so it came from inside a solid.
  *
- * Writes the ray's `PROBE_RAY_STRUCT`, with the `meshes` row of the hit's surface and E_dir as its
- * light, which shade turns into the ray's radiance, and its probe's place in the list in its flags.
+ * Writes the ray's `PROBE_RAY_STRUCT`, with E_dir as its light, which shade turns into the ray's
+ * radiance, and its probe's place in the list in its flags.
  *
  * @type {ComputeShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAqDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAwBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAoJpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAkDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAuJpB;6BAvP0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -21,24 +21,21 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import {
     BRICK_ATLAS_TEXTURE_RESOURCE,
     BRICK_LEVELS_RESOURCE,
     BRICK_MAP_TEXTURE_RESOURCE,
-    BRICK_OBJECTS_RESOURCE,
     BRICK_OCCUPANCY_TEXTURE_RESOURCE,
     BRICK_SAMPLER_RESOURCE,
-    chunk_brick_clipmap_object,
     chunk_brick_clipmap_trace
 } from "../brick/chunk_brick_clipmap_trace.js";
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_guide,
-    chunk_probe_clipmap_guided_ray_jitter,
-    chunk_probe_clipmap_ray_jitter,
     chunk_probe_clipmap_ray_layout,
+    chunk_probe_clipmap_ray_jitter,
     chunk_probe_clipmap_ray_origin,
+    chunk_probe_clipmap_ray_visit,
     chunk_probe_clipmap_ray_texel,
     PROBE_GUIDE_READ_RESOURCE,
     PROBE_ORIGINS_READ_RESOURCE,
@@ -80,7 +77,6 @@ resources.createGroup()
     .add(PROBE_RAYS_WRITE_RESOURCE)
     .add(PROBE_RAY_SUMS_READ_RESOURCE)
     .add(PROBE_GUIDE_READ_RESOURCE)
-    .add(STBN_VEC2_RESOURCE)
     .add(LIGHT_DATA_RESOURCE);
 
 resources.createGroup()
@@ -88,8 +84,7 @@ resources.createGroup()
     .add(BRICK_MAP_TEXTURE_RESOURCE)
     .add(BRICK_OCCUPANCY_TEXTURE_RESOURCE)
     .add(BRICK_ATLAS_TEXTURE_RESOURCE)
-    .add(BRICK_SAMPLER_RESOURCE)
-    .add(BRICK_OBJECTS_RESOURCE);
+    .add(BRICK_SAMPLER_RESOURCE);
 
 /**
  * Trace (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.6): a thread a ray of the frame's updates, dispatched
@@ -101,10 +96,10 @@ resources.createGroup()
  *   or a spread subset below R = n_r². On a guided one, the walk position whose rays the ray is among
  *   in the probe's guide (`chunk_probe_clipmap_guide`), found by bisecting the first rays. A texel's rays
  *   then follow one another, in the walk's order.
- * - **Direction**: the texel's octahedral square, jittered by STBN at the texel, moved by the slot's
- *   hash so that neighbouring probes do not jitter alike, and at the update count: one stratified,
- *   jittered ray a texel, LPV's own pattern. A guided texel's later rays rotate that jitter by R2
- *   (`probe_clipmap_guided_ray_jitter`).
+ * - **Direction**: the texel's octahedral square, jittered by a point of one of the texel's Sobol sequences
+ *   (`probe_clipmap_ray_jitter`): the sequence of the ray's round among the texel's rays and of the kind of
+ *   update, at the count of the probe's earlier updates of that kind (`probe_clipmap_ray_visit`). A texel's
+ *   rays of a round and kind are stratified inside it over the updates of that kind it takes them on.
  * - **Origin**: a point of a small ball around the probe where relocation left it, `probe_origins`, one a
  *   ray (`probe_clipmap_ray_origin`); t_min one voxel of the brick cascade there.
  * - **Direct light**: a hit off a front face takes E_dir = Σ colour·max(0, n·l)·visibility over the
@@ -118,8 +113,8 @@ resources.createGroup()
  *   surface turned from a light traces no ray toward it, since the light gives it nothing.
  * - **Back face**: a hit whose field's gradient is along the ray, so it came from inside a solid.
  *
- * Writes the ray's `PROBE_RAY_STRUCT`, with the `meshes` row of the hit's surface and E_dir as its
- * light, which shade turns into the ray's radiance, and its probe's place in the list in its flags.
+ * Writes the ray's `PROBE_RAY_STRUCT`, with E_dir as its light, which shade turns into the ray's
+ * radiance, and its probe's place in the list in its flags.
  *
  * @type {ComputeShader}
  */
@@ -158,7 +153,7 @@ fn main(
     let k = probe_clipmap_ray_probe(ray);
 
     if (k >= probe_ray_sums.count) {
-        probe_rays[ray].row = 0u;
+        probe_rays[ray].albedo = 0u;
         probe_rays[ray].flags = PROBE_RAY_NONE;
 
         return;
@@ -177,19 +172,23 @@ fn main(
     let updates = probe_state_updates(state.x);
 
     var texel: u32;
-    var jitter: vec2<f32>;
+    // the ray's place among its texel's rays in the update, as accumulation counts them
+    var round: u32;
 
     if (probe_clipmap_guided(state.x, settings.uniform_period, settings.rays_per_probe, texels)) {
         let base = k * probe_clipmap_guide_words(n);
         let position = probe_trace_guided_position(base, i, texels);
 
         texel = probe_clipmap_guide_texel(position, updates, n);
-        jitter = probe_clipmap_guided_ray_jitter(slot, texel, i - probe_guide[base + position], updates, rays, n);
+        round = i - probe_guide[base + position];
     } else {
         texel = probe_clipmap_ray_texel(i, updates, rays, texels);
-        jitter = probe_clipmap_ray_jitter(slot, texel, i, updates, rays, n);
+        // every texel once, then again: below R = n_r² the update's rays are all its first
+        round = i / texels;
     }
 
+    let visit = probe_clipmap_ray_visit(state.x, round, rays, texels, settings.uniform_period, settings.rays_per_probe);
+    let jitter = probe_clipmap_ray_jitter(slot, texel, visit.x, visit.y);
     let direction = uv_octahedral_unit_decode((vec2<f32>(f32(texel % n), f32(texel / n)) + jitter) / f32(n));
     let packed = pack2x16unorm(uv_octahedral_unit_encode(direction));
 
@@ -245,7 +244,7 @@ fn main(
     probe_rays[ray].t = hit.t;
     probe_rays[ray].direction = packed;
     probe_rays[ray].normal = select(0u, pack2x16unorm(uv_octahedral_unit_encode(hit.normal)), is_hit);
-    probe_rays[ray].row = brick_clipmap_object(hit);
+    probe_rays[ray].albedo = 0u;
     probe_rays[ray].flags = hit.kind | select(0u, PROBE_RAY_BACK_FACE, back_face) | (select(0u, hit.cascade, is_hit) << PROBE_RAY_CASCADE_SHIFT) | (k << PROBE_RAY_PROBE_SHIFT);
     probe_rays[ray].light = rgbe9995_encode(direct);
 }
@@ -254,14 +253,13 @@ fn main(
             chunk_probe_clipmap_ray_layout,
             chunk_probe_clipmap_ray_texel,
             chunk_probe_clipmap_ray_jitter,
+            chunk_probe_clipmap_ray_visit,
             chunk_probe_clipmap_ray_origin,
             chunk_probe_clipmap_guide,
-            chunk_probe_clipmap_guided_ray_jitter,
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
             chunk_uv_octahedral_unit_encode,
             chunk_brick_clipmap_trace,
-            chunk_brick_clipmap_object,
             chunk_cone_sample_direction,
             chunk_pcg3d,
             chunk_hash_to_float01,

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAUE;AAexB;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CAqCpB;6BAtF0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAcE;AAexB;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CAqCpB;6BA1F0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -7,7 +7,7 @@ import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_s
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import {
@@ -30,6 +30,10 @@ export const PROBE_WANT_SETTINGS = WebGPUStruct.from({
     frame: u32,
     /** what the wanted list holds at most: every key, or fewer where the wants cannot want more */
     wanted_capacity: u32,
+    /** where the windows were placed around, world metres: the selection boxes' centre, as the pick reads it */
+    anchor: vec3f,
+    /** a selection box's half side, in its cascade's cells, as the pick reads it */
+    select_half: f32,
 }, "ProbeWantSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -83,7 +87,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
     let bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
 
-    probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.wanted_capacity);
+    probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.anchor, settings.select_half, settings.wanted_capacity);
 }
 `, [
             chunk_probe_clipmap,

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

@@ -4,8 +4,8 @@
  * `PROBE_DISPATCH_RAYS` of that clipmap, before its frame's lifetime writes them over. The points go on this
  * clipmap's wanted list, through its levels.
  *
- * A front-face hit whose `row` the light passes left non-zero wants the cages its pick reads in this clipmap:
- * the bounce pass clears the row of a hit whose first set held probes, so a hit wants only where that set
+ * A front-face hit whose `albedo` the light passes left non-zero wants the cages its pick reads in this clipmap:
+ * the bounce pass clears the albedo of a hit whose first set held probes, so a hit wants only where that set
  * had none, and this clipmap's probes are its fallback (`shader_probe_clipmap_bounce`). So a probe a hit needs
  * is admitted where the first set has none, and kept while hits read it. Until its first update a NEW probe
  * weighs nothing and the hit takes no bounce: light is lost for a frame or two, never invented.

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

@@ -37,8 +37,8 @@ resources.createGroup()
  * `PROBE_DISPATCH_RAYS` of that clipmap, before its frame's lifetime writes them over. The points go on this
  * clipmap's wanted list, through its levels.
  *
- * A front-face hit whose `row` the light passes left non-zero wants the cages its pick reads in this clipmap:
- * the bounce pass clears the row of a hit whose first set held probes, so a hit wants only where that set
+ * A front-face hit whose `albedo` the light passes left non-zero wants the cages its pick reads in this clipmap:
+ * the bounce pass clears the albedo of a hit whose first set held probes, so a hit wants only where that set
  * had none, and this clipmap's probes are its fallback (`shader_probe_clipmap_bounce`). So a probe a hit needs
  * is admitted where the first set has none, and kept while hits read it. Until its first update a NEW probe
  * weighs nothing and the hit takes no bounce: light is lost for a frame or two, never invented.
@@ -75,10 +75,10 @@ fn main(
         let k = record.flags >> PROBE_RAY_PROBE_SHIFT;
         let slot = probe_trace.elements[k];
 
-        // shade left a front-face hit's albedo in its row and zero in any other ray's, and the bounce pass
-        // cleared the row of a hit its first set served: a ray that takes no bounce, a black hit's among them,
+        // shade left a front-face hit's albedo and zero in any other ray's, and the bounce pass cleared the
+        // albedo of a hit its first set served: a ray that takes no bounce, a black hit's among them,
         // or that had its probes, wants nothing
-        wants = record.row != 0u;
+        wants = record.albedo != 0u;
 
         let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
         let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
@@ -88,7 +88,7 @@ fn main(
         bias_direction = mix(normal, -direction, ${PROBE_RECEIVER_BIAS_VIEW});
     }
 
-    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.wanted_capacity);
+    probe_clipmap_want(wants, position, bias_direction, settings.cascade_count, settings.resolution, settings.anchor, settings.select_half, settings.wanted_capacity);
 }
 `, [
             chunk_probe_clipmap,

package/src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The step of a hash table's probe sequence: `(5 index + 1) mod 2^K`, which visits every record of a
+ * table of 2^K records once before it repeats. The WGSL twin of
+ * `core/collection/map/generate_next_linear_congruential_index.js`.
+ *
+ * ```wgsl
+ * fn generate_next_linear_congruential_index(index: u32, mask: u32) -> u32   // mask: 2^K - 1
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_generate_next_linear_congruential_index: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_generate_next_linear_congruential_index.d.ts.map

package/src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_generate_next_linear_congruential_index.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,4DAFU,SAAS,CAUhB;0BArBuB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/hash_table/chunk_generate_next_linear_congruential_index.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The step of a hash table's probe sequence: `(5 index + 1) mod 2^K`, which visits every record of a
+ * table of 2^K records once before it repeats. The WGSL twin of
+ * `core/collection/map/generate_next_linear_congruential_index.js`.
+ *
+ * ```wgsl
+ * fn generate_next_linear_congruential_index(index: u32, mask: u32) -> u32   // mask: 2^K - 1
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_generate_next_linear_congruential_index = CodeChunk.from(
+    //language=WGSL
+    `
+fn generate_next_linear_congruential_index(index: u32, mask: u32) -> u32 {
+    let index5 = index * 5u;
+
+    return (index5 + 1u) & mask;
+}
+`);

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The encoded key of a record removed from a table the device keeps ({@link chunk_hash_table_atomic}):
+ * a probe passes over it as over another key's record, and an insert may take its place. No key
+ * encodes to it, keys staying below `0xFFFFFFFE`.
+ * @type {number}
+ */
+export const HASH_TABLE_REMOVED: number;
+/**
+ * The table `cpu_build_hash_table` lays out (`[element_count, table_size]`, then `table_size` records
+ * of `(key + 1, value)`, an empty record 0) kept on the device: inserted into and removed from by
+ * atomics, on `hash_table_get`'s probe sequence and limit. A key may hold several records, which find
+ * visits in turn; the caller tells them apart by what their values name. `element_count` counts the
+ * records held.
+ *
+ * ```wgsl
+ * fn hash_table_atomic_start(table, offset: u32, key: u32) -> vec2<u32>                           // a cursor at the key's first record
+ * fn hash_table_atomic_find(table, offset: u32, key: u32, cursor: ptr<function, vec2<u32>>) -> u32  // the key's next record, or HASH_TABLE_MISS
+ * fn hash_table_atomic_value(table, record: u32) -> u32
+ * fn hash_table_atomic_insert(table, offset: u32, key: u32, value: u32) -> bool                    // false: no record free within the probe limit
+ * fn hash_table_atomic_remove(table, offset: u32, record: u32)
+ * ```
+ *
+ * `table` is a `ptr<storage, array<atomic<u32>>, read_write>`, and a record is named by the word it
+ * starts at. Insert claims the first empty or removed record of the key's sequence by
+ * compare-exchange on its key and stores the value after it, so a find racing that insert in one
+ * dispatch may read the value before it lands: a caller whose inserts share a dispatch with its finds
+ * checks what a value names before trusting it. Inserts and removes of different records may share a
+ * dispatch. A find ends at the sequence's first empty record or at the probe limit.
+ *
+ * A table holds at least `HASH_TABLE_PROBE_LIMIT` records, a power of two, so that the probes of a
+ * key's sequence meet no record twice.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_hash_table_atomic: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_hash_table_atomic.d.ts.map

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hash_table_atomic.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,iCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,sCAFU,SAAS,CAmFZ;0BAxHmB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_atomic.js

@@ -0,0 +1,122 @@
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_generate_next_linear_congruential_index } from "./chunk_generate_next_linear_congruential_index.js";
+import { HASH_TABLE_MISS, HASH_TABLE_PROBE_LIMIT } from "./cpu_build_hash_table.js";
+
+/**
+ * The encoded key of a record removed from a table the device keeps ({@link chunk_hash_table_atomic}):
+ * a probe passes over it as over another key's record, and an insert may take its place. No key
+ * encodes to it, keys staying below `0xFFFFFFFE`.
+ * @type {number}
+ */
+export const HASH_TABLE_REMOVED = 0xFFFFFFFF;
+
+/**
+ * The table `cpu_build_hash_table` lays out (`[element_count, table_size]`, then `table_size` records
+ * of `(key + 1, value)`, an empty record 0) kept on the device: inserted into and removed from by
+ * atomics, on `hash_table_get`'s probe sequence and limit. A key may hold several records, which find
+ * visits in turn; the caller tells them apart by what their values name. `element_count` counts the
+ * records held.
+ *
+ * ```wgsl
+ * fn hash_table_atomic_start(table, offset: u32, key: u32) -> vec2<u32>                           // a cursor at the key's first record
+ * fn hash_table_atomic_find(table, offset: u32, key: u32, cursor: ptr<function, vec2<u32>>) -> u32  // the key's next record, or HASH_TABLE_MISS
+ * fn hash_table_atomic_value(table, record: u32) -> u32
+ * fn hash_table_atomic_insert(table, offset: u32, key: u32, value: u32) -> bool                    // false: no record free within the probe limit
+ * fn hash_table_atomic_remove(table, offset: u32, record: u32)
+ * ```
+ *
+ * `table` is a `ptr<storage, array<atomic<u32>>, read_write>`, and a record is named by the word it
+ * starts at. Insert claims the first empty or removed record of the key's sequence by
+ * compare-exchange on its key and stores the value after it, so a find racing that insert in one
+ * dispatch may read the value before it lands: a caller whose inserts share a dispatch with its finds
+ * checks what a value names before trusting it. Inserts and removes of different records may share a
+ * dispatch. A find ends at the sequence's first empty record or at the probe limit.
+ *
+ * A table holds at least `HASH_TABLE_PROBE_LIMIT` records, a power of two, so that the probes of a
+ * key's sequence meet no record twice.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_hash_table_atomic = CodeChunk.from(
+    //language=WGSL
+    `
+const HASH_TABLE_MISS = ${HASH_TABLE_MISS}u;
+const HASH_TABLE_REMOVED = ${HASH_TABLE_REMOVED}u;
+const HASH_TABLE_PROBE_LIMIT = ${HASH_TABLE_PROBE_LIMIT}u;
+
+fn hash_table_atomic_start(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, key: u32) -> vec2<u32> {
+    let mask = atomicLoad(&(*table)[offset + 1u]) - 1u;
+
+    // the record index, then the probes taken
+    return vec2<u32>(hash_lowbias32(key) & mask, 0u);
+}
+
+fn hash_table_atomic_find(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, key: u32, cursor: ptr<function, vec2<u32>>) -> u32 {
+    let mask = atomicLoad(&(*table)[offset + 1u]) - 1u;
+    let encoded = key + 1u;
+
+    while ((*cursor).y < HASH_TABLE_PROBE_LIMIT) {
+        let record = offset + 2u + 2u * (*cursor).x;
+        let stored = atomicLoad(&(*table)[record]);
+
+        *cursor = vec2<u32>(generate_next_linear_congruential_index((*cursor).x, mask), (*cursor).y + 1u);
+
+        if (stored == 0u) {
+            // the key's sequence ends at its first empty record
+            (*cursor).y = HASH_TABLE_PROBE_LIMIT;
+
+            return HASH_TABLE_MISS;
+        }
+
+        if (stored == encoded) {
+            return record;
+        }
+    }
+
+    return HASH_TABLE_MISS;
+}
+
+fn hash_table_atomic_value(table: ptr<storage, array<atomic<u32>>, read_write>, record: u32) -> u32 {
+    return atomicLoad(&(*table)[record + 1u]);
+}
+
+fn hash_table_atomic_insert(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, key: u32, value: u32) -> bool {
+    let mask = atomicLoad(&(*table)[offset + 1u]) - 1u;
+
+    var index = hash_lowbias32(key) & mask;
+
+    for (var probe = 0u; probe < HASH_TABLE_PROBE_LIMIT; probe++) {
+        let record = offset + 2u + 2u * index;
+        let stored = atomicLoad(&(*table)[record]);
+
+        if (stored == 0u || stored == HASH_TABLE_REMOVED) {
+            let claim = atomicCompareExchangeWeak(&(*table)[record], stored, key + 1u);
+
+            if (claim.exchanged) {
+                atomicStore(&(*table)[record + 1u], value);
+                atomicAdd(&(*table)[offset], 1u);
+
+                return true;
+            }
+
+            if (claim.old_value == stored) {
+                // a weak exchange may fail on a record that still holds what it read: the same record again
+                continue;
+            }
+        }
+
+        index = generate_next_linear_congruential_index(index, mask);
+    }
+
+    return false;
+}
+
+fn hash_table_atomic_remove(table: ptr<storage, array<atomic<u32>>, read_write>, offset: u32, record: u32) {
+    atomicStore(&(*table)[record], HASH_TABLE_REMOVED);
+    atomicSub(&(*table)[offset], 1u);
+}
+`, [
+        chunk_generate_next_linear_congruential_index,
+        chunk_hash_lowbias32,
+    ]);

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_hash_table_get.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,mCAFU,SAAS,CAkDlB;0BAjEyB,oCAAoC"}
+{"version":3,"file":"chunk_hash_table_get.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,mCAFU,SAAS,CAkDlB;0BAvDyB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/hash_table/chunk_hash_table_get.js

@@ -1,16 +1,6 @@
 import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-
-const chunk_generate_next_linear_congruential_index = CodeChunk.from(
-    //language=WGSL
-    `
-fn generate_next_linear_congruential_index(index:u32, mask: u32) -> u32{
-    let index5 = index * 5;
-
-    return (index5 + 1) & mask;
-}
-    `
-)
+import { chunk_generate_next_linear_congruential_index } from "./chunk_generate_next_linear_congruential_index.js";
 
 /**
  * @see cpu_build_hash_table

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.d.ts

@@ -40,6 +40,14 @@ export function cpu_hash_table_word_count(input_size: number): number;
  * @see cpu_build_hash_table to build at a given size
  */
 export function cpu_hash_table_create(table: Uint32Array, inputs: number[], input_size: number): boolean;
+/**
+ * Maximum number of slots visited per operation.
+ * Must match the WGSL twins ({@link chunk_hash_table_get}, `chunk_hash_table_atomic`): a lookup probes
+ * at most this many slots, so an insert that cannot place a record within the limit must report it —
+ * otherwise it would create an entry that lookups can never reach.
+ * @type {number}
+ */
+export const HASH_TABLE_PROBE_LIMIT: number;
 /**
  * Sentinel returned on lookup miss.
  * Must match the WGSL twin ({@link chunk_hash_table_get}).

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cpu_build_hash_table.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js"],"names":[],"mappings":"AAoEA;;;;;;GAMG;AACH,0CALW,WAAW,UACX,MAAM,OACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;;;;;GASG;AACH,6CARW,WAAW,iBACX,MAAM,cACN,MAAM,UACN,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CA2BnB;AAWD;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AACH,6CARW,WAAW,UACX,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CAkBnB;AAnLD;;;;GAIG;AACH,8BAFU,MAAM,CAE0B"}
+{"version":3,"file":"cpu_build_hash_table.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js"],"names":[],"mappings":"AAsEA;;;;;;GAMG;AACH,0CALW,WAAW,UACX,MAAM,OACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;;;;;GASG;AACH,6CARW,WAAW,iBACX,MAAM,cACN,MAAM,UACN,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CA2BnB;AAWD;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;GAcG;AACH,6CARW,WAAW,UACX,MAAM,EAAE,cACR,MAAM,GACJ,OAAO,CAkBnB;AA9LD;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB;AAIzC;;;;GAIG;AACH,8BAFU,MAAM,CAE0B"}

package/src/shade/renderer/gpu_primitive/hash_table/cpu_build_hash_table.js

@@ -8,12 +8,14 @@ import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
 
 /**
  * Maximum number of slots visited per operation.
- * Must match the WGSL twin ({@link chunk_hash_table_get}): a lookup probes at most this many slots,
- * so an insert that cannot place a record within the limit must report it — otherwise it would
- * create an entry that lookups can never reach.
+ * Must match the WGSL twins ({@link chunk_hash_table_get}, `chunk_hash_table_atomic`): a lookup probes
+ * at most this many slots, so an insert that cannot place a record within the limit must report it —
+ * otherwise it would create an entry that lookups can never reach.
  * @type {number}
  */
-const PROBE_LIMIT = 32;
+export const HASH_TABLE_PROBE_LIMIT = 32;
+
+const PROBE_LIMIT = HASH_TABLE_PROBE_LIMIT;
 
 /**
  * Sentinel returned on lookup miss.