@woosh/meep-engine 3.61.2 → 3.61.3

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

@@ -1,12 +1,12 @@
 /**
  * The next bounce a front-face hit takes, E_ind (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7;
  * WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.4): a thread a ray, after the light pass through the same launch,
- * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `row`.
+ * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `albedo`.
  *
  * - **The first clipmap**: the frustum's probes, picked at the hit along its normal, the view back along
  *   the ray, with the ray's own pick noise (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_PICK`), drawn
  *   apart from the jitter that placed the hit (`probe_clipmap_pick_in`).
- * - **Where it has probes**, their SH is the bounce, and the ray's `row` is cleared: a hit the first clipmap
+ * - **Where it has probes**, their SH is the bounce, and the ray's `albedo` is cleared: a hit the first clipmap
  *   serves wants nothing of the fallback (`shader_probe_clipmap_want_hits`).
  * - **Where it has none**, the fallback's, the world cache's: the same pick there, at its own spacing.
  * - **Where neither has**, the bounce is **zero**, not the environment: a hit behind the camera in a cave
@@ -17,7 +17,7 @@
  * none. The records hold the SH their projection last wrote, at most a frame old, so each frame takes one more
  * bounce. LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
  *
- * Every probe ray takes it, of either clipmap; only the frustum's rays' rows are read after, by the world
+ * Every probe ray takes it, of either clipmap; only the frustum's rays' albedos are read after, by the world
  * cache's wants.
  *
  * @type {ComputeShader}

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

@@ -70,12 +70,12 @@ resources.createGroup()
 /**
  * The next bounce a front-face hit takes, E_ind (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7;
  * WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.4): a thread a ray, after the light pass through the same launch,
- * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `row`.
+ * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `albedo`.
  *
  * - **The first clipmap**: the frustum's probes, picked at the hit along its normal, the view back along
  *   the ray, with the ray's own pick noise (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_PICK`), drawn
  *   apart from the jitter that placed the hit (`probe_clipmap_pick_in`).
- * - **Where it has probes**, their SH is the bounce, and the ray's `row` is cleared: a hit the first clipmap
+ * - **Where it has probes**, their SH is the bounce, and the ray's `albedo` is cleared: a hit the first clipmap
  *   serves wants nothing of the fallback (`shader_probe_clipmap_want_hits`).
  * - **Where it has none**, the fallback's, the world cache's: the same pick there, at its own spacing.
  * - **Where neither has**, the bounce is **zero**, not the environment: a hit behind the camera in a cave
@@ -86,7 +86,7 @@ resources.createGroup()
  * none. The records hold the SH their projection last wrote, at most a frame old, so each frame takes one more
  * bounce. LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
  *
- * Every probe ray takes it, of either clipmap; only the frustum's rays' rows are read after, by the world
+ * Every probe ray takes it, of either clipmap; only the frustum's rays' albedos are read after, by the world
  * cache's wants.
  *
  * @type {ComputeShader}
@@ -104,7 +104,7 @@ fn main(
 ) {
     let ray = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
     let record = probe_rays[ray];
-    let albedo = unpack4x8unorm(record.row).rgb;
+    let albedo = unpack4x8unorm(record.albedo).rgb;
     let front_hit = (record.flags & PROBE_RAY_KIND_MASK) == ${BRICK_TRACE_HIT}u && (record.flags & PROBE_RAY_BACK_FACE) == 0u;
 
     // only a front-face hit that bounces anything takes more light
@@ -131,7 +131,7 @@ fn main(
 
     if (probes.found) {
         // served: nothing of the fallback is wanted here
-        probe_rays[ray].row = 0u;
+        probe_rays[ray].albedo = 0u;
     } else {
         probes = probe_clipmap_sh_in(
             &bounce_fallback_records,

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

@@ -7,6 +7,8 @@
  * - A pixel no probe weighs anything for takes the environment's for both.
  * - The two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the
  *   diffuse, the specular is occluded along its lobe, and the result is added to the scene's colour.
+ * - `PROBE_CLIPMAP_INDIRECT_LOBE` decides what is added: both lobes by default; for the mode's indirect debug
+ *   views, one lobe's light alone, as sampled, before the surface's material and occlusion.
  *
  * @type {ImageShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js"],"names":[],"mappings":"AAuIA;;;;;;;;;;;GAWG;AACH,qDAFU,WAAW,CA0BlB;4BAtJyB,gCAAgC"}
+{"version":3,"file":"shader_probe_clipmap_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js"],"names":[],"mappings":"AAyIA;;;;;;;;;;;;;GAaG;AACH,qDAFU,WAAW,CA0BlB;4BA1JyB,gCAAgC"}

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

@@ -25,6 +25,7 @@ import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
 import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_probe_clipmap_indirect_lobe } from "./chunk_probe_clipmap_indirect_lobe.js";
 import { chunk_probe_clipmap_pick, PROBE_CLIPMAP_SAMPLING_GROUP } from "./chunk_probe_clipmap_pick.js";
 import { chunk_probe_clipmap_sample_radiance } from "./chunk_probe_clipmap_sample_radiance.js";
 
@@ -113,7 +114,7 @@ fn main(
     let spec_direction = normalize(mix(reflect(-view_direction, normal), normal, alpha));
     let specular_occlusion = compute_specular_occlusion_bn(spec_direction, bent_normal, occlusion, roughness);
 
-    return vec4(indirect[0] * specular_occlusion + indirect[1], 1.0);
+    return vec4(probe_clipmap_indirect_lobe(indirect[0] * specular_occlusion, indirect[1], radiance, irradiance), 1.0);
 }
 `, [
     chunk_project_position_from_depth,
@@ -131,6 +132,7 @@ fn main(
     chunk_get_ibl_radiance,
     chunk_compute_indirect_specular,
     chunk_compute_specular_occlusion_bn,
+    chunk_probe_clipmap_indirect_lobe,
 ]);
 
 /**
@@ -142,6 +144,8 @@ fn main(
  * - A pixel no probe weighs anything for takes the environment's for both.
  * - The two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the
  *   diffuse, the specular is occluded along its lobe, and the result is added to the scene's colour.
+ * - `PROBE_CLIPMAP_INDIRECT_LOBE` decides what is added: both lobes by default; for the mode's indirect debug
+ *   views, one lobe's light alone, as sampled, before the surface's material and occlusion.
  *
  * @type {ImageShader}
  */

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

