@woosh/meep-engine 3.46.0 → 3.49.0

package/src/shade/playground/tonemap_sdr/ToneMapCompare.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The operators this page compares, in the order the shader's `switch` takes them.
+ *
+ * {@link GT7 } and {@link PBRNeutral } take a peak, {@link ToneMapCompareheadroom }; at 1 they are what the renderer runs
+ * on an SDR display. {@link GT7Reference } is SDR only and ignores it.
+ */
+export type CompareOperator = number;
+export namespace CompareOperator {
+    let GT7Reference: number;
+    let GT7: number;
+    let PBRNeutral: number;
+}
+export const COMPARE_OPERATOR_LABELS: string[];
+/**
+ * The exposure that puts an exposed 0.18 at 0.18 out, per operator, as a multiplier. Solved by bisection on CPU ports
+ * of the same functions (each port checked against its source; the GT7 one against Polyphony's compiled sample code
+ * to 1.8e-4). Used only when "match mid-grey" is on. Both engine operators write mid-grey the same at every peak.
+ *
+ * @type {number[]}
+ */
+export const MID_GREY_GAIN: number[];
+/**
+ * How the comparison is laid out.
+ */
+export type CompareLayout = number;
+export namespace CompareLayout {
+    let Pair: number;
+    let Single: number;
+    let Split: number;
+}
+/**
+ * Draws the scene through the engine's tone mapping operators, in place of the engine's own tonemap.
+ *
+ * The engine still tonemaps the frame; this overwrites the canvas afterwards from the same HDR colour, so every
+ * operator sees exactly the input the renderer's tonemap pass sees. Exposure is the page's own, fixed: turn the engine's
+ * automatic exposure off, or the engine's picture and this one will not agree.
+ */
+export class ToneMapCompare {
+    /**
+     * Off: the engine's own output is left on the canvas.
+     * @type {boolean}
+     */
+    enabled: boolean;
+    /**
+     * @type {CompareLayout}
+     */
+    layout: CompareLayout;
+    /**
+     * Which operator {@link CompareLayout.Single} and {@link CompareLayout.Split} show.
+     * @type {CompareOperator}
+     */
+    operator: CompareOperator;
+    /**
+     * The display's peak in units of SDR white, for the operators that take one. 1 is their SDR form. 4 is a
+     * 1000 cd/m² display under the 250 cd/m² paper white, which is what the renderer assumes for HDR.
+     *
+     * {@link CompareLayout.Single} shows the operator at this peak, clipped to SDR white; {@link CompareLayout.Split}
+     * shows it on the right half only, beside the SDR form.
+     * @type {number}
+     */
+    headroom: number;
+    /**
+     * In f-stops, over a scene value of 1.
+     * @type {number}
+     */
+    exposure_ev: number;
+    /**
+     * Give each operator the exposure that puts 0.18 at 0.18 out, so the pair compares shapes rather than brightness.
+     * @type {boolean}
+     */
+    match_mid_grey: boolean;
+    /**
+     * Convert to Display P3 before encoding. Right for a canvas configured `display-p3`, which is how the engine
+     * configures its canvas; every tonemap pass converts the same way. Off writes Rec.709 values into it, as
+     * `shader_tonemap_LDR` did before it converted.
+     * @type {boolean}
+     */
+    convert_to_p3: boolean;
+    extensions: (CaptureToneMapInput | DrawToneMapCompare)[];
+}
+/**
+ * The last thing at {@link FramePhase.BeforePresent}: hold on to the HDR colour the tonemapper is about to read.
+ */
+declare class CaptureToneMapInput extends RenderExtension {
+    /**
+     * @param {ToneMapCompare} owner
+     */
+    constructor(owner: ToneMapCompare);
+    record(frame: any): void;
+    #private;
+}
+/**
+ * The first thing at {@link FramePhase.Overlay}: draw the comparison over the canvas the engine's tonemapper wrote.
+ */
+declare class DrawToneMapCompare extends RenderExtension {
+    /**
+     * @param {ToneMapCompare} owner
+     */
+    constructor(owner: ToneMapCompare);
+    record(frame: any): void;
+    #private;
+}
+import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
+export {};
+//# sourceMappingURL=ToneMapCompare.d.ts.map

