@woosh/meep-engine 3.64.0 → 3.65.0

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

@@ -4,13 +4,17 @@
 export const PROBE_DUE_SETTINGS: WebGPUStruct;
 /**
  * Due (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.5): a thread an entry of the frame's active list,
- * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due
- * when a want waits on it:
- * - it is NEW, in the first pass, which lists them first: it has had no update;
- * - in the second pass, it is ALIVE or DEAD, a pixel or a hit wanted it since its last update, its
- *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe is due every
- *   period like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a solid
- *   notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
+ * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due:
+ * - in the first pass, which lists them first, when it is NEW: it has had no update;
+ * - in the second pass, when it is ALIVE or DEAD and `(frame + h(slot)) mod P` is 0, where P is
+ *   - T when a want waits on it: a pixel or a hit wanted it since its last update, its wanted time past
+ *     its traced time;
+ *   - T · `idle_periods` when it is idle, none waiting on it. Every live probe keeps being updated, so one
+ *     that readers reach without wanting it, the bounce at a hit among them, and one a want comes back to,
+ *     holds light no older than that. Its update is any other probe's.
+ *
+ *   A DEAD probe is due like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a
+ *   solid notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
  *
  * Wanted since its last update, not this frame: a hit wants a probe the frame after its own probe's
  * update, so a probe that only hits keep is wanted on few of its turns. Measured on Sponza with the
@@ -19,8 +23,8 @@ export const PROBE_DUE_SETTINGS: WebGPUStruct;
  * waits on nothing: the update comes after admit in its frame, so its traced time is the want's or later.
  *
  * The due go on the trace list, which holds the frame's updates, at most U: past it the count still
- * rises and nothing is written, and a probe not listed waits its next turn. With T = ⌈P_w / U⌉ over the
- * probes waiting, the expected count a frame is under U, so only NEW probes past U, a camera cut, wait.
+ * rises and nothing is written, and a probe not listed waits its next turn. Schedule's T keeps the
+ * expected count a frame under U, so only NEW probes past U, a camera cut, wait.
  *
  * @type {ComputeShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_due.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.js"],"names":[],"mappings":"AAkBA;;GAEG;AACH,iCAFU,YAAY,CAWC;AAavB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uCAFU,aAAa,CA4CpB;6BApG0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_due.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.js"],"names":[],"mappings":"AAkBA;;GAEG;AACH,iCAFU,YAAY,CAaC;AAavB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uCAFU,aAAa,CA6CpB;6BA3G0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -28,6 +28,8 @@ export const PROBE_DUE_SETTINGS = WebGPUStruct.from({
     frame: u32,
     /** 1 for the pass that lists the NEW probes, 0 for the one that lists the rest */
     new_only: u32,
+    /** periods between an idle probe's turns, `probe_clipmap_idle_periods`, at least 1 */
+    idle_periods: u32,
 }, "ProbeDueSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -43,13 +45,17 @@ resources.createGroup()
 
 /**
  * Due (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.5): a thread an entry of the frame's active list,
- * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due
- * when a want waits on it:
- * - it is NEW, in the first pass, which lists them first: it has had no update;
- * - in the second pass, it is ALIVE or DEAD, a pixel or a hit wanted it since its last update, its
- *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe is due every
- *   period like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a solid
- *   notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
+ * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due:
+ * - in the first pass, which lists them first, when it is NEW: it has had no update;
+ * - in the second pass, when it is ALIVE or DEAD and `(frame + h(slot)) mod P` is 0, where P is
+ *   - T when a want waits on it: a pixel or a hit wanted it since its last update, its wanted time past
+ *     its traced time;
+ *   - T · `idle_periods` when it is idle, none waiting on it. Every live probe keeps being updated, so one
+ *     that readers reach without wanting it, the bounce at a hit among them, and one a want comes back to,
+ *     holds light no older than that. Its update is any other probe's.
+ *
+ *   A DEAD probe is due like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a
+ *   solid notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
  *
  * Wanted since its last update, not this frame: a hit wants a probe the frame after its own probe's
  * update, so a probe that only hits keep is wanted on few of its turns. Measured on Sponza with the
@@ -58,8 +64,8 @@ resources.createGroup()
  * waits on nothing: the update comes after admit in its frame, so its traced time is the want's or later.
  *
  * The due go on the trace list, which holds the frame's updates, at most U: past it the count still
- * rises and nothing is written, and a probe not listed waits its next turn. With T = ⌈P_w / U⌉ over the
- * probes waiting, the expected count a frame is under U, so only NEW probes past U, a camera cut, wait.
+ * rises and nothing is written, and a probe not listed waits its next turn. Schedule's T keeps the
+ * expected count a frame under U, so only NEW probes past U, a camera cut, wait.
  *
  * @type {ComputeShader}
  */
