@woosh/meep-engine 3.63.3 → 3.64.0

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

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

@@ -0,0 +1,25 @@
+import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
+import { chunk_PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { chunk_tonemap_gt7 } from "../../shader/chunk/color/tonemap/gt7/chunk_tonemap_gt7.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ToneMapOperator } from "./ToneMapOperator.js";
+
+/**
+ * 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 = new ToneMapOperator("gt7", CodeChunk.from(
+    //language=WGSL
+    `
+fn tone_map_operator(scene: vec3<f32>, peak_nits: f32) -> vec3<f32> {
+    return tonemap_gt7_rec2020(CRM_FROM_REC709_TO_REC2020 * scene, peak_nits, PAPER_WHITE_NITS);
+}
+    `, [
+        chunk_tonemap_gt7,
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_PAPER_WHITE_NITS,
+    ]
+));

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

@@ -0,0 +1,9 @@
+/**
+ * No tone mapping: the exposed colour as it is, with 1.0 at the paper white. An SDR output clips everything above
+ * it, and an HDR output shows it as far as the display reaches.
+ *
+ * @type {ToneMapOperator}
+ */
+export const TONE_MAP_OPERATOR_NONE: ToneMapOperator;
+import { ToneMapOperator } from "./ToneMapOperator.js";
+//# sourceMappingURL=TONE_MAP_OPERATOR_NONE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TONE_MAP_OPERATOR_NONE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/TONE_MAP_OPERATOR_NONE.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,qCAFU,eAAe,CAWtB;gCAjB6B,sBAAsB"}

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

@@ -0,0 +1,20 @@
+import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ToneMapOperator } from "./ToneMapOperator.js";
+
+/**
+ * No tone mapping: the exposed colour as it is, with 1.0 at the paper white. An SDR output clips everything above
+ * it, and an HDR output shows it as far as the display reaches.
+ *
+ * @type {ToneMapOperator}
+ */
+export const TONE_MAP_OPERATOR_NONE = new ToneMapOperator("none", CodeChunk.from(
+    //language=WGSL
+    `
+fn tone_map_operator(scene: vec3<f32>, peak_nits: f32) -> vec3<f32> {
+    return CRM_FROM_REC709_TO_REC2020 * scene;
+}
+    `, [
+        chunk_CRM_FROM_REC709_TO_REC2020,
+    ]
+));

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

@@ -0,0 +1,14 @@
+/**
+ * Khronos PBR Neutral (Lalish, 2024). Base colours under 0.8 come out as they are, less a 0.04 Fresnel offset, and
+ * hues never shift: made for showing products. SDR is the specification, which rolls highlights off to SDR white
+ * and toward white. HDR puts the display's peak over the paper white in place of the specification's 1, so
+ * everything below the compression start looks the same on both outputs; a display under the paper white gets the
+ * SDR form.
+ *
+ * An exposed 0.18 shows at 0.14 of SDR white, where GT7 shows it at 0.179.
+ *
+ * @type {ToneMapOperator}
+ */
+export const TONE_MAP_OPERATOR_PBR_NEUTRAL: ToneMapOperator;
+import { ToneMapOperator } from "./ToneMapOperator.js";
+//# sourceMappingURL=TONE_MAP_OPERATOR_PBR_NEUTRAL.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TONE_MAP_OPERATOR_PBR_NEUTRAL.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/TONE_MAP_OPERATOR_PBR_NEUTRAL.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,4CAFU,eAAe,CActB;gCAzB6B,sBAAsB"}

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

