@woosh/meep-engine 3.63.2 → 3.64.0

package/src/shade/renderer/buffer/table/GPUDatabaseDefinition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabaseDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabaseDefinition.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;GAUG;AACH;IA0DI;;;;;OAKG;IACH,0CAHW,MAAM,GACJ,qBAAqB,CAIjC;IA9BD;;;OAGG;IACH,2CAFW,MAAM,EAkBhB;IAvDD;;OAEG;IACH,aAFU,uBAAuB,EAAE,CAElB;IAOjB;;;OAGG;IACH,iBAFU,MAAM,CAEA;IA8FhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,eAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,KAAW,EAAE,MAAM,CAAC;QACpB,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,QAAc,EAAE,OAAO,CAAC;QACxB,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,YAAY,CAgDxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gBAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,WAAiB,EAAE,MAAM,CAAC;QAC1B,WAAiB,EAAE,MAAM,CAAC;QAC1B,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,aAAa,CAmDzB;IAiCD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;OAKG;IACH,iBAHW,uBAAuB,GACrB,aAAa,EAAE,CAM3B;IAED;;;;;OAKG;IACH,gBAHW,uBAAuB,GACrB,YAAY,EAAE,CAM1B;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;;;OAOG;IACH,aAiEC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,uBAAuB,GAAC,SAAS,CAM7C;IAED;;OAEG;IACH,0BAEC;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;wCA5fuC,8BAA8B;6BAFzC,mBAAmB;8BAClB,oBAAoB"}
+{"version":3,"file":"GPUDatabaseDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabaseDefinition.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;GAUG;AACH;IA0DI;;;;;OAKG;IACH,0CAHW,MAAM,GACJ,qBAAqB,CAIjC;IA9BD;;;OAGG;IACH,2CAFW,MAAM,EAkBhB;IAvDD;;OAEG;IACH,aAFU,uBAAuB,EAAE,CAElB;IAOjB;;;OAGG;IACH,iBAFU,MAAM,CAEA;IA8FhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,eAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,KAAW,EAAE,MAAM,CAAC;QACpB,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,QAAc,EAAE,OAAO,CAAC;QACxB,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,YAAY,CAgDxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gBAVW;QACV,KAAW,EAAE,MAAM,CAAC;QACpB,WAAiB,EAAE,MAAM,CAAC;QAC1B,WAAiB,EAAE,MAAM,CAAC;QAC1B,eAAqB,EAAE,qBAAqB,CAAC;QAC7C,YAAkB,EAAE,MAAM,CAAC;QAC3B,MAAY,EAAE,OAAO,CAAC;KACnB,GACS,aAAa,CAmDzB;IAiCD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;;;OAKG;IACH,iBAHW,uBAAuB,GACrB,aAAa,EAAE,CAM3B;IAED;;;;;OAKG;IACH,gBAHW,uBAAuB,GACrB,YAAY,EAAE,CAM1B;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;;;OAOG;IACH,aAiEC;IAED;;;;OAIG;IACH,UAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,uBAAuB,GAAC,SAAS,CAM7C;IAED;;OAEG;IACH,0BAEC;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;;CANtD;wCA7fuC,8BAA8B;6BAFzC,mBAAmB;8BAClB,oBAAoB"}

package/src/shade/renderer/buffer/table/GPUDatabaseDefinition.js

