@woosh/meep-engine 3.63.3 → 3.64.0

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

@@ -0,0 +1,92 @@
+import { assert } from "../../../../core/assert.js";
+import { ANIMATION_CURVE_KEYFRAME_STRUCT } from "../../animation/ANIMATION_CURVE_KEYFRAME_STRUCT.js";
+import { chunk_color_grade } from "../../shader/chunk/color/grade/chunk_color_grade.js";
+import { chunk_tonemap_lut } from "../../shader/chunk/color/tonemap/chunk_tonemap_lut.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { COLOR_GRADE_STRUCT } from "./ColorGrade.js";
+
+/**
+ * Immediate data of a bake: the peak the operator is evaluated for, `PAPER_WHITE_NITS` for an SDR LUT.
+ */
+export const TONEMAP_LUT_BAKE_SETTINGS = WebGPUStruct.from({ peak_nits: f32 });
+
+/**
+ * Edge of the cube of LUT texels one workgroup bakes.
+ */
+export const TONEMAP_LUT_BAKE_GROUP = 4;
+
+/**
+ * @type {WeakMap<ToneMapOperator, ComputeShader>}
+ */
+const shaders = new WeakMap();
+
+/**
+ * The compute shader that bakes `operator` into a LUT, `lut`, one texel a thread: the texel's PQ signal decoded to
+ * exposed scene colour, through the colour grade and the operator, and encoded again, as {@link chunk_tonemap_lut}
+ * describes. The grade is `grade`, a {@link COLOR_GRADE_STRUCT}, and `grade_keys`, its curves' keyframes; see
+ * `ColorGrade#pack`. Built on first use and kept for the operator.
+ *
+ * Dispatch `ceil(resolution / TONEMAP_LUT_BAKE_GROUP)` workgroups along each axis.
+ *
+ * @param {ToneMapOperator} operator
+ * @returns {ComputeShader}
+ */
+export function shader_tonemap_lut_bake(operator) {
+    assert.defined(operator, 'operator');
+
+    let shader = shaders.get(operator);
+
+    if (shader !== undefined) {
+        return shader;
+    }
+
+    const resources = new ShaderResourceSetDescriptor();
+
+    resources.setImmediate("settings", TONEMAP_LUT_BAKE_SETTINGS);
+
+    const group = resources.createGroup()
+        .addStorageTexture("lut", "rgba16float", "3d", "write-only")
+        .addUniform("grade", COLOR_GRADE_STRUCT)
+        .addStorageBuffer("grade_keys", WebGPUArray.from(ANIMATION_CURVE_KEYFRAME_STRUCT));
+
+    operator.declare(group);
+
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP})
+fn main(@builtin(global_invocation_id) texel: vec3<u32>) {
+    let size = textureDimensions(lut);
+
+    if (any(texel >= size)) {
+        return;
+    }
+
+    let scene = tonemap_lut_pq_decode(vec3<f32>(texel) / vec3<f32>(size - 1u));
+
+    let display = tone_map_operator(color_grade(scene, grade, &grade_keys), settings.peak_nits);
+
+    textureStore(lut, texel, vec4<f32>(tonemap_lut_pq_encode(display), 1.0));
+}
+        `, [
+            chunk_tonemap_lut,
+            chunk_color_grade,
+            operator.chunk,
+        ]
+    );
+
+    shader = ComputeShader.from({
+        label: `Tonemap/LUT bake/${operator.label}`,
+        body,
+        resources,
+    });
+
+    shaders.set(operator, shader);
+
+    return shader;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Immediate data of {@link shader_tonemap_lut_sdr_from_hdr}: the peak the HDR LUT was graded for, cd/m².
+ */
+export const TONEMAP_LUT_SDR_FROM_HDR_SETTINGS: WebGPUStruct;
+/**
+ * An SDR LUT from an HDR one of the same resolution: each texel through the BT.2390 EETF, from the HDR LUT's graded
+ * peak down to the paper white. The EETF maps the brightest channel's signal and the three channels scale by the
+ * same ratio of light, so the hue holds and no channel passes SDR white. Below the EETF's knee a texel is unchanged.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_tonemap_lut_sdr_from_hdr: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_tonemap_lut_sdr_from_hdr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_tonemap_lut_sdr_from_hdr.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/shader_tonemap_lut_sdr_from_hdr.js"],"names":[],"mappings":"AAUA;;GAEG;AACH,6DAA8F;AAgD9F;;;;;;GAMG;AACH,8CAFU,aAAa,CAMpB;6BAjE0B,mCAAmC;8BAHlC,+BAA+B"}

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

@@ -0,0 +1,73 @@
+import { chunk_bt2390_eetf } from "../../shader/chunk/color/tonemap/chunk_bt2390_eetf.js";
+import { chunk_PAPER_WHITE_NITS } from "../../shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js";
+import { chunk_tonemap_lut } from "../../shader/chunk/color/tonemap/chunk_tonemap_lut.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { TONEMAP_LUT_BAKE_GROUP } from "./shader_tonemap_lut_bake.js";
+
+/**
+ * Immediate data of {@link shader_tonemap_lut_sdr_from_hdr}: the peak the HDR LUT was graded for, cd/m².
+ */
+export const TONEMAP_LUT_SDR_FROM_HDR_SETTINGS = WebGPUStruct.from({ source_peak_nits: f32 });
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", TONEMAP_LUT_SDR_FROM_HDR_SETTINGS);
+resources.createGroup()
+    .addTexture("hdr_lut", "unfilterable-float", "3d")
+    .addStorageTexture("sdr_lut", "rgba16float", "3d", "write-only");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP}, ${TONEMAP_LUT_BAKE_GROUP})
+fn main(@builtin(global_invocation_id) texel: vec3<u32>) {
+    let size = textureDimensions(sdr_lut);
+
+    if (any(texel >= size)) {
+        return;
+    }
+
+    let signal = textureLoad(hdr_lut, texel, 0).rgb;
+
+    // the brightest channel's signal; the other two follow it by the same ratio of light, which keeps the hue
+    let brightest = max(signal.r, max(signal.g, signal.b));
+
+    let source_peak = tonemap_lut_pq_encode(vec3<f32>(settings.source_peak_nits / PAPER_WHITE_NITS)).x;
+    let target_peak = tonemap_lut_pq_encode(vec3<f32>(1.0)).x;
+
+    let mapped = bt2390_eetf(brightest, source_peak, target_peak);
+
+    let light = tonemap_lut_pq_decode(signal);
+    let before = tonemap_lut_pq_decode(vec3<f32>(brightest)).x;
+    let after = tonemap_lut_pq_decode(vec3<f32>(mapped)).x;
+
+    var scale = 1.0;
+    if (before > 0.0) {
+        scale = after / before;
+    }
+
+    textureStore(sdr_lut, texel, vec4<f32>(tonemap_lut_pq_encode(light * scale), 1.0));
+}
+    `, [
+        chunk_tonemap_lut,
+        chunk_bt2390_eetf,
+        chunk_PAPER_WHITE_NITS,
+    ]
+);
+
+/**
+ * An SDR LUT from an HDR one of the same resolution: each texel through the BT.2390 EETF, from the HDR LUT's graded
+ * peak down to the paper white. The EETF maps the brightest channel's signal and the three channels scale by the
+ * same ratio of light, so the hue holds and no channel passes SDR white. Below the EETF's knee a texel is unchanged.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_tonemap_lut_sdr_from_hdr = ComputeShader.from({
+    label: "Tonemap/LUT SDR from HDR",
+    body,
+    resources,
+});

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#286@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#289@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#286@#execute_fill"(record: object, _resources: any, context: {
+    static "__#289@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#286@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#289@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#288@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#291@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#289@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#292@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#292@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#289@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#289@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#289@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#289@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#292@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#292@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#292@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#292@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#285@#execute"(data: {
+    static "__#288@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/query/GPUFluidQueries.d.ts

@@ -49,7 +49,7 @@ export class GPUFluidQueries {
      * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#290@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#293@#execute"(pass: object, resources: import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts

@@ -34,7 +34,7 @@ export class GPUProbeClipmapGI {
      * @param {ProbeClipmapSettings} settings
      * @returns {boolean} whether it is what the settings' world cache describes, in their frustum's windows
      */