package/src/shade/playground/tonemap_sdr/ToneMapCompare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToneMapCompare.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/tonemap_sdr/ToneMapCompare.js"],"names":[],"mappings":";;;;;;8BA6BU,MAAM;;;;;;AAiBhB,+CAIE;AAEF;;;;;;GAMG;AACH,4BAFU,MAAM,EAAE,CAEoC;;;;4BAK5C,MAAM;;;;;;AAiQhB;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;OAEG;IACH,QAFU,aAAa,CAEK;IAE5B;;;OAGG;IACH,UAFU,eAAe,CAEa;IAEtC;;;;;;;OAOG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,gBAFU,OAAO,CAEM;IAEvB;;;;;OAKG;IACH,eAFU,OAAO,CAEI;IAGjB,yDAA+E;CAEtF;AAhJD;;GAEG;AACH;IAUI;;OAEG;IACH,mBAFW,cAAc,EAMxB;IAED,yBAMC;;CACJ;AAED;;GAEG;AACH;IAUI;;OAEG;IACH,mBAFW,cAAc,EAMxB;IAED,yBA8BC;;CACJ;gCA5T+B,6CAA6C"}

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

@@ -0,0 +1,380 @@
+import { FramePhase } from "../../renderer/extension/FramePhase.js";
+import { FrameRecord } from "../../renderer/extension/FrameRecord.js";
+import { PresentTarget } from "../../renderer/extension/PresentTarget.js";
+import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
+import { SceneColor } from "../../renderer/extension/SceneColor.js";
+import { chunk_CRM_FROM_REC2020_TO_P3 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC2020_TO_P3.js";
+import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
+import { chunk_sRGBTransferOETF } from "../../renderer/shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
+import { chunk_PAPER_WHITE_NITS } from "../../renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { chunk_tonemap_khronos_pbr } from "../../renderer/shader/chunk/color/tonemap/chunk_tonemap_khronos_pbr.js";
+import { chunk_tonemap_gt7 } from "../../renderer/shader/chunk/color/tonemap/gt7/chunk_tonemap_gt7.js";
+import {
+    chunk_dither_color_8bit_triangle_noise
+} from "../../renderer/shader/chunk/texture/dither/chunk_dither_color_8bit_triangle_noise.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { graph_image_pass } from "../../renderer/shader/graph/graph_image_pass.js";
+import { ImageShader } from "../../renderer/shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../renderer/shader/ShaderDescriptor.js";
+import { f32, u32 } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { chunk_tonemap_gt7_sdr_reference } from "./chunk_tonemap_gt7_sdr_reference.js";
+
+/**
+ * The operators this page compares, in the order the shader's `switch` takes them.
+ *
+ * {@link GT7} and {@link PBRNeutral} take a peak, {@link ToneMapCompare#headroom}; at 1 they are what the renderer runs
+ * on an SDR display. {@link GT7Reference} is SDR only and ignores it.
+ *
+ * @enum {number}
+ */
+export const CompareOperator = {
+    /** GT7's sample code in SDR mode, {@link chunk_tonemap_gt7_sdr_reference}: a reference for the engine's GT7 */
+    GT7Reference: 0,
+    /**
+     * the engine's `tonemap_gt7` with the paper white at `PAPER_WHITE_NITS` and the peak at the headroom times that:
+     * what `ShadeToneMappingMode.GT7` runs
+     */
+    GT7: 1,
+    /**
+     * the engine's `tonemap_khronos_pbr` at the headroom: what `ShadeToneMappingMode.PBR_NEUTRAL` runs, and at
+     * headroom 1 the Khronos specification
+     */
+    PBRNeutral: 2,
+};
+
+export const COMPARE_OPERATOR_LABELS = [
+    'GT7 SDR (Polyphony sample)',
+    'GT7 (engine)',
+    'PBR Neutral (engine)',
+];
+
+/**
+ * The exposure that puts an exposed 0.18 at 0.18 out, per operator, as a multiplier. Solved by bisection on CPU ports
+ * of the same functions (each port checked against its source; the GT7 one against Polyphony's compiled sample code
+ * to 1.8e-4). Used only when "match mid-grey" is on. Both engine operators write mid-grey the same at every peak.
+ *
+ * @type {number[]}
+ */
+export const MID_GREY_GAIN = [1.0033, 1.0033, 1.2222];
+
+/**
+ * How the comparison is laid out.
+ *
+ * @enum {number}
+ */
+export const CompareLayout = {
+    /**
+     * the engine's two operators side by side, {@link CompareOperator.GT7} on the left and
+     * {@link CompareOperator.PBRNeutral} on the right, each the whole frame at half size
+     */
+    Pair: 0,
+    /** one operator, full size */
+    Single: 1,
+    /**
+     * one operator, its SDR form on the left half and its form at {@link ToneMapCompare#headroom} on the right, both
+     * clipped to SDR white: what an HDR display shows below SDR white. Where the two forms agree, the seam is invisible.
+     */
+    Split: 2,
+};
+
+const SETTINGS = WebGPUStruct.from({
+    exposure: f32,
+    gain_0: f32,
+    gain_1: f32,
+    gain_2: f32,
+    /** the display's peak in units of SDR white, for the operators that take one */
+    headroom: f32,
+    layout_index: u32,
+    operator_index: u32,
+    /** 1: convert Rec.709 to Display P3 before encoding, for a canvas configured `display-p3` */
+    to_p3: u32,
+});
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SETTINGS);
+resources.createGroup()
+    .addTexture("input_color", "float");
+
+const shader_tonemap_compare = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "tonemap_sdr/compare",
+        resources,
+        body: CodeChunk.from(
+            //language=WGSL
+            `
+fn compare_gain(op: u32) -> f32 {
+    switch op {
+        case 0u: { return settings.gain_0; }
+        case 1u: { return settings.gain_1; }
+        default: { return settings.gain_2; }
+    }
+}
+
+// headroom: the peak in units of SDR white, 1 for the SDR form. Every result is clipped to SDR white, so above 1 this
+// is what an HDR display shows below SDR white.
+fn compare_tonemap(op: u32, c: vec3<f32>, headroom: f32) -> vec3<f32> {
+    switch op {
+        case 0u: { return tonemap_gt7_sdr_reference(c); }
+        case 1u: { return saturate(tonemap_gt7(c, PAPER_WHITE_NITS * headroom, PAPER_WHITE_NITS)); }
+        default: { return saturate(tonemap_khronos_pbr(c, headroom)); }
+    }
+}
+
+@fragment
+fn main(
+  @builtin(position) coord : vec4<f32>,
+) -> @location(0) vec4<f32> {
+
+    let size = vec2<i32>(textureDimensions(input_color));
+    let pixel = vec2<i32>(coord.xy);
+    let half_size = size / 2;
+
+    var op = settings.operator_index;
+    var headroom = settings.headroom;
+    var color: vec3<f32>;
+
+    // a dark rule down the middle of the two-sided layouts
+    if (settings.layout_index != 1u && abs(pixel.x - half_size.x) < 1) {
+        return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+    }
+
+    if (settings.layout_index == 0u) {
+        // GT7 on the left, PBR Neutral on the right
+        let right = pixel.x >= half_size.x;
+
+        op = select(1u, 2u, right);
+
+        // the whole frame on each side at half size, centred vertically: a 2x2 box of scene texels per output
+        // pixel, averaged in linear light
+        let origin = vec2<i32>(select(0, half_size.x, right), size.y / 4);
+        let local = pixel - origin;
+
+        if (local.y < 0 || local.y >= half_size.y) {
+            return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+        }
+
+        let source = local * 2;
+        let last = size - vec2<i32>(1);
+
+        color = (
+            textureLoad(input_color, min(source, last), 0).rgb
+            + textureLoad(input_color, min(source + vec2<i32>(1, 0), last), 0).rgb
+            + textureLoad(input_color, min(source + vec2<i32>(0, 1), last), 0).rgb
+            + textureLoad(input_color, min(source + vec2<i32>(1, 1), last), 0).rgb
+        ) * 0.25;
+    } else {
+        if (settings.layout_index == 2u) {
+            // the SDR form on the left, the form at the headroom on the right
+            headroom = select(1.0, settings.headroom, pixel.x > half_size.x);
+        }
+
+        color = textureLoad(input_color, pixel, 0).rgb;
+    }
+
+    color = max(color, vec3<f32>(0.0)) * (settings.exposure * compare_gain(op));
+
+    color = compare_tonemap(op, color, headroom);
+
+    if (settings.to_p3 == 1u) {
+        color = CRM_FROM_REC2020_TO_P3 * (CRM_FROM_REC709_TO_REC2020 * color);
+    }
+
+    color = sRGBTransferOETF(color);
+
+    color += dither_color_8bit_triangle_noise(coord.xy);
+
+    return vec4<f32>(color, 1.0);
+}
+`,
+            [
+                chunk_tonemap_gt7_sdr_reference,
+                chunk_tonemap_gt7,
+                chunk_tonemap_khronos_pbr,
+                chunk_PAPER_WHITE_NITS,
+                chunk_CRM_FROM_REC709_TO_REC2020,
+                chunk_CRM_FROM_REC2020_TO_P3,
+                chunk_sRGBTransferOETF,
+                chunk_dither_color_8bit_triangle_noise,
+            ]
+        ),
+    }),
+    targets: [
+        {
+            label: "tonemap_sdr compare",
+            format: "rgba8unorm",
+        }
+    ],
+});
+
+/**
+ * The scene colour as the engine's tonemapper is given it, carried on to the overlay phase.
+ *
+ * {@link SceneColor} is not carried past {@link FramePhase.BeforePresent}; a record of one's own is carried at every
+ * phase.
+ */
+class ToneMapInput extends FrameRecord {
+    #color = -1;
+
+    /**
+     * @returns {number}
+     */
+    get color() {
+        return this.read(this.#color);
+    }
+
+    /**
+     * @param {number} handle
+     */
+    set color(handle) {
+        this.#color = this.publish(handle);
+    }
+}
+
+/**
+ * The last thing at {@link FramePhase.BeforePresent}: hold on to the HDR colour the tonemapper is about to read.
+ */
+class CaptureToneMapInput extends RenderExtension {
+    name = 'tonemap_sdr/capture';
+    phase = FramePhase.BeforePresent;
+    relative_order = Number.MAX_SAFE_INTEGER;
+
+    /**
+     * @type {ToneMapCompare}
+     */
+    #owner;
+
+    /**
+     * @param {ToneMapCompare} owner
+     */
+    constructor(owner) {
+        super();
+
+        this.#owner = owner;
+    }
+
+    record(frame) {
+        if (!this.#owner.enabled) {
+            return;
+        }
+
+        frame.create(ToneMapInput).color = frame.get(SceneColor).color;
+    }
+}
+
+/**
+ * The first thing at {@link FramePhase.Overlay}: draw the comparison over the canvas the engine's tonemapper wrote.
+ */
+class DrawToneMapCompare extends RenderExtension {
+    name = 'tonemap_sdr/draw';
+    phase = FramePhase.Overlay;
+    relative_order = -Number.MAX_SAFE_INTEGER;
+
+    /**
+     * @type {ToneMapCompare}
+     */
+    #owner;
+
+    /**
+     * @param {ToneMapCompare} owner
+     */
+    constructor(owner) {
+        super();
+
+        this.#owner = owner;
+    }
+
+    record(frame) {
+        const owner = this.#owner;
+
+        if (!owner.enabled) {
+            return;
+        }
+
+        const present = frame.get(PresentTarget);
+        const gains = owner.match_mid_grey ? MID_GREY_GAIN : [1, 1, 1];
+
+        const [canvas] = graph_image_pass({
+            graph: frame.graph,
+            shader: shader_tonemap_compare,
+            inputs: {
+                input_color: frame.get(ToneMapInput).color,
+                settings: {
+                    exposure: Math.pow(2, owner.exposure_ev),
+                    gain_0: gains[0],
+                    gain_1: gains[1],
+                    gain_2: gains[2],
+                    headroom: owner.headroom,
+                    layout_index: owner.layout,
+                    operator_index: owner.operator,
+                    to_p3: owner.convert_to_p3 ? 1 : 0,
+                },
+            },
+            output: [present.canvas],
+        });
+
+        present.canvas = canvas;
+    }
+}
+
+/**
+ * Draws the scene through the engine's tone mapping operators, in place of the engine's own tonemap.
+ *
+ * The engine still tonemaps the frame; this overwrites the canvas afterwards from the same HDR colour, so every
+ * operator sees exactly the input the renderer's tonemap pass sees. Exposure is the page's own, fixed: turn the engine's
+ * automatic exposure off, or the engine's picture and this one will not agree.
+ */
+export class ToneMapCompare {
+    /**
+     * Off: the engine's own output is left on the canvas.
+     * @type {boolean}
+     */
+    enabled = true;
+
+    /**
+     * @type {CompareLayout}
+     */
+    layout = CompareLayout.Pair;
+
+    /**
+     * Which operator {@link CompareLayout.Single} and {@link CompareLayout.Split} show.
+     * @type {CompareOperator}
+     */
+    operator = CompareOperator.PBRNeutral;
+
+    /**
+     * The display's peak in units of SDR white, for the operators that take one. 1 is their SDR form. 4 is a
+     * 1000 cd/m² display under the 250 cd/m² paper white, which is what the renderer assumes for HDR.
+     *
+     * {@link CompareLayout.Single} shows the operator at this peak, clipped to SDR white; {@link CompareLayout.Split}
+     * shows it on the right half only, beside the SDR form.
+     * @type {number}
+     */
+    headroom = 1;
+
+    /**
+     * In f-stops, over a scene value of 1.
+     * @type {number}
+     */
+    exposure_ev = 0;
+
+    /**
+     * Give each operator the exposure that puts 0.18 at 0.18 out, so the pair compares shapes rather than brightness.
+     * @type {boolean}
+     */
+    match_mid_grey = false;
+
+    /**
+     * Convert to Display P3 before encoding. Right for a canvas configured `display-p3`, which is how the engine
+     * configures its canvas; every tonemap pass converts the same way. Off writes Rec.709 values into it, as
+     * `shader_tonemap_LDR` did before it converted.
+     * @type {boolean}
+     */
+    convert_to_p3 = true;
+
+    constructor() {
+        this.extensions = [new CaptureToneMapInput(this), new DrawToneMapCompare(this)];
+    }
+}

package/src/shade/playground/tonemap_sdr/chunk_tonemap_gt7_sdr_reference.d.ts

@@ -0,0 +1,32 @@
+/**
+ * GT7 tone mapping in its SDR mode, as Polyphony's sample code defines it: `GT7ToneMapping::initializeAsSDR()`
+ * followed by `applyToneMapping()`, ICtCp as the UCS.
+ *
+ * This is a comparison port for the playground, not the engine's operator. The engine's `tonemap_gt7` departs from
+ * the sample code in four places:
+ * - it weights the per-channel colour 0.7, where the sample weights it 0.4 (`blendRatio_` 0.6 is the untwisted one's);
+ * - it fades chroma over a fixed PQ window of 0.7–1.0, where the sample fades over 0.98–1.16 of the target's own
+ *   intensity;
+ * - it does not clamp at the target;
+ * - its final blend is in ICtCp, where the sample's is in linear Rec.2020 RGB. The talk tried the UCS, preferred RGB
+ *   (slide 150), and says a UCS blend works as well (slide 153, hidden in the presented deck).
+ *
+ * At SDR the first three carry nearly all of the difference. The playground shows both.
+ *
+ * What the sample says about SDR, and what this keeps:
+ * - the curve is initialized with the SDR paper white, 250 cd/m², as its peak — 2.5 frame-buffer units, where
+ *   GT7's frame buffer has 1.0 = 100 cd/m²;
+ * - the result is multiplied by 1 / 2.5, so the paper white lands at 1.0 for the sRGB encoding.
+ *
+ * Shade's exposed scene value has 1.0 at the paper white rather than at 100 cd/m², so the input is scaled by 2.5
+ * before the curve. That puts an exposed 0.18 at 0.179 out.
+ *
+ * Input: exposed linear Rec.709. Output: display-linear Rec.709 in [0, 1].
+ *
+ * @see https://blog.selfshadow.com/publications/s2025-shading-course/pdi/supplemental/gt7_tone_mapping.cpp
+ * @see "Driving Toward Reality: Physically Based Tone Mapping and Perceptual Fidelity in Gran Turismo 7", slide 153
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_gt7_sdr_reference: CodeChunk;
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_tonemap_gt7_sdr_reference.d.ts.map

package/src/shade/playground/tonemap_sdr/chunk_tonemap_gt7_sdr_reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_tonemap_gt7_sdr_reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/tonemap_sdr/chunk_tonemap_gt7_sdr_reference.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8CAFU,SAAS,CAoEjB;0BAjGwB,6CAA6C"}

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

@@ -0,0 +1,104 @@
+import { chunk_CRM_FROM_REC2020_TO_REC709 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC2020_TO_REC709.js";
+import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../../renderer/shader/chunk/color/conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
+import { chunk_iCtCp_to_rgb } from "../../renderer/shader/chunk/color/iCtCp/chunk_iCtCp_to_rgb.js";
+import { chunk_rgb_to_iCtCp } from "../../renderer/shader/chunk/color/iCtCp/chunk_rgb_to_iCtCp.js";
+import { chunk_gt_evaluate_curve } from "../../renderer/shader/chunk/color/tonemap/gt7/chunk_gt_evaluate_curve.js";
+import { GT7_TONE_MAPPING_CURVE_STRUCT } from "../../renderer/shader/chunk/color/tonemap/gt7/GT7_TONE_MAPPING_CURVE_STRUCT.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+
+/**
+ * GT7 tone mapping in its SDR mode, as Polyphony's sample code defines it: `GT7ToneMapping::initializeAsSDR()`
+ * followed by `applyToneMapping()`, ICtCp as the UCS.
+ *
+ * This is a comparison port for the playground, not the engine's operator. The engine's `tonemap_gt7` departs from
+ * the sample code in four places:
+ * - it weights the per-channel colour 0.7, where the sample weights it 0.4 (`blendRatio_` 0.6 is the untwisted one's);
+ * - it fades chroma over a fixed PQ window of 0.7–1.0, where the sample fades over 0.98–1.16 of the target's own
+ *   intensity;
+ * - it does not clamp at the target;
+ * - its final blend is in ICtCp, where the sample's is in linear Rec.2020 RGB. The talk tried the UCS, preferred RGB
+ *   (slide 150), and says a UCS blend works as well (slide 153, hidden in the presented deck).
+ *
+ * At SDR the first three carry nearly all of the difference. The playground shows both.
+ *
+ * What the sample says about SDR, and what this keeps:
+ * - the curve is initialized with the SDR paper white, 250 cd/m², as its peak — 2.5 frame-buffer units, where
+ *   GT7's frame buffer has 1.0 = 100 cd/m²;
+ * - the result is multiplied by 1 / 2.5, so the paper white lands at 1.0 for the sRGB encoding.
+ *
+ * Shade's exposed scene value has 1.0 at the paper white rather than at 100 cd/m², so the input is scaled by 2.5
+ * before the curve. That puts an exposed 0.18 at 0.179 out.
+ *
+ * Input: exposed linear Rec.709. Output: display-linear Rec.709 in [0, 1].
+ *
+ * @see https://blog.selfshadow.com/publications/s2025-shading-course/pdi/supplemental/gt7_tone_mapping.cpp
+ * @see "Driving Toward Reality: Physically Based Tone Mapping and Perceptual Fidelity in Gran Turismo 7", slide 153
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_gt7_sdr_reference = CodeChunk.from(
+    //language=WGSL
+    `
+fn tonemap_gt7_sdr_reference(rgb_rec709: vec3<f32>) -> vec3<f32> {
+
+    // GRAN_TURISMO_SDR_PAPER_WHITE / REFERENCE_LUMINANCE
+    const SDR_TARGET: f32 = 2.5;
+
+    // GT7ToneMapping::initializeParameters
+    const BLEND_RATIO: f32 = 0.6;
+    const FADE_START: f32 = 0.98;
+    const FADE_END: f32 = 1.16;
+
+    // GTToneMappingCurveV2::initializeCurve(SDR_TARGET, 0.25, 0.538, 0.444, 1.280)
+    const alpha = 0.25;
+    const linear_section = 0.444;
+
+    var curve: ${GT7_TONE_MAPPING_CURVE_STRUCT.wgsl_ref};
+
+    curve.peakIntensity = SDR_TARGET;
+    curve.midPoint = 0.538;
+    curve.linearSection = linear_section;
+    curve.toeStrength = 1.280;
+
+    let k = (linear_section - 1.0) / (alpha - 1.0);
+    curve.kA = SDR_TARGET * linear_section + SDR_TARGET * k;
+    curve.kB = -SDR_TARGET * k * exp(linear_section / k);
+    curve.kC = -1.0 / (k * SDR_TARGET);
+
+    // the paper white is 1.0 here and 2.5 in GT7's frame buffer
+    let rgb = (CRM_FROM_REC709_TO_REC2020 * rgb_rec709) * SDR_TARGET;
+
+    let ucs = rgb_to_iCtCp(rgb);
+
+    // per channel: the "skewed" colour
+    let skewed = vec3<f32>(
+        gt_evaluate_curve(&curve, rgb.r),
+        gt_evaluate_curve(&curve, rgb.g),
+        gt_evaluate_curve(&curve, rgb.b),
+    );
+
+    let skewed_ucs = rgb_to_iCtCp(skewed);
+
+    let target_ucs = rgb_to_iCtCp(vec3<f32>(SDR_TARGET)).x;
+
+    let chroma_scale = 1.0 - smoothstep(FADE_START, FADE_END, ucs.x / target_ucs);
+
+    // intensity from the skewed colour, chroma from the original, faded toward the target
+    let scaled = iCtCp_to_rgb(vec3<f32>(skewed_ucs.x, ucs.yz * chroma_scale));
+
+    let blended = mix(skewed, scaled, BLEND_RATIO);
+
+    // the SDR correction: the target lands at 1.0
+    let display_2020 = min(blended, vec3<f32>(SDR_TARGET)) / SDR_TARGET;
+
+    return saturate(CRM_FROM_REC2020_TO_REC709 * display_2020);
+}
+`,
+    [
+        GT7_TONE_MAPPING_CURVE_STRUCT.declaration_chunk,
+        chunk_gt_evaluate_curve,
+        chunk_rgb_to_iCtCp,
+        chunk_iCtCp_to_rgb,
+        chunk_CRM_FROM_REC709_TO_REC2020,
+        chunk_CRM_FROM_REC2020_TO_REC709,
+    ]
+);