@woosh/meep-engine 3.63.3 → 3.64.1

package/src/shade/renderer/deferred/tonemap/shader_tonemap_lut_bake.js

@@ -0,0 +1,92 @@
+import { assert } from "../../../../core/assert.js";
+import { ANIMATION_CURVE_KEYFRAME_STRUCT } from "../../animation/ANIMATION_CURVE_KEYFRAME_STRUCT.js";
+import { chunk_color_grade } from "../../shader/chunk/color/grade/chunk_color_grade.js";
+import { chunk_tonemap_lut } from "../../shader/chunk/color/tonemap/chunk_tonemap_lut.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { COLOR_GRADE_STRUCT } from "./ColorGrade.js";
+
+/**
+ * Immediate data of a bake: the peak the operator is evaluated for, `PAPER_WHITE_NITS` for an SDR LUT.
+ */
+export const TONEMAP_LUT_BAKE_SETTINGS = WebGPUStruct.from({ peak_nits: f32 });
+
+/**
+ * Edge of the cube of LUT texels one workgroup bakes.
+ */
+export const TONEMAP_LUT_BAKE_GROUP = 4;
+
+/**
+ * @type {WeakMap<ToneMapOperator, ComputeShader>}
+ */
+const shaders = new WeakMap();
+
+/**
+ * The compute shader that bakes `operator` into a LUT, `lut`, one texel a thread: the texel's PQ signal decoded to
+ * exposed scene colour, through the colour grade and the operator, and encoded again, as {@link chunk_tonemap_lut}
+ * describes. The grade is `grade`, a {@link COLOR_GRADE_STRUCT}, and `grade_keys`, its curves' keyframes; see
+ * `ColorGrade#pack`. Built on first use and kept for the operator.
+ *
+ * Dispatch `ceil(resolution / TONEMAP_LUT_BAKE_GROUP)` workgroups along each axis.
+ *
+ * @param {ToneMapOperator} operator
+ * @returns {ComputeShader}
+ */
+export function shader_tonemap_lut_bake(operator) {
+    assert.defined(operator, 'operator');
+
+    let shader = shaders.get(operator);
+
+    if (shader !== undefined) {
+        return shader;
+    }
+
+    const resources = new ShaderResourceSetDescriptor();
+
+    resources.setImmediate("settings", TONEMAP_LUT_BAKE_SETTINGS);
+
+    const group = resources.createGroup()
+        .addStorageTexture("lut", "rgba16float", "3d", "write-only")
+        .addUniform("grade", COLOR_GRADE_STRUCT)
+        .addStorageBuffer("grade_keys", WebGPUArray.from(ANIMATION_CURVE_KEYFRAME_STRUCT));
+
+    operator.declare(group);
+
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP})
+fn main(@builtin(global_invocation_id) texel: vec3<u32>) {
+    let size = textureDimensions(lut);
+
+    if (any(texel >= size)) {
+        return;
+    }
+
+    let scene = tonemap_lut_pq_decode(vec3<f32>(texel) / vec3<f32>(size - 1u));
+
+    let display = tone_map_operator(color_grade(scene, grade, &grade_keys), settings.peak_nits);
+
+    textureStore(lut, texel, vec4<f32>(tonemap_lut_pq_encode(display), 1.0));
+}
+        `, [
+            chunk_tonemap_lut,
+            chunk_color_grade,
+            operator.chunk,
+        ]
+    );
+
+    shader = ComputeShader.from({
+        label: `Tonemap/LUT bake/${operator.label}`,
+        body,
+        resources,
+    });
+
+    shaders.set(operator, shader);
+
+    return shader;
+}

package/src/shade/renderer/deferred/tonemap/shader_tonemap_lut_sdr_from_hdr.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Immediate data of {@link shader_tonemap_lut_sdr_from_hdr}: the peak the HDR LUT was graded for, cd/m².
+ */
+export const TONEMAP_LUT_SDR_FROM_HDR_SETTINGS: WebGPUStruct;
+/**
+ * An SDR LUT from an HDR one of the same resolution: each texel through the BT.2390 EETF, from the HDR LUT's graded
+ * peak down to the paper white. The EETF maps the brightest channel's signal and the three channels scale by the
+ * same ratio of light, so the hue holds and no channel passes SDR white. Below the EETF's knee a texel is unchanged.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_tonemap_lut_sdr_from_hdr: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_tonemap_lut_sdr_from_hdr.d.ts.map

package/src/shade/renderer/deferred/tonemap/shader_tonemap_lut_sdr_from_hdr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_lut_sdr_from_hdr.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_lut_sdr_from_hdr.js"],"names":[],"mappings":"AAUA;;GAEG;AACH,6DAA8F;AAgD9F;;;;;;GAMG;AACH,8CAFU,aAAa,CAMpB;6BAjE0B,mCAAmC;8BAHlC,+BAA+B"}

package/src/shade/renderer/deferred/tonemap/shader_tonemap_lut_sdr_from_hdr.js

@@ -0,0 +1,73 @@
+import { chunk_bt2390_eetf } from "../../shader/chunk/color/tonemap/chunk_bt2390_eetf.js";
+import { chunk_PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { chunk_tonemap_lut } from "../../shader/chunk/color/tonemap/chunk_tonemap_lut.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { TONEMAP_LUT_BAKE_GROUP } from "./shader_tonemap_lut_bake.js";
+
+/**
+ * Immediate data of {@link shader_tonemap_lut_sdr_from_hdr}: the peak the HDR LUT was graded for, cd/m².
+ */
+export const TONEMAP_LUT_SDR_FROM_HDR_SETTINGS = WebGPUStruct.from({ source_peak_nits: f32 });
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", TONEMAP_LUT_SDR_FROM_HDR_SETTINGS);
+resources.createGroup()
+    .addTexture("hdr_lut", "unfilterable-float", "3d")
+    .addStorageTexture("sdr_lut", "rgba16float", "3d", "write-only");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP})
+fn main(@builtin(global_invocation_id) texel: vec3<u32>) {
+    let size = textureDimensions(sdr_lut);
+
+    if (any(texel >= size)) {
+        return;
+    }
+
+    let signal = textureLoad(hdr_lut, texel, 0).rgb;
+
+    // the brightest channel's signal; the other two follow it by the same ratio of light, which keeps the hue
+    let brightest = max(signal.r, max(signal.g, signal.b));
+
+    let source_peak = tonemap_lut_pq_encode(vec3<f32>(settings.source_peak_nits / PAPER_WHITE_NITS)).x;
+    let target_peak = tonemap_lut_pq_encode(vec3<f32>(1.0)).x;
+
+    let mapped = bt2390_eetf(brightest, source_peak, target_peak);
+
+    let light = tonemap_lut_pq_decode(signal);
+    let before = tonemap_lut_pq_decode(vec3<f32>(brightest)).x;
+    let after = tonemap_lut_pq_decode(vec3<f32>(mapped)).x;
+
+    var scale = 1.0;
+    if (before > 0.0) {
+        scale = after / before;
+    }
+
+    textureStore(sdr_lut, texel, vec4<f32>(tonemap_lut_pq_encode(light * scale), 1.0));
+}
+    `, [
+        chunk_tonemap_lut,
+        chunk_bt2390_eetf,
+        chunk_PAPER_WHITE_NITS,
+    ]
+);
+
+/**
+ * An SDR LUT from an HDR one of the same resolution: each texel through the BT.2390 EETF, from the HDR LUT's graded
+ * peak down to the paper white. The EETF maps the brightest channel's signal and the three channels scale by the
+ * same ratio of light, so the hue holds and no channel passes SDR white. Below the EETF's knee a texel is unchanged.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_tonemap_lut_sdr_from_hdr = ComputeShader.from({
+    label: "Tonemap/LUT SDR from HDR",
+    body,
+    resources,
+});

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#286@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#289@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#286@#execute_fill"(record: object, _resources: any, context: {
+    static "__#289@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#286@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#289@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#288@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#291@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#289@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#292@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#292@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#289@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#289@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#289@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#289@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#292@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#292@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#292@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#292@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#285@#execute"(data: {
+    static "__#288@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#290@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#293@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts

@@ -34,7 +34,7 @@ export class GPUProbeClipmapGI {
      * @param {ProbeClipmapSettings} settings
      * @returns {boolean} whether it is what the settings' world cache describes, in their frustum's windows
      */
