@woosh/meep-engine 3.64.0 → 3.64.1

package/src/format/image/exr/exr_write.js

@@ -0,0 +1,378 @@
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+import { compress_bytes } from "../../../core/binary/compression/compress_bytes.js";
+import { EndianType } from "../../../core/binary/EndianType.js";
+import { utf8_encode_into } from "../../../core/binary/utf8/utf8_encode_into.js";
+import { utf8_encoded_length } from "../../../core/binary/utf8/utf8_encoded_length.js";
+import {
+    EXR_FLAG_LONG_NAMES,
+    EXR_LONG_NAME_BYTES,
+    EXR_MAGIC,
+    EXR_SHORT_NAME_BYTES,
+    EXR_VERSION
+} from "./exr_constants.js";
+import { exr_compare_names } from "./exr_compare_names.js";
+import { exr_sample_bits } from "./exr_sample_bits.js";
+import { exr_scanlines_per_chunk } from "./exr_scanlines_per_chunk.js";
+import { ExrCompression } from "./ExrCompression.js";
+import { ExrPixelType } from "./ExrPixelType.js";
+
+/**
+ * The largest value of the format's signed 32-bit fields: a chunk's size, and the data window's corners.
+ *
+ * @readonly
+ * @type {number}
+ */
+const INT32_MAX = 0x7FFFFFFF;
+
+/**
+ * Write an image as a scanline OpenEXR file.
+ *
+ * Each channel is written in the pixel type its array holds — a `Float16Array` as HALF, a `Float32Array`
+ * as FLOAT, a `Uint32Array` as UINT — and its samples go into the file as the bits they are. The header
+ * carries OpenEXR's required attributes and nothing else: both windows at the origin exactly covering the
+ * pixels, increasing line order, square pixels and the default screen window.
+ *
+ * Under {@link ExrCompression.ZIP} and {@link ExrCompression.ZIPS} a chunk that deflate does not make
+ * smaller is stored as it is, as OpenEXR's own writer does and every reader expects.
+ *
+ * The channels' arrays are read chunk by chunk as earlier chunks are compressed, so keep them unchanged
+ * until the promise settles.
+ *
+ * @param {ExrImage} image channels in any order, with distinct names of 1 to 255 bytes in UTF-8
+ * @param {ExrCompression} compression {@link ExrCompression.None}, {@link ExrCompression.ZIPS} or
+ * {@link ExrCompression.ZIP}
+ * @returns {Promise<ArrayBuffer>} the whole file
+ * @throws {Error} naming what about the image or the compression method cannot be written
+ *
+ * @see https://openexr.com/en/latest/OpenEXRFileLayout.html
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export async function exr_write(image, compression) {
+    const width = image.width;
+    const height = image.height;
+
+    // the data window's corners are signed 32-bit integers
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1
+        || width - 1 > INT32_MAX || height - 1 > INT32_MAX) {
+        throw new Error(`EXR: cannot write a ${width}x${height} image; a side is 1 to 2^31 pixels`);
+    }
+
+    const scanlines_per_chunk = exr_scanlines_per_chunk(compression);
+
+    const channels = sort_channels(image.channels, width * height);
+    const channel_count = channels.length;
+
+    let pixel_bytes = 0;
+    let long_names = false;
+
+    const plane_bits = new Array(channel_count);
+
+    for (let c = 0; c < channel_count; c++) {
+        const channel = channels[c];
+
+        pixel_bytes += channel.data.BYTES_PER_ELEMENT;
+        long_names ||= channel.name_bytes.length > EXR_SHORT_NAME_BYTES;
+
+        plane_bits[c] = exr_sample_bits(channel.data);
+    }
+
+    const line_bytes = width * pixel_bytes;
+    const chunk_bytes = Math.min(scanlines_per_chunk, height) * line_bytes;
+
+    if (chunk_bytes > INT32_MAX) {
+        throw new Error(`EXR: a chunk of this image would be ${chunk_bytes} bytes, more than a chunk's 32-bit size holds`);
+    }
+
+    const chunk_count = Math.ceil(height / scanlines_per_chunk);
+
+    const buffer = new BinaryBuffer();
+
+    // OpenEXR is little-endian throughout
+    buffer.endianness = EndianType.LittleEndian;
+
+    buffer.writeUint32(EXR_MAGIC);
+    buffer.writeUint32(long_names ? EXR_VERSION | EXR_FLAG_LONG_NAMES : EXR_VERSION);
+
+    write_header(buffer, channels, compression, width, height);
+
+    // No chunk is stored larger than its scanlines, so this bounds the file: the output is allocated
+    // once, and uncompressed it is exactly the file.
+    buffer.setCapacity(buffer.position + chunk_count * 16 + height * line_bytes);
+
+    // each entry is known once its chunk has been written; reserve the table and fill it in as they are
+    const table_offset = buffer.position;
+
+    for (let i = 0; i < chunk_count; i++) {
+        buffer.writeUint64(0n);
+    }
+
+    const raw = new BinaryBuffer();
+
+    raw.endianness = EndianType.LittleEndian;
+    raw.setCapacity(chunk_bytes);
+
+    const prepared = compression === ExrCompression.None ? null : new Uint8Array(chunk_bytes);
+
+    for (let i = 0; i < chunk_count; i++) {
+        const first_line = i * scanlines_per_chunk;
+        const line_count = Math.min(scanlines_per_chunk, height - first_line);
+        const unpacked_size = line_count * line_bytes;
+
+        raw.position = 0;
+
+        write_scanlines(raw, plane_bits, width, first_line, line_count);
+
+        let payload = raw.raw_bytes;
+        let payload_size = unpacked_size;
+
+        if (prepared !== null) {
+            zip_prepare(raw.raw_bytes, prepared, unpacked_size);
+
+            const compressed = await compress_bytes([prepared.subarray(0, unpacked_size)], "deflate");
+
+            if (compressed.length < unpacked_size) {
+                payload = compressed;
+                payload_size = compressed.length;
+            }
+        }
+
+        const offset = buffer.position;
+
+        buffer.position = table_offset + i * 8;
+        buffer.writeUint64(BigInt(offset));
+        buffer.position = offset;
+
+        // the data window starts at the origin, so a chunk's scanline is its first row
+        buffer.writeInt32(first_line);
+        buffer.writeInt32(payload_size);
+        buffer.writeBytes(payload, 0, payload_size);
+    }
+
+    buffer.trim();
+
+    return buffer.data;
+}
+
+/**
+ * Check the channels and sort them by {@link exr_compare_names}, which is the order a file lists them in
+ * and lays out their samples in.
+ *
+ * @param {ExrChannel[]} channels
+ * @param {number} sample_count every channel's
+ * @returns {{name: string, name_bytes: Uint8Array, data: (Float16Array|Float32Array|Uint32Array), pixel_type: ExrPixelType}[]}
+ */
+function sort_channels(channels, sample_count) {
+    const channel_count = channels.length;
+
+    if (channel_count === 0) {
+        throw new Error("EXR: the image has no channels");
+    }
+
+    const result = new Array(channel_count);
+
+    for (let c = 0; c < channel_count; c++) {
+        const { name, data } = channels[c];
+
+        if (typeof name !== "string" || name.length === 0 || name.includes("\0")) {
+            throw new Error(`EXR: channel name '${name}' is not a non-empty string without a null`);
+        }
+
+        const name_bytes = new Uint8Array(utf8_encoded_length(name));
+
+        utf8_encode_into(name, name_bytes, 0);
+
+        if (name_bytes.length > EXR_LONG_NAME_BYTES) {
+            throw new Error(`EXR: channel name '${name}' is ${name_bytes.length} bytes in UTF-8, more than ${EXR_LONG_NAME_BYTES}`);
+        }
+
+        let pixel_type;
+
+        if (data instanceof Float16Array) {
+            pixel_type = ExrPixelType.HALF;
+        } else if (data instanceof Float32Array) {
+            pixel_type = ExrPixelType.FLOAT;
+        } else if (data instanceof Uint32Array) {
+            pixel_type = ExrPixelType.UINT;
+        } else {
+            throw new Error(
+                `EXR: channel '${name}' holds ${data?.constructor?.name};`
+                + ` samples are Float16Array (HALF), Float32Array (FLOAT) or Uint32Array (UINT)`
+            );
+        }
+
+        if (data.length !== sample_count) {
+            throw new Error(`EXR: channel '${name}' holds ${data.length} samples, where the image has ${sample_count}`);
+        }
+
+        result[c] = { name, name_bytes, data, pixel_type };
+    }
+
+    result.sort((a, b) => exr_compare_names(a.name_bytes, b.name_bytes));
+
+    for (let c = 1; c < channel_count; c++) {
+        if (exr_compare_names(result[c - 1].name_bytes, result[c].name_bytes) === 0) {
+            throw new Error(`EXR: there are two channels named '${result[c].name}'`);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Write the header: OpenEXR's required attributes, in its order, then the terminator.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {{name_bytes: Uint8Array, pixel_type: ExrPixelType}[]} channels sorted by name
+ * @param {ExrCompression} compression
+ * @param {number} width
+ * @param {number} height
+ */
+function write_header(buffer, channels, compression, width, height) {
+    let channel_list_bytes = 1;
+
+    for (let c = 0; c < channels.length; c++) {
+        // name and terminator; pixel type; pLinear and three reserved bytes; x and y sampling
+        channel_list_bytes += channels[c].name_bytes.length + 1 + 4 + 4 + 8;
+    }
+
+    write_attribute(buffer, "channels", "chlist", channel_list_bytes);
+
+    for (let c = 0; c < channels.length; c++) {
+        const name_bytes = channels[c].name_bytes;
+
+        buffer.writeBytes(name_bytes, 0, name_bytes.length);
+        buffer.writeUint8(0);
+
+        buffer.writeInt32(channels[c].pixel_type);
+        buffer.writeUint32(0);
+        buffer.writeInt32(1);
+        buffer.writeInt32(1);
+    }
+
+    buffer.writeUint8(0);
+
+    write_attribute(buffer, "compression", "compression", 1);
+    buffer.writeUint8(compression);
+
+    write_attribute(buffer, "dataWindow", "box2i", 16);
+    write_window(buffer, width, height);
+
+    write_attribute(buffer, "displayWindow", "box2i", 16);
+    write_window(buffer, width, height);
+
+    // increasing Y
+    write_attribute(buffer, "lineOrder", "lineOrder", 1);
+    buffer.writeUint8(0);
+
+    write_attribute(buffer, "pixelAspectRatio", "float", 4);
+    buffer.writeFloat32(1);
+
+    write_attribute(buffer, "screenWindowCenter", "v2f", 8);
+    buffer.writeFloat32(0);
+    buffer.writeFloat32(0);
+
+    write_attribute(buffer, "screenWindowWidth", "float", 4);
+    buffer.writeFloat32(1);
+
+    buffer.writeUint8(0);
+}
+
+/**
+ * @param {BinaryBuffer} buffer
+ * @param {string} name
+ * @param {string} type
+ * @param {number} size bytes of the value that follows
+ */
+function write_attribute(buffer, name, type, size) {
+    write_name(buffer, name);
+    write_name(buffer, type);
+
+    buffer.writeInt32(size);
+}
+
+/**
+ * @param {BinaryBuffer} buffer
+ * @param {string} name ASCII
+ */
+function write_name(buffer, name) {
+    buffer.writeASCIIString(name);
+    buffer.writeUint8(0);
+}
+
+/**
+ * A `box2i` from the origin to the last pixel.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} width
+ * @param {number} height
+ */
+function write_window(buffer, width, height) {
+    buffer.writeInt32(0);
+    buffer.writeInt32(0);
+    buffer.writeInt32(width - 1);
+    buffer.writeInt32(height - 1);
+}
+
+/**
+ * Gather a chunk's scanlines from the channel planes — the inverse of `read_scanlines` in `exr_read`.
+ *
+ * @param {BinaryBuffer} destination
+ * @param {(Uint16Array|Uint32Array)[]} plane_bits in channel list order
+ * @param {number} width
+ * @param {number} first_line
+ * @param {number} line_count
+ */
+function write_scanlines(destination, plane_bits, width, first_line, line_count) {
+    const channel_count = plane_bits.length;
+
+    for (let line = first_line; line < first_line + line_count; line++) {
+        const row = line * width;
+
+        for (let c = 0; c < channel_count; c++) {
+            const bits = plane_bits[c];
+
+            if (bits.BYTES_PER_ELEMENT === 2) {
+                destination.writeUint16Array(bits, row, width);
+            } else {
+                destination.writeUint32Array(bits, row, width);
+            }
+        }
+    }
+}
+
+/**
+ * Transform a chunk the way ZIP compression does before deflating it — the inverse of
+ * `zip_reconstruct` in `exr_read`.
+ *
+ * The bytes at even positions are moved ahead of those at odd ones — for half floats, the low bytes of
+ * the samples ahead of their high bytes — and the result is delta-coded byte by byte with a bias of
+ * 128, which turns smooth image data into the small, repetitive values deflate codes cheaply.
+ *
+ * @param {Uint8Array} source the chunk's pixel data
+ * @param {Uint8Array} destination
+ * @param {number} length bytes, at least one
+ */
+function zip_prepare(source, destination, length) {
+    const half = (length + 1) >> 1;
+
+    let previous = source[0];
+
+    destination[0] = previous;
+
+    for (let i = 1; i < half; i++) {
+        const value = source[2 * i];
+
+        destination[i] = value - previous + 128;
+
+        previous = value;
+    }
+
+    for (let i = half; i < length; i++) {
+        const value = source[2 * (i - half) + 1];
+
+        destination[i] = value - previous + 128;
+
+        previous = value;
+    }
+}

package/src/shade/playground/probe_clipmap/index.html

@@ -124,6 +124,11 @@
 
     <hr>
 
+    <label>
+        <input type="checkbox" id="sun" checked>
+        <span>Sun <span class="hint">— the directional light; L flips it</span></span>
+    </label>
+
     <label>
         <span>Sun height</span>
         <input type="range" id="sun_elevation" min="2" max="88" value="62">

package/src/shade/playground/probe_clipmap/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAsSzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAuUzB"}

package/src/shade/playground/probe_clipmap/main.js

@@ -178,7 +178,11 @@ export async function start() {
     // a sun the sliders turn, whatever lights the file brought
     const sun = make_sunlight({ intensity: 7.2 });
 
-    place_light(scene, sun);
+    /**
+     * The sun's entity while it is in the scene, -1 while the toggle has it out.
+     * @type {number}
+     */
+    let sun_entity = place_light(scene, sun);
 
     const rotation = new Quaternion();
     const sun_direction = new Vector3();
@@ -229,6 +233,33 @@ export async function start() {
     element('sun_elevation').addEventListener('input', on_sun_input);
     element('sun_azimuth').addEventListener('input', on_sun_input);
 
+    const sun_toggle = element('sun');
+
+    /**
+     * Take the sun out of the scene, or put it back; out, it is gone from the lights, its shadows and the
+     * probes' hits alike, rather than dimmed to nothing.
+     * @param {boolean} enabled
+     */
+    function set_sun(enabled) {
+        sun_toggle.checked = enabled;
+
+        if (enabled === (sun_entity !== -1)) {
+            return;
+        }
+
+        if (enabled) {
+            sun_entity = place_light(scene, sun);
+        } else {
+            scene.lights.remove(sun);
+            scene.dataset.removeEntity(sun_entity);
+            sun_entity = -1;
+        }
+
+        lights_changed();
+    }
+
+    sun_toggle.addEventListener('change', event => set_sun(event.target.checked));
+
     load_default_environment(scene);
 
     // ---- controls -------------------------------------------------------------------------
@@ -311,6 +342,8 @@ export async function start() {
         } else if (event.code === 'KeyT') {
             ray_resampling_toggle.checked = !ray_resampling_toggle.checked;
             renderer.probe_clipmap.ray_resampling = ray_resampling_toggle.checked;
+        } else if (event.code === 'KeyL') {
+            set_sun(sun_entity === -1);
         }
     });
 

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":"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"}

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.