@woosh/meep-engine 3.65.0 → 3.67.0

package/package.json

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

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

@@ -151,6 +151,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":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA8UzB"}

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

@@ -279,6 +279,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}

package/src/shade/renderer/Renderer.js

@@ -3404,8 +3404,6 @@ export class Renderer {
             });
         }
 
-        let exposure = -1;
-
         /*
          The scene as it stands before bloom composites over it: what the metering reads, and what
          bloom reads too.
@@ -3437,21 +3435,22 @@ export class Renderer {
             current_color_out = bloom.composited;
         }
 
-        if (this.feature_automatic_exposure_enabled) {
-            // TODO force time_delta_second to a very high value on view transition
+        const gr_exposure_adaptation = graph_import_buffer(graph, this.#autoexposure.adaptation, "exposure adaptation");
 
-            exposure = this.#autoexposure.update({
+        // TODO force time_delta_second to a very high value on view transition
+        const exposure = this.feature_automatic_exposure_enabled
+            ? this.#autoexposure.update({
                 graph,
                 input_color: metered_color,
                 multiplier: gr_exposure_multiplier,
+                adaptation: gr_exposure_adaptation,
                 time_delta_seconds,
+            })
+            : this.#autoexposure.unadapted({
+                graph,
+                multiplier: gr_exposure_multiplier,
+                adaptation: gr_exposure_adaptation,
             });
-        }
-
-
-        if (this.feature_automatic_exposure_enabled === false) {
-            exposure = this.#autoexposure.unadapted({ graph, multiplier: gr_exposure_multiplier });
-        }
 
 
         // current_color_out = graph_draw_texture_as_rgba({
@@ -3477,7 +3476,8 @@ export class Renderer {
         current_color_out = this.tone_mapper.render({
             graph,
             input_color: current_color_out,
-            exposure,
+            exposure: exposure.multiplier,
+            adaptation: exposure.adaptation,
             hdr: this.#hdr_supported,
             target: gr_texture_canvas,
         });

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

@@ -9,6 +9,10 @@
  * - `zone_bounds`: `shadows_max`, `highlights_min`, `highlights_max`.
  * - `curve_counts`: the keys of the hue, saturation and lightness curves. They follow the uniform in `grade_keys`, in
  *   that order.
+ * - `luma_curve_counts`: the keys of the red, green, blue and all-channel saturation-against-luma curves. They follow
+ *   the hue curves' keys in `grade_keys`, in that order.
+ * - `luma_gain_counts`: the keys of the red, green and blue gain-against-luma curves and the exposure-against-luma
+ *   curve. They follow the saturation-against-luma curves' keys in `grade_keys`, in that order.
  */
 export const COLOR_GRADE_STRUCT: WebGPUStruct;
 /**
@@ -64,8 +68,20 @@ export class ColorGradeZone {
  * 2. **Primaries**, Unreal's `ColorCorrectAll` in AP1: saturation, contrast, gamma, gain and offset for {@link global},
  *    {@link shadows}, {@link midtones} and {@link highlights}, the zones blended by AP1 luma between
  *    {@link shadows_max}, {@link highlights_min} and {@link highlights_max}. Values from an Unreal project's post-process
- *    settings give the same result. The colour is clamped at zero in Rec.709 after it, as the operator takes it.
- * 3. **Hue curves**, in OkLCh. Each curve's time is the colour's OkLCh hue in degrees, 0 to 360, and is evaluated as
+ *    settings give the same result.
+ * 3. **Gain against luma**, in AP1 after the primaries: each channel multiplied by its gain at the colour's AP1 luma's
+ *    stops from middle grey — {@link luma_gain_red}, {@link luma_gain_green}, {@link luma_gain_blue} — and every channel
+ *    by 2 to the power of {@link luma_exposure} there. Grading by tonal range at any luma, with any blend between ranges:
+ *    a range that fades in and out over spans of stops, as a smoothstep does, is a cubic between its edges, so ranges
+ *    sum exactly into curves keyed at their edges. A curve with no keys is a gain of 1, or an exposure of 0. Clamped at
+ *    zero.
+ * 4. **Saturation against luma**, after the gain against luma: each channel drawn away from the colour's AP1 luma by its
+ *    factor at that luma's stops from middle grey, `log2(luma / 0.18)`: {@link luma_saturation} times the channel's
+ *    own curve — {@link luma_saturation_red}, {@link luma_saturation_green}, {@link luma_saturation_blue}. Unreal's
+ *    saturation and per-channel saturation, varying across the tonal range. Each curve is evaluated as
+ *    {@link AnimationCurve#evaluate} would and holds its end keys' values beyond them; a curve with no keys is a factor
+ *    of 1, and a colour with no luma is left as it is. Clamped at zero, as the primaries' saturation is. The colour is clamped at zero in Rec.709 after it, as the operator takes it.
+ * 5. **Hue curves**, in OkLCh. Each curve's time is the colour's OkLCh hue in degrees, 0 to 360, and is evaluated as
  *    {@link AnimationCurve#evaluate} would; a curve with no keys does nothing. The curve holds its end keys' values
  *    outside them, so for a seamless circle key 0 and 360 with the same value and tangent.
  *    - {@link hue_shift}: degrees added to the hue.
@@ -143,8 +159,61 @@ export class ColorGrade {
      */
     readonly hue_lightness: AnimationCurve;
     /**
-     * The grade as the bake reads it: {@link COLOR_GRADE_STRUCT}, then the three curves' keys, each
-     * {@link COLOR_GRADE_KEY_FLOATS} floats, with room for one key when there are none. The array is reused while the
+     * Saturation of every channel against the colour's AP1 luma in stops from middle grey: 1 leaves it, 0 draws it to
+     * the luma. Each channel's own curve multiplies it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation: AnimationCurve;
+    /**
+     * Saturation of the red channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation_red: AnimationCurve;
+    /**
+     * Saturation of the green channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation_green: AnimationCurve;
+    /**
+     * Saturation of the blue channel against the colour's AP1 luma in stops from middle grey, times
+     * {@link luma_saturation}.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_saturation_blue: AnimationCurve;
+    /**
+     * Gain of the red channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_gain_red: AnimationCurve;
+    /**
+     * Gain of the green channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_gain_green: AnimationCurve;
+    /**
+     * Gain of the blue channel against the colour's AP1 luma in stops from middle grey: 1 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_gain_blue: AnimationCurve;
+    /**
+     * Exposure of every channel against the colour's AP1 luma in stops from middle grey, in stops: 0 leaves it.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly luma_exposure: AnimationCurve;
+    /**
+     * The grade as the bake reads it: {@link COLOR_GRADE_STRUCT}, then the three hue curves' keys, the four
+     * saturation-against-luma curves' keys (red, green, blue, all) and the four gain-against-luma curves' keys (red,
+     * green, blue, exposure), each {@link COLOR_GRADE_KEY_FLOATS} floats, with room for one key when there are none. The array is reused while the
      * key count stays the same.
      *
      * @returns {Float32Array}

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

@@ -1 +1 @@
-{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ColorGrade.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,8CAyBG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH;IACI;;;;OAIG;IACH,qBAFU,OAAO,CAEoB;IAErC;;;;OAIG;IACH,mBAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,gBAFU,OAAO,CAEe;IAEhC;;;OAGG;IACH,eAFU,OAAO,CAEc;IAE/B;;;;OAIG;IACH,iBAFU,OAAO,CAEgB;CACpC;AAwED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACI;;;OAGG;IACH,mBAFU,MAAM,CAEsC;IAEtD;;;OAGG;IACH,YAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,iBAFU,cAAc,CAEM;IAE9B;;;OAGG;IACH,kBAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,mBAFU,cAAc,CAEQ;IAEhC;;;OAGG;IACH,qBAFU,cAAc,CAEU;IAElC;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,oBAFU,cAAc,CAES;IAEjC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAarC;;;;;;OAMG;IACH,QAFa,YAAY,CAqDxB;;CACJ;6BA5U4B,mCAAmC;wBAHxC,kCAAkC;+BAC3B,sDAAsD"}
+{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ColorGrade.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,8CA2BG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH;IACI;;;;OAIG;IACH,qBAFU,OAAO,CAEoB;IAErC;;;;OAIG;IACH,mBAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,gBAFU,OAAO,CAEe;IAEhC;;;OAGG;IACH,eAFU,OAAO,CAEc;IAE/B;;;;OAIG;IACH,iBAFU,OAAO,CAEgB;CACpC;AAwED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACI;;;OAGG;IACH,mBAFU,MAAM,CAEsC;IAEtD;;;OAGG;IACH,YAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,iBAFU,cAAc,CAEM;IAE9B;;;OAGG;IACH,kBAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,mBAFU,cAAc,CAEQ;IAEhC;;;OAGG;IACH,qBAFU,cAAc,CAEU;IAElC;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,oBAFU,cAAc,CAES;IAEjC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAErC;;;;;OAKG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;;OAKG;IACH,8BAFU,cAAc,CAEmB;IAE3C;;;;;OAKG;IACH,gCAFU,cAAc,CAEqB;IAE7C;;;;;OAKG;IACH,+BAFU,cAAc,CAEoB;IAE5C;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAErC;;;;OAIG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAarC;;;;;;;OAOG;IACH,QAFa,YAAY,CAgFxB;;CACJ;6BAtb4B,mCAAmC;wBAHxC,kCAAkC;+BAC3B,sDAAsD"}