-    static "__#211@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
+    static "__#214@#world_cache_built_for"(world_cache: GPUProbeClipmap, settings: ProbeClipmapSettings): boolean;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#309@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#312@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -51,7 +51,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#217@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#220@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Linear Rec.709 (D65) to AP1 (ACES white), Bradford-adapted, as Unreal's `WorkingColorSpace.ToAP1` for an sRGB
+ * working space. Row-major.
+ * @type {Float64Array}
+ */
+export const M3_REC709_TO_AP1: Float64Array;
+/**
+ * The inverse of {@link M3_REC709_TO_AP1}. Row-major.
+ * @type {Float64Array}
+ */
+export const M3_AP1_TO_REC709: Float64Array;
+/**
+ * - `CRM_FROM_REC709_TO_AP1` and `CRM_FROM_AP1_TO_REC709`: {@link M3_REC709_TO_AP1} and its inverse.
+ * - `AP1_LUMINANCE`: AP1's contribution of each channel to Y, the row Unreal calls `AP1_RGB2Y`.
+ *
+ * Derived from the two spaces' chromaticities, so neither matrix is a rounded transcription of the other.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_CRM_REC709_AP1: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_CRM_REC709_AP1.d.ts.map

package/src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_CRM_REC709_AP1.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,+BAFU,YAAY,CAE8B;AAIpD;;;GAGG;AACH,+BAFU,YAAY,CAE8B;AAYpD;;;;;;;GAOG;AACH,mCAFU,SAAS,CASjB;0BAzDwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/conversion/chunk_CRM_REC709_AP1.js

@@ -0,0 +1,62 @@
+import { m3_chromatic_adaptation_bradford } from "../../../../../../core/color/xyz/m3_chromatic_adaptation_bradford.js";
+import { m3_rgb_to_xyz_from_primaries } from "../../../../../../core/color/xyz/m3_rgb_to_xyz_from_primaries.js";
+import { m3_invert } from "../../../../../../core/geom/mat3/m3_invert.js";
+import { m3_multiply } from "../../../../../../core/geom/mat3/m3_multiply.js";
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+const REC709_TO_XYZ = new Float64Array(9);
+m3_rgb_to_xyz_from_primaries(REC709_TO_XYZ, [0.640, 0.330, 0.300, 0.600, 0.150, 0.060], 0.3127, 0.3290);
+
+// ACES AP1 (ACEScg) primaries and the ACES white, S-2014-004
+const AP1_WHITE_X = 0.32168;
+const AP1_WHITE_Y = 0.33767;
+const AP1_TO_XYZ = new Float64Array(9);
+m3_rgb_to_xyz_from_primaries(AP1_TO_XYZ, [0.713, 0.293, 0.165, 0.830, 0.128, 0.044], AP1_WHITE_X, AP1_WHITE_Y);
+
+const XYZ_TO_AP1 = new Float64Array(9);
+m3_invert(XYZ_TO_AP1, AP1_TO_XYZ);
+
+const D65_TO_ACES_WHITE = new Float64Array(9);
+m3_chromatic_adaptation_bradford(D65_TO_ACES_WHITE, 0.3127, 0.3290, AP1_WHITE_X, AP1_WHITE_Y);
+
+/**
+ * Linear Rec.709 (D65) to AP1 (ACES white), Bradford-adapted, as Unreal's `WorkingColorSpace.ToAP1` for an sRGB
+ * working space. Row-major.
+ * @type {Float64Array}
+ */
+export const M3_REC709_TO_AP1 = new Float64Array(9);
+m3_multiply(M3_REC709_TO_AP1, D65_TO_ACES_WHITE, REC709_TO_XYZ);
+m3_multiply(M3_REC709_TO_AP1, XYZ_TO_AP1, M3_REC709_TO_AP1);
+
+/**
+ * The inverse of {@link M3_REC709_TO_AP1}. Row-major.
+ * @type {Float64Array}
+ */
+export const M3_AP1_TO_REC709 = new Float64Array(9);
+m3_invert(M3_AP1_TO_REC709, M3_REC709_TO_AP1);
+
+/**
+ * @param {Float64Array} m row-major
+ * @returns {string} a WGSL `mat3x3<f32>` constructor, column by column
+ */
+function wgsl_mat3(m) {
+    const column = c => `vec3<f32>(${m[c]}, ${m[3 + c]}, ${m[6 + c]})`;
+    return `mat3x3<f32>(${column(0)}, ${column(1)}, ${column(2)})`;
+}
+
+/**
+ * - `CRM_FROM_REC709_TO_AP1` and `CRM_FROM_AP1_TO_REC709`: {@link M3_REC709_TO_AP1} and its inverse.
+ * - `AP1_LUMINANCE`: AP1's contribution of each channel to Y, the row Unreal calls `AP1_RGB2Y`.
+ *
+ * Derived from the two spaces' chromaticities, so neither matrix is a rounded transcription of the other.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_CRM_REC709_AP1 = CodeChunk.from(
+    //language=WGSL
+    `
+const CRM_FROM_REC709_TO_AP1 = ${wgsl_mat3(M3_REC709_TO_AP1)};
+const CRM_FROM_AP1_TO_REC709 = ${wgsl_mat3(M3_AP1_TO_REC709)};
+const AP1_LUMINANCE = vec3<f32>(${AP1_TO_XYZ[3]}, ${AP1_TO_XYZ[4]}, ${AP1_TO_XYZ[5]});
+    `
+);

package/src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `color_grade(scene, grade, keys)`: exposed scene-linear Rec.709 through a {@link ColorGrade}, white balance, then
+ * primaries, then hue curves, to Rec.709 again, not negative. `grade` is the grade's {@link COLOR_GRADE_STRUCT} and
+ * `keys` the curves' keyframes. See `ColorGrade` for what each stage does.
+ *
+ * Also defines each stage on its own: `color_grade_primaries(ap1, grade)` and
+ * `color_grade_hue_curves(color, counts, keys)`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_color_grade: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_color_grade.d.ts.map

package/src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_color_grade.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,gCAFU,SAAS,CA0HjB;0BAxIwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/grade/chunk_color_grade.js

@@ -0,0 +1,140 @@
+import { ANIMATION_CURVE_KEYFRAME_STRUCT } from "../../../../animation/ANIMATION_CURVE_KEYFRAME_STRUCT.js";
+import { chunk_animation_curve_evaluate_keys } from "../../../../animation/chunk_animation_curve_evaluate_keys.js";
+import { COLOR_GRADE_STRUCT } from "../../../../deferred/tonemap/ColorGrade.js";
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_CRM_REC709_AP1 } from "../conversion/chunk_CRM_REC709_AP1.js";
+import { chunk_linear_srgb_to_oklab } from "../oklab/chunk_linear_srgb_to_oklab.js";
+import { chunk_oklab_compute_max_saturation } from "../oklab/chunk_oklab_compute_max_saturation.js";
+import { chunk_oklab_to_linear_srgb } from "../oklab/chunk_oklab_to_linear_srgb.js";
+
+/**
+ * `color_grade(scene, grade, keys)`: exposed scene-linear Rec.709 through a {@link ColorGrade}, white balance, then
+ * primaries, then hue curves, to Rec.709 again, not negative. `grade` is the grade's {@link COLOR_GRADE_STRUCT} and
+ * `keys` the curves' keyframes. See `ColorGrade` for what each stage does.
+ *
+ * Also defines each stage on its own: `color_grade_primaries(ap1, grade)` and
+ * `color_grade_hue_curves(color, counts, keys)`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_color_grade = CodeChunk.from(
+    //language=WGSL
+    `
+// Unreal's ColorCorrect: one zone's grade, in AP1
+fn color_grade_correct(
+    color: vec3<f32>,
+    saturation: vec3<f32>,
+    contrast: vec3<f32>,
+    gamma: vec3<f32>,
+    gain: vec3<f32>,
+    offset: vec3<f32>,
+) -> vec3<f32> {
+    let luma = dot(color, AP1_LUMINANCE);
+
+    var c = max(vec3<f32>(0.0), mix(vec3<f32>(luma), color, saturation));
+    c = pow(c * (1.0 / 0.18), contrast) * 0.18;
+    c = pow(c, 1.0 / gamma);
+
+    return c * gain + offset;
+}
+
+// Unreal's ColorCorrectAll: the three zones, blended by luma
+fn color_grade_primaries(ap1: vec3<f32>, grade: ${COLOR_GRADE_STRUCT.wgsl_ref}) -> vec3<f32> {
+    let luma = dot(ap1, AP1_LUMINANCE);
+
+    let shadows = color_grade_correct(
+        ap1,
+        grade.shadows_saturation.xyz, grade.shadows_contrast.xyz, grade.shadows_gamma.xyz,
+        grade.shadows_gain.xyz, grade.shadows_offset.xyz,
+    );
+    let midtones = color_grade_correct(
+        ap1,
+        grade.midtones_saturation.xyz, grade.midtones_contrast.xyz, grade.midtones_gamma.xyz,
+        grade.midtones_gain.xyz, grade.midtones_offset.xyz,
+    );
+    let highlights = color_grade_correct(
+        ap1,
+        grade.highlights_saturation.xyz, grade.highlights_contrast.xyz, grade.highlights_gamma.xyz,
+        grade.highlights_gain.xyz, grade.highlights_offset.xyz,
+    );
+
+    let weight_shadows = 1.0 - smoothstep(0.0, grade.zone_bounds.x, luma);
+    let weight_highlights = smoothstep(grade.zone_bounds.y, grade.zone_bounds.z, luma);
+    let weight_midtones = 1.0 - weight_shadows - weight_highlights;
+
+    return shadows * weight_shadows + midtones * weight_midtones + highlights * weight_highlights;
+}
+
+// hue shift, chroma scale and lightness against OkLCh hue; counts.xyz are the three curves' keys, in that order
+fn color_grade_hue_curves(
+    color: vec3<f32>,
+    counts: vec4<u32>,
+    keys: ptr<storage, array<${ANIMATION_CURVE_KEYFRAME_STRUCT.wgsl_ref}>, read>,
+) -> vec3<f32> {
+    if (all(counts.xyz == vec3<u32>(0u))) {
+        return color;
+    }
+
+    let lab = linear_srgb_to_oklab(color);
+    let chroma = length(lab.yz);
+
+    // a grey has no hue, and every edit below leaves it where it is
+    if (chroma <= 0.0 || lab.x <= 0.0) {
+        return color;
+    }
+
+    let direction = lab.yz / chroma;
+    let hue_signed = degrees(atan2(direction.y, direction.x));
+    let hue = select(hue_signed, hue_signed + 360.0, hue_signed < 0.0);
+
+    var shift = 0.0;
+    var scale = 1.0;
+    var stops = 0.0;
+
+    if (counts.x > 0u) {
+        shift = animation_curve_evaluate_keys(keys, 0u, counts.x, hue);
+    }
+    if (counts.y > 0u) {
+        scale = animation_curve_evaluate_keys(keys, counts.x, counts.y, hue);
+    }
+    if (counts.z > 0u) {
+        stops = animation_curve_evaluate_keys(keys, counts.x + counts.y, counts.z, hue);
+    }
+
+    // saturation relative to the Rec.709 gamut's edge at this hue: 0 for a grey, 1 on the edge
+    let relative = min(chroma / lab.x / oklab_compute_max_saturation(direction.x, direction.y), 1.0);
+
+    let angle = radians(shift);
+    let rotated = vec2<f32>(
+        direction.x * cos(angle) - direction.y * sin(angle),
+        direction.x * sin(angle) + direction.y * cos(angle),
+    );
+
+    // Oklab is the cube root of a linear map, so scaling L, a and b by cbrt(2^k) scales the light by exactly 2^k
+    let exposure = exp2(stops * relative / 3.0);
+
+    return oklab_to_linear_srgb(vec3<f32>(lab.x, rotated * (chroma * scale)) * exposure);
+}
+
+fn color_grade(
+    scene: vec3<f32>,
+    grade: ${COLOR_GRADE_STRUCT.wgsl_ref},
+    keys: ptr<storage, array<${ANIMATION_CURVE_KEYFRAME_STRUCT.wgsl_ref}>, read>,
+) -> vec3<f32> {
+    let white_balance = mat3x3<f32>(grade.white_balance_c0.xyz, grade.white_balance_c1.xyz, grade.white_balance_c2.xyz);
+
+    let ap1 = color_grade_primaries(CRM_FROM_REC709_TO_AP1 * (white_balance * scene), grade);
+
+    let graded = max(CRM_FROM_AP1_TO_REC709 * ap1, vec3<f32>(0.0));
+
+    return max(color_grade_hue_curves(graded, grade.curve_counts, keys), vec3<f32>(0.0));
+}
+    `, [
+        COLOR_GRADE_STRUCT.declaration_chunk,
+        chunk_animation_curve_evaluate_keys,
+        chunk_CRM_REC709_AP1,
+        chunk_linear_srgb_to_oklab,
+        chunk_oklab_to_linear_srgb,
+        chunk_oklab_compute_max_saturation,
+    ]
+);

package/src/shade/renderer/shader/chunk/color/oklab/chunk_oklab_compute_max_saturation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `oklab_compute_max_saturation(a, b)`: the largest saturation S = C / L in linear sRGB (Rec.709) at the hue of the
+ * unit Oklab direction (a, b), where the first channel reaches zero. Ottosson's polynomial and one Halley step; the
+ * WGSL twin of `core/color/oklab/compute_max_saturation.js`.
+ *
+ * @see https://bottosson.github.io/posts/gamutclipping/
+ * @type {CodeChunk}
+ */
+export const chunk_oklab_compute_max_saturation: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_oklab_compute_max_saturation.d.ts.map