-    static "__#211@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
+    static "__#214@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
     /**
      * @param {GraphicsContext} graphics
      */

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

@@ -1,9 +1,8 @@
 /**
  * Words of a listed probe's maps, as accumulation writes them for projection and publish: two a
  * radiance texel, rgba as half floats; one a radiance texel, its rays this update, resolved and back
- * faces; one a depth texel, its moments as half floats; then one a radiance texel, how far its sample
- * fell from its mean in its own deviation and that it blended one, as half floats, which the probe's ray
- * request reads (`PROBE_CHANGE_SIGNIFICANCE`).
+ * faces; one a depth texel, its moments as half floats; then one a radiance texel, its estimator's short
+ * mean less its mean and its deviation, luminance, as half floats, which the probe's L0 estimator sums.
  *
  * @param {number} radiance_resolution n_r
  * @param {number} depth_resolution n_d
@@ -276,16 +275,6 @@ export const PROBE_DEAD_RAYS: number;
  * @type {number}
  */
 export const PROBE_RAYS_PER_TEXEL_MAX: number;
-/**
- * How far a probe's change score may go from its own running mean, in its own running deviation, before
- * the probe's light counts as moved (§8.6); and how far a texel's sample may fall from its mean, in its
- * own deviation, before it counts at that. The score sums the texels' falls over the root of their
- * count, each held to this, which the central limit makes near normal however a texel's own fall is
- * spread. A normal score passes it on all but 0.27% of updates; Sponza's probes past 64 updates, the light
- * still, asked for the most on 1.1–1.3% (measured, §8.6), each such update costing one at the most rays.
- * @type {number}
- */
-export const PROBE_CHANGE_SIGNIFICANCE: number;
 /**
  * Rays a guided update gives one radiance texel at most, the same gather budget as a depth texel's
  * ({@link PROBE_DEPTH_TEXEL_RAYS}). The guide holds each texel's weight down to it and spreads what it
@@ -366,8 +355,7 @@ export const PROBE_WANT_WORKGROUP_TILES: number;
  */
 export const PROBE_FILL_WORKGROUP_SIZE: number;
 /**
- * Lattice cells a cascade's blend skirt is deep: one cell of the coarser cascade, the distance over
- * which the spacing doubles (§8.1).
+ * Lattice cells a cascade's blend skirt is deep: two cells of the coarser cascade (§8.1).
  * @type {number}
  */
 export const PROBE_BLEND_SKIRT: number;

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

