@woosh/meep-engine 3.60.6 → 3.60.8

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

@@ -1,11 +1,18 @@
 import { SamplerDescriptor } from "../../../../descriptor/texture/SamplerDescriptor.js";
 import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
-import { chunk_uv_octahedral_unit_encode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { CLIPMAP_LEVEL_ARRAY } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import {
+    chunk_uv_octahedral_unit_encode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_index_to_grid2d_reciprocal } from "../../../shader/chunk/grid/chunk_index_to_grid2d_reciprocal.js";
 import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
 import { chunk_pick2_wrs_mat2x4 } from "../../../shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.js";
-import { METRO_L1_IRRADIANCE_STRUCT } from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
-import { chunk_texture_octahedral_skirt_uv } from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import {
+    chunk_texture_octahedral_skirt_uv
+} from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
@@ -16,10 +23,11 @@ import {
     PROBE_DEPTH_HISTORY_RESOURCE,
     PROBE_LEVELS_RESOURCE,
     PROBE_RADIANCE_HISTORY_RESOURCE,
+    PROBE_RECORD_STRUCT,
     PROBE_RECORDS_READ_RESOURCE,
     PROBE_STATES_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import { chunk_probe_clipmap_cage } from "./chunk_probe_clipmap_cage.js";
+import { chunk_probe_clipmap_cage_in } from "./chunk_probe_clipmap_cage.js";
 import { PROBE_RECEIVER_BIAS_VIEW } from "./PROBE_CLIPMAP.js";
 
 /**
@@ -80,16 +88,25 @@ export const PROBE_DEPTH_SAMPLER_DESCRIPTOR = Object.freeze(SamplerDescriptor.fr
  */
 export const PROBE_DEPTH_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("probe_depth_sampler", "filtering", PROBE_DEPTH_SAMPLER_DESCRIPTOR);
 
+const LEVELS = `ptr<uniform, ${CLIPMAP_LEVEL_ARRAY.wgsl_ref}>`;
+const SAMPLING = `ptr<uniform, ${PROBE_SAMPLING_STRUCT.wgsl_ref}>`;
+const STATES = `ptr<storage, array<vec2<u32>>, read>`;
+const RECORDS = `ptr<storage, array<${PROBE_RECORD_STRUCT.wgsl_ref}>, read>`;
+
 /**
- * A point's picked probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1), and their SH (§9.2):
+ * A point's picked probes in one clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1), and their SH (§9.2),
+ * the clipmap passed whole: its levels, shape, indirection, states and depth atlas to the pick, its records to
+ * the SH. It binds nothing but the depth's sampler, so a shader can pick from two clipmaps, as the bounce pass
+ * does (`shader_probe_clipmap_bounce`).
  *
  * ```wgsl
- * fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick
- * fn probe_clipmap_sh_of(pick: ProbeClipmapPick) -> ProbeClipmapSH
- * fn probe_clipmap_sample_sh(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapSH
+ * fn probe_clipmap_pick_in(levels: ptr<uniform, ClipmapLevelArray>, sampling: ptr<uniform, ProbeSampling>, indirection: texture_3d<u32>, states: ptr<storage, array<vec2<u32>>, read>, depth: texture_2d<f32>, position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick
+ * fn probe_clipmap_sh_in(records: ptr<storage, array<ProbeRecord>, read>, pick: ProbeClipmapPick) -> ProbeClipmapSH
+ * fn probe_clipmap_corner_slot_in(sampling, indirection, cascade: u32, point: vec3<i32>) -> u32
+ * fn probe_clipmap_depth_moments_in(sampling, depth, slot: u32, direction: vec3<f32>) -> vec2<f32>
  * ```
  *
- * - **The cage**: `probe_clipmap_cage` along mix(n, v, 0.2), as want takes it, so a pixel reads the
+ * - **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
  *   nothing; one with weighs its trilinear weight × `probe_visibility_weight`: the wrap back-face term
@@ -100,9 +117,8 @@ export const PROBE_DEPTH_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("pr
  *   whose corners weigh nothing gives way to the next coarser, without a skirt. With none left the
  *   weights are zero, and the fallback is the caller's (§9.1, step 6).
  * - **The SH**: the picked records' Metro L1 structs mixed by their weights; resolved with
- *   `resolve_irradiance_sh_to_diffuse` at the caller's normal, it gives E/π. `probe_clipmap_sh_of` takes a
- *   pick already made, so a pass that samples the specular too picks once; `probe_clipmap_sample_sh` picks
- *   and takes it.
+ *   `resolve_irradiance_sh_to_diffuse` at the caller's normal, it gives E/π. `found` says whether any probe
+ *   weighed anything.
  *
  * Per cascade read: 8 indirection loads, 8 state words and 8 depth taps, then 2 indirection loads for
  * the pair; then two records a cascade read for the SH. A depth tile's place takes no integer division
@@ -110,7 +126,7 @@ export const PROBE_DEPTH_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("pr
  *
  * @type {CodeChunk}
  */
-export const chunk_probe_clipmap_pick = CodeChunk.from(
+export const chunk_probe_clipmap_pick_in = CodeChunk.from(
     //language=WGSL
     `
 struct ProbeClipmapPick {
@@ -130,11 +146,11 @@ struct ProbeClipmapSH {
     found: bool,
 }
 
-fn probe_clipmap_corner_slot(cascade: u32, point: vec3<i32>) -> u32 {
-    let resolution = probe_sampling.resolution;
+fn probe_clipmap_corner_slot_in(sampling: ${SAMPLING}, indirection: texture_3d<u32>, cascade: u32, point: vec3<i32>) -> u32 {
+    let resolution = (*sampling).resolution;
     let storage = vec3<u32>(point) & vec3<u32>(resolution - 1u);
 
-    return textureLoad(probe_indirection, probe_clipmap_indirection_texel(cascade, storage, resolution), 0).r;
+    return textureLoad(indirection, probe_clipmap_indirection_texel(cascade, storage, resolution), 0).r;
 }
 
 fn probe_clipmap_corner(k: u32) -> vec3<i32> {
@@ -142,30 +158,30 @@ fn probe_clipmap_corner(k: u32) -> vec3<i32> {
 }
 
 // a slot's depth moments toward a direction, in spacings: one bilinear tap of its tile, through its skirt
-fn probe_clipmap_depth_moments(slot: u32, direction: vec3<f32>) -> vec2<f32> {
-    let side = probe_sampling.depth_resolution + 2u;
-    let place = index_to_grid2d_reciprocal(slot, probe_sampling.depth_tiles_per_row, probe_sampling.depth_tiles_per_row_reciprocal);
+fn probe_clipmap_depth_moments_in(sampling: ${SAMPLING}, depth: texture_2d<f32>, slot: u32, direction: vec3<f32>) -> vec2<f32> {
+    let side = (*sampling).depth_resolution + 2u;
+    let place = index_to_grid2d_reciprocal(slot, (*sampling).depth_tiles_per_row, (*sampling).depth_tiles_per_row_reciprocal);
     let tile = vec2<f32>(place * side);
     let in_tile = texture_octahedral_skirt_uv(uv_octahedral_unit_encode(direction), f32(side)) * f32(side);
 
-    return textureSampleLevel(probe_depth, probe_depth_sampler, (tile + in_tile) * probe_sampling.depth_texel, 0.0).rg;
+    return textureSampleLevel(depth, probe_depth_sampler, (tile + in_tile) * (*sampling).depth_texel, 0.0).rg;
 }
 
-fn probe_clipmap_corner_weight(cascade: u32, cage: vec3<i32>, k: u32, position: vec3<f32>, normal: vec3<f32>, biased: vec3<f32>) -> f32 {
+fn probe_clipmap_corner_weight_in(levels: ${LEVELS}, sampling: ${SAMPLING}, indirection: texture_3d<u32>, states: ${STATES}, depth: texture_2d<f32>, cascade: u32, cage: vec3<i32>, k: u32, position: vec3<f32>, normal: vec3<f32>, biased: vec3<f32>) -> f32 {
     let point = cage + probe_clipmap_corner(k);
-    let slot = probe_clipmap_corner_slot(cascade, point);
+    let slot = probe_clipmap_corner_slot_in(sampling, indirection, cascade, point);
 
     if (slot == PROBE_CLIPMAP_NONE) {
         return 0.0;
     }
 
-    let state = probe_states[slot];
+    let state = (*states)[slot];
 
     if (probe_state_kind(state.x) != PROBE_STATE_ALIVE) {
         return 0.0;
     }
 
-    let spacing = probe_levels[cascade].cell_size;
+    let spacing = (*levels)[cascade].cell_size;
     let probe = vec3<f32>(point) * spacing + probe_clipmap_offset_decode(state.y, spacing);
 
     let f = biased / spacing - vec3<f32>(cage);
@@ -175,36 +191,36 @@ fn probe_clipmap_corner_weight(cascade: u32, cage: vec3<i32>, k: u32, position:
 
     let to_point = biased - probe;
     let distance = length(to_point);
-    let moments = probe_clipmap_depth_moments(slot, to_point / max(distance, 1e-6));
+    let moments = probe_clipmap_depth_moments_in(sampling, depth, slot, to_point / max(distance, 1e-6));
     let visibility = probe_visibility_chebyshev(moments, distance / spacing);
 
     // the back-face term from the point itself, not the biased one
     return trilinear * probe_visibility_weight(normalize(probe - position), normal, visibility);
 }
 
-fn probe_clipmap_pick_cascade(cascade: u32, position: vec3<f32>, normal: vec3<f32>, bias_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPair {
+fn probe_clipmap_pick_cascade_in(levels: ${LEVELS}, sampling: ${SAMPLING}, indirection: texture_3d<u32>, states: ${STATES}, depth: texture_2d<f32>, cascade: u32, position: vec3<f32>, normal: vec3<f32>, bias_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPair {
     var out: ProbeClipmapPair;
     var cage: vec3<i32>;
 
-    if (!probe_clipmap_cage(cascade, position, bias_direction, &cage)) {
+    if (!probe_clipmap_cage_in(levels, cascade, position, bias_direction, &cage)) {
         return out;
     }
 
-    let biased = probe_clipmap_biased(cascade, position, bias_direction);
+    let biased = probe_clipmap_biased_in(levels, cascade, position, bias_direction);
 
     // each corner by name: a dynamic index would put the weights in local memory
     let weights = mat2x4<f32>(
         vec4<f32>(
-            probe_clipmap_corner_weight(cascade, cage, 0u, position, normal, biased),
-            probe_clipmap_corner_weight(cascade, cage, 1u, position, normal, biased),
-            probe_clipmap_corner_weight(cascade, cage, 2u, position, normal, biased),
-            probe_clipmap_corner_weight(cascade, cage, 3u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 0u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 1u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 2u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 3u, position, normal, biased),
         ),
         vec4<f32>(
-            probe_clipmap_corner_weight(cascade, cage, 4u, position, normal, biased),
-            probe_clipmap_corner_weight(cascade, cage, 5u, position, normal, biased),
-            probe_clipmap_corner_weight(cascade, cage, 6u, position, normal, biased),
-            probe_clipmap_corner_weight(cascade, cage, 7u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 4u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 5u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 6u, position, normal, biased),
+            probe_clipmap_corner_weight_in(levels, sampling, indirection, states, depth, cascade, cage, 7u, position, normal, biased),
         ),
     );
 
@@ -215,19 +231,19 @@ fn probe_clipmap_pick_cascade(cascade: u32, position: vec3<f32>, normal: vec3<f3
     let pick = pick2_wrs_mat2x4(weights, noise);
 
     out.slots = vec2<u32>(
-        probe_clipmap_corner_slot(cascade, cage + probe_clipmap_corner(pick.indices.x)),
-        probe_clipmap_corner_slot(cascade, cage + probe_clipmap_corner(pick.indices.y)),
+        probe_clipmap_corner_slot_in(sampling, indirection, cascade, cage + probe_clipmap_corner(pick.indices.x)),
+        probe_clipmap_corner_slot_in(sampling, indirection, cascade, cage + probe_clipmap_corner(pick.indices.y)),
     );
     out.weights = vec2<f32>(1.0 - pick.blend, pick.blend);
 
     return out;
 }
 
-fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick {
+fn probe_clipmap_pick_in(levels: ${LEVELS}, sampling: ${SAMPLING}, indirection: texture_3d<u32>, states: ${STATES}, depth: texture_2d<f32>, position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick {
     var out: ProbeClipmapPick;
 
-    let count = probe_sampling.cascade_count;
-    let selection = clipmap_select_finest(&probe_levels, count, position, PROBE_BLEND_SKIRT);
+    let count = (*sampling).cascade_count;
+    let selection = clipmap_select_finest(levels, count, position, PROBE_BLEND_SKIRT);
 
     if (selection.level == CLIPMAP_LEVEL_NONE) {
         return out;
@@ -237,7 +253,7 @@ fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: ve
 
     var cascade = selection.level;
     var skirt = selection.edge_weight;
-    var pair = probe_clipmap_pick_cascade(cascade, position, normal, bias_direction, noise);
+    var pair = probe_clipmap_pick_cascade_in(levels, sampling, indirection, states, depth, cascade, position, normal, bias_direction, noise);
 
     // a cascade whose corners weigh nothing gives way to the next coarser, whole
     for (var next = cascade + 1u; next < count; next++) {
@@ -247,14 +263,14 @@ fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: ve
 
         cascade = next;
         skirt = 0.0;
-        pair = probe_clipmap_pick_cascade(cascade, position, normal, bias_direction, noise);
+        pair = probe_clipmap_pick_cascade_in(levels, sampling, indirection, states, depth, cascade, position, normal, bias_direction, noise);
     }
 
     out.slots = vec4<u32>(pair.slots, pair.slots);
     out.weights = vec4<f32>(pair.weights, 0.0, 0.0);
 
     if (skirt > 0.0 && cascade + 1u < count && pair.weights.x + pair.weights.y > 0.0) {
-        let coarse = probe_clipmap_pick_cascade(cascade + 1u, position, normal, bias_direction, noise);
+        let coarse = probe_clipmap_pick_cascade_in(levels, sampling, indirection, states, depth, cascade + 1u, position, normal, bias_direction, noise);
 
         if (coarse.weights.x + coarse.weights.y > 0.0) {
             out.slots = vec4<u32>(pair.slots, coarse.slots);
@@ -265,7 +281,7 @@ fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: ve
     return out;
 }
 
-fn probe_clipmap_sh_of(pick: ProbeClipmapPick) -> ProbeClipmapSH {
+fn probe_clipmap_sh_in(records: ${RECORDS}, pick: ProbeClipmapPick) -> ProbeClipmapSH {
     var out: ProbeClipmapSH;
 
     out.found = dot(pick.weights, vec4<f32>(1.0)) > 0.0;
@@ -276,52 +292,92 @@ fn probe_clipmap_sh_of(pick: ProbeClipmapPick) -> ProbeClipmapSH {
 
     // each by name, the slots of a weight of zero not read
     if (pick.weights.x > 0.0) {
-        let sh = probe_record_sh_decode(probe_records[pick.slots.x].sh);
+        let sh = probe_record_sh_decode((*records)[pick.slots.x].sh);
         out.sh.CoCg += pick.weights.x * sh.CoCg;
         out.sh.Y += pick.weights.x * sh.Y;
     }
     if (pick.weights.y > 0.0) {
-        let sh = probe_record_sh_decode(probe_records[pick.slots.y].sh);
+        let sh = probe_record_sh_decode((*records)[pick.slots.y].sh);
         out.sh.CoCg += pick.weights.y * sh.CoCg;
         out.sh.Y += pick.weights.y * sh.Y;
     }
     if (pick.weights.z > 0.0) {
-        let sh = probe_record_sh_decode(probe_records[pick.slots.z].sh);
+        let sh = probe_record_sh_decode((*records)[pick.slots.z].sh);
         out.sh.CoCg += pick.weights.z * sh.CoCg;
         out.sh.Y += pick.weights.z * sh.Y;
     }
     if (pick.weights.w > 0.0) {
-        let sh = probe_record_sh_decode(probe_records[pick.slots.w].sh);
+        let sh = probe_record_sh_decode((*records)[pick.slots.w].sh);
         out.sh.CoCg += pick.weights.w * sh.CoCg;
         out.sh.Y += pick.weights.w * sh.Y;
     }
 
     return out;
 }
-
-fn probe_clipmap_sample_sh(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapSH {
-    return probe_clipmap_sh_of(probe_clipmap_pick(position, normal, view_direction, noise));
-}
-
 `, [
     chunk_probe_clipmap,
     chunk_clipmap_select_finest,
-    chunk_probe_clipmap_cage,
+    chunk_probe_clipmap_cage_in,
     chunk_index_to_grid2d_reciprocal,
     chunk_uv_octahedral_unit_encode,
     chunk_texture_octahedral_skirt_uv,
     chunk_probe_visibility_weight,
     chunk_pick2_wrs_mat2x4,
+    PROBE_SAMPLING_STRUCT.declaration_chunk,
     METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
 ]);
 
+chunk_probe_clipmap_pick_in.requireResource(PROBE_DEPTH_SAMPLER_RESOURCE);
+
+/**
+ * {@link chunk_probe_clipmap_pick_in} over the clipmap a shader binds under the probes' names, as every reader
+ * of the screen's probes does (§9.5):
+ *
+ * ```wgsl
+ * fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick
+ * fn probe_clipmap_sh_of(pick: ProbeClipmapPick) -> ProbeClipmapSH
+ * fn probe_clipmap_sample_sh(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapSH
+ * fn probe_clipmap_corner_slot(cascade: u32, point: vec3<i32>) -> u32
+ * fn probe_clipmap_depth_moments(slot: u32, direction: vec3<f32>) -> vec2<f32>
+ * ```
+ *
+ * `probe_clipmap_sh_of` takes a pick already made, so a pass that samples the specular too picks once;
+ * `probe_clipmap_sample_sh` picks and takes it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_pick = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_corner_slot(cascade: u32, point: vec3<i32>) -> u32 {
+    return probe_clipmap_corner_slot_in(&probe_sampling, probe_indirection, cascade, point);
+}
+
+fn probe_clipmap_depth_moments(slot: u32, direction: vec3<f32>) -> vec2<f32> {
+    return probe_clipmap_depth_moments_in(&probe_sampling, probe_depth, slot, direction);
+}
+
+fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick {
+    return probe_clipmap_pick_in(&probe_levels, &probe_sampling, probe_indirection, &probe_states, probe_depth, position, normal, view_direction, noise);
+}
+
+fn probe_clipmap_sh_of(pick: ProbeClipmapPick) -> ProbeClipmapSH {
+    return probe_clipmap_sh_in(&probe_records, pick);
+}
+
+fn probe_clipmap_sample_sh(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapSH {
+    return probe_clipmap_sh_of(probe_clipmap_pick(position, normal, view_direction, noise));
+}
+`, [
+    chunk_probe_clipmap_pick_in,
+]);
+
 chunk_probe_clipmap_pick.requireResource(PROBE_LEVELS_RESOURCE);
 chunk_probe_clipmap_pick.requireResource(PROBE_SAMPLING_RESOURCE);
 chunk_probe_clipmap_pick.requireResource(PROBE_INDIRECTION_READ_RESOURCE);
 chunk_probe_clipmap_pick.requireResource(PROBE_STATES_READ_RESOURCE);
 chunk_probe_clipmap_pick.requireResource(PROBE_RECORDS_READ_RESOURCE);
 chunk_probe_clipmap_pick.requireResource(PROBE_DEPTH_HISTORY_RESOURCE);
-chunk_probe_clipmap_pick.requireResource(PROBE_DEPTH_SAMPLER_RESOURCE);
 
 /**
  * What {@link chunk_probe_clipmap_pick} reads, as a group a reader of the probes adds to its shader (§9.5).

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

@@ -0,0 +1,19 @@
+/**
+ * What re-sampling a probe's neighbours shares between its passes (`shader_probe_clipmap_resample`,
+ * `shader_probe_clipmap_candidate`, `shader_probe_clipmap_resample_rays`):
+ *
+ * ```wgsl
+ * fn probe_resample_offset(j: u32) -> vec3<i32> // the j-th of the 26 neighbours' lattice offsets, the 3×3×3 around the point, its centre skipped
+ * fn probe_resample_visibility(moments: vec2<f32>, distance: f32) -> f32 // distance: in the moments' spacings
+ * ```
+ *
+ * `probe_resample_visibility` is how well a probe's depth moments toward a point confirm a surface at its distance:
+ * `s² / (s² + (d − μ)²)`, μ the mean depth, s² the depth's variance plus the receiver bias squared
+ * (`PROBE_RECEIVER_BIAS`). Two-sided, unlike Chebyshev's: depth nearer than the point is an occluder between, and
+ * depth farther sees past the point.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_resample: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_resample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_resample.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_resample.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,SAAS,CAiBhB;0BAlCuB,uCAAuC"}

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

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { PROBE_RECEIVER_BIAS } from "./PROBE_CLIPMAP.js";
+
+/**
+ * What re-sampling a probe's neighbours shares between its passes (`shader_probe_clipmap_resample`,
+ * `shader_probe_clipmap_candidate`, `shader_probe_clipmap_resample_rays`):
+ *
+ * ```wgsl
+ * fn probe_resample_offset(j: u32) -> vec3<i32> // the j-th of the 26 neighbours' lattice offsets, the 3×3×3 around the point, its centre skipped
+ * fn probe_resample_visibility(moments: vec2<f32>, distance: f32) -> f32 // distance: in the moments' spacings
+ * ```
+ *
+ * `probe_resample_visibility` is how well a probe's depth moments toward a point confirm a surface at its distance:
+ * `s² / (s² + (d − μ)²)`, μ the mean depth, s² the depth's variance plus the receiver bias squared
+ * (`PROBE_RECEIVER_BIAS`). Two-sided, unlike Chebyshev's: depth nearer than the point is an occluder between, and
+ * depth farther sees past the point.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_resample = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_resample_offset(j: u32) -> vec3<i32> {
+    let index = j + select(0u, 1u, j >= 13u);
+
+    return vec3<i32>(vec3<u32>(index % 3u, (index / 3u) % 3u, index / 9u)) - vec3<i32>(1);
+}
+
+fn probe_resample_visibility(moments: vec2<f32>, distance: f32) -> f32 {
+    let spread = max(moments.y - moments.x * moments.x, 0.0) + ${PROBE_RECEIVER_BIAS} * ${PROBE_RECEIVER_BIAS};
+    let gap = distance - moments.x;
+
+    return spread / (spread + gap * gap);
+}
+`);

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kDAFU,SAAS,CAsIZ;0BA7KmB,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kDAFU,SAAS,CAsIZ;0BA7KmB,uCAAuC"}

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

@@ -1,12 +1,18 @@
 import { chunk_roughness_to_mip_ratio } from "../../../light/environment/chunk_roughness_to_mip_ratio.js";
-import { chunk_uv_octahedral_unit_encode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import {
+    chunk_uv_octahedral_unit_encode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_index_to_grid2d_reciprocal } from "../../../shader/chunk/grid/chunk_index_to_grid2d_reciprocal.js";
 import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
-import { METRO_L1_IRRADIANCE_STRUCT } from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
 import {
     chunk_resolve_irradiance_sh_to_specular
 } from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.js";
-import { chunk_texture_octahedral_skirt_uv } from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
+import {
+    chunk_texture_octahedral_skirt_uv
+} from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import {
     PROBE_LEVELS_RESOURCE,

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

@@ -3,14 +3,14 @@
  * 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, key_count: u32, flag: u32)
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, 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
- * point's bit is set, and a point whose bit was clear goes on the wanted list with `flag` over its key,
- * so the list holds every point wanted this frame once, with its first wanter's flag.
+ * 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.
  *
  * A workgroup's lanes want a few cages between them, so the first lane to want a cage claims it in the
  * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at

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

@@ -29,14 +29,14 @@ 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, key_count: u32, flag: u32)
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, 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
- * point's bit is set, and a point whose bit was clear goes on the wanted list with `flag` over its key,
- * so the list holds every point wanted this frame once, with its first wanter's flag.
+ * 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.
  *
  * A workgroup's lanes want a few cages between them, so the first lane to want a cage claims it in the
  * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
@@ -80,7 +80,7 @@ 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, key_count: u32, flag: u32) {
+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);
 
     let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
@@ -117,7 +117,7 @@ fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32
             first = (atomicOr(&probe_wanted_bits[key >> 5u], bit) & bit) == 0u;
         }
 
-        collection_u32_append(&probe_wanted, first, key | flag, key_count);
+        collection_u32_append(&probe_wanted, first, key, wanted_capacity);
     }
 }
 `, [

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

@@ -20,13 +20,12 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  * - **Radiance**: the mean of the texel's resolved rays, a back face's being zero, is a sample of the
  *   texel's multi-scale mean (`chunk_multiscale_mean`), its estimator in `probe_estimators` and its mean
  *   in the atlas.
- *   - Δt and τ are frames: Δt since the probe's last update, τ `response_frames`.
- *   - The short mean blends by β = max(1/(a+1), 1 − e^(−Δt·p/τ)), its variance by the same with 2τ. a is
- *     the texel's own count of the updates that reached it, held in its alpha; p the updates between a
- *     texel's rays: one over the share of updates that reach it, averaged over the uniform period
- *     (`probe_clipmap_guide_rate`), n_r²/R below one ray a texel when every update is uniform. A texel
- *     the guide passes over thus blends what it takes as fully as its rarity asks. Counting a texel
- *     rather than the probe keeps β right where an update covers a subset.
+ *   - The short mean blends by β = max(1/(a+1), `PROBE_SHORT_BLEND`), its variance by max(1/(a+1),
+ *     `PROBE_VARIANCE_BLEND`), a the texel's own count of the updates that reached it, held in its alpha.
+ *     A sample's blend is a sample's however long since the last one: a probe nobody wanted, or a texel the
+ *     guide passes over, takes no more of its next sample for the wait. A change in the light is the
+ *     estimator's to find. Counting a texel rather than the probe keeps β right where an update covers a
+ *     subset.
  *   - The mean blends by at least 1/(a+1) until the count reaches its limit: a young texel is its running
  *     mean, which the estimator's blend reduction, nothing at its seed, would otherwise hold back. Past it
  *     the estimator alone, down to 1/8192 an update on a noisy texel.
@@ -35,20 +34,17 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  *   - A texel's first sample seeds both means. A texel no ray reached keeps its history.
  *   - Where the frame re-samples (`PROBE_CLIPMAP_RESAMPLING`), the sample pools the rays with the texel's
  *     re-samples of the probe's neighbours (`shader_probe_clipmap_resample`), each a ray's worth at a
- *     visibility of one (`chunk_probe_clipmap_resampled`). Only a texel some ray reached takes them: its
- *     time terms are a sampled texel's.
+ *     visibility of one (`chunk_probe_clipmap_resampled`). Only a texel some ray reached takes them.
  * - **Depth**: the moments (d, d²) of the rays landing in the texel, in spacings: a miss the limit, a
  *   back face 0.2·t (DDGI 2021's shortening), a hit t, every sample held to the limit, the farthest a
  *   cage tests a relocated probe, (1 + 0.45)·√3 (`PROBE_DEPTH_LIMIT`, D9). On a uniform update the
- *   sample is the plain mean, blended by the probe's α = max(1/(n+1), 1 − e^(−Δt/τ)), n its updates. At
+ *   sample is the plain mean, blended by the probe's α = max(1/(n+1), `PROBE_SHORT_BLEND`), n its updates. At
  *   most 64 rays a texel, which the settings hold R to (R ≤ 64·n_d²).
  *   - On a guided update the sample is a mean of means: each radiance texel inside the depth texel gives
  *     its own mean, since the guide gives the brighter ones more rays, at most 64/f² of its rays,
  *     evenly strided. It is taken only when every one of them took rays. The guide gives a dark one,
  *     a back face's or a shadowed wall's, none, and the lit ones' depths are not the whole texel's: its
  *     depth comes from the uniform updates.
- *   - The time term's period is one over the share of updates that reach the depth texel, a uniform
- *     update counting as reaching every one, a guided one as often as its least reached radiance texel.
  * - **A new probe's history is another probe's**, its slot's last owner: on its first update a texel
  *   no ray reached is cleared, radiance to nothing seen, depth to the moments of a miss.
  * - **Stored rounded stochastically** onto halves (`f16_round_stochastic`), with noise fresh for each

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA4CA;;GAEG;AACH,wCAFU,YAAY,CAqBQ;AAqB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,8CAFU,aAAa,CAsVpB;6BAtd0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA8CA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAoB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,8CAFU,aAAa,CA0TpB;6BApb0B,sCAAsC;8BAHrC,kCAAkC"}