@@ -87,13 +93,14 @@ fn main(
         // wanted since its last update
         let waiting = probe_records[slot].wanted_frame > probe_records[slot].traced_frame;
 
-        let period = max(probe_counters[PROBE_COUNTER_PERIOD], 1u);
+        // an idle probe's turn comes once in as many periods as the settings give
+        let period = max(probe_counters[PROBE_COUNTER_PERIOD], 1u) * select(max(settings.idle_periods, 1u), 1u, waiting);
         let turn = settings.frame + hash_lowbias32(slot);
 
         if (settings.new_only != 0u) {
             due = kind == PROBE_STATE_NEW;
         } else {
-            due = waiting && (kind == PROBE_STATE_ALIVE || kind == PROBE_STATE_DEAD) && turn % period == 0u;
+            due = (kind == PROBE_STATE_ALIVE || kind == PROBE_STATE_DEAD) && turn % period == 0u;
         }
     }
 

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

@@ -204,7 +204,7 @@ fn probe_clipmap_local_irradiance(cascade: u32, position: vec3<f32>, normal: vec
         return estimate;
     }
 
-    let shadow = brick_clipmap_trace(lifted, to_light / span, 0.0, reach, settings.brick_cascade_count);
+    let shadow = brick_clipmap_trace(lifted, to_light / span, 0.0, reach, settings.brick_cascade_count, settings.brick_atlas_shift);
 
     return select(vec3<f32>(0.0), estimate, shadow.kind == BRICK_TRACE_MISS);
 }

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

