@woosh/meep-engine 3.63.3 → 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/playground/tonemap_sdr/README.md

@@ -1,14 +1,17 @@
 # Tone mapping: GT7 and PBR Neutral, SDR and HDR
 
-The renderer has four tone mapping modes, each one choice for every output (`ShadeToneMappingMode`):
+The renderer's `ToneMapper` has four built-in operators, each one choice for every output (`renderer.tone_mapper.operator`):
 
-- `ACES`, the default: Unreal Engine's look;
-- `GT7`;
-- `PBR_NEUTRAL`;
-- `NONE`.
+- `TONE_MAP_OPERATOR_ACES`, the default: Unreal Engine's look;
+- `TONE_MAP_OPERATOR_GT7`;
+- `TONE_MAP_OPERATOR_PBR_NEUTRAL`;
+- `TONE_MAP_OPERATOR_NONE`.
+
+The tone mapper bakes the operator into a 3D LUT per output and draws through it; this page evaluates the operators
+directly.
 
 This page compares GT7 and PBR Neutral, and shows each one's HDR form beside its SDR form. ACES is not one of its
-views; the engine's own canvas shows it, and `shader_tonemap_aces.spec.js` holds it to Unreal's and OpenColorIO's numbers.
+views; the engine's own canvas shows it, and `TONE_MAP_OPERATOR_ACES.spec.js` holds it to Unreal's and OpenColorIO's numbers.
 
 The engine renders and tonemaps each frame as usual. Two extensions then redraw the canvas from the HDR colour the
 tonemapper was given:
@@ -16,8 +19,8 @@ tonemapper was given:
 | | operator | source |
 |---|---|---|
 | 1 | GT7, Polyphony's sample | `chunk_tonemap_gt7_sdr_reference.js` beside this page: the sample code's `initializeAsSDR()`, SDR only |
-| 2 | GT7, engine | `tonemap_gt7_rec2020` at `PAPER_WHITE_NITS · peak` and `PAPER_WHITE_NITS`, back in Rec.709, what `ShadeToneMappingMode.GT7` runs |
-| 3 | PBR Neutral, engine | `tonemap_khronos_pbr(c, peak)`, what `ShadeToneMappingMode.PBR_NEUTRAL` runs; at peak 1 the Khronos specification |
+| 2 | GT7, engine | `tonemap_gt7_rec2020` at `PAPER_WHITE_NITS · peak` and `PAPER_WHITE_NITS`, back in Rec.709, what `TONE_MAP_OPERATOR_GT7` runs |
+| 3 | PBR Neutral, engine | `tonemap_khronos_pbr(c, peak)`, what `TONE_MAP_OPERATOR_PBR_NEUTRAL` runs; at peak 1 the Khronos specification |
 
 All of them see the same input. Exposure is the page's own and fixed per scene, with the engine's automatic exposure off.
 

package/src/shade/playground/tonemap_sdr/ToneMapCompare.js

@@ -35,11 +35,11 @@ export const CompareOperator = {
     GT7Reference: 0,
     /**
      * the engine's `tonemap_gt7` with the paper white at `PAPER_WHITE_NITS` and the peak at the headroom times that:
-     * what `ShadeToneMappingMode.GT7` runs
+     * what `TONE_MAP_OPERATOR_GT7` runs
      */
     GT7: 1,
     /**
-     * the engine's `tonemap_khronos_pbr` at the headroom: what `ShadeToneMappingMode.PBR_NEUTRAL` runs, and at
+     * the engine's `tonemap_khronos_pbr` at the headroom: what `TONE_MAP_OPERATOR_PBR_NEUTRAL` runs, and at
      * headroom 1 the Khronos specification
      */
     PBRNeutral: 2,

package/src/shade/renderer/Renderer.d.ts

@@ -54,12 +54,11 @@ export class Renderer {
      */
     transparency_mode: ShadeTransparencyMode;
     /**
-     * How the exposed scene colour becomes display colour, on every output. An SDR and an HDR display run the same
-     * mode, so a scene looks alike on both; see {@link ShadeToneMappingMode}. ACES, Unreal's default look, unless set. Read every frame, so it can be flipped
-     * at runtime. A mode not in use at {@link initialize} compiles its pass on the first frame that draws with it.
-     * @type {ShadeToneMappingMode}
+     * How the exposed scene colour becomes display colour, on every output: its operator, the resolution of its LUTs,
+     * and LUTs of the user's own. Made by {@link initialize}.
+     * @type {ToneMapper}
      */
-    tone_mapping_mode: ShadeToneMappingMode;
+    tone_mapper: ToneMapper;
     /**
      * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
      * @type {AVBOITSettings}
@@ -579,7 +578,7 @@ import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
-import { ShadeToneMappingMode } from "./ShadeToneMappingMode.js";
+import { ToneMapper } from "./deferred/tonemap/ToneMapper.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
 import { ShaderSwitchSet } from "./shader/compiler/ShaderSwitchSet.js";
 import { MotionBlur } from "./postprocess/motion_blur/MotionBlur.js";

package/src/shade/renderer/Renderer.d.ts.map

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