@@ -1 +1 @@
-{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}

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

@@ -291,9 +291,8 @@ export const PROBE_DEPTH_TEXEL_RAYS = 64;
 /**
  * Words of a listed probe's maps, as accumulation writes them for projection and publish: two a
  * radiance texel, rgba as half floats; one a radiance texel, its rays this update, resolved and back
- * faces; one a depth texel, its moments as half floats; then one a radiance texel, how far its sample
- * fell from its mean in its own deviation and that it blended one, as half floats, which the probe's ray
- * request reads (`PROBE_CHANGE_SIGNIFICANCE`).
+ * faces; one a depth texel, its moments as half floats; then one a radiance texel, its estimator's short
+ * mean less its mean and its deviation, luminance, as half floats, which the probe's L0 estimator sums.
  *
  * @param {number} radiance_resolution n_r
  * @param {number} depth_resolution n_d
@@ -337,17 +336,6 @@ export const PROBE_DEAD_RAYS = 16;
  */
 export const PROBE_RAYS_PER_TEXEL_MAX = 4;
 
-/**
- * How far a probe's change score may go from its own running mean, in its own running deviation, before
- * the probe's light counts as moved (§8.6); and how far a texel's sample may fall from its mean, in its
- * own deviation, before it counts at that. The score sums the texels' falls over the root of their
- * count, each held to this, which the central limit makes near normal however a texel's own fall is
- * spread. A normal score passes it on all but 0.27% of updates; Sponza's probes past 64 updates, the light
- * still, asked for the most on 1.1–1.3% (measured, §8.6), each such update costing one at the most rays.
- * @type {number}
- */
-export const PROBE_CHANGE_SIGNIFICANCE = 3;
-
 /**
  * Rays a guided update gives one radiance texel at most, the same gather budget as a depth texel's
  * ({@link PROBE_DEPTH_TEXEL_RAYS}). The guide holds each texel's weight down to it and spreads what it
@@ -469,11 +457,10 @@ export const PROBE_WANT_WORKGROUP_TILES = 8;
 export const PROBE_FILL_WORKGROUP_SIZE = 64;
 
 /**
- * Lattice cells a cascade's blend skirt is deep: one cell of the coarser cascade, the distance over
- * which the spacing doubles (§8.1).
+ * Lattice cells a cascade's blend skirt is deep: two cells of the coarser cascade (§8.1).
  * @type {number}
  */
