@woosh/meep-engine 3.61.2 → 3.62.0

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

@@ -0,0 +1,22 @@
+/**
+ * The cascade a point reads, and how far into its blend skirt it is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1,
+ * "Selection"), in the clipmap whose levels `levels` points at. Want takes it to choose the cascades a pixel
+ * wants, and the pick to read them.
+ *
+ * ```wgsl
+ * fn probe_clipmap_select_in(levels: ptr<uniform, ClipmapLevelArray>, count: u32, anchor: vec3<f32>, select_half: f32, position: vec3<f32>) -> ClipmapSelection
+ * ```
+ *
+ * Each cascade's selection box is centred on the `anchor` the windows were placed around, `select_half` of the
+ * cascade's cells to a side. The finest of the first `count` cascades whose box holds the point answers, its
+ * `edge_weight` rising from 0 at {@link PROBE_BLEND_SKIRT} cells inside the box's nearest face to 1 on it: the
+ * share the next coarser cascade takes. A point no box holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
+ *
+ * The boxes follow the anchor, not the windows' corners, which move a whole step at a time: a point's weight
+ * moves as far as the anchor did over the skirt's depth, never a step's worth in one frame.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_select_in: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_select.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_select.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_select.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,4CAFU,SAAS,CA2BhB;0BA/CuB,uCAAuC"}

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

@@ -0,0 +1,50 @@
+import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
+import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_LIMIT } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { PROBE_BLEND_SKIRT } from "./PROBE_CLIPMAP.js";
+
+/**
+ * The cascade a point reads, and how far into its blend skirt it is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1,
+ * "Selection"), in the clipmap whose levels `levels` points at. Want takes it to choose the cascades a pixel
+ * wants, and the pick to read them.
+ *
+ * ```wgsl
+ * fn probe_clipmap_select_in(levels: ptr<uniform, ClipmapLevelArray>, count: u32, anchor: vec3<f32>, select_half: f32, position: vec3<f32>) -> ClipmapSelection
+ * ```
+ *
+ * Each cascade's selection box is centred on the `anchor` the windows were placed around, `select_half` of the
+ * cascade's cells to a side. The finest of the first `count` cascades whose box holds the point answers, its
+ * `edge_weight` rising from 0 at {@link PROBE_BLEND_SKIRT} cells inside the box's nearest face to 1 on it: the
+ * share the next coarser cascade takes. A point no box holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
+ *
+ * The boxes follow the anchor, not the windows' corners, which move a whole step at a time: a point's weight
+ * moves as far as the anchor did over the skirt's depth, never a step's worth in one frame.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_select_in = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_select_in(levels: ptr<uniform, ${CLIPMAP_LEVEL_ARRAY.wgsl_ref}>, count: u32, anchor: vec3<f32>, select_half: f32, position: vec3<f32>) -> ClipmapSelection {
+    let offset = abs(position - anchor);
+    let reach = max(max(offset.x, offset.y), offset.z);
+
+    for (var i = 0u; i < ${CLIPMAP_LEVEL_LIMIT}u; i++) {
+        if (i >= count) {
+            break;
+        }
+
+        // the point's depth inside the box, in the cascade's cells
+        let edge = select_half - reach / (*levels)[i].cell_size;
+
+        if (edge >= 0.0) {
+            return ClipmapSelection(i, saturate(1.0 - edge / ${PROBE_BLEND_SKIRT}.0));
+        }
+    }
+
+    return ClipmapSelection(CLIPMAP_LEVEL_NONE, 0.0);
+}
+`, [
+    // ClipmapSelection and CLIPMAP_LEVEL_NONE
+    chunk_clipmap_select_finest,
+]);

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

@@ -3,12 +3,12 @@
  * for want's pixels and the hits' wants alike.
  *
  * ```wgsl
- * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, wanted_capacity: u32)
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32)
  * ```
  *
- * The cages are the pick's: the finest cascade whose cage window holds the point, the cage of the point
- * biased along `bias_direction` by that cascade's spacing, and in the cascade's blend skirt the next
- * cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
+ * The cages are the pick's: the cascade `probe_clipmap_select_in` answers for the point, by the windows'
+ * `anchor` and `select_half` as the pick reads them, the cage of the point biased along `bias_direction` by
+ * that cascade's spacing, and in the cascade's blend skirt the next cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
  * point's bit is set, and a point whose bit was clear goes on the wanted list by its key, so the list
  * holds every point wanted this frame once.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CAgFZ;0BA7HmB,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CAgFZ;0BA9HmB,uCAAuC"}

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

@@ -1,5 +1,4 @@
 import { chunk_collection_u32_append } from "../../../gpu_primitive/chunk_collection_u32_append.js";
-import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import {
     chunk_probe_clipmap,
@@ -8,6 +7,7 @@ import {
     PROBE_WANTED_WRITE_RESOURCE
 } from "./chunk_probe_clipmap.js";
 import { chunk_probe_clipmap_cage } from "./chunk_probe_clipmap_cage.js";
+import { chunk_probe_clipmap_select_in } from "./chunk_probe_clipmap_select.js";
 import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 
 /**
@@ -29,12 +29,12 @@ const WANT_CLAIM_PROBES = 16;
  * for want's pixels and the hits' wants alike.
  *
  * ```wgsl
- * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, wanted_capacity: u32)
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32)
  * ```
  *
- * The cages are the pick's: the finest cascade whose cage window holds the point, the cage of the point
- * biased along `bias_direction` by that cascade's spacing, and in the cascade's blend skirt the next
- * cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
+ * The cages are the pick's: the cascade `probe_clipmap_select_in` answers for the point, by the windows'
+ * `anchor` and `select_half` as the pick reads them, the cage of the point biased along `bias_direction` by
+ * that cascade's spacing, and in the cascade's blend skirt the next cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
  * point's bit is set, and a point whose bit was clear goes on the wanted list by its key, so the list
  * holds every point wanted this frame once.
  *
@@ -80,8 +80,8 @@ fn probe_want_claim(key: u32) -> bool {
     return true;
 }
 
-fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, wanted_capacity: u32) {
-    let selection = clipmap_select_finest(&probe_levels, cascade_count, position, PROBE_BLEND_SKIRT);
+fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32) {
+    let selection = probe_clipmap_select_in(&probe_levels, cascade_count, anchor, select_half, position);
 
     let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
     let finest = select(0u, selection.level, held);
@@ -122,7 +122,7 @@ fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32
 }
 `, [
         chunk_probe_clipmap,
-        chunk_clipmap_select_finest,
+        chunk_probe_clipmap_select_in,
         chunk_probe_clipmap_cage,
         chunk_collection_u32_append,
     ]);

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_diffuse.js

@@ -49,8 +49,8 @@ fn main(
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
 
     // the surface's own normal picks, as want chose by it; the bent normal resolves, as IBL's does
-    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).xy);
-    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).xy);
+    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).x);
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).x);
 
     let noise = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index));
     let probes = probe_clipmap_sample_sh(position, normal, view_direction, noise);

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":"AA2IA;;;;;;;;;;;;;GAaG;AACH,qDAFU,WAAW,CA0BlB;4BA3JyB,gCAAgC"}

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

@@ -11,6 +11,7 @@ import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/
 import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
 import { chunk_compute_indirect_specular } from "../../../shader/chunk/material/chunk_compute_indirect_specular.js";
+import { chunk_decode_g_buffer_albedo } from "../../../shader/chunk/material/chunk_decode_g_buffer_albedo.js";
 import { chunk_decode_g_buffer_metalness } from "../../../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
 import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
 import { chunk_metalness_to_specular_color } from "../../../shader/chunk/material/chunk_metalness_to_specular_color.js";
@@ -25,6 +26,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";
 
@@ -60,7 +62,7 @@ fn main(
     let texel_pbr = textureLoad(tGBufferPBR, i_coord, 0);
     let albedo_ao = textureLoad(tGBufferAlbedo, i_coord, 0);
 
-    let albedo = albedo_ao.rgb;
+    let albedo = decode_g_buffer_albedo(albedo_ao.rgb);
     let occlusion = albedo_ao.a;
 
     let f_metalness = decode_g_buffer_metalness(texel_pbr);
@@ -74,8 +76,8 @@ fn main(
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
 
     // the surface's own normal picks, as want chose by it; the bent normal resolves the diffuse, as IBL's does
-    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).xy);
-    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).xy);
+    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).x);
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).x);
 
     // one pick for both lobes
     let noise = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index));
@@ -113,12 +115,13 @@ 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,
     chunk_mat4_extract_position,
     chunk_decode_g_buffer_normal,
+    chunk_decode_g_buffer_albedo,
     chunk_decode_g_buffer_metalness,
     chunk_decode_g_buffer_roughness,
     chunk_metalness_to_specular_color,
@@ -131,6 +134,7 @@ fn main(
     chunk_get_ibl_radiance,
     chunk_compute_indirect_specular,
     chunk_compute_specular_occlusion_bn,
+    chunk_probe_clipmap_indirect_lobe,
 ]);
 
 /**
@@ -142,6 +146,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"}