@woosh/meep-engine 3.65.0 → 3.68.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.65.0",
+  "version": "3.68.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/graphics3/GraphicsEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IAmEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;OAaG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAqB7B;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAuDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CA2DnB;;CACJ;sBA74BY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;gCAC3E,OAAO,mEAAmE,EAAE,iBAAiB;8BAC7F,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAfrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IAmEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAgBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;OAaG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAqB7B;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAuDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CA2DnB;;CACJ;sBAz4BY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;gCAC3E,OAAO,mEAAmE,EAAE,iBAAiB;8BAC7F,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAdrC,kCAAkC;mCAKxB,yBAAyB;mBAXzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}

package/src/engine/graphics3/GraphicsEngine.js

@@ -9,7 +9,6 @@ import { Renderer } from "../../shade/renderer/Renderer.js";
 import { Scene } from "../../shade/renderer/scene/Scene.js";
 import { Sampler2D } from "../graphics/texture/sampler/Sampler2D.js";
 import EmptyView from "../../view/elements/EmptyView.js";
-import { make_default_environment } from "./make_default_environment.js";
 import { shade_camera_projection_ray } from "./shade_camera_projection_ray.js";
 import { ShadeCameraAdapter } from "./ShadeCameraAdapter.js";
 
@@ -334,16 +333,12 @@ export class GraphicsEngine {
         this.#scene = scene;
 
         /*
-         Shade lights with indirect by default and a scene without an environment renders unlit, so
-         the engine supplies one rather than leaving every caller to. Turning global illumination off
-         is the thing that takes a decision, not turning it on.
-
-         A scene that arrives with an environment keeps it: the scene owns its lighting and this only
-         fills in what is missing. Otherwise handing over a scene would silently discard the
-         environment it was built with, and the fix would be to call things in a particular order.
+         Shade lights with indirect by default and a scene with neither an authored environment nor
+         an active procedural atmosphere renders unlit, so the engine enables Hillaire sky/IBL on
+         scenes that arrive without an explicit environment or explicit `atmosphere.enabled = false`.
          */
         if (scene.lights.environment === undefined) {
-            scene.lights.environment = make_default_environment();
+            scene.atmosphere.enable_by_default();
         }
     }
 

package/src/engine/graphics3/load_cube_environment.js

@@ -12,9 +12,9 @@ import { ShadeTexture } from "../../shade/renderer/texture/ShadeTexture.js";
 import { ShadeImage } from "../../shade/renderer/texture/source/ShadeImage.js";
 
 /**
- * Resolution of the octahedral map, matching `make_default_environment` for the same reason: it is
- * convolved into irradiance and a handful of roughness mips before anything samples it, so what
- * matters is that it is smooth and correctly oriented rather than detailed.
+ * Resolution of the octahedral map: it is convolved into irradiance and a handful of roughness mips
+ * before anything samples it, so what matters is that it is smooth and correctly oriented rather
+ * than detailed.
  *
  * @type {number}
  */

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#497@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#500@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#497@#clear_field"(fluid: FluidComponent): void;
+    static "__#500@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#497@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#500@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#497@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#500@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/format/lut/cube/CubeLut.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A 3D lookup table as a `.cube` file holds it — what {@link cube_read } returns and {@link cube_write } takes.
+ *
+ * Entry `r + g·size + b·size²` holds the output for the input at lattice point (r, g, b): the input whose channel c
+ * is `domain_min[c] + (domain_max[c] - domain_min[c]) · i / (size - 1)` for that channel's index i. Red runs
+ * fastest, then green, then blue, as the format lays the entries out.
+ *
+ * The format carries numbers only. What the input and output mean — their primaries, transfer curves and units — is
+ * a contract between the writer and the reader, stated outside the table; a `.cube` file conventionally says it in
+ * its comments.
+ */
+type CubeLut = {
+    /**
+     * the `TITLE`, `""` when the file has none
+     */
+    title: string;
+    /**
+     * the comment lines in file order, each without its `#` and the space after it
+     */
+    comments: string[];
+    /**
+     * entries along each edge, at least 2
+     */
+    size: number;
+    /**
+     * the input at lattice index 0, per channel
+     */
+    domain_min: number[];
+    /**
+     * the input at lattice index `size - 1`, per channel
+     */
+    domain_max: number[];
+    /**
+     * `size³` RGB triples
+     */
+    data: Float32Array;
+};
+//# sourceMappingURL=CubeLut.d.ts.map

