@woosh/meep-engine 3.61.2 → 3.62.0

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

@@ -0,0 +1,10 @@
+/**
+ * Which of a pixel's two lobes the fused indirect pass writes (`chunk_probe_clipmap_indirect_lobe`): both, the
+ * frame's, by default; one alone for the mode's indirect debug views (`ProbeClipmapDebugView.IndirectDiffuse`,
+ * `ProbeClipmapDebugView.IndirectSpecular`).
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_INDIRECT_LOBE: ShaderSwitch;
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+//# sourceMappingURL=PROBE_CLIPMAP_INDIRECT_LOBE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PROBE_CLIPMAP_INDIRECT_LOBE.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP_INDIRECT_LOBE.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,0CAFU,YAAY,CAEgG;6BAVzF,0CAA0C"}

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

@@ -0,0 +1,11 @@
+import { ShaderSwitch } from "../../../shader/compiler/ShaderSwitch.js";
+import { ProbeClipmapIndirectLobe } from "./ProbeClipmapIndirectLobe.js";
+
+/**
+ * Which of a pixel's two lobes the fused indirect pass writes (`chunk_probe_clipmap_indirect_lobe`): both, the
+ * frame's, by default; one alone for the mode's indirect debug views (`ProbeClipmapDebugView.IndirectDiffuse`,
+ * `ProbeClipmapDebugView.IndirectSpecular`).
+ *
+ * @type {ShaderSwitch}
+ */
+export const PROBE_CLIPMAP_INDIRECT_LOBE = ShaderSwitch.enum('probe clipmap indirect lobe', ProbeClipmapIndirectLobe);

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

@@ -0,0 +1,11 @@
+/**
+ * What the probe clipmap's fused indirect pass (`shader_probe_clipmap_indirect_lighting`) writes of a pixel's
+ * two lobes, by {@link PROBE_CLIPMAP_INDIRECT_LOBE }.
+ */
+export type ProbeClipmapIndirectLobe = number;
+export namespace ProbeClipmapIndirectLobe {
+    let Both: number;
+    let Diffuse: number;
+    let Specular: number;
+}
+//# sourceMappingURL=ProbeClipmapIndirectLobe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProbeClipmapIndirectLobe.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/ProbeClipmapIndirectLobe.js"],"names":[],"mappings":";;;;uCAKU,MAAM"}

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