@@ -0,0 +1,30 @@
+import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
+import { chunk_PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { chunk_tonemap_khronos_pbr } from "../../shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ToneMapOperator } from "./ToneMapOperator.js";
+
+/**
+ * Khronos PBR Neutral (Lalish, 2024). Base colours under 0.8 come out as they are, less a 0.04 Fresnel offset, and
+ * hues never shift: made for showing products. SDR is the specification, which rolls highlights off to SDR white
+ * and toward white. HDR puts the display's peak over the paper white in place of the specification's 1, so
+ * everything below the compression start looks the same on both outputs; a display under the paper white gets the
+ * SDR form.
+ *
+ * An exposed 0.18 shows at 0.14 of SDR white, where GT7 shows it at 0.179.
+ *
+ * @type {ToneMapOperator}
+ */
+export const TONE_MAP_OPERATOR_PBR_NEUTRAL = new ToneMapOperator("pbr neutral", CodeChunk.from(
+    //language=WGSL
+    `
+fn tone_map_operator(scene: vec3<f32>, peak_nits: f32) -> vec3<f32> {
+    let peak = max(peak_nits / PAPER_WHITE_NITS, 1.0);
+    return CRM_FROM_REC709_TO_REC2020 * tonemap_khronos_pbr(max(scene, vec3<f32>(0.0)), peak);
+}
+    `, [
+        chunk_tonemap_khronos_pbr,
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_PAPER_WHITE_NITS,
+    ]
+));

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

@@ -0,0 +1,54 @@
+/**
+ * @typedef {import("../../shader/compiler/CodeChunk.js").CodeChunk} CodeChunk
+ * @typedef {import("../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} ShaderResourceGroupDescriptor
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ */
+/**
+ * A tone-mapping function, in WGSL, that {@link ToneMapper} bakes into its LUTs.
+ *
+ * {@link chunk} defines
+ *
+ *     fn tone_map_operator(scene: vec3<f32>, peak_nits: f32) -> vec3<f32>
+ *
+ * - `scene`: exposed linear Rec.709, 1 at the paper white. Not negative; the LUT's encoding clamps at zero.
+ * - `peak_nits`: the display's peak in cd/m². An SDR display is `PAPER_WHITE_NITS`.
+ * - returns linear Rec.2020 display light, 1 at the paper white (`PAPER_WHITE_NITS`).
+ *
+ * An operator whose chunk reads bindings of its own adds them in {@link declare} and supplies them in {@link bind}.
+ * The chunk is linked once into its bake shader, so its text must not change after first use.
+ */
+export class ToneMapOperator {
+    /**
+     * @param {string} label
+     * @param {CodeChunk} chunk defines `tone_map_operator`, see the class
+     */
+    constructor(label: string, chunk: CodeChunk);
+    /**
+     * @readonly
+     * @type {string}
+     */
+    readonly label: string;
+    /**
+     * @readonly
+     * @type {CodeChunk}
+     */
+    readonly chunk: CodeChunk;
+    /**
+     * Add the bindings {@link chunk} reads to the bake shader's group. None by default.
+     *
+     * @param {ShaderResourceGroupDescriptor} group
+     */
+    declare(group: ShaderResourceGroupDescriptor): void;
+    /**
+     * Supply the bindings {@link declare} added, for a bake at `peak_nits`. None by default.
+     *
+     * @param {FrameGraph} graph the frame the bake is recorded into
+     * @param {number} peak_nits
+     * @param {Object} bindings the bake pass's bindings, to add to by name
+     */
+    bind(graph: FrameGraph, peak_nits: number, bindings: any): void;
+}
+export type CodeChunk = import("../../shader/compiler/CodeChunk.js").CodeChunk;
+export type ShaderResourceGroupDescriptor = import("../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor;
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+//# sourceMappingURL=ToneMapOperator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ToneMapOperator.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ToneMapOperator.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACI;;;OAGG;IACH,mBAHW,MAAM,SACN,SAAS,EAkBnB;IAXG;;;OAGG;IACH,gBAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,gBAFU,SAAS,CAED;IAGtB;;;;OAIG;IACH,eAFW,6BAA6B,QAGvC;IAED;;;;;;OAMG;IACH,YAJW,UAAU,aACV,MAAM,uBAIhB;CACJ;wBA3DY,OAAO,oCAAoC,EAAE,SAAS;4CACtD,OAAO,wDAAwD,EAAE,6BAA6B;yBAC9F,OAAO,8DAA8D,EAAE,UAAU"}