package/src/format/lut/cube/CubeLut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubeLut.d.ts","sourceRoot":"","sources":["../../../../../src/format/lut/cube/CubeLut.js"],"names":[],"mappings":";;;;;;;;;;;;;;;WAYc,MAAM;;;;cACN,MAAM,EAAE;;;;UACR,MAAM;;;;gBACN,MAAM,EAAE;;;;gBACR,MAAM,EAAE;;;;UACR,YAAY"}

package/src/format/lut/cube/CubeLut.js

@@ -0,0 +1,23 @@
+/**
+ * A 3D lookup table as a `.cube` file holds it — what {@link cube_read} returns and {@link cube_write} takes.
+ *
+ * Entry `r + g·size + b·size²` holds the output for the input at lattice point (r, g, b): the input whose channel c
+ * is `domain_min[c] + (domain_max[c] - domain_min[c]) · i / (size - 1)` for that channel's index i. Red runs
+ * fastest, then green, then blue, as the format lays the entries out.
+ *
+ * The format carries numbers only. What the input and output mean — their primaries, transfer curves and units — is
+ * a contract between the writer and the reader, stated outside the table; a `.cube` file conventionally says it in
+ * its comments.
+ *
+ * @typedef {object} CubeLut
+ * @property {string} title the `TITLE`, `""` when the file has none
+ * @property {string[]} comments the comment lines in file order, each without its `#` and the space after it
+ * @property {number} size entries along each edge, at least 2
+ * @property {number[]} domain_min the input at lattice index 0, per channel
+ * @property {number[]} domain_max the input at lattice index `size - 1`, per channel
+ * @property {Float32Array} data `size³` RGB triples
+ *
+ * @see Adobe Systems, "Cube LUT Specification", version 1.0, 2013
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */

package/src/format/lut/cube/cube_read.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Read a 3D LUT in the `.cube` format.
+ *
+ * **What it reads**: `TITLE`, `LUT_3D_SIZE`, `DOMAIN_MIN`, `DOMAIN_MAX` and comment lines, in any order ahead of the
+ * table, then the table: one entry per line, three decimal numbers apart by spaces or tabs, red fastest. Blank lines
+ * are skipped anywhere and comments are kept wherever they are. `DOMAIN_MIN` and `DOMAIN_MAX` default to 0 and 1,
+ * as the format defines.
+ *
+ * **What it refuses**, by name: a 1D LUT (`LUT_1D_SIZE`), any other keyword, a keyword after the table has begun, a
+ * size under 2, a table with more or fewer than `size³` entries, an entry that is not three decimal numbers, and a
+ * domain whose minimum is not under its maximum in every channel. A size is checked against what the text could hold
+ * before anything is allocated for the table, so a file cannot claim more entries than its own length allows.
+ *
+ * @param {string} text the whole file
+ * @returns {CubeLut}
+ * @throws {Error} naming the line and what is wrong with it
+ *
+ * @see cube_write
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function cube_read(text: string): CubeLut;
+//# sourceMappingURL=cube_read.d.ts.map

package/src/format/lut/cube/cube_read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cube_read.d.ts","sourceRoot":"","sources":["../../../../../src/format/lut/cube/cube_read.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,gCARW,MAAM,GACJ,OAAO,CAmJnB"}

package/src/format/lut/cube/cube_read.js