@@ -0,0 +1,15 @@
+/**
+ * What the probe clipmap's fused indirect pass (`shader_probe_clipmap_indirect_lighting`) writes of a pixel's
+ * two lobes, by {@link PROBE_CLIPMAP_INDIRECT_LOBE}.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const ProbeClipmapIndirectLobe = {
+    /** the diffuse and the specular summed: what the frame adds */
+    Both: 0,
+    /** the probes' irradiance at the bent normal over π, before the surface's albedo, metalness and occlusion */
+    Diffuse: 1,
+    /** the probes' radiance along the surface's lobe, before its split-sum reflectance and occlusion */
+    Specular: 2,
+};

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"AAyEA;;;;;;GAMG;AACH,kCAFU,YAAY,CAsBG;AAEzB;;;;;GAKG;AACH,+BAFU,YAAY,CAuBA;AAEtB;;;;;;GAMG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;;GAIG;AACH,+CAFU,wBAAwB,CAE0G;AAE5I;;;;GAIG;AACH,0CAFU,wBAAwB,CAE+F;AAEjI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwF;AAE1H;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAEjJ;;;GAGG;AACH,0CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,sCAFU,wBAAwB,CAEkG;AAEpI;;;;GAIG;AACH,2CAFU,wBAAwB,CAEoF;AAEtH;;;GAGG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;;GAKG;AACH,oCAFU,YAAY,CAKK;AAE3B;;;GAGG;AACH,2CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,4CAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;GAGG;AACH,0CAFU,wBAAwB,CAEyG;AAE3I;;;GAGG;AACH,4CAFU,wBAAwB,CAEoG;AAEtI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,yCAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,wCAFU,wBAAwB,CAEyF;AAE3H;;;;GAIG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;GAGG;AACH,0CAFU,wBAAwB,CAEmG;AAErI;;;GAGG;AACH,yCAFU,wBAAwB,CAE2F;AAE7H;;;GAGG;AACH,sCAFU,wBAAwB,CAEqF;AAEvH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,0CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,wCAFU,wBAAwB,CAEsG;AAExI;;;GAGG;AACH,uCAFU,wBAAwB,CAE+F;AAEjI;;;;;GAKG;AACH,8CAFU,wBAAwB,CAE0G;AAE5I;;;;GAIG;AACH,gDAFU,wBAAwB,CAE8G;AAEhJ;;;GAGG;AACH,iDAFU,wBAAwB,CAE2G;AAE7I;;;GAGG;AACH,mDAFU,wBAAwB,CAE+G;AAEjJ;;;;;GAKG;AACH,4CAFU,wBAAwB,CAEsG;AAExI;;;GAGG;AACH,2CAFU,wBAAwB,CAE+F;AAEjI;;;;;GAKG;AACH,mCAFU,YAAY,CAWI;AAE1B;;;GAGG;AACH,4CAFU,wBAAwB,CAEkH;AAEpJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE2G;AAE7I;;;;GAIG;AACH,wCAFU,wBAAwB,CAEmF;AAErH;;;GAGG;AACH,uCAFU,wBAAwB,CAE4E;AAE9G;;;;;;GAMG;AACH,wCAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,6CAFU,wBAAwB,CAEgG;AAElI;;;;;GAKG;AACH,6CAFU,wBAAwB,CAEqG;AAEvI;;;GAGG;AACH,4CAFU,wBAAwB,CAE8F;AAEhI;;;;GAIG;AACH,2CAFU,wBAAwB,CAEwG;AAE1I;;;;GAIG;AACH,0CAFU,wBAAwB,CAEuF;AAEzH;;;GAGG;AACH,yCAFU,wBAAwB,CAEgF;AAElH;;;GAGG;AACH,qCAFU,YAAY,CAOD;AAErB;;;GAGG;AACH,8CAFU,wBAAwB,CAEwH;AAE1J;;;GAGG;AACH,6CAFU,wBAAwB,CAEiH;AAEnJ;;;GAGG;AACH,0CAFU,YAAY,CAYU;AAEhC;;;GAGG;AACH,8CAFU,wBAAwB,CAE6H;AAE/J;;;GAGG;AACH,6CAFU,wBAAwB,CAEsH;AAExJ;;;;GAIG;AACH,8CAFU,wBAAwB,CAE+E;AAEjH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,4CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,kCAFU,SAAS,CAgIhB;AAEH;;;;;;;;;;GAUG;AACH,6CAFU,SAAS,CA8BhB;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,SAAS,CA+BhB;AAEH;;;;;;;;;;;;;;GAcG;AACH,4CAFU,SAAS,CAehB;AAEH;;;;;;;;;;;;;;GAcG;AACH,6CAFU,SAAS,CAahB;AAEH;;;;;;;;;;;;GAYG;AACH,6CAFU,SAAS,CAehB;AAEH;;;GAGG;AACH,yCAFU,wBAAwB,CAEqF;AAEvH;;;GAGG;AACH,wCAFU,wBAAwB,CAE8E;AAEhH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAFU,SAAS,CAwDhB;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAFU,SAAS,CA6BhB;AAEH;;;;;;;;;GASG;AACH,iDAFU,SAAS,CAahB;AAIH;;;;;;;;;;GAUG;AACH,yCAFU,SAAS,CAgBhB;6BAhgC0B,sCAAsC;yCAZ1B,sDAAsD;0BADrE,uCAAuC"}

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