@@ -2,7 +2,7 @@
  * The light a front-face hit takes from the local lights (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
  * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`, its probe the one trace wrote
  * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
- * ray's \`row\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
+ * ray's \`albedo\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
  * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
  *   clusters, built over the bricks' cascades so that every hit has one, at most

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

@@ -71,7 +71,7 @@ resources.createGroup()
  * The light a front-face hit takes from the local lights (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
  * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`, its probe the one trace wrote
  * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
- * ray's \`row\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
+ * ray's \`albedo\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
  * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
  *   clusters, built over the bricks' cascades so that every hit has one, at most
@@ -216,7 +216,7 @@ fn main(
 ) {
     let ray = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
     let record = probe_rays[ray];
-    let albedo = unpack4x8unorm(record.row).rgb;
+    let albedo = unpack4x8unorm(record.albedo).rgb;
     let front_hit = (record.flags & PROBE_RAY_KIND_MASK) == ${BRICK_TRACE_HIT}u && (record.flags & PROBE_RAY_BACK_FACE) == 0u;
 
     // only a front-face hit that bounces anything takes more light

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

@@ -10,13 +10,16 @@
  *   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}

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAyDpB;8BAlH2B,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yCAFU,aAAa,CA4DpB;8BA7H2B,kCAAkC"}

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,9 +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 white noise of the probe's slot, its update
- *   count and the ray's place in the update (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_JITTER`), on
- *   uniform and guided updates alike. Nothing stratifies the jitter inside a texel.
+ * - **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
@@ -28,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":"AAmDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAuBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,yCAFU,aAAa,CAgJpB;6BAjP0B,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

@@ -25,18 +25,17 @@ 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_ray_layout,
-    chunk_probe_clipmap_ray_noise,
+    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,
@@ -85,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
@@ -98,9 +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 white noise of the probe's slot, its update
- *   count and the ray's place in the update (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_JITTER`), on
- *   uniform and guided updates alike. Nothing stratifies the jitter inside a texel.
+ * - **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
@@ -114,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}
  */
@@ -154,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;
@@ -173,16 +172,23 @@ fn main(
     let updates = probe_state_updates(state.x);
 
     var texel: u32;
+    // 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(probe_trace_guided_position(base, i, texels), updates, n);
+        texel = probe_clipmap_guide_texel(position, updates, n);
+        round = i - probe_guide[base + position];
     } else {
         texel = probe_clipmap_ray_texel(i, updates, rays, texels);
+        // every texel once, then again: below R = n_r² the update's rays are all its first
+        round = i / texels;
     }
 
-    let jitter = probe_clipmap_ray_noise(slot, updates, i, PROBE_RAY_NOISE_JITTER);
+    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));
 
@@ -238,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);
 }
@@ -246,14 +252,14 @@ fn main(
             chunk_probe_clipmap,
             chunk_probe_clipmap_ray_layout,
             chunk_probe_clipmap_ray_texel,
-            chunk_probe_clipmap_ray_noise,
+            chunk_probe_clipmap_ray_jitter,
+            chunk_probe_clipmap_ray_visit,
             chunk_probe_clipmap_ray_origin,
             chunk_probe_clipmap_guide,
             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"}