@@ -0,0 +1,199 @@
+/**
+ * A decimal number as a `.cube` file writes one: optional sign, digits with an optional point, optional exponent.
+ * Narrower than `Number()`, which also takes hexadecimal, `Infinity` and the empty string.
+ * @type {RegExp}
+ */
+const DECIMAL = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+
+/**
+ * @param {string} token
+ * @param {number} line_number
+ * @returns {number}
+ */
+function parse_number(token, line_number) {
+    if (!DECIMAL.test(token)) {
+        throw new Error(`CUBE: line ${line_number}: '${token}' is not a number`);
+    }
+
+    return Number(token);
+}
+
+/**
+ * @param {string[]} tokens the keyword and its three values
+ * @param {number} line_number
+ * @returns {number[]}
+ */
+function parse_triple(tokens, line_number) {
+    if (tokens.length !== 4) {
+        throw new Error(`CUBE: line ${line_number}: ${tokens[0]} takes three numbers, found ${tokens.length - 1}`);
+    }
+
+    return [
+        parse_number(tokens[1], line_number),
+        parse_number(tokens[2], line_number),
+        parse_number(tokens[3], line_number),
+    ];
+}
+
+/**
+ * Read a 3D LUT in the `.cube` format.
+ *
+ * **What it reads**: `TITLE`, `LUT_3D_SIZE`, `DOMAIN_MIN`, `DOMAIN_MAX` and comment lines, in any order ahead of the
+ * table, then the table: one entry per line, three decimal numbers apart by spaces or tabs, red fastest. Blank lines
+ * are skipped anywhere and comments are kept wherever they are. `DOMAIN_MIN` and `DOMAIN_MAX` default to 0 and 1,
+ * as the format defines.
+ *
+ * **What it refuses**, by name: a 1D LUT (`LUT_1D_SIZE`), any other keyword, a keyword after the table has begun, a
+ * size under 2, a table with more or fewer than `size³` entries, an entry that is not three decimal numbers, and a
+ * domain whose minimum is not under its maximum in every channel. A size is checked against what the text could hold
+ * before anything is allocated for the table, so a file cannot claim more entries than its own length allows.
+ *
+ * @param {string} text the whole file
+ * @returns {CubeLut}
+ * @throws {Error} naming the line and what is wrong with it
+ *
+ * @see cube_write
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function cube_read(text) {
+    const lines = text.split(/\r\n|\n|\r/);
+    const line_count = lines.length;
+
+    let title = "";
+    const comments = [];
+    let size = 0;
+    const domain_min = [0, 0, 0];
+    const domain_max = [1, 1, 1];
+
+    /**
+     * @type {Float32Array|null}
+     */
+    let data = null;
+    let entries = 0;
+    let entry_count = 0;
+
+    for (let i = 0; i < line_count; i++) {
+        const line_number = i + 1;
+        const line = lines[i].trim();
+
+        if (line.length === 0) {
+            continue;
+        }
+
+        if (line.charCodeAt(0) === 35 /* # */) {
+            // the text after `# ` as it stands, trailing spaces and all
+            comments.push(lines[i].trimStart().substring(1).replace(/^ /, ""));
+            continue;
+        }
+
+        const tokens = line.split(/[ \t]+/);
+        const head = tokens[0];
+
+        if (/^[A-Za-z_]/.test(head)) {
+            if (entries > 0) {
+                throw new Error(`CUBE: line ${line_number}: keyword ${head} after the table has begun`);
+            }
+
+            switch (head) {
+                case "TITLE": {
+                    const match = /^TITLE[ \t]+"([^"]*)"$/.exec(line);
+
+                    if (match === null) {
+                        throw new Error(`CUBE: line ${line_number}: TITLE takes one quoted string`);
+                    }
+
+                    title = match[1];
+                    break;
+                }
+
+                case "LUT_3D_SIZE": {
+                    if (tokens.length !== 2 || !/^\d+$/.test(tokens[1])) {
+                        throw new Error(`CUBE: line ${line_number}: LUT_3D_SIZE takes one whole number`);
+                    }
+
+                    size = Number(tokens[1]);
+
+                    if (size < 2) {
+                        throw new Error(`CUBE: line ${line_number}: LUT_3D_SIZE is ${size}, under the format's 2`);
+                    }
+
+                    break;
+                }
+
+                case "DOMAIN_MIN": {
+                    const values = parse_triple(tokens, line_number);
+                    domain_min[0] = values[0];
+                    domain_min[1] = values[1];
+                    domain_min[2] = values[2];
+                    break;
+                }
+
+                case "DOMAIN_MAX": {
+                    const values = parse_triple(tokens, line_number);
+                    domain_max[0] = values[0];
+                    domain_max[1] = values[1];
+                    domain_max[2] = values[2];
+                    break;
+                }
+
+                case "LUT_1D_SIZE":
+                    throw new Error(`CUBE: line ${line_number}: a 1D LUT, where a 3D LUT was expected`);
+
+                default:
+                    throw new Error(`CUBE: line ${line_number}: unsupported keyword ${head}`);
+            }
+
+            continue;
+        }
+
+        // the table
+        if (data === null) {
+            if (size === 0) {
+                throw new Error(`CUBE: line ${line_number}: table entry before LUT_3D_SIZE`);
+            }
+
+            entry_count = size * size * size;
+
+            // every entry is at least three one-digit numbers and two separators, five characters, and each but the
+            // last ends its line
+            if (entry_count * 6 - 1 > text.length) {
+                throw new Error(`CUBE: LUT_3D_SIZE ${size} needs ${entry_count} entries, more than a file of ${text.length} characters can hold`);
+            }
+
+            data = new Float32Array(entry_count * 3);
+        }
+
+        if (tokens.length !== 3) {
+            throw new Error(`CUBE: line ${line_number}: an entry is three numbers, found ${tokens.length}`);
+        }
+
+        if (entries >= entry_count) {
+            throw new Error(`CUBE: line ${line_number}: more than the ${entry_count} entries of LUT_3D_SIZE ${size}`);
+        }
+
+        const at = entries * 3;
+
+        data[at] = parse_number(tokens[0], line_number);
+        data[at + 1] = parse_number(tokens[1], line_number);
+        data[at + 2] = parse_number(tokens[2], line_number);
+
+        entries++;
+    }
+
+    if (size === 0) {
+        throw new Error("CUBE: no LUT_3D_SIZE");
+    }
+
+    if (entries !== size * size * size) {
+        throw new Error(`CUBE: ${entries} entries, where LUT_3D_SIZE ${size} needs ${size * size * size}`);
+    }
+
+    for (let c = 0; c < 3; c++) {
+        if (!(domain_min[c] < domain_max[c])) {
+            throw new Error(`CUBE: the domain of channel ${c} runs from ${domain_min[c]} to ${domain_max[c]}`);
+        }
+    }
+
+    return { title, comments, size, domain_min, domain_max, data };
+}