@@ -6,6 +6,7 @@ import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to
 import { chunk_sphere_sample_volume } from "../../../shader/chunk/geometry/sphere/chunk_sphere_sample_volume.js";
 import { chunk_mod_v3i } from "../../../shader/chunk/geometry/vec3/chunk_mod_v3i.js";
 import { chunk_lower_bound_branchless } from "../../../shader/chunk/math/chunk_lower_bound_branchless.js";
+import { chunk_sobol_sample_vec2 } from "../../../shader/chunk/noise/chunk_sobol_sample_vec2.js";
 import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
 import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import { chunk_pcg4d } from "../../../shader/chunk/random/pcg/chunk_pcg4d.js";
@@ -113,10 +114,10 @@ export const PROBE_RAY_STRUCT = WebGPUStruct.from({
     /** the hit's normal, octahedral, two unorm16; zero but for a hit */
     normal: u32,
     /**
-     * The `meshes` row whose surface the hit is on, 0 for none. After shade, the hit's diffuse albedo,
-     * `pack4x8unorm`, which the light pass reads; zero for any other ray.
+     * Zero from trace; shade writes a front-face hit's diffuse albedo, `pack4x8unorm`, which the light and
+     * bounce passes read, and zero for any other ray.
      */
-    row: u32,
+    albedo: u32,
     /** its kind, the back face, and the hit's cascade (`PROBE_CLIPMAP.js`) */
     flags: u32,
     /**
@@ -131,8 +132,8 @@ export const PROBE_RAY_STRUCT = WebGPUStruct.from({
 /**
  * The cascades' cage windows, a {@link CLIPMAP_LEVEL_ARRAY} as a uniform, finest first: a cell of
  * cascade `c` is the cage of the eight lattice points at its corners, so its window is one short of the
- * lattice's on each axis, and `clipmap_select_finest` over it answers the finest cascade whose whole
- * cage holds a point (§8.1).
+ * lattice's on each axis. `probe_clipmap_select_in` chooses a point's cascade by boxes on the anchor that lie
+ * inside these windows (§9.1, "Selection").
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_LEVELS_RESOURCE = ShaderResourceDescriptor.uniform("probe_levels", CLIPMAP_LEVEL_ARRAY);
@@ -761,12 +762,10 @@ fn probe_clipmap_texel_ray(texel: u32, round: u32, updates: u32, rays: u32, texe
 /**
  * A ray's noise (§8.6, §8.7): a hash of the probe's slot, its update count, the ray's place among the
  * update's rays and a stream, the same in every pass that knows the ray. It never repeats over a probe's
- * updates. Uniform and guided updates alike, the trace jitters its ray inside its texel by stream
- * `PROBE_RAY_NOISE_JITTER`, and the bounce picks the probes at its hit by `PROBE_RAY_NOISE_PICK`, which is
- * independent of the jitter that placed the hit.
+ * updates. The bounce picks the probes at its hit by stream `PROBE_RAY_NOISE_PICK`, which is independent of
+ * the jitter that placed the hit (`probe_clipmap_ray_jitter`).
  *
- * This is white noise. Nothing stratifies it across texels, across updates, or across a texel's rays,
- * which may clump. Each component lies inside (0, 1), at the centre of one of 2^23 bins, so a weighted
+ * This is white noise. Each component lies inside (0, 1), at the centre of one of 2^23 bins, so a weighted
  * draw by it never meets either end.
  *
  * ```wgsl
@@ -778,7 +777,6 @@ fn probe_clipmap_texel_ray(texel: u32, round: u32, updates: u32, rays: u32, texe
 export const chunk_probe_clipmap_ray_noise = CodeChunk.from(
     //language=WGSL
     `
-const PROBE_RAY_NOISE_JITTER = ${PROBE_RAY_NOISE_JITTER}u;
 const PROBE_RAY_NOISE_PICK = ${PROBE_RAY_NOISE_PICK}u;
 
 fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> vec2<f32> {
@@ -791,6 +789,34 @@ fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> ve
     chunk_pcg4d,
 ]);
 
+/**
+ * Where a ray lands inside its octahedral texel (§8.6), as a point of the texel's square in [0, 1)²: point
+ * `index` of the texel's jitter sequence `sequence`, a shuffled, Owen-scrambled Sobol (0, 2)-sequence
+ * (`sample_sobol_2d`) seeded by the probe's slot, the texel and the sequence. Which sequence and index a ray
+ * takes is `probe_clipmap_ray_visit`'s.
+ *
+ * The points of an aligned run of 2^m indices of one sequence put one in each dyadic cell of area 2^-m of the
+ * texel. Different slots, texels and sequences draw independent sequences.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, sequence: u32, index: u32) -> vec2<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_jitter = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_ray_jitter(slot: u32, texel: u32, sequence: u32, index: u32) -> vec2<f32> {
+    let seed = pcg4d(vec4<u32>(slot, texel, sequence, ${PROBE_RAY_NOISE_JITTER}u)).x;
+
+    return sample_sobol_2d(index, seed);
+}
+`, [
+    chunk_pcg4d,
+    chunk_sobol_sample_vec2,
+]);
+
 /**
  * Where a ray of an update starts (§8.6): a point of the ball of `PROBE_RAY_ORIGIN_JITTER` of the spacing
  * around the probe, uniform in its volume, as Brick4's bake jitters its probes. The point is drawn from the
@@ -923,6 +949,57 @@ fn probe_clipmap_guide_start(before: u32, total: u32, rays: u32, phase: f32) ->
     chunk_pcg3d,
 ]);
 
+/**
+ * Which of its texel's jitter sequences a ray of an update takes, and its index there (`.x`, `.y`), for
+ * `probe_clipmap_ray_jitter` (§8.6). A texel has a sequence for each round (the ray's place among the
+ * texel's rays in the update, from 0) and each kind of update: uniform, guided, and a DEAD probe's. The index
+ * counts the texel's earlier visits of that kind:
+ * - uniform: the probe's uniform updates before this one (its first n_r²/R, then every `period`-th), over
+ *   the uniform updates between two of the texel's rays below R = n_r², n_r²/R;
+ * - guided: the probe's guided updates before this one;
+ * - DEAD: its updates before this one, over n_r²/R where its rays are fewer than the texels.
+ *
+ * So a texel that takes a ray of a round on every update of a kind has that round's rays of the kind
+ * stratified inside it, whichever other updates it takes rays on: those of an aligned run of 2^m indices
+ * put one in each dyadic cell of area 2^-m. A texel passed over on some guided updates takes a subset of
+ * such a run. The indices of a kind only grow, so no sequence gives a texel a point twice until the 30-bit
+ * update count wraps.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_visit(state: u32, round: u32, rays: u32, texels: u32, period: u32, rays_per_probe: u32) -> vec2<u32> // state: the first word; rays: the update's
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_visit = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_ray_visit(state: u32, round: u32, rays: u32, texels: u32, period: u32, rays_per_probe: u32) -> vec2<u32> {
+    let updates = probe_state_updates(state);
+
+    // the uniform updates between two of a texel's rays: the subsets of the texels go round in that many
+    let spread = max(texels / rays, 1u);
+
+    if (probe_state_kind(state) == PROBE_STATE_DEAD) {
+        return vec2<u32>(3u * round + 2u, updates / spread);
+    }
+
+    // the probe's uniform updates before this one: its first, then the multiples of the period past them
+    let early = texels / rays_per_probe;
+    let later = select(0u, (updates + period - 1u) / period - (early + period - 1u) / period, updates > early);
+    let uniform_before = min(updates, early) + later;
+
+    if (probe_clipmap_guided(state, period, rays_per_probe, texels)) {
+        return vec2<u32>(3u * round + 1u, updates - uniform_before);
+    }
+
+    return vec2<u32>(3u * round, uniform_before / spread);
+}
+`, [
+    chunk_probe_clipmap,
+    chunk_probe_clipmap_guide,
+]);
+
 /**
  * The rays a guided update gives a radiance texel, `R·(w + e)/W`, from the probe's guide (§8.6), whose words start
  * at `base`; nothing for a guide the guide passes never wrote.

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

@@ -0,0 +1,43 @@
+/**
+ * The material a probe ray's hit takes its light with:
+ *
+ * ```wgsl
+ * struct ProbeClipmapHitMaterial { found: bool, albedo: vec3<f32>, emissive: vec3<f32> }
+ * fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> ProbeClipmapHitMaterial
+ * ```
+ *
+ * The hit is at `position` in brick cascade `cascade`, its field's normal `normal`: the brick holding it,
+ * looked up in the brick map at the hit's cascade as the march found it, and its material there
+ * (`brick_material_surface`), albedo and emissive. A hit whose brick carries no material for its surface
+ * is black, `found` false.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_hit_material: CodeChunk;
+/**
+ * The material a probe ray's hit takes its light with, from one texel of the brick material:
+ *
+ * ```wgsl
+ * fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32) -> ProbeClipmapHitMaterial
+ * ```
+ *
+ * As {@link chunk_probe_clipmap_hit_material} finds the hit's brick, one of the texels its blend weighs
+ * drawn by `u` in [0, 1) in proportion to its weight (`brick_material_surface_pick`): the blend on
+ * average, which a probe's blend of its rays takes.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_hit_material_pick: CodeChunk;
+/**
+ * A probe ray's hit's metalness and roughness, as {@link chunk_probe_clipmap_hit_material} finds its
+ * surface, for the debug views: the GI's light takes none of it yet.
+ *
+ * ```wgsl
+ * fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> vec3<f32> // (metalness, roughness, 1 if found)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_hit_metal_rough: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_hit_material.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_hit_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_material.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;GAcG;AACH,+CAFU,SAAS,CAoB+C;AAElE;;;;;;;;;;;;GAYG;AACH,oDAFU,SAAS,CAoBoD;AAEvE;;;;;;;;;GASG;AACH,kDAFU,SAAS,CAgBmD;0BAxI5C,uCAAuC"}

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

@@ -0,0 +1,138 @@
+import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_brick_clipmap } from "../brick/chunk_brick_clipmap.js";
+import { BRICK_LEVELS_RESOURCE, BRICK_MAP_TEXTURE_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
+import {
+    chunk_brick_material_metal_rough,
+    chunk_brick_material_surface,
+    chunk_brick_material_surface_pick
+} from "../material/chunk_brick_material.js";
+
+/**
+ * The brick of a hit's cascade holding its position: its slot, or no slot, and the position in voxels
+ * from its corner; and the material a hit's read gives.
+ */
+const brick_at = CodeChunk.from(
+    //language=WGSL
+    `
+struct ProbeClipmapHitBrick {
+    entry: u32,
+    local: vec3<f32>,
+}
+
+struct ProbeClipmapHitMaterial {
+    found: bool,
+    albedo: vec3<f32>,
+    emissive: vec3<f32>,
+}
+
+fn probe_clipmap_hit_brick(position: vec3<f32>, cascade: u32) -> ProbeClipmapHitBrick {
+    let level = brick_levels[cascade];
+    let resolution = u32(level.size.x);
+    let cell = vec3<i32>(floor(position / level.cell_size));
+
+    var out: ProbeClipmapHitBrick;
+
+    out.entry = textureLoad(brick_map, brick_clipmap_map_texel(cascade, vec3<u32>(cell) & vec3<u32>(resolution - 1u), resolution), 0).x;
+    out.local = (position - vec3<f32>(cell) * level.cell_size) / (level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0);
+
+    return out;
+}
+`, [chunk_brick_clipmap]);
+
+brick_at.requireResource(BRICK_LEVELS_RESOURCE);
+brick_at.requireResource(BRICK_MAP_TEXTURE_RESOURCE);
+
+/**
+ * The material a probe ray's hit takes its light with:
+ *
+ * ```wgsl
+ * struct ProbeClipmapHitMaterial { found: bool, albedo: vec3<f32>, emissive: vec3<f32> }
+ * fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> ProbeClipmapHitMaterial
+ * ```
+ *
+ * The hit is at `position` in brick cascade `cascade`, its field's normal `normal`: the brick holding it,
+ * looked up in the brick map at the hit's cascade as the march found it, and its material there
+ * (`brick_material_surface`), albedo and emissive. A hit whose brick carries no material for its surface
+ * is black, `found` false.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_hit_material = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> ProbeClipmapHitMaterial {
+    var out: ProbeClipmapHitMaterial;
+
+    let brick = probe_clipmap_hit_brick(position, cascade);
+
+    if (brick_clipmap_entry_holds_slot(brick.entry)) {
+        let seen = brick_material_surface(brick.entry, brick.local, normal);
+
+        out.found = seen.found;
+        out.albedo = seen.albedo;
+        out.emissive = seen.emissive;
+    }
+
+    return out;
+}
+`, [brick_at, chunk_brick_clipmap, chunk_brick_material_surface]);
+
+/**
+ * The material a probe ray's hit takes its light with, from one texel of the brick material:
+ *
+ * ```wgsl
+ * fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32) -> ProbeClipmapHitMaterial
+ * ```
+ *
+ * As {@link chunk_probe_clipmap_hit_material} finds the hit's brick, one of the texels its blend weighs
+ * drawn by `u` in [0, 1) in proportion to its weight (`brick_material_surface_pick`): the blend on
+ * average, which a probe's blend of its rays takes.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_hit_material_pick = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32) -> ProbeClipmapHitMaterial {
+    var out: ProbeClipmapHitMaterial;
+
+    let brick = probe_clipmap_hit_brick(position, cascade);
+
+    if (brick_clipmap_entry_holds_slot(brick.entry)) {
+        let seen = brick_material_surface_pick(brick.entry, brick.local, normal, u);
+
+        out.found = seen.found;
+        out.albedo = seen.albedo;
+        out.emissive = seen.emissive;
+    }
+
+    return out;
+}
+`, [brick_at, chunk_brick_clipmap, chunk_brick_material_surface_pick]);
+
+/**
+ * A probe ray's hit's metalness and roughness, as {@link chunk_probe_clipmap_hit_material} finds its
+ * surface, for the debug views: the GI's light takes none of it yet.
+ *
+ * ```wgsl
+ * fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> vec3<f32> // (metalness, roughness, 1 if found)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_hit_metal_rough = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> vec3<f32> {
+    let brick = probe_clipmap_hit_brick(position, cascade);
+
+    if (!brick_clipmap_entry_holds_slot(brick.entry)) {
+        return vec3<f32>(0.0);
+    }
+
+    let seen = brick_material_metal_rough(brick.entry, brick.local, normal);
+
+    return vec3<f32>(seen.metal_rough, select(0.0, 1.0, seen.found));
+}
+`, [brick_at, chunk_brick_clipmap, chunk_brick_material_metal_rough]);

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

@@ -0,0 +1,21 @@
+/**
+ * What the fused indirect pass writes of a pixel's indirect light, by {@link PROBE_CLIPMAP_INDIRECT_LOBE}:
+ *
+ * ```wgsl
+ * fn probe_clipmap_indirect_lobe(
+ *     specular: vec3<f32>,   // the radiance resolved by the surface's material and occluded
+ *     diffuse: vec3<f32>,    // the irradiance resolved by the surface's material and occluded
+ *     radiance: vec3<f32>,   // the probes' radiance along the surface's lobe, as sampled
+ *     irradiance: vec3<f32>, // the probes' irradiance at the bent normal, as sampled
+ * ) -> vec3<f32>
+ * ```
+ *
+ * - `Both`, the default: `specular + diffuse`, what the frame adds.
+ * - `Diffuse`: `irradiance / π`, the light alone, in radiance units: what a white Lambertian surface would send back.
+ * - `Specular`: `radiance`, the light alone.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_probe_clipmap_indirect_lobe: CodeChunkChoice;
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_probe_clipmap_indirect_lobe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_indirect_lobe.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_indirect_lobe.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AACH,gDAFU,eAAe,CAE0E;gCAvBnE,6CAA6C"}

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

@@ -0,0 +1,49 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import { PROBE_CLIPMAP_INDIRECT_LOBE } from "./PROBE_CLIPMAP_INDIRECT_LOBE.js";
+import { ProbeClipmapIndirectLobe } from "./ProbeClipmapIndirectLobe.js";
+
+/**
+ * What the fused indirect pass writes of a pixel's indirect light, by {@link PROBE_CLIPMAP_INDIRECT_LOBE}:
+ *
+ * ```wgsl
+ * fn probe_clipmap_indirect_lobe(
+ *     specular: vec3<f32>,   // the radiance resolved by the surface's material and occluded
+ *     diffuse: vec3<f32>,    // the irradiance resolved by the surface's material and occluded
+ *     radiance: vec3<f32>,   // the probes' radiance along the surface's lobe, as sampled
+ *     irradiance: vec3<f32>, // the probes' irradiance at the bent normal, as sampled
+ * ) -> vec3<f32>
+ * ```
+ *
+ * - `Both`, the default: `specular + diffuse`, what the frame adds.
+ * - `Diffuse`: `irradiance / π`, the light alone, in radiance units: what a white Lambertian surface would send back.
+ * - `Specular`: `radiance`, the light alone.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_probe_clipmap_indirect_lobe = CodeChunkChoice.from(PROBE_CLIPMAP_INDIRECT_LOBE);
+
+chunk_probe_clipmap_indirect_lobe.add(ProbeClipmapIndirectLobe.Both, CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_indirect_lobe(specular: vec3<f32>, diffuse: vec3<f32>, radiance: vec3<f32>, irradiance: vec3<f32>) -> vec3<f32> {
+    return specular + diffuse;
+}
+`));
+
+chunk_probe_clipmap_indirect_lobe.add(ProbeClipmapIndirectLobe.Diffuse, CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_indirect_lobe(specular: vec3<f32>, diffuse: vec3<f32>, radiance: vec3<f32>, irradiance: vec3<f32>) -> vec3<f32> {
+    return irradiance * RECIPROCAL_PI;
+}
+`, [RECIPROCAL_PI_DECLARATION]));
+
+chunk_probe_clipmap_indirect_lobe.add(ProbeClipmapIndirectLobe.Specular, CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_indirect_lobe(specular: vec3<f32>, diffuse: vec3<f32>, radiance: vec3<f32>, irradiance: vec3<f32>) -> vec3<f32> {
+    return radiance;
+}
+`));

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

@@ -37,6 +37,8 @@ export const PROBE_DEPTH_SAMPLER_RESOURCE: ShaderResourceDescriptor;
  * fn probe_clipmap_depth_moments_in(sampling, depth, slot: u32, direction: vec3<f32>) -> vec2<f32>
  * ```
  *
+ * - **The cascade**: `probe_clipmap_select_in` by the sampling's `anchor` and `select_half`, as want takes it:
+ *   boxes on the anchor, so the blend between cascades moves with the anchor, not a window's step at a time.
  * - **The cage**: `probe_clipmap_cage_in` along mix(n, v, 0.2), as want takes it, so a pixel reads the
  *   probes it wanted.
  * - **The weights**, visibility only, of the cage's eight corners: a corner without an ALIVE probe weighs

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_pick.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,oCAFU,YAAY,CAuBF;AAEpB;;;GAGG;AACH,sCAFU,wBAAwB,CAE+E;AAEjH;;;GAGG;AACH,8CAFU,wBAAwB,CAEiF;AAEnH;;;GAGG;AACH,6CAFU,iBAAiB,CAQvB;AAEJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAOjJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,0CAFU,SAAS,CAiMhB;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0BhB;AASH;;;;;;;GAOG;AACH,2CAFU,6BAA6B,CAWG;6BAlXb,sCAAsC;yCAH1B,sDAAsD;kCAd7D,qDAAqD;0BAa7D,uCAAuC;8CAEnB,2DAA2D"}
+{"version":3,"file":"chunk_probe_clipmap_pick.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,oCAFU,YAAY,CA2BF;AAEpB;;;GAGG;AACH,sCAFU,wBAAwB,CAE+E;AAEjH;;;GAGG;AACH,8CAFU,wBAAwB,CAEiF;AAEnH;;;GAGG;AACH,6CAFU,iBAAiB,CAQvB;AAEJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAOjJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,0CAFU,SAAS,CAiMhB;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0BhB;AASH;;;;;;;GAOG;AACH,2CAFU,6BAA6B,CAWG;6BAzXb,sCAAsC;yCAH1B,sDAAsD;kCAb7D,qDAAqD;0BAY7D,uCAAuC;8CAEnB,2DAA2D"}

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

@@ -1,5 +1,4 @@
 import { SamplerDescriptor } from "../../../../descriptor/texture/SamplerDescriptor.js";
-import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { CLIPMAP_LEVEL_ARRAY } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import {
     chunk_uv_octahedral_unit_encode
@@ -14,7 +13,7 @@ import {
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { f32, u32, vec2f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32, vec2f, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import {
     chunk_probe_clipmap,
@@ -26,6 +25,7 @@ import {
     PROBE_STATES_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
 import { chunk_probe_clipmap_cage_in } from "./chunk_probe_clipmap_cage.js";
+import { chunk_probe_clipmap_select_in } from "./chunk_probe_clipmap_select.js";
 import { PROBE_RECEIVER_BIAS_VIEW } from "./PROBE_CLIPMAP.js";
 
 /**
@@ -54,6 +54,10 @@ export const PROBE_SAMPLING_STRUCT = WebGPUStruct.from({
     radiance_texel: vec2f,
     /** one over the radiance atlas's tiles a row, rounded to f32 */
     radiance_tiles_per_row_reciprocal: f32,
+    /** where the windows were placed around, world metres: the selection boxes' centre */
+    anchor: vec3f,
+    /** a selection box's half side, in its cascade's cells */
+    select_half: f32,
 }, "ProbeSampling");
 
 /**
@@ -104,6 +108,8 @@ const RECORDS = `ptr<storage, array<${PROBE_RECORD_STRUCT.wgsl_ref}>, read>`;
  * fn probe_clipmap_depth_moments_in(sampling, depth, slot: u32, direction: vec3<f32>) -> vec2<f32>
  * ```
  *
+ * - **The cascade**: `probe_clipmap_select_in` by the sampling's `anchor` and `select_half`, as want takes it:
+ *   boxes on the anchor, so the blend between cascades moves with the anchor, not a window's step at a time.
  * - **The cage**: `probe_clipmap_cage_in` along mix(n, v, 0.2), as want takes it, so a pixel reads the
  *   probes it wanted.
  * - **The weights**, visibility only, of the cage's eight corners: a corner without an ALIVE probe weighs
@@ -240,7 +246,7 @@ fn probe_clipmap_pick_in(levels: ${LEVELS}, sampling: ${SAMPLING}, indirection:
     var out: ProbeClipmapPick;
 
     let count = (*sampling).cascade_count;
-    let selection = clipmap_select_finest(levels, count, position, PROBE_BLEND_SKIRT);
+    let selection = probe_clipmap_select_in(levels, count, (*sampling).anchor, (*sampling).select_half, position);
 
     if (selection.level == CLIPMAP_LEVEL_NONE) {
         return out;
@@ -305,7 +311,7 @@ fn probe_clipmap_sh_in(records: ${RECORDS}, pick: ProbeClipmapPick) -> ProbeClip
 }
 `, [
     chunk_probe_clipmap,
-    chunk_clipmap_select_finest,
+    chunk_probe_clipmap_select_in,
     chunk_probe_clipmap_cage_in,
     chunk_index_to_grid2d_reciprocal,
     chunk_uv_octahedral_unit_encode,