-export const PROBE_BLEND_SKIRT = 2;
+export const PROBE_BLEND_SKIRT = 4;
 
 /**
  * The receiver bias's length, in lattice cells of the cascade picked (§9.1).

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

@@ -189,8 +189,8 @@ export const PROBE_RAY_SUMS_WRITE_RESOURCE: ShaderResourceDescriptor;
  */
 export const PROBE_RAY_SUMS_READ_RESOURCE: ShaderResourceDescriptor;
 /**
- * A slot's ray request (§8.6), as projection writes it after each update: the rays its next guided update
- * asks for, and what tells it the probe's light moved.
+ * A slot's request (§8.6, §8.8), as projection writes it after each update: what the probe's next update takes,
+ * by its L0 estimator, a multi-scale mean estimator over the probe's whole light (`shader_probe_clipmap_project`).
  *
  * @type {WebGPUStruct}
  */
@@ -201,7 +201,7 @@ export const PROBE_REQUEST_STRUCT: WebGPUStruct;
  */
 export const PROBE_REQUESTS_WRITE_RESOURCE: ShaderResourceDescriptor;
 /**
- * Each slot's ray request, as the ray counts pass reads it.
+ * Each slot's request, as the ray counts and accumulation read it.
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_REQUESTS_READ_RESOURCE: ShaderResourceDescriptor;

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"AAyEA;;;;;;GAMG;AACH,kCAFU,YAAY,CAsBG;AAEzB;;;;;GAKG;AACH,+BAFU,YAAY,CAuBA;AAEtB;;;;;;GAMG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;;GAIG;AACH,+CAFU,wBAAwB,CAE0G;AAE5I;;;;GAIG;AACH,0CAFU,wBAAwB,CAE+F;AAEjI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwF;AAE1H;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAEjJ;;;GAGG;AACH,0CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,sCAFU,wBAAwB,CAEkG;AAEpI;;;;GAIG;AACH,2CAFU,wBAAwB,CAEoF;AAEtH;;;GAGG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;;GAKG;AACH,oCAFU,YAAY,CAKK;AAE3B;;;GAGG;AACH,2CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,4CAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;GAGG;AACH,0CAFU,wBAAwB,CAEyG;AAE3I;;;GAGG;AACH,4CAFU,wBAAwB,CAEoG;AAEtI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,yCAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,wCAFU,wBAAwB,CAEyF;AAE3H;;;;GAIG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;GAGG;AACH,0CAFU,wBAAwB,CAEmG;AAErI;;;GAGG;AACH,yCAFU,wBAAwB,CAE2F;AAE7H;;;GAGG;AACH,sCAFU,wBAAwB,CAEqF;AAEvH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,0CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,wCAFU,wBAAwB,CAEsG;AAExI;;;GAGG;AACH,uCAFU,wBAAwB,CAE+F;AAEjI;;;;;GAKG;AACH,8CAFU,wBAAwB,CAE0G;AAE5I;;;;GAIG;AACH,gDAFU,wBAAwB,CAE8G;AAEhJ;;;GAGG;AACH,iDAFU,wBAAwB,CAE2G;AAE7I;;;GAGG;AACH,mDAFU,wBAAwB,CAE+G;AAEjJ;;;;;GAKG;AACH,4CAFU,wBAAwB,CAEsG;AAExI;;;GAGG;AACH,2CAFU,wBAAwB,CAE+F;AAEjI;;;;;GAKG;AACH,mCAFU,YAAY,CAWI;AAE1B;;;GAGG;AACH,4CAFU,wBAAwB,CAEkH;AAEpJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE2G;AAE7I;;;;GAIG;AACH,wCAFU,wBAAwB,CAEmF;AAErH;;;GAGG;AACH,uCAFU,wBAAwB,CAE4E;AAE9G;;;;;;GAMG;AACH,wCAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,6CAFU,wBAAwB,CAEgG;AAElI;;;;;GAKG;AACH,6CAFU,wBAAwB,CAEqG;AAEvI;;;GAGG;AACH,4CAFU,wBAAwB,CAE8F;AAEhI;;;;GAIG;AACH,2CAFU,wBAAwB,CAEwG;AAE1I;;;;GAIG;AACH,0CAFU,wBAAwB,CAEuF;AAEzH;;;GAGG;AACH,yCAFU,wBAAwB,CAEgF;AAElH;;;GAGG;AACH,qCAFU,YAAY,CAOD;AAErB;;;GAGG;AACH,8CAFU,wBAAwB,CAEwH;AAE1J;;;GAGG;AACH,6CAFU,wBAAwB,CAEiH;AAEnJ;;;GAGG;AACH,0CAFU,YAAY,CAcU;AAEhC;;;GAGG;AACH,8CAFU,wBAAwB,CAE6H;AAE/J;;;GAGG;AACH,6CAFU,wBAAwB,CAEsH;AAExJ;;;;GAIG;AACH,8CAFU,wBAAwB,CAE+E;AAEjH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,4CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,kCAFU,SAAS,CAgIhB;AAEH;;;;;;;;;;GAUG;AACH,6CAFU,SAAS,CA8BhB;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,SAAS,CA+BhB;AAEH;;;;;;;;;;;;;;GAcG;AACH,4CAFU,SAAS,CAehB;AAEH;;;;;;;;;;;;;;GAcG;AACH,6CAFU,SAAS,CAahB;AAEH;;;;;;;;;;;;GAYG;AACH,6CAFU,SAAS,CAehB;AAEH;;;GAGG;AACH,yCAFU,wBAAwB,CAEqF;AAEvH;;;GAGG;AACH,wCAFU,wBAAwB,CAE8E;AAEhH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAFU,SAAS,CAwDhB;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAFU,SAAS,CA6BhB;AAEH;;;;;;;;;GASG;AACH,iDAFU,SAAS,CAahB;AAIH;;;;;;;;;;GAUG;AACH,yCAFU,SAAS,CAgBhB;6BAlgC0B,sCAAsC;yCAZ1B,sDAAsD;0BADrE,uCAAuC"}

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

@@ -340,20 +340,20 @@ export const PROBE_RAY_SUMS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuf
 export const PROBE_RAY_SUMS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_ray_sums", COLLECTION_U32_STRUCT_READ);
 
 /**
- * A slot's ray request (§8.6), as projection writes it after each update: the rays its next guided update
- * asks for, and what tells it the probe's light moved.
+ * A slot's request (§8.6, §8.8), as projection writes it after each update: what the probe's next update takes,
+ * by its L0 estimator, a multi-scale mean estimator over the probe's whole light (`shader_probe_clipmap_project`).
  *
  * @type {WebGPUStruct}
  */
 export const PROBE_REQUEST_STRUCT = WebGPUStruct.from({
     /** the rays the probe's next guided update asks for */
     rays: u32,
-    /** the running mean of the update's change score: its texels' falls from their means, each in its own deviation, summed over the root of their count */
-    change_mean: f32,
-    /** the running variance of the change score */
-    change_variance: f32,
-    /** the scores its running statistics hold, up to `PROBE_RADIANCE_SAMPLES_LIMIT` */
-    changes: u32,
+    /** the least blend of every texel's long mean on the next update: the L0 estimator's catch-up */
+    blend: f32,
+    /** the L0 estimator's inconsistency, the smoothed history of its means' gap over its deviation */
+    inconsistency: f32,
+    /** the L0 estimator's blend reduction */
+    reduction: f32,
 }, "ProbeRequest").pack();
 
 /**
@@ -363,7 +363,7 @@ export const PROBE_REQUEST_STRUCT = WebGPUStruct.from({
 export const PROBE_REQUESTS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_requests", WebGPUArray.from(PROBE_REQUEST_STRUCT), true);
 
 /**
- * Each slot's ray request, as the ray counts pass reads it.
+ * Each slot's request, as the ray counts and accumulation read it.
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_REQUESTS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_requests", WebGPUArray.from(PROBE_REQUEST_STRUCT));
@@ -463,10 +463,12 @@ export const PROBE_PROJECTION_ROW_STRUCT = WebGPUStruct.from({
     resolved: u32,
     /** of them, the back faces */
     back_faces: u32,
-    /** how far the update's samples fell from their texels' means, each in its own deviation, luminance, summed */
-    change: f32,
-    /** the texels that blended a sample */
-    blended: f32,
+    /** the texels' short means less their means, luminance, each by its solid angle, summed: L0's gap */
+    gap: f32,
+    /** the texels' deviations squared, luminance, each by its solid angle squared, summed: L0's variance */
+    variance: f32,
+    /** the texels' short means, luminance, each by its solid angle, summed: L0's short mean */
+    level: f32,
 }, "ProbeProjectionRow").pack();
 
 /**

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

@@ -9,9 +9,9 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  * `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
@@ -29,6 +29,10 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  *   - 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.

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