@woosh/meep-engine 3.61.1 → 3.61.3

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

@@ -1,6 +1,6 @@
 /**
- * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 48 bytes a slot: where it is, when it
- * was wanted and traced, its last update's back faces, and its irradiance. Where
+ * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 64 bytes a slot: where it is, when it
+ * was wanted and traced, its last update's back faces, and the radiance its rays saw. Where
  * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
@@ -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;
@@ -274,7 +274,7 @@ export const PROBE_CANDIDATES_WRITE_RESOURCE: ShaderResourceDescriptor;
  */
 export const PROBE_CANDIDATES_READ_RESOURCE: ShaderResourceDescriptor;
 /**
- * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
+ * A row of a listed probe's radiance map, projected: its radiance SH3, and its rays this update.
  * @type {WebGPUStruct}
  */
 export const PROBE_PROJECTION_ROW_STRUCT: WebGPUStruct;
@@ -326,8 +326,9 @@ export const PROBE_DEPTH_STORE_RESOURCE: ShaderResourceDescriptor;
  * fn probe_clipmap_age_bucket(age: u32) -> u32 // the bucket of frames unwanted that eviction orders by
  * fn probe_record_flags(back_face: f32, cascade: u32) -> u32
  * fn probe_record_cascade(flags: u32) -> u32
- * fn probe_record_sh_encode(sh: MetroL1) -> vec3<u32> // held to the half float's largest, ±65,504
- * fn probe_record_sh_decode(sh: vec3<u32>) -> MetroL1
+ * fn probe_record_sh_encode(sh: array<vec3<f32>, 9>) -> array<u32, 7> // sh: radiance SH3
+ * fn probe_record_sh_decode(words: array<u32, 7>) -> array<vec3<f32>, 9> // radiance SH3
+ * fn probe_record_mean_radiance(words: array<u32, 7>) -> vec3<f32> // over the sphere
  * fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 // the state's second word
  * fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32>
  * fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 // a listed probe's, in probe_maps
@@ -374,12 +375,32 @@ export const chunk_probe_clipmap_ray_layout: CodeChunk;
  */
 export const chunk_probe_clipmap_ray_texel: CodeChunk;
 /**
- * The STBN jitter of a ray in its texel (§8.6): the noise moved by the slot's hash so that neighbouring
- * probes do not jitter alike, and a fresh sample for each update and each round of a texel's rays. The
- * trace aims its ray by it, and the light pass picks the probes at its hit with it (§8.7).
+ * 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. 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. 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
+ * fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> vec2<f32> // ray: its index among the update's rays
+ * ```
+ *
+ * @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, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // ray: its index among the probe's R; n: n_r
+ * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, sequence: u32, index: u32) -> vec2<f32>
  * ```
  *
  * @type {CodeChunk}
@@ -446,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.
@@ -469,18 +513,6 @@ export const chunk_probe_clipmap_guide_expected: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_listed: CodeChunk;
-/**
- * The jitter of a guided update's ray in its texel. The first ray takes the texel's STBN jitter
- * (`probe_clipmap_ray_jitter` at round 0). The rest rotate it by the R2 sequence, so a texel's rays
- * spread over it the way a lattice does.
- *
- * ```wgsl
- * fn probe_clipmap_guided_ray_jitter(slot: u32, texel: u32, round: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // round: the ray's place among its texel's
- * ```
- *
- * @type {CodeChunk}
- */
-export const chunk_probe_clipmap_guided_ray_jitter: CodeChunk;
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";

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":"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"}

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

@@ -6,14 +6,13 @@ 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_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
-import { chunk_r2_canonical } from "../../../shader/chunk/noise/r/chunk_r2_canonical.js";
-import { chunk_hash_lowbias32 } from "../../../shader/chunk/random/chunk_hash_lowbias32.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";
 import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+    chunk_sh3_color_multiply_scalar