@@ -6,9 +6,10 @@ export const PROBE_PROJECT_SETTINGS: WebGPUStruct;
  * Projection, rows (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a row of each listed probe's
  * radiance map, dispatched through `PROBE_DISPATCH_ROWS`. It sums the row's texels, new and kept, as
  * RGB radiance SH3, `L·Y(ω)·dω` over each texel's solid angle, so that `sh3_color_get_irradiance_at` gives
- * E; the row's rays this update, resolved and back faces; and how far the update's
- * samples fell from their means, with that sum's variance. One row of the probe's projection each, which
- * the probe's pass sums.
+ * E; the row's rays this update, resolved and back faces; and the row's part of L0 as the texels'
+ * estimators hold it, each texel by its solid angle: their short means less their means, their deviations
+ * squared (by the solid angle squared) and their short means, luminance. One row of the probe's projection
+ * each, which the probe's pass sums.
  *
  * @type {ComputeShader}
  */
@@ -25,21 +26,20 @@ export const shader_probe_clipmap_project_rows: ComputeShader;
  * radiance is nothing, so their share would read a probe inside a solid as alive. Such an update keeps
  * the probe's kind and its back-face share.
  *
- * **The probe's ray request** (§8.6): the rays its next guided update asks for, in `probe_requests`.
- * - After a probe's first update, the most: Enshrouded's new probe that asks for all it can have.
- * - When its light has moved, the most again. The update's change score sums its blended texels' falls
- *   from their means, luminance, each in its own deviation and held to `PROBE_CHANGE_SIGNIFICANCE` by
- *   accumulation, over the root of their count. A test texel by texel sees no change under a one-ray
- *   texel's own noise (measured: the estimator's inconsistency barely moves on a doubling); a sum of the
- *   falls unbounded is one bright sample's.
- * - The score is held to the probe's own: moved means past `PROBE_CHANGE_SIGNIFICANCE` of its running
- *   deviation, at least one, from its running mean, both over the estimator's variance window,
- *   `PROBE_VARIANCE_BLEND` an update however long since the last. A probe whose means sit off its samples
- *   (the estimator's own bias on texels lit by few rays) scores steadily off zero.
- * - Measured, Sponza on the 4090, the camera and the light still, 3,600 frames settled: of the probes
- *   past 64 updates, 4.2% asked for the most against a sum of the raw falls held to zero, 3.2% with each
- *   texel's fall bounded, and 1.1–1.3% held to their own statistics.
- * - Otherwise half what it asked for last, down to the fewest: a converged probe sips.
+ * **The probe's L0 estimator** (§8.6, §8.8): a multi-scale mean estimator (`chunk_multiscale_mean`) over the
+ * probe's whole light, L0, the solid-angle-weighted sum of its radiance texels. Its short and long means are
+ * L0 of the texels' short and long means, and its deviation the root of their deviations' sum, each by its
+ * solid angle squared, as the rows sum them; its inconsistency and blend reduction are the probe's own, in
+ * `probe_requests`. Its catch-up, the published estimator's, decides what the probe's next update takes:
+ * - **Blend**: every texel's long mean blends by at least the catch-up (`shader_probe_clipmap_accumulate`).
+ *   A one-ray texel's own test sees no change under its own noise; L0 pools every texel's evidence, so a
+ *   change in the probe's whole light, brighter or darker, is found where no texel can find it.
+ * - **Rays**: the next guided update asks for half what the last asked for, raised toward the most by the
+ *   catch-up, and never under the fewest: a probe whose light moved asks for more, a steady one sips.
+ * - After a probe's first update the most rays, a blend of nothing and the estimator seeded as a texel's is,
+ *   an inconsistency of one and no blend reduction: its slot's last owner's state is not its own.
+ * - An update whose texels hold no spread, L0's deviation nothing, leaves the estimator as it was and halves
+ *   the rays.
  *
  * @type {ComputeShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH,qCAFU,YAAY,CAmBK;AAW3B;;;;;;;;;GASG;AACH,gDAFU,aAAa,CAsDpB;AAcH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,2CAFU,aAAa,CA8FpB;6BA3P0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.js"],"names":[],"mappings":"AAgCA;;GAEG;AACH,qCAFU,YAAY,CAmBK;AAW3B;;;;;;;;;;GAUG;AACH,gDAFU,aAAa,CAyDpB;AAcH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2CAFU,aAAa,CA0FpB;6BArP0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -1,3 +1,5 @@
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_multiscale_mean } from "../../../shader/chunk/filter/chunk_multiscale_mean.js";
 import {
     chunk_octahedral_solid_angle
 } from "../../../shader/chunk/geometry/octahedron/chunk_octahedral_solid_angle.js";
@@ -26,12 +28,7 @@ import {
     PROBE_STATES_STORE_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import {
-    PROBE_CHANGE_SIGNIFICANCE,
-    PROBE_RADIANCE_SAMPLES_LIMIT,
-    PROBE_THREAD_WORKGROUP_SIZE,
-    PROBE_VARIANCE_BLEND
-} from "./PROBE_CLIPMAP.js";
+import { PROBE_SHORT_BLEND, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 
 /**
  * @type {WebGPUStruct}
@@ -68,9 +65,10 @@ row_resources.createGroup()
  * Projection, rows (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a row of each listed probe's
  * radiance map, dispatched through `PROBE_DISPATCH_ROWS`. It sums the row's texels, new and kept, as
  * RGB radiance SH3, `L·Y(ω)·dω` over each texel's solid angle, so that `sh3_color_get_irradiance_at` gives
- * E; the row's rays this update, resolved and back faces; and how far the update's
- * samples fell from their means, with that sum's variance. One row of the probe's projection each, which
- * the probe's pass sums.
+ * E; the row's rays this update, resolved and back faces; and the row's part of L0 as the texels'
+ * estimators hold it, each texel by its solid angle: their short means less their means, their deviations
+ * squared (by the solid angle squared) and their short means, luminance. One row of the probe's projection
+ * each, which the probe's pass sums.
  *
  * @type {ComputeShader}
  */
@@ -106,13 +104,15 @@ fn main(
         let uv = (vec2<f32>(f32(x), f32(row)) + 0.5) * inverse;
         let solid_angle = octahedral_solid_angle(uv, inverse);
         let rays = probe_maps[maps + 2u * texels + i];
-        let change = unpack2x16float(probe_maps[maps + 3u * texels + settings.depth_resolution * settings.depth_resolution + i]);
+        // the texel's estimator: its short mean less its mean, and its deviation, luminance
+        let state = unpack2x16float(probe_maps[maps + 3u * texels + settings.depth_resolution * settings.depth_resolution + i]);
 
         sh3_color_accumulate(&row_sum.sh, light * solid_angle, sh3_basis_at(uv_octahedral_unit_decode(uv)));
         row_sum.resolved += rays & 0xFFFFu;
         row_sum.back_faces += rays >> 16u;
-        row_sum.change += change.x;
-        row_sum.blended += change.y;
+        row_sum.gap += state.x * solid_angle;
+        row_sum.variance += state.y * state.y * solid_angle * solid_angle;
+        row_sum.level += (rgb_to_luminance(light) + state.x) * solid_angle;
     }
 
     probe_projection[thread] = row_sum;
@@ -124,6 +124,7 @@ fn main(
             chunk_uv_octahedral_unit_decode,
             chunk_sh3_basis_at,
             chunk_sh3_color_accumulate,
+            chunk_rgb_to_luminance,
             PROBE_PROJECTION_ROW_STRUCT.declaration_chunk,
         ]),
 });
