@woosh/meep-engine 3.61.2 → 3.61.3

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,

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

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

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

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

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

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

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

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

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

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

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

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