+} from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_multiply_scalar.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import {
@@ -22,13 +21,15 @@ import {
     u32,
     vec2u,
     vec3i,
-    vec3u,
+    vec3f,
     vec4f,
     vec4u
 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { BRICK4_PROBE_ENCODED_SIZE } from "../../brick4/BRICK4_PROBE_ENCODED_SIZE.js";
+import { chunk_brick4_sh3_color_unpack } from "../../brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.js";
+import { chunk_brick4_sh3_color_pack } from "../../brick4/gpu/encoding/v2/chunk_brick4_sh3_color_encode.js";
 import {
     PROBE_AGE_BUCKETS,
     PROBE_BLEND_SKIRT,
@@ -54,6 +55,8 @@ import {
     PROBE_RAY_CASCADE_SHIFT,
     PROBE_RAY_KIND_MASK,
     PROBE_RAY_NONE,
+    PROBE_RAY_NOISE_JITTER,
+    PROBE_RAY_NOISE_PICK,
     PROBE_RAY_ORIGIN_JITTER,
     PROBE_RAY_PROBE_SHIFT,
     PROBE_RECORD_CASCADE_SHIFT,
@@ -69,8 +72,8 @@ import {
 } from "./PROBE_CLIPMAP.js";
 
 /**
- * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 48 bytes a slot: where it is, when it
- * was wanted and traced, its last update's back faces, and its irradiance. Where
+ * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 64 bytes a slot: where it is, when it
+ * was wanted and traced, its last update's back faces, and the radiance its rays saw. Where
  * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
@@ -88,10 +91,13 @@ export const PROBE_RECORD_STRUCT = WebGPUStruct.from({
     /** the frame it was last updated */
     traced_frame: u32,
     /**
-     * The irradiance its rays saw, the Metro L1 encoding (luma as SH2, chroma constant) in half floats:
-     * Y's xy, Y's zw, CoCg. `probe_record_sh_decode`.
+     * The radiance its rays saw as RGB SH3, a quarter of every coefficient in Brick4's encoding
+     * (`brick4_sh3_color_pack`): band 0 RGB9E5, bands 1 and 2 eight bits a coefficient over it. A power of two
+     * scales RGB9E5's exponent alone, so `probe_record_sh_decode` gives the radiance SH3 to the bit as Brick4's
+     * codec decodes it wherever each lit channel's mean radiance is past 2·10⁻⁵, while band 0 holds a mean radiance
+     * to 73,804, past the rays' own largest light, 65,408.
      */
-    sh: vec3u,
+    sh: WebGPUArray.from(u32, BRICK4_PROBE_ENCODED_SIZE),
 }, "ProbeRecord").pack();
 
 /**
@@ -108,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,
     /**
@@ -126,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);
@@ -448,11 +454,11 @@ export const PROBE_CANDIDATES_WRITE_RESOURCE = ShaderResourceDescriptor.storageB
 export const PROBE_CANDIDATES_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_candidates", WebGPUArray.from(PROBE_CANDIDATE_STRUCT));
 
 /**
- * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
+ * A row of a listed probe's radiance map, projected: its radiance SH3, and its rays this update.
  * @type {WebGPUStruct}
  */
 export const PROBE_PROJECTION_ROW_STRUCT = WebGPUStruct.from({
-    sh: METRO_L1_IRRADIANCE_STRUCT,
+    sh: WebGPUArray.from(vec3f, 9),
     /** the update's rays that resolved, a back face's among them */
     resolved: u32,
     /** of them, the back faces */
@@ -517,8 +523,9 @@ export const PROBE_DEPTH_STORE_RESOURCE = ShaderResourceDescriptor.storageTextur
  * fn probe_clipmap_age_bucket(age: u32) -> u32 // the bucket of frames unwanted that eviction orders by
  * fn probe_record_flags(back_face: f32, cascade: u32) -> u32
  * fn probe_record_cascade(flags: u32) -> u32
- * fn probe_record_sh_encode(sh: MetroL1) -> vec3<u32> // held to the half float's largest, ±65,504
- * fn probe_record_sh_decode(sh: vec3<u32>) -> MetroL1
+ * fn probe_record_sh_encode(sh: array<vec3<f32>, 9>) -> array<u32, 7> // sh: radiance SH3
+ * fn probe_record_sh_decode(words: array<u32, 7>) -> array<vec3<f32>, 9> // radiance SH3
+ * fn probe_record_mean_radiance(words: array<u32, 7>) -> vec3<f32> // over the sphere
  * fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 // the state's second word
  * fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32>
  * fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 // a listed probe's, in probe_maps
@@ -618,20 +625,20 @@ fn probe_record_cascade(flags: u32) -> u32 {
     return flags >> PROBE_RECORD_CASCADE_SHIFT;
 }
 
-fn probe_record_sh_encode(sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref}) -> vec3<u32> {
-    let y = clamp(sh.Y, vec4<f32>(-65504.0), vec4<f32>(65504.0));
-    let cocg = clamp(sh.CoCg, vec2<f32>(-65504.0), vec2<f32>(65504.0));
+// the power of two at or below band 0's basis constant, 1/√(4π): band 0 holds a mean radiance past RGB9E5's largest value
+const PROBE_RECORD_SH_SCALE = 0.25;
 
-    return vec3<u32>(pack2x16float(y.xy), pack2x16float(y.zw), pack2x16float(cocg));
+fn probe_record_sh_encode(sh: array<vec3<f32>, 9>) -> array<u32, ${BRICK4_PROBE_ENCODED_SIZE}> {
+    return brick4_sh3_color_pack(sh3_color_multiply_scalar(sh, PROBE_RECORD_SH_SCALE));
 }
 
-fn probe_record_sh_decode(sh: vec3<u32>) -> ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref} {
-    var out: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
-
-    out.Y = vec4<f32>(unpack2x16float(sh.x), unpack2x16float(sh.y));
-    out.CoCg = unpack2x16float(sh.z);
+fn probe_record_sh_decode(words: array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>) -> array<vec3<f32>, 9> {
+    return brick4_sh3_color_unpack(words, 1.0 / PROBE_RECORD_SH_SCALE);
+}
 
-    return out;
+fn probe_record_mean_radiance(words: array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>) -> vec3<f32> {
+    // band 0 times its basis constant
+    return brick4_sh3_color_unpack_dc(words) * (0.28209479177387814 / PROBE_RECORD_SH_SCALE);
 }
 
 fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 {
@@ -653,7 +660,9 @@ fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32> {
 }
 `, [
     PROBE_RECORD_STRUCT.declaration_chunk,
-    METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+    chunk_brick4_sh3_color_pack,
+    chunk_brick4_sh3_color_unpack,
+    chunk_sh3_color_multiply_scalar,
     chunk_clipmap_key,
     chunk_mod_v3i,
 ]);
@@ -751,35 +760,62 @@ fn probe_clipmap_texel_ray(texel: u32, round: u32, updates: u32, rays: u32, texe
 ]);
 
 /**
- * The STBN jitter of a ray in its texel (§8.6): the noise moved by the slot's hash so that neighbouring
- * probes do not jitter alike, and a fresh sample for each update and each round of a texel's rays. The
- * trace aims its ray by it, and the light pass picks the probes at its hit with it (§8.7).
+ * 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. 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. 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
- * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // ray: its index among the probe's R; n: n_r
+ * fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> vec2<f32> // ray: its index among the update's rays
  * ```
  *
  * @type {CodeChunk}
  */
-export const chunk_probe_clipmap_ray_jitter = CodeChunk.from(
+export const chunk_probe_clipmap_ray_noise = CodeChunk.from(
     //language=WGSL
     `
-fn probe_clipmap_ray_jitter(slot: u32, texel: u32, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> {
-    let texels = n * n;
-    let round = select(0u, ray / texels, rays >= texels);
-    let per_texel = max(rays / texels, 1u);
+const PROBE_RAY_NOISE_PICK = ${PROBE_RAY_NOISE_PICK}u;
 
-    let scramble = hash_lowbias32(slot);
-    let noise_xy = vec2<u32>(texel % n, texel / n) + vec2<u32>(scramble & 127u, (scramble >> 7u) & 127u);
+fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> vec2<f32> {
+    let hash = pcg4d(vec4<u32>(slot, updates, ray, stream));
 
-    return stbn_sample_vec2(vec3<u32>(noise_xy, updates * per_texel + round));
+    // 23 bits and a half fit f32's 24 exactly: the centre of the last bin stays under 1
+    return (vec2<f32>(hash.xy >> vec2<u32>(9u)) + 0.5) * (1.0 / 8388608.0);
 }
 `, [
-    chunk_hash_lowbias32,
-    chunk_stbn_sample_vec2,
+    chunk_pcg4d,
 ]);
 
-chunk_probe_clipmap_ray_jitter.requireResource(STBN_VEC2_RESOURCE);
+/**
+ * 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
@@ -913,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.
@@ -967,25 +1054,3 @@ fn probe_clipmap_listed(slot: u32, capacity: u32) -> u32 {
 
 chunk_probe_clipmap_listed.requireResource(PROBE_LISTED_READ_RESOURCE);
 chunk_probe_clipmap_listed.requireResource(PROBE_TRACE_READ_RESOURCE);
-
-/**
- * The jitter of a guided update's ray in its texel. The first ray takes the texel's STBN jitter
- * (`probe_clipmap_ray_jitter` at round 0). The rest rotate it by the R2 sequence, so a texel's rays
- * spread over it the way a lattice does.
- *
- * ```wgsl
- * fn probe_clipmap_guided_ray_jitter(slot: u32, texel: u32, round: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // round: the ray's place among its texel's
- * ```
- *
- * @type {CodeChunk}
- */
-export const chunk_probe_clipmap_guided_ray_jitter = CodeChunk.from(
-    //language=WGSL
-    `
-fn probe_clipmap_guided_ray_jitter(slot: u32, texel: u32, round: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> {
-    return fract(probe_clipmap_ray_jitter(slot, texel, 0u, updates, rays, n) + r2_canonical(round) - 0.5);
-}
-`, [
-    chunk_probe_clipmap_ray_jitter,
-    chunk_r2_canonical,
-]);

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"}