@@ -152,21 +153,20 @@ probe_resources.createGroup()
  * radiance is nothing, so their share would read a probe inside a solid as alive. Such an update keeps
  * the probe's kind and its back-face share.
  *
- * **The probe's ray request** (§8.6): the rays its next guided update asks for, in `probe_requests`.
- * - After a probe's first update, the most: Enshrouded's new probe that asks for all it can have.
- * - When its light has moved, the most again. The update's change score sums its blended texels' falls
- *   from their means, luminance, each in its own deviation and held to `PROBE_CHANGE_SIGNIFICANCE` by
- *   accumulation, over the root of their count. A test texel by texel sees no change under a one-ray
- *   texel's own noise (measured: the estimator's inconsistency barely moves on a doubling); a sum of the
- *   falls unbounded is one bright sample's.
- * - The score is held to the probe's own: moved means past `PROBE_CHANGE_SIGNIFICANCE` of its running
- *   deviation, at least one, from its running mean, both over the estimator's variance window,
- *   `PROBE_VARIANCE_BLEND` an update however long since the last. A probe whose means sit off its samples
- *   (the estimator's own bias on texels lit by few rays) scores steadily off zero.
- * - Measured, Sponza on the 4090, the camera and the light still, 3,600 frames settled: of the probes
- *   past 64 updates, 4.2% asked for the most against a sum of the raw falls held to zero, 3.2% with each
- *   texel's fall bounded, and 1.1–1.3% held to their own statistics.
- * - Otherwise half what it asked for last, down to the fewest: a converged probe sips.
+ * **The probe's L0 estimator** (§8.6, §8.8): a multi-scale mean estimator (`chunk_multiscale_mean`) over the
+ * probe's whole light, L0, the solid-angle-weighted sum of its radiance texels. Its short and long means are
+ * L0 of the texels' short and long means, and its deviation the root of their deviations' sum, each by its
+ * solid angle squared, as the rows sum them; its inconsistency and blend reduction are the probe's own, in
+ * `probe_requests`. Its catch-up, the published estimator's, decides what the probe's next update takes:
+ * - **Blend**: every texel's long mean blends by at least the catch-up (`shader_probe_clipmap_accumulate`).
+ *   A one-ray texel's own test sees no change under its own noise; L0 pools every texel's evidence, so a
+ *   change in the probe's whole light, brighter or darker, is found where no texel can find it.
+ * - **Rays**: the next guided update asks for half what the last asked for, raised toward the most by the
+ *   catch-up, and never under the fewest: a probe whose light moved asks for more, a steady one sips.
+ * - After a probe's first update the most rays, a blend of nothing and the estimator seeded as a texel's is,
+ *   an inconsistency of one and no blend reduction: its slot's last owner's state is not its own.
+ * - An update whose texels hold no spread, L0's deviation nothing, leaves the estimator as it was and halves
+ *   the rays.
  *
  * @type {ComputeShader}
  */
@@ -201,8 +201,9 @@ fn main(
 
         sum.resolved += part.resolved;
         sum.back_faces += part.back_faces;
-        sum.change += part.change;
-        sum.blended += part.blended;
+        sum.gap += part.gap;
+        sum.variance += part.variance;
+        sum.level += part.level;
     }
 
     let state = probe_states[slot].x;
@@ -227,28 +228,22 @@ fn main(
     probe_records[slot].sh = probe_record_sh_encode(sum.sh);
     probe_records[slot].traced_frame = settings.frame;
 
-    // the next guided update's rays: the most after the first update and whenever the light moved, else half
+    // the L0 estimator: the next update's blend and rays
     var request = probe_requests[slot];
 
     if (updates == 0u) {
-        // its slot's last owner's statistics are not its own
-        request = ${PROBE_REQUEST_STRUCT.make({ rays: "settings.rays_max", change_mean: "0.0", change_variance: "0.0", changes: "0u" })};
-    } else if (sum.blended > 0.0) {
-        let score = sum.change / sqrt(sum.blended);
-        let reach = ${PROBE_CHANGE_SIGNIFICANCE} * max(sqrt(request.change_variance), 1.0);
-        let moved = abs(score - request.change_mean) > reach;
-
-        // the score's running statistics, a running mean while young, then over the estimator's variance
-        // window; a score past their reach counts at it, so a change in the light does not become the probe's
-        // own spread, while a lasting shift of its own still does within a few windows
-        let held = clamp(score, request.change_mean - reach, request.change_mean + reach);
-        let blend = max(1.0 / f32(request.changes + 1u), ${PROBE_VARIANCE_BLEND});
-        let mean = mix(request.change_mean, held, blend);
-
-        request.change_variance = mix(request.change_variance, (held - request.change_mean) * (held - mean), blend);
-        request.change_mean = mean;
-        request.changes = min(request.changes + 1u, ${PROBE_RADIANCE_SAMPLES_LIMIT}u);
-        request.rays = select(max(settings.rays_min, request.rays >> 1u), settings.rays_max, moved);
+        // seeded: its slot's last owner's state is not its own
+        request = ${PROBE_REQUEST_STRUCT.make({ rays: "settings.rays_max", blend: "0.0", inconsistency: "1.0", reduction: "0.0" })};
+    } else if (sum.variance > 0.0) {
+        let deviation = sqrt(sum.variance);
+        let relative = abs(sum.gap) / deviation;
+        let inconsistency = mix(request.inconsistency, relative, ${PROBE_SHORT_BLEND});
+        let blend = saturate(multiscale_mean_catch_up(relative, inconsistency, request.reduction));
+
+        request.reduction = mix(request.reduction, multiscale_mean_blend_reduction(sum.level / deviation), MULTISCALE_MEAN_REDUCTION_BLEND);
+        request.inconsistency = inconsistency;
+        request.blend = blend;
+        request.rays = max(settings.rays_min, u32(round(mix(f32(request.rays >> 1u), f32(settings.rays_max), blend))));
     } else {
         request.rays = max(settings.rays_min, request.rays >> 1u);
     }
@@ -259,6 +254,7 @@ fn main(
             chunk_probe_clipmap,
             chunk_probe_clipmap_guide,
             chunk_folded_workgroup_index,
+            chunk_multiscale_mean,
             PROBE_PROJECTION_ROW_STRUCT.declaration_chunk,
             PROBE_REQUEST_STRUCT.declaration_chunk,
         ]),

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_relocate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_relocate.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,sCAFU,YAAY,CAOM;AAkB5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,aAAa,CAyDpB;6BAzH0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_relocate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_relocate.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,sCAFU,YAAY,CASM;AAkB5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,aAAa,CAyDpB;6BA3H0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -31,6 +31,8 @@ export const PROBE_RELOCATE_SETTINGS = WebGPUStruct.from({
     trace_capacity: u32,
     /** the brick clipmap's cascades, what its field is read through */
     brick_cascade_count: u32,
+    /** the brick atlas's footprint as shifts, `GPUBrickClipmap#atlas_shift` */
+    brick_atlas_shift: u32,
 }, "ProbeRelocateSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -97,13 +99,13 @@ fn main(
     var position = lattice;
 
     for (var step = 0u; step < ${PROBE_RELOCATION_STEPS}u; step++) {
-        let distance = brick_clipmap_distance(position, settings.brick_cascade_count);
+        let distance = brick_clipmap_distance(position, settings.brick_cascade_count, settings.brick_atlas_shift);
 
         if (distance >= clearance) {
             break;
         }
 
-        let gradient = brick_clipmap_gradient(position, settings.brick_cascade_count);
+        let gradient = brick_clipmap_gradient(position, settings.brick_cascade_count, settings.brick_atlas_shift);
 
         if (all(gradient == vec3<f32>(0.0))) {
             break;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_retire.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_retire.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,oCAFU,YAAY,CASI;AAiB1B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0CAFU,aAAa,CAsFpB;6BAxJ0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_retire.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_retire.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,oCAFU,YAAY,CASI;AAiB1B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0CAFU,aAAa,CAqFpB;6BAvJ0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -120,10 +120,9 @@ fn main(
 
         // the oldest buckets whole, and as many of the one below them as are asked for; one that left its
         // window goes anyway and takes none of those
-        let whole = PROBE_AGE_BUCKETS - min(probe_eviction.buckets, PROBE_AGE_BUCKETS);
-        var evicted = evictable && counted >= whole;
+        var evicted = evictable && age_eviction_whole(counted, probe_eviction.buckets);
 
-        if (held && evictable && counted + 1u == whole && probe_eviction.remaining > 0u) {
+        if (held && evictable && age_eviction_partial(counted, probe_eviction.buckets) && probe_eviction.remaining > 0u) {
             evicted = atomicAdd(&probe_counters[PROBE_COUNTER_EVICTED], 1u) < probe_eviction.remaining;
         }
 

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

@@ -6,9 +6,11 @@ export const PROBE_SCHEDULE_SETTINGS: WebGPUStruct;
  * Schedule (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.5): one thread, after admit, when the frame's
  * active list is whole.
  * - The period: with P_w the probes waiting for an update, the NEW and those wanted since their last
- *   update, `T = max(1, ⌈P_w / U⌉)` frames, so that every probe a want waits on is updated within a period
- *   and the period follows the live count. Retire and admit counted them in
- *   `probe_counters[PROBE_COUNTER_WAITING]`, which it empties for the next frame's; the period goes to
+ *   update, P_i the idle, every other live probe, and m `idle_periods`,
+ *   `T = max(1, ⌈(P_w + P_i / m) / U⌉)` frames. Every probe a want waits on is updated within a period and
+ *   every idle one within m of them, a frame's updates U at most on average, and the period follows the
+ *   live count. Retire and admit counted the waiting in `probe_counters[PROBE_COUNTER_WAITING]`, which it
+ *   empties for the next frame's; the idle are the rest of the frame's active list. The period goes to
  *   `probe_counters[PROBE_COUNTER_PERIOD]` for the due passes.
  * - The next frame's eviction, `probe_eviction`: as many slots as the free ones fall short of the frame's
  *   wanted points and the slack, the probes wanted longest ago first. Walking retire's age buckets from the

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_schedule.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_schedule.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,sCAFU,YAAY,CAWM;AAa5B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4CAFU,aAAa,CA8DpB;6BAzH0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_schedule.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_schedule.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,sCAFU,YAAY,CAaM;AAa5B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAFU,aAAa,CA2CpB;6BA1G0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -26,6 +26,8 @@ export const PROBE_SCHEDULE_SETTINGS = WebGPUStruct.from({
     trace_capacity: u32,
     /** slots kept free beyond the frame's wanted points, ⌈capacity · PROBE_FREE_SLACK⌉ */
     slack: u32,
+    /** idle probes the period counts as one waiting, `probe_clipmap_idle_periods`, at least 1 */
+    idle_periods: u32,
 }, "ProbeScheduleSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -43,9 +45,11 @@ resources.createGroup()
  * Schedule (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.5): one thread, after admit, when the frame's
  * active list is whole.
  * - The period: with P_w the probes waiting for an update, the NEW and those wanted since their last
- *   update, `T = max(1, ⌈P_w / U⌉)` frames, so that every probe a want waits on is updated within a period
- *   and the period follows the live count. Retire and admit counted them in
- *   `probe_counters[PROBE_COUNTER_WAITING]`, which it empties for the next frame's; the period goes to
+ *   update, P_i the idle, every other live probe, and m `idle_periods`,
+ *   `T = max(1, ⌈(P_w + P_i / m) / U⌉)` frames. Every probe a want waits on is updated within a period and
+ *   every idle one within m of them, a frame's updates U at most on average, and the period follows the
+ *   live count. Retire and admit counted the waiting in `probe_counters[PROBE_COUNTER_WAITING]`, which it
+ *   empties for the next frame's; the idle are the rest of the frame's active list. The period goes to
  *   `probe_counters[PROBE_COUNTER_PERIOD]` for the due passes.
  * - The next frame's eviction, `probe_eviction`: as many slots as the free ones fall short of the frame's
  *   wanted points and the slack, the probes wanted longest ago first. Walking retire's age buckets from the
@@ -73,47 +77,28 @@ export const shader_probe_clipmap_schedule = ComputeShader.from({
         `
 @compute @workgroup_size(1)
 fn main() {
+    let live = min(probe_active_write.count, settings.capacity);
     let waiting = atomicLoad(&probe_counters[PROBE_COUNTER_WAITING]);
+    let idle = live - min(waiting, live);
+    let idle_periods = max(settings.idle_periods, 1u);
     let traced = max(settings.trace_capacity, 1u);
 
     atomicStore(&probe_counters[PROBE_COUNTER_WAITING], 0u);
-    atomicStore(&probe_counters[PROBE_COUNTER_PERIOD], max(divide_round_up_u32(waiting, traced), 1u));
+    // ⌈(P_w + P_i / m) / U⌉ in whole numbers
+    atomicStore(&probe_counters[PROBE_COUNTER_PERIOD], max(divide_round_up_u32(waiting * idle_periods + idle, traced * idle_periods), 1u));
 
     // the slots short of the frame's wanted points and the slack
     let wanted = min(probe_wanted.count, settings.wanted_capacity);
     let room = wanted + settings.slack;
     let free = atomicLoad(&probe_counters[PROBE_COUNTER_FREE]);
 
-    var lacking = select(0u, room - free, room > free);
-    var buckets = 0u;
-    var remaining = 0u;
-
-    for (var k = 0u; k < PROBE_AGE_BUCKETS; k++) {
-        let at = PROBE_COUNTER_AGES + PROBE_AGE_BUCKETS - 1u - k;
-        let aged = atomicLoad(&probe_counters[at]);
-
-        atomicStore(&probe_counters[at], 0u);
+    let plan = age_eviction_plan(&probe_counters, PROBE_COUNTER_AGES, select(0u, room - free, room > free));
 
-        // a bucket nothing was counted in is taken only for an older one: what ages into a bucket below every
-        // probe counted is not asked for
-        if (lacking > 0u && aged > 0u) {
-            if (aged <= lacking) {
-                lacking -= aged;
-                buckets = k + 1u;
-            } else {
-                buckets = k;
-                remaining = lacking;
-                lacking = 0u;
-            }
-        }
-    }
-
-    probe_eviction.buckets = buckets;
-    probe_eviction.remaining = remaining;
+    probe_eviction.buckets = plan.x;
+    probe_eviction.remaining = plan.y;
 
     atomicStore(&probe_counters[PROBE_COUNTER_EVICTED], 0u);
 
-    let live = min(probe_active_write.count, settings.capacity);
     let folded = folded_dispatch(divide_round_up_u32(live, PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_ACTIVE] = folded.x;

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

@@ -110,7 +110,7 @@ fn main(
         let cascade = (record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK;
 
         let draw = hash_to_float01(pcg4d(vec4<u32>(probe_trace.elements[k], record.direction, 0x510E527Fu, 0u)).x);
-        let surface = probe_clipmap_hit_material_pick(position, normal, cascade, draw);
+        let surface = probe_clipmap_hit_material_pick(position, normal, cascade, draw, settings.brick_atlas_shift);
         let direct = rgbe9995_decode(record.light);
 
         radiance = surface.emissive + surface.albedo * direct * RECIPROCAL_PI;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAkDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAuJpB;6BAvP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAkDA;;GAEG;AACH,mCAFU,YAAY,CAiBG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAuJpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -64,6 +64,8 @@ export const PROBE_TRACE_SETTINGS = WebGPUStruct.from({
     t_max: f32,
     /** updates between a probe's uniform ones, `PROBE_UNIFORM_PERIOD` */
     uniform_period: u32,
+    /** the brick atlas's footprint as shifts, `GPUBrickClipmap#atlas_shift` */
+    brick_atlas_shift: u32,
 }, "ProbeTraceSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -198,7 +200,7 @@ fn main(
     let start = brick_clipmap_start(origin, cascade_count);
     let t_min = brick_levels[min(start, cascade_count - 1u)].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
 
-    let hit = brick_clipmap_trace(origin, direction, t_min, settings.t_max, cascade_count);
+    let hit = brick_clipmap_trace(origin, direction, t_min, settings.t_max, cascade_count, settings.brick_atlas_shift);
 
     let is_hit = hit.kind == BRICK_TRACE_HIT;
     let back_face = is_hit && dot(hit.normal, direction) > 0.0;
@@ -229,7 +231,7 @@ fn main(
                     // a point of the disk of its own for each light, apart from the origin's draw
                     let hash = pcg3d(vec3<u32>(slot, packed, 0x3C6EF372u + shadowed));
                     let toward = cone_sample_direction(-light.direction, light.disk_radius, vec2<f32>(hash_to_float01(hash.x), hash_to_float01(hash.y)));
-                    let shadow = brick_clipmap_trace(lifted, toward, 0.0, settings.t_max, cascade_count);
+                    let shadow = brick_clipmap_trace(lifted, toward, 0.0, settings.t_max, cascade_count, settings.brick_atlas_shift);
 
                     visible = select(0.0, 1.0, shadow.kind == BRICK_TRACE_MISS);
                 }

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

@@ -2,6 +2,11 @@
  * @type {WebGPUStruct}
  */
 export const PROBE_WANT_SETTINGS: WebGPUStruct;
+/**
+ * {@link PROBE_WANT_SETTINGS} and how the surface's normals are read.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_WANT_SURFACE_SETTINGS: WebGPUStruct;
 /**
  * Want (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): a thread a tile of {@link PROBE_WANT_TILE}² pixels,
  * the launch the screen's tiles.
@@ -10,6 +15,12 @@ export const PROBE_WANT_SETTINGS: WebGPUStruct;
  * that pixel's pick reads (§9.1), biased along `mix(n, v, 0.2)`, through `probe_clipmap_want`. A sky
  * pixel wants nothing.
  *
+ * The surface is any the frame holds a depth and a normal of, a pixel each: the G-buffer's, or one drawn
+ * apart from it whose reader picks its probes per pixel, the water's interface. `gBufferDepth` is its
+ * reverse-Z depth, zero where it has no surface; `gBufferNormals` its normals, octahedral in the channel
+ * `settings.normal_channel`, as the G-buffer packs its own in its first. Where `settings.two_sided` is set,
+ * a normal that faces away from the eye is turned to face it, as a reader of such a surface turns it.
+ *
  * At a cascade's outer edge a lattice cell is 58 pixels on a 1080p screen at a 60° field of view, and
  * 19 at 120°, so a tile of 8 samples every cell several times a frame, and a workgroup's 64 tiles want
  * a few cages between them, which its claims keep to one want each.

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAcE;AAexB;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CAqCpB;6BA1F0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAcE;AAExB;;;GAGG;AACH,0CAFU,YAAY,CAaS;AAe/B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,aAAa,CAyCpB;6BArH0B,sCAAsC;8BAHrC,kCAAkC"}