package/src/format/lut/cube/cube_write.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Write a 3D LUT in the `.cube` format: the comments, `TITLE` where there is one, `LUT_3D_SIZE`, `DOMAIN_MIN`,
+ * `DOMAIN_MAX`, then one entry per line, red fastest. Each number is the shortest decimal that reads back as the same
+ * 32-bit float, so {@link cube_read} returns exactly the values written.
+ *
+ * @param {CubeLut} lut
+ * @returns {string} the file, lines ending in `\n`
+ * @throws {Error} where a value is not finite, or the title or a comment cannot be written on one line
+ *
+ * @see cube_read
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function cube_write({ title, comments, size, domain_min, domain_max, data }: CubeLut): string;
+//# sourceMappingURL=cube_write.d.ts.map

package/src/format/lut/cube/cube_write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cube_write.d.ts","sourceRoot":"","sources":["../../../../../src/format/lut/cube/cube_write.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;GAYG;AACH,oFARW,OAAO,GACL,MAAM,CAsDlB"}

package/src/format/lut/cube/cube_write.js

@@ -0,0 +1,90 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * The shortest decimal that reads back as the same 32-bit float.
+ *
+ * @param {number} value a float32 value, finite
+ * @returns {string}
+ */
+function format_f32(value) {
+    for (let precision = 1; precision < 9; precision++) {
+        const text = value.toPrecision(precision);
+
+        if (Math.fround(Number(text)) === value) {
+            return text;
+        }
+    }
+
+    // nine significant digits always identify a float32
+    return value.toPrecision(9);
+}
+
+/**
+ * @param {number[]} triple
+ * @returns {string}
+ */
+function format_triple(triple) {
+    return `${format_f32(Math.fround(triple[0]))} ${format_f32(Math.fround(triple[1]))} ${format_f32(Math.fround(triple[2]))}`;
+}
+
+/**
+ * Write a 3D LUT in the `.cube` format: the comments, `TITLE` where there is one, `LUT_3D_SIZE`, `DOMAIN_MIN`,
+ * `DOMAIN_MAX`, then one entry per line, red fastest. Each number is the shortest decimal that reads back as the same
+ * 32-bit float, so {@link cube_read} returns exactly the values written.
+ *
+ * @param {CubeLut} lut
+ * @returns {string} the file, lines ending in `\n`
+ * @throws {Error} where a value is not finite, or the title or a comment cannot be written on one line
+ *
+ * @see cube_read
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function cube_write({ title, comments, size, domain_min, domain_max, data }) {
+    assert.isString(title, 'title');
+    assert.isArray(comments, 'comments');
+    assert.isNonNegativeInteger(size, 'size');
+    assert.greaterThanOrEqual(size, 2, 'size');
+    assert.isInstanceOf(data, Float32Array, 'data', 'Float32Array');
+    assert.equal(data.length, size * size * size * 3, 'data.length !== size³ × 3');
+
+    if (/["\r\n]/.test(title)) {
+        throw new Error(`CUBE: a title cannot hold a quote or a line break, '${title}'`);
+    }
+
+    const lines = [];
+
+    for (const comment of comments) {
+        assert.isString(comment, 'comment');
+
+        if (/[\r\n]/.test(comment)) {
+            throw new Error(`CUBE: a comment cannot hold a line break, '${comment}'`);
+        }
+
+        lines.push(`# ${comment}`);
+    }
+
+    if (title.length > 0) {
+        lines.push(`TITLE "${title}"`);
+    }
+
+    lines.push(`LUT_3D_SIZE ${size}`);
+    lines.push(`DOMAIN_MIN ${format_triple(domain_min)}`);
+    lines.push(`DOMAIN_MAX ${format_triple(domain_max)}`);
+
+    const value_count = data.length;
+
+    for (let i = 0; i < value_count; i++) {
+        if (!Number.isFinite(data[i])) {
+            throw new Error(`CUBE: entry ${Math.floor(i / 3)} holds ${data[i]}, which the format cannot write`);
+        }
+    }
+
+    for (let i = 0; i < value_count; i += 3) {
+        lines.push(`${format_f32(data[i])} ${format_f32(data[i + 1])} ${format_f32(data[i + 2])}`);
+    }
+
+    lines.push("");
+
+    return lines.join("\n");
+}

package/src/shade/playground/probe_clipmap/README.md

@@ -28,6 +28,7 @@ has the two lines that put it there. Another scene loads with `?scene=/some/othe
 | Sun height, Sun turn | where the sun stands |
 | Point lights | eight shadowed point lights along the scene's long axis, which the probes' hits take as local lights |
 | TAA | the resolve the probe pick's noise is meant for |
+| Auto exposure | the exposure metered from the frame and adapted to it; off, the factor is 2^compensation, 1 on this page |
 | Bake budget | mesh SDF bricks baked a frame while the caches fill; the page starts above the engine's default so Sponza bakes in seconds |
 
 Drag to orbit, wheel to zoom, WASD to move. The stats line reads the frame time and the mesh SDF bake's

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

@@ -89,6 +89,7 @@
         <span>Indirect light</span>
         <select id="indirect">
             <option value="ProbeClipmap" selected>Probe clipmap</option>
+            <option value="ScreenProbes">Screen probes — Lumen's gather over the clipmap's world</option>
             <option value="IBL">IBL</option>
         </select>
     </label>
@@ -124,6 +125,48 @@
 
     <hr>
 
+    <label>
+        <span>Screen probes</span>
+        <select id="screen_probe_debug_view">
+            <option value="None" selected>Debug: none</option>
+            <option value="IndirectDiffuse">Indirect diffuse — irradiance / π, before the material</option>
+            <option value="ProbePlacement">Probe placement — uniform green, adaptive red, uncovered blue</option>
+            <option value="TraceKinds">Trace kinds — screen red, bricks green, world probes blue</option>
+        </select>
+    </label>
+
+    <label>
+        <span>Downsample</span>
+        <select id="screen_probe_downsample">
+            <option value="2">1 probe / 2×2 pixels</option>
+            <option value="4">1 probe / 4×4 pixels</option>
+            <option value="8">1 probe / 8×8 pixels</option>
+            <option value="16" selected>1 probe / 16×16 pixels</option>
+            <option value="32">1 probe / 32×32 pixels</option>
+        </select>
+    </label>
+
+    <label>
+        <span>Octahedron</span>
+        <select id="screen_probe_octahedron">
+            <option value="4">4×4 rays a probe</option>
+            <option value="8" selected>8×8 rays a probe</option>
+            <option value="16">16×16 rays a probe</option>
+        </select>
+    </label>
+
+    <label>
+        <input type="checkbox" id="screen_probe_importance" checked>
+        <span>Importance sampling <span class="hint">— rays follow the BRDF and last frame's light</span></span>
+    </label>
+
+    <label>
+        <input type="checkbox" id="screen_probe_screen_traces" checked>
+        <span>Screen traces <span class="hint">— the depth buffer before the SDF bricks</span></span>
+    </label>
+
+    <hr>
+
     <label>
         <input type="checkbox" id="sun" checked>
         <span>Sun <span class="hint">— the directional light; L flips it</span></span>
@@ -151,6 +194,11 @@
         <span>TAA <span class="hint">— resolves the probe pick's noise</span></span>
     </label>
 
+    <label>
+        <input type="checkbox" id="auto_exposure" checked>
+        <span>Auto exposure <span class="hint">— off, the exposure is 1</span></span>
+    </label>
+
     <hr>
 
     <label>

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,CAuUzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA0WzB"}

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

@@ -12,6 +12,7 @@ import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCa
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { ProbeClipmapDebugView } from "../../renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
+import { ScreenProbeDebugView } from "../../renderer/global_illumination/screen_probe/ScreenProbeDebugView.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { PointLight } from "../../renderer/light/model/PointLight.js";
 import { place_light } from "../../renderer/light/place_light.js";
@@ -272,6 +273,34 @@ export async function start() {
         renderer.probe_clipmap.debug_view = ProbeClipmapDebugView[event.target.value];
     });
 
+    element('screen_probe_debug_view').addEventListener('change', event => {
+        renderer.screen_probes.debug_view = ScreenProbeDebugView[event.target.value];
+    });
+
+    element('screen_probe_downsample').addEventListener('change', event => {
+        renderer.screen_probes.downsample_factor = Number(event.target.value);
+    });
+
+    element('screen_probe_octahedron').addEventListener('change', event => {
+        renderer.screen_probes.octahedron_resolution = Number(event.target.value);
+    });
+
+    element('screen_probe_importance').addEventListener('change', event => {
+        renderer.screen_probes.importance_sampling = event.target.checked;
+    });
+
+    element('screen_probe_screen_traces').addEventListener('change', event => {
+        renderer.screen_probes.screen_traces = event.target.checked;
+    });
+
+    // ?mode=ScreenProbes starts the page in another mode, as the panel's select would set it
+    const mode = new URLSearchParams(location.search).get('mode');
+
+    if (mode !== null && ShadeIndirectLightingMode[mode] !== undefined) {
+        renderer.indirect_lighting_mode = ShadeIndirectLightingMode[mode];
+        element('indirect').value = mode;
+    }
+
     const taa_toggle = element('taa');
     const path_tracing_toggle = element('path_tracing');
 
@@ -279,6 +308,13 @@ export async function start() {
         renderer.feature_taa_enabled = event.target.checked;
     });
 
+    const auto_exposure_toggle = element('auto_exposure');
+
+    auto_exposure_toggle.checked = renderer.feature_automatic_exposure_enabled;
+    auto_exposure_toggle.addEventListener('change', event => {
+        renderer.feature_automatic_exposure_enabled = event.target.checked;
+    });
+
     /**
      * What TAA was before the tracer turned it off, to give it back when the tracer goes.
      * @type {boolean}