package/src/shade/renderer/shader/chunk/color/oklab/chunk_oklab_compute_max_saturation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_oklab_compute_max_saturation.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/oklab/chunk_oklab_compute_max_saturation.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,iDAFU,SAAS,CAwDjB;0BAhEwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/oklab/chunk_oklab_compute_max_saturation.js

@@ -0,0 +1,65 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * `oklab_compute_max_saturation(a, b)`: the largest saturation S = C / L in linear sRGB (Rec.709) at the hue of the
+ * unit Oklab direction (a, b), where the first channel reaches zero. Ottosson's polynomial and one Halley step; the
+ * WGSL twin of `core/color/oklab/compute_max_saturation.js`.
+ *
+ * @see https://bottosson.github.io/posts/gamutclipping/
+ * @type {CodeChunk}
+ */
+export const chunk_oklab_compute_max_saturation = CodeChunk.from(
+    //language=WGSL
+    `
+fn oklab_compute_max_saturation(a: f32, b: f32) -> f32 {
+    // the channel that reaches zero first selects the coefficients
+    var k0: f32; var k1: f32; var k2: f32; var k3: f32; var k4: f32;
+    var wl: f32; var wm: f32; var ws: f32;
+
+    if (-1.88170328 * a - 0.80936493 * b > 1.0) {
+        // red
+        k0 = 1.19086277; k1 = 1.76576728; k2 = 0.59662641; k3 = 0.75515197; k4 = 0.56771245;
+        wl = 4.0767416621; wm = -3.3077115913; ws = 0.2309699292;
+    } else if (1.81444104 * a - 1.19445276 * b > 1.0) {
+        // green
+        k0 = 0.73956515; k1 = -0.45954404; k2 = 0.08285427; k3 = 0.12541070; k4 = 0.14503204;
+        wl = -1.2684380046; wm = 2.6097574011; ws = -0.3413193965;
+    } else {
+        // blue
+        k0 = 1.35733652; k1 = -0.00915799; k2 = -1.15130210; k3 = -0.50559606; k4 = 0.00692167;
+        wl = -0.0041960863; wm = -0.7034186147; ws = 1.7076147010;
+    }
+
+    var s = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b;
+
+    let k_l = 0.3963377774 * a + 0.2158037573 * b;
+    let k_m = -0.1055613458 * a - 0.0638541728 * b;
+    let k_s = -0.0894841775 * a - 1.2914855480 * b;
+
+    let l_ = 1.0 + s * k_l;
+    let m_ = 1.0 + s * k_m;
+    let s_ = 1.0 + s * k_s;
+
+    let l = l_ * l_ * l_;
+    let m = m_ * m_ * m_;
+    let s3 = s_ * s_ * s_;
+
+    let l_ds = 3.0 * k_l * l_ * l_;
+    let m_ds = 3.0 * k_m * m_ * m_;
+    let s_ds = 3.0 * k_s * s_ * s_;
+
+    let l_ds2 = 6.0 * k_l * k_l * l_;
+    let m_ds2 = 6.0 * k_m * k_m * m_;
+    let s_ds2 = 6.0 * k_s * k_s * s_;
+
+    let f = wl * l + wm * m + ws * s3;
+    let f1 = wl * l_ds + wm * m_ds + ws * s_ds;
+    let f2 = wl * l_ds2 + wm * m_ds2 + ws * s_ds2;
+
+    // one Halley step
+    s = s - f * f1 / (f1 * f1 - 0.5 * f * f2);
+
+    return s;
+}
+    `
+);

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_bt2390_eetf.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The EETF of ITU-R BT.2390 (§5.4.1): maps a PQ signal mastered for a display reaching `source_peak` onto one
+ * reaching `target_peak`, all three PQ signals, with black at zero on both.
+ *
+ * The signal is first normalised to the source's range. Up to the knee, KS = 1.5 × maxLum − 0.5, it passes
+ * through; past it, a Hermite spline carries it to maxLum, the target's peak in the same normalisation, which the
+ * source's peak reaches with zero slope. The spline meets the identity at the knee with slope 1. A signal past
+ * `source_peak` is held at it. A target at or above the source passes every signal through.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_bt2390_eetf: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_bt2390_eetf.d.ts.map

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_bt2390_eetf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_bt2390_eetf.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/chunk_bt2390_eetf.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,gCAFU,SAAS,CA0BjB;0BArCwB,gCAAgC"}