@woosh/meep-engine 3.64.0 → 3.64.1

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":"AA+CA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAsB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,8CAFU,aAAa,CA2TpB;6BAvb0B,sCAAsC;8BAJrC,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":"AA+CA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAwB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,8CAFU,aAAa,CAgUpB;6BAlc0B,sCAAsC;8BAJrC,kCAAkC"}

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

@@ -29,6 +29,7 @@ import {
     PROBE_RAY_STRUCT,
     PROBE_RAY_SUMS_READ_RESOURCE,
     PROBE_RAYS_READ_RESOURCE,
+    PROBE_REQUESTS_READ_RESOURCE,
     PROBE_RESAMPLES_READ_RESOURCE,
     PROBE_STATES_READ_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
@@ -36,7 +37,6 @@ import {
 import { chunk_probe_clipmap_resampled } from "./chunk_probe_clipmap_resampled.js";
 import {
     PROBE_BACK_FACE_DEPTH,
-    PROBE_CHANGE_SIGNIFICANCE,
     PROBE_DEPTH_LIMIT,
     PROBE_DEPTH_TEXEL_RAYS,
     PROBE_RADIANCE_SAMPLES_LIMIT,
@@ -82,6 +82,8 @@ resources.createGroup()
     .add(PROBE_RADIANCE_HISTORY_RESOURCE)
     .add(PROBE_DEPTH_HISTORY_RESOURCE)
     .add(PROBE_ESTIMATORS_RESOURCE)
+    // the probes' L0 blends, as their last projection left them
+    .add(PROBE_REQUESTS_READ_RESOURCE)
     // read only where the frame re-samples (chunk_probe_clipmap_resampled)
     .add(PROBE_RESAMPLES_READ_RESOURCE)
     // the factor the display multiplies radiance by ahead of its tone curve, as the last frame was shown
@@ -94,9 +96,9 @@ resources.createGroup()
  * `probe_maps` (`probe_clipmap_maps_words`): two words a radiance texel, rgba as half floats; then a
  * word a radiance texel, its rays this update, resolved in the low half and back faces in the high,
  * which classification sums; then a word a depth texel, its moments as half floats; then a word a
- * radiance texel, how far its sample fell from its mean in its own deviation, luminance, held to
- * `PROBE_CHANGE_SIGNIFICANCE`, and one for its blending one, as half floats, which the probe's ray request
- * sums (zero where no sample was blended).
+ * radiance texel, its estimator after the update as the probe's L0 estimator sums it
+ * (`shader_probe_clipmap_project`): its short mean less its mean and its deviation (the estimator's own,
+ * floored at the display's exposure), luminance, as half floats; nothing for a texel no ray has reached.
  *
  * - **A texel's rays**: on a uniform update (`PROBE_UNIFORM_PERIOD`), `probe_clipmap_texel_ray`'s. On a
  *   guided one, the run that begins at its walk position in the probe's guide, at most
@@ -114,6 +116,10 @@ resources.createGroup()
  *   - 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.
+ *   - And by at least the probe's L0 blend (`PROBE_REQUEST_STRUCT`'s `blend`), its L0 estimator's catch-up
+ *     after its last update: a change in the probe's whole light, which the texels' own tests, a one-ray
+ *     sample's noise apiece, do not see. The texel's own catch-up stays, for light that moves without
+ *     changing L0.
  *   - Samples are clipped once the variance's window has passed, when 1/(a+1) is no longer its blend:
  *     before that it holds no spread to clip to.
  *   - A texel's first sample seeds both means. A texel no ray reached keeps its history.
@@ -268,34 +274,29 @@ fn main(
         let tile = index_to_grid2d(slot, settings.radiance_tiles_per_row) * (n + 2u * settings.radiance_skirt) + settings.radiance_skirt;
         let history = select(textureLoad(probe_radiance, tile + vec2<u32>(i % n, i / n), 0), vec4<f32>(0.0), updates == 0u);
 
+        let estimator = slot * texels + i;
+
         var texel = history;
-        // how far the sample fell from the texel's mean in its own deviation, luminance, and that it blended
-        // one: the probe's ray request reads their sums. A texel's part is held to PROBE_CHANGE_SIGNIFICANCE,
-        // so that one bright sample is one texel's at most
-        var change = vec2<f32>(0.0);
+        // the texel's estimator, its history's until a sample is blended
+        var e = probe_accumulate_estimator(history.rgb, probe_estimators[estimator]);
 
         if (count > 0u) {
             // the rays, and the neighbours' re-samples where the frame took them
             let pooled = probe_clipmap_resampled(k * texels + i, sum, count);
             let sample = pooled.rgb / pooled.w;
-            let estimator = slot * texels + i;
+            let before = e;
 
-            var e = multiscale_mean_seed(sample);
+            e = multiscale_mean_seed(sample);
 
             if (history.a > 0.0) {
                 let ramp = 1.0 / (history.a + 1.0);
-                let before = probe_accumulate_estimator(history.rgb, probe_estimators[estimator]);
-                // the estimator's own floor on the deviation, at the display's exposure
-                let deviation = rgb_to_luminance(max(multiscale_mean_deviation_floor(before.short_mean, probe_exposure.value), sqrt(max(vec3<f32>(0.0), before.variance))));
-
-                change = vec2<f32>(clamp(rgb_to_luminance(sample - history.rgb) / deviation, -${PROBE_CHANGE_SIGNIFICANCE}.0, ${PROBE_CHANGE_SIGNIFICANCE}.0), 1.0);
 
                 e = multiscale_mean_add(
                     before,
                     sample,
                     max(ramp, ${PROBE_SHORT_BLEND}),
                     max(ramp, ${PROBE_VARIANCE_BLEND}),
-                    select(0.0, ramp, history.a < ${PROBE_RADIANCE_SAMPLES_LIMIT}.0),
+                    max(select(0.0, ramp, history.a < ${PROBE_RADIANCE_SAMPLES_LIMIT}.0), probe_requests[slot].blend),
                     ramp <= ${PROBE_VARIANCE_BLEND},
                     probe_exposure.value,
                 );
@@ -306,13 +307,23 @@ fn main(
             probe_estimators[estimator] = probe_accumulate_estimator_words(e, slot, per_probe + 2u * i, updates);
         }
 
+        // the estimator as the probe's L0 estimator sums it, its deviation floored at the display's exposure as
+        // the estimator's own; nothing for a texel no ray has reached
+        var state = vec2<f32>(0.0);
+
+        if (texel.a > 0.0) {
+            let deviation = max(multiscale_mean_deviation_floor(e.short_mean, probe_exposure.value), sqrt(max(vec3<f32>(0.0), e.variance)));
+
+            state = vec2<f32>(rgb_to_luminance(e.short_mean - e.mean), rgb_to_luminance(deviation));
+        }
+
         // the count is whole, which any noise keeps
         let stored = f16_round_stochastic(texel, vec4<f32>(probe_accumulate_store_noise(slot, i, updates), 0.0));
 
         probe_maps[maps + 2u * i] = pack2x16float(stored.rg);
         probe_maps[maps + 2u * i + 1u] = pack2x16float(stored.ba);
         probe_maps[maps + 2u * texels + i] = count | (back_faces << 16u);
-        probe_maps[maps + 3u * texels + m * m + i] = pack2x16float(change);
+        probe_maps[maps + 3u * texels + m * m + i] = pack2x16float(state);
 
         return;
     }

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/shader/chunk/filter/chunk_multiscale_mean.d.ts

@@ -8,8 +8,16 @@
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
  * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
  * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
+ * fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32
+ * fn multiscale_mean_blend_reduction(level: f32) -> f32
+ * const MULTISCALE_MEAN_REDUCTION_BLEND: f32
  * ```
  *
+ * `multiscale_mean_catch_up` and `multiscale_mean_blend_reduction` are the long mean's decision alone, for an
+ * estimator over a quantity the caller keeps the means of itself: `relative` the means' gap over the deviation,
+ * `inconsistency` its smoothed history, `reduction` the blend reduction as it stood before this sample, and `level`
+ * the short mean over the deviation. The reduction follows `level`'s by `MULTISCALE_MEAN_REDUCTION_BLEND` a sample.
+ *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
  * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,oCAFU,SAAS,CAuDZ;0BAhHmB,6BAA6B"}
+{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,oCAFU,SAAS,CAiEZ;0BAlImB,6BAA6B"}

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js

@@ -16,8 +16,16 @@ const EXPOSURE_MAX = '1.70141183e38';
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
  * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
  * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
+ * fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32
+ * fn multiscale_mean_blend_reduction(level: f32) -> f32
+ * const MULTISCALE_MEAN_REDUCTION_BLEND: f32
  * ```
  *
+ * `multiscale_mean_catch_up` and `multiscale_mean_blend_reduction` are the long mean's decision alone, for an
+ * estimator over a quantity the caller keeps the means of itself: `relative` the means' gap over the deviation,
+ * `inconsistency` its smoothed history, `reduction` the blend reduction as it stood before this sample, and `level`
+ * the short mean over the deviation. The reduction follows `level`'s by `MULTISCALE_MEAN_REDUCTION_BLEND` a sample.
+ *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
  * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's
@@ -79,6 +87,16 @@ fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f {
     return max(vec3f(sqrt(1e-5) / multiscale_mean_exposure(exposure)), max(abs(short_mean) * exp2(-10.0), vec3f(exp2(-24.0))));
 }
 
+const MULTISCALE_MEAN_REDUCTION_BLEND: f32 = 0.1;
+
+fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32 {
+    return clamp(smoothstep(0.0, 1.0, relative * max(0.02, inconsistency - 0.2)), 1.0 / 256.0, 1.0) * reduction;
+}
+
+fn multiscale_mean_blend_reduction(level: f32) -> f32 {
+    return clamp(0.5 * level, 1.0 / 32.0, 1.0);
+}
+
 fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
     var y = sample;
 
@@ -95,15 +113,15 @@ fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, sho
 
     let relative = rgb_to_luminance(abs(e.mean - short_mean) / deviation);
     let inconsistency = mix(e.inconsistency, relative, short_blend);
-    let reduction = clamp(rgb_to_luminance(0.5 * short_mean / deviation), 1.0 / 32.0, 1.0);
+    let reduction = multiscale_mean_blend_reduction(rgb_to_luminance(short_mean / deviation));
 
-    let catch_up = clamp(smoothstep(0.0, 1.0, relative * max(0.02, inconsistency - 0.2)), 1.0 / 256.0, 1.0) * e.reduction;
+    let catch_up = multiscale_mean_catch_up(relative, inconsistency, e.reduction);
 
     return ${MULTISCALE_MEAN_STRUCT.make({
         mean: 'mix(e.mean, y, max(saturate(catch_up), mean_blend_min))',
         short_mean: 'short_mean',
         variance: 'variance',
-        reduction: 'mix(e.reduction, reduction, 0.1)',
+        reduction: 'mix(e.reduction, reduction, MULTISCALE_MEAN_REDUCTION_BLEND)',
         inconsistency: 'inconsistency',
     })};
 }