@@ -175,7 +175,8 @@ export class GPUDatabaseDefinition {
      * it into every link word the row has, whatever `nullable` says, because a freed row points
      * nowhere; a new page starts with it in every link word too. So a link no write has touched names
      * no row, on a row never written as on one freed, and a value that leaves a link out leaves it
-     * naming nothing.
+     * naming nothing. That holds on the GPU for every occupied row and every freed one; a row the GPU
+     * has never been sent reads 0 there instead (see {@link GPUDatabase}).
      *
      * `owning` means one thing: removing the row that holds the link removes the row it names, and
      * that row's owned rows in turn ({@link GPUTypedTable#remove}). Nothing else follows it.

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

@@ -0,0 +1,158 @@
+/**
+ * The grade as the bake reads it, a uniform. Every field is 16 bytes, in this order, never packed: field i is at byte
+ * 16 · i, which is how {@link ColorGrade#pack} writes it.
+ *
+ * - `white_balance_c0..c2`: the white-balance matrix on linear Rec.709, by column.
+ * - per zone, `{zone}_saturation`, `_contrast`, `_gamma`, `_gain`, `_offset`: the zone's values with the global ones
+ *   folded in and each vector's fourth component applied to the first three, as Unreal's `ColorCorrectAll` combines
+ *   them.
+ * - `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.
+ */
+export const COLOR_GRADE_STRUCT: WebGPUStruct;
+/**
+ * Floats of {@link COLOR_GRADE_STRUCT} at the head of {@link ColorGrade#pack}'s data.
+ * @type {number}
+ */
+export const COLOR_GRADE_HEADER_FLOATS: number;
+/**
+ * Floats of one keyframe in `grade_keys`: time, value, in tangent, out tangent.
+ * @type {number}
+ */
+export const COLOR_GRADE_KEY_FLOATS: number;
+/**
+ * One zone of Unreal's primary grade: shadows, midtones, highlights, or all of them. Each vector is RGB and a master
+ * value that scales (or, for the offset, adds to) all three.
+ */
+export class ColorGradeZone {
+    /**
+     * Blend between the luma and the colour; 0 is grey, 1 leaves it.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly saturation: Vector4;
+    /**
+     * Power about 0.18.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly contrast: Vector4;
+    /**
+     * The colour is raised to 1 / gamma.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly gamma: Vector4;
+    /**
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly gain: Vector4;
+    /**
+     * Added last.
+     * @readonly
+     * @type {Vector4}
+     */
+    readonly offset: Vector4;
+}
+/**
+ * A colour grade on the exposed scene colour, ahead of the tone-mapping operator, baked into the tone mapper's LUTs.
+ * Neutral as constructed. In order:
+ *
+ * 1. **White balance**, Unreal's temperature white balance on linear Rec.709; see `m3_white_balance_rec709`.
+ * 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
+ *    {@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.
+ *    - {@link hue_saturation}: a multiplier on the chroma.
+ *    - {@link hue_lightness}: stops of exposure, the light multiplied by 2^stops at the same chromaticity, weighted by
+ *      the colour's saturation relative to the most saturated Rec.709 colour of its hue. A grey never moves, and a
+ *      colour on the gamut's edge takes the full value.
+ *    All three are read at the colour's hue before any of them applies.
+ *
+ * Read by the tone mapper every frame; any change bakes the LUTs again. A LUT the user supplies is not graded.
+ */
+export class ColorGrade {
+    /**
+     * Colour temperature of the white the grade makes neutral, K. 6500 does nothing.
+     * @type {number}
+     */
+    white_temperature: number;
+    /**
+     * Offset of that white along its isotherm, -1 to 1 as in Unreal. 0 does nothing.
+     * @type {number}
+     */
+    white_tint: number;
+    /**
+     * Applies in every zone, under the zone's own values.
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly global: ColorGradeZone;
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly shadows: ColorGradeZone;
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly midtones: ColorGradeZone;
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    readonly highlights: ColorGradeZone;
+    /**
+     * AP1 luma at which the shadows' weight reaches 0. Unreal's default.
+     * @type {number}
+     */
+    shadows_max: number;
+    /**
+     * AP1 luma at which the highlights' weight starts to rise from 0. Unreal's default.
+     * @type {number}
+     */
+    highlights_min: number;
+    /**
+     * AP1 luma at which the highlights' weight reaches 1. Unreal's default.
+     * @type {number}
+     */
+    highlights_max: number;
+    /**
+     * Degrees added to the OkLCh hue, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly hue_shift: AnimationCurve;
+    /**
+     * Multiplier on the OkLCh chroma, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    readonly hue_saturation: AnimationCurve;
+    /**
+     * Stops of exposure, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    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
+     * key count stays the same.
+     *
+     * @returns {Float32Array}
+     */
+    pack(): Float32Array;
+    #private;
+}
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { Vector4 } from "../../../../core/geom/Vector4.js";
+import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
+//# sourceMappingURL=ColorGrade.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,337 @@
+import { assert } from "../../../../core/assert.js";
+import { Vector4 } from "../../../../core/geom/Vector4.js";
+import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
+import { vec4f, vec4u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { m3_white_balance_rec709, WHITE_BALANCE_NEUTRAL_TEMPERATURE, WHITE_BALANCE_NEUTRAL_TINT } from "./m3_white_balance_rec709.js";
+
+/**
+ * The grade as the bake reads it, a uniform. Every field is 16 bytes, in this order, never packed: field i is at byte
+ * 16 · i, which is how {@link ColorGrade#pack} writes it.
+ *
+ * - `white_balance_c0..c2`: the white-balance matrix on linear Rec.709, by column.
+ * - per zone, `{zone}_saturation`, `_contrast`, `_gamma`, `_gain`, `_offset`: the zone's values with the global ones
+ *   folded in and each vector's fourth component applied to the first three, as Unreal's `ColorCorrectAll` combines
+ *   them.
+ * - `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.
+ */
+export const COLOR_GRADE_STRUCT = WebGPUStruct.from({
+    white_balance_c0: vec4f,
+    white_balance_c1: vec4f,
+    white_balance_c2: vec4f,
+
+    shadows_saturation: vec4f,
+    shadows_contrast: vec4f,
+    shadows_gamma: vec4f,
+    shadows_gain: vec4f,
+    shadows_offset: vec4f,
+
+    midtones_saturation: vec4f,
+    midtones_contrast: vec4f,
+    midtones_gamma: vec4f,
+    midtones_gain: vec4f,
+    midtones_offset: vec4f,
+
+    highlights_saturation: vec4f,
+    highlights_contrast: vec4f,
+    highlights_gamma: vec4f,
+    highlights_gain: vec4f,
+    highlights_offset: vec4f,
+
+    zone_bounds: vec4f,
+    curve_counts: vec4u,
+});
+
+/**
+ * Floats of {@link COLOR_GRADE_STRUCT} at the head of {@link ColorGrade#pack}'s data.
+ * @type {number}
+ */
+export const COLOR_GRADE_HEADER_FLOATS = 80;
+
+/**
+ * Floats of one keyframe in `grade_keys`: time, value, in tangent, out tangent.
+ * @type {number}
+ */
+export const COLOR_GRADE_KEY_FLOATS = 4;
+
+/**
+ * One zone of Unreal's primary grade: shadows, midtones, highlights, or all of them. Each vector is RGB and a master
+ * value that scales (or, for the offset, adds to) all three.
+ */
+export class ColorGradeZone {
+    /**
+     * Blend between the luma and the colour; 0 is grey, 1 leaves it.
+     * @readonly
+     * @type {Vector4}
+     */
+    saturation = new Vector4(1, 1, 1, 1);
+
+    /**
+     * Power about 0.18.
+     * @readonly
+     * @type {Vector4}
+     */
+    contrast = new Vector4(1, 1, 1, 1);
+
+    /**
+     * The colour is raised to 1 / gamma.
+     * @readonly
+     * @type {Vector4}
+     */
+    gamma = new Vector4(1, 1, 1, 1);
+
+    /**
+     * @readonly
+     * @type {Vector4}
+     */
+    gain = new Vector4(1, 1, 1, 1);
+
+    /**
+     * Added last.
+     * @readonly
+     * @type {Vector4}
+     */
+    offset = new Vector4(0, 0, 0, 0);
+}
+
+const scratch_m3 = new Float64Array(9);
+
+/**
+ * @param {Float32Array} out
+ * @param {number} at float index
+ * @param {Vector4} zone
+ * @param {Vector4} global
+ */
+function write_product(out, at, zone, global) {
+    const master = zone[3] * global[3];
+
+    out[at] = zone[0] * global[0] * master;
+    out[at + 1] = zone[1] * global[1] * master;
+    out[at + 2] = zone[2] * global[2] * master;
+    out[at + 3] = 0;
+}
+
+/**
+ * @param {Float32Array} out
+ * @param {number} at float index
+ * @param {Vector4} zone
+ * @param {Vector4} global
+ */
+function write_sum(out, at, zone, global) {
+    const master = zone[3] + global[3];
+
+    out[at] = zone[0] + global[0] + master;
+    out[at + 1] = zone[1] + global[1] + master;
+    out[at + 2] = zone[2] + global[2] + master;
+    out[at + 3] = 0;
+}
+
+/**
+ * @param {Float32Array} out
+ * @param {number} at float index
+ * @param {ColorGradeZone} zone
+ * @param {ColorGradeZone} global
+ */
+function write_zone(out, at, zone, global) {
+    write_product(out, at, zone.saturation, global.saturation);
+    write_product(out, at + 4, zone.contrast, global.contrast);
+    write_product(out, at + 8, zone.gamma, global.gamma);
+    write_product(out, at + 12, zone.gain, global.gain);
+    write_sum(out, at + 16, zone.offset, global.offset);
+}
+
+/**
+ * @param {Float32Array} out
+ * @param {number} at float index
+ * @param {AnimationCurve} curve
+ * @returns {number} the float index after the curve's keys
+ */
+function write_keys(out, at, curve) {
+    const keys = curve.keys;
+    const count = keys.length;
+
+    for (let i = 0; i < count; i++) {
+        const key = keys[i];
+
+        out[at] = key.time;
+        out[at + 1] = key.value;
+        out[at + 2] = key.inTangent;
+        out[at + 3] = key.outTangent;
+
+        at += COLOR_GRADE_KEY_FLOATS;
+    }
+
+    return at;
+}
+
+/**
+ * A colour grade on the exposed scene colour, ahead of the tone-mapping operator, baked into the tone mapper's LUTs.
+ * Neutral as constructed. In order:
+ *
+ * 1. **White balance**, Unreal's temperature white balance on linear Rec.709; see `m3_white_balance_rec709`.
+ * 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
+ *    {@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.
+ *    - {@link hue_saturation}: a multiplier on the chroma.
+ *    - {@link hue_lightness}: stops of exposure, the light multiplied by 2^stops at the same chromaticity, weighted by
+ *      the colour's saturation relative to the most saturated Rec.709 colour of its hue. A grey never moves, and a
+ *      colour on the gamut's edge takes the full value.
+ *    All three are read at the colour's hue before any of them applies.
+ *
+ * Read by the tone mapper every frame; any change bakes the LUTs again. A LUT the user supplies is not graded.
+ */
+export class ColorGrade {
+    /**
+     * Colour temperature of the white the grade makes neutral, K. 6500 does nothing.
+     * @type {number}
+     */
+    white_temperature = WHITE_BALANCE_NEUTRAL_TEMPERATURE;
+
+    /**
+     * Offset of that white along its isotherm, -1 to 1 as in Unreal. 0 does nothing.
+     * @type {number}
+     */
+    white_tint = WHITE_BALANCE_NEUTRAL_TINT;
+
+    /**
+     * Applies in every zone, under the zone's own values.
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    global = new ColorGradeZone();
+
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    shadows = new ColorGradeZone();
+
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    midtones = new ColorGradeZone();
+
+    /**
+     * @readonly
+     * @type {ColorGradeZone}
+     */
+    highlights = new ColorGradeZone();
+
+    /**
+     * AP1 luma at which the shadows' weight reaches 0. Unreal's default.
+     * @type {number}
+     */
+    shadows_max = 0.09;
+
+    /**
+     * AP1 luma at which the highlights' weight starts to rise from 0. Unreal's default.
+     * @type {number}
+     */
+    highlights_min = 0.5;
+
+    /**
+     * AP1 luma at which the highlights' weight reaches 1. Unreal's default.
+     * @type {number}
+     */
+    highlights_max = 1;
+
+    /**
+     * Degrees added to the OkLCh hue, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    hue_shift = new AnimationCurve();
+
+    /**
+     * Multiplier on the OkLCh chroma, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    hue_saturation = new AnimationCurve();
+
+    /**
+     * Stops of exposure, against the hue in degrees.
+     * @readonly
+     * @type {AnimationCurve}
+     */
+    hue_lightness = new AnimationCurve();
+
+    /**
+     * @type {Float32Array}
+     */
+    #data = new Float32Array(COLOR_GRADE_HEADER_FLOATS + COLOR_GRADE_KEY_FLOATS);
+
+    /**
+     * {@link #data}'s words, for the curve counts.
+     * @type {Uint32Array}
+     */
+    #words = new Uint32Array(this.#data.buffer);
+
+    /**
+     * 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
+     * key count stays the same.
+     *
+     * @returns {Float32Array}
+     */
+    pack() {
+        assert.isNumber(this.white_temperature, 'white_temperature');
+        assert.greaterThan(this.white_temperature, 0, 'white_temperature');
+        assert.isNumber(this.white_tint, 'white_tint');
+
+        const hue_count = this.hue_shift.keys.length;
+        const saturation_count = this.hue_saturation.keys.length;
+        const lightness_count = this.hue_lightness.keys.length;
+
+        const length = COLOR_GRADE_HEADER_FLOATS
+            + COLOR_GRADE_KEY_FLOATS * Math.max(1, hue_count + saturation_count + lightness_count);
+
+        if (this.#data.length !== length) {
+            this.#data = new Float32Array(length);
+            this.#words = new Uint32Array(this.#data.buffer);
+        }
+
+        const out = this.#data;
+
+        m3_white_balance_rec709(scratch_m3, this.white_temperature, this.white_tint);
+
+        for (let column = 0; column < 3; column++) {
+            out[column * 4] = scratch_m3[column];
+            out[column * 4 + 1] = scratch_m3[3 + column];
+            out[column * 4 + 2] = scratch_m3[6 + column];
+            out[column * 4 + 3] = 0;
+        }
+
+        write_zone(out, 12, this.shadows, this.global);
+        write_zone(out, 32, this.midtones, this.global);
+        write_zone(out, 52, this.highlights, this.global);
+
+        out[72] = this.shadows_max;
+        out[73] = this.highlights_min;
+        out[74] = this.highlights_max;
+        out[75] = 0;
+
+        const words = this.#words;
+        words[76] = hue_count;
+        words[77] = saturation_count;
+        words[78] = lightness_count;
+        words[79] = 0;
+
+        let at = COLOR_GRADE_HEADER_FLOATS;
+        at = write_keys(out, at, this.hue_shift);
+        at = write_keys(out, at, this.hue_saturation);
+        at = write_keys(out, at, this.hue_lightness);
+
+        out.fill(0, at);
+
+        return out;
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Trilinear over a tone-mapping LUT. Clamp-to-edge, so a coordinate on the outer texel centres reads that texel
+ * alone; the LUT has no mips.
+ *
+ * @type {Readonly<SamplerDescriptor>}
+ */
+export const SAMPLER_TONEMAP_LUT: Readonly<SamplerDescriptor>;
+import { SamplerDescriptor } from "../../../descriptor/texture/SamplerDescriptor.js";
+//# sourceMappingURL=SAMPLER_TONEMAP_LUT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SAMPLER_TONEMAP_LUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/SAMPLER_TONEMAP_LUT.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,kCAFU,SAAS,iBAAiB,CAAC,CAQjC;kCAd8B,kDAAkD"}

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

@@ -0,0 +1,15 @@
+import { SamplerDescriptor } from "../../../descriptor/texture/SamplerDescriptor.js";
+
+/**
+ * Trilinear over a tone-mapping LUT. Clamp-to-edge, so a coordinate on the outer texel centres reads that texel
+ * alone; the LUT has no mips.
+ *
+ * @type {Readonly<SamplerDescriptor>}
+ */
+export const SAMPLER_TONEMAP_LUT = Object.freeze(SamplerDescriptor.from({
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge",
+    addressModeW: "clamp-to-edge",
+}));

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

@@ -0,0 +1,6 @@
+/**
+ * @type {ToneMapOperator}
+ */
+export const TONE_MAP_OPERATOR_ACES: ToneMapOperator;
+import { ToneMapOperator } from "./ToneMapOperator.js";
+//# sourceMappingURL=TONE_MAP_OPERATOR_ACES.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TONE_MAP_OPERATOR_ACES.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/TONE_MAP_OPERATOR_ACES.js"],"names":[],"mappings":"AAgFA;;GAEG;AACH,qCAFU,eAAe,CAEuC;gCAzEhC,sBAAsB"}

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

@@ -0,0 +1,84 @@
+import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
+import { ACES2_BLOCK_FLOATS } from "../../shader/chunk/color/tonemap/aces/aces2_transform_block.js";
+import { chunk_aces2_output_transform } from "../../shader/chunk/color/tonemap/aces/chunk_aces2_output_transform.js";
+import { chunk_tonemap_ue_filmic } from "../../shader/chunk/color/tonemap/aces/chunk_tonemap_ue_filmic.js";
+import { chunk_PAPER_WHITE_NITS, PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { graph_import_raw_buffer } from "../../shader/graph/graph_import_raw_buffer.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { TonemapAces2Tables } from "./TonemapAces2Tables.js";
+import { ToneMapOperator } from "./ToneMapOperator.js";
+
+const chunk = CodeChunk.from(
+    //language=WGSL
+    `
+const ACES2_SDR_BLOCK: u32 = 0u;
+const ACES2_DISPLAY_BLOCK: u32 = ${ACES2_BLOCK_FLOATS}u;
+
+fn tone_map_operator(scene: vec3<f32>, peak_nits: f32) -> vec3<f32> {
+    // the SDR picture first, which is what Unreal 5.8 does with Filmic on any display
+    var picture = tonemap_ue_filmic(scene);
+
+    if (peak_nits > PAPER_WHITE_NITS) {
+        // back to the scene through ACES 2.0 at SDR white, then out again through ACES 2.0 at the display's peak over
+        // the paper white. Both transforms take SDR white for 100 cd/m² and both are limited to Rec.709, the SDR
+        // picture's own gamut, so as the headroom shrinks to none the picture becomes the SDR one.
+        picture = aces2_forward(ACES2_DISPLAY_BLOCK, aces2_inverse(ACES2_SDR_BLOCK, picture));
+    }
+
+    return CRM_FROM_REC709_TO_REC2020 * picture;
+}
+    `, [
+        chunk_tonemap_ue_filmic,
+        chunk_aces2_output_transform,
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_PAPER_WHITE_NITS,
+    ]
+);
+
+/**
+ * Unreal Engine's default look, the tone mapper's default too.
+ *
+ * - **SDR** is UE's "Filmic" tone mapper at its default settings, the ACES-derived curve every Unreal title ships with
+ *   unless it chose otherwise.
+ * - **HDR** is what Unreal 5.8 does with the same method: the SDR picture, taken back to the scene through the inverse
+ *   ACES 2.0 output transform for an SDR display, and rendered again with the ACES 2.0 output transform for the
+ *   display's headroom, both limited to Rec.709. A display at or under the paper white shows the SDR picture.
+ *
+ * An exposed 0.18 shows at 0.18 of SDR white, with a mid-tone contrast of 1.36 against GT7's 1.05. On HDR the picture
+ * expands into the headroom and mid-grey rises with it, by ACES 2.0's design: 0.26 of SDR white at 1000 cd/m².
+ *
+ * Binds `aces2_tables`, the two transforms' parameters and gamut tables, built by {@link TonemapAces2Tables} for the
+ * peak of each HDR bake.
+ */
+class ToneMapOperatorAces extends ToneMapOperator {
+    #tables = new TonemapAces2Tables();
+
+    constructor() {
+        super("aces", chunk);
+    }
+
+    declare(group) {
+        group.addStorageBuffer("aces2_tables", WebGPUArray.from(f32));
+    }
+
+    bind(graph, peak_nits, bindings) {
+        // an SDR bake never reads the tables, so they are not built for it
+        if (peak_nits > PAPER_WHITE_NITS) {
+            this.#tables.update(peak_nits);
+        }
+
+        bindings.aces2_tables = graph_import_raw_buffer({
+            graph,
+            value: this.#tables.data.buffer,
+            label: "tonemap/aces2 tables",
+            usage: GPUBufferUsage.STORAGE,
+        });
+    }
+}
+
+/**
+ * @type {ToneMapOperator}
+ */
+export const TONE_MAP_OPERATOR_ACES = new ToneMapOperatorAces();

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

@@ -0,0 +1,10 @@
+/**
+ * GT7 tone mapping (Polyphony Digital, SIGGRAPH 2025), in its own Rec.2020. An exposed 1.0 shows at the paper white
+ * on every display. On SDR the peak is the paper white, the curve's SDR mode, which clips there; HDR rolls off to the
+ * display's peak.
+ *
+ * @type {ToneMapOperator}
+ */
+export const TONE_MAP_OPERATOR_GT7: ToneMapOperator;
+import { ToneMapOperator } from "./ToneMapOperator.js";
+//# sourceMappingURL=TONE_MAP_OPERATOR_GT7.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TONE_MAP_OPERATOR_GT7.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/TONE_MAP_OPERATOR_GT7.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,oCAFU,eAAe,CAatB;gCApB6B,sBAAsB"}