@woosh/meep-engine 3.63.2 → 3.64.0

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

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_bt2390_eetf.js

@@ -0,0 +1,38 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+fn bt2390_eetf(signal: f32, source_peak: f32, target_peak: f32) -> f32 {
+    let e1 = clamp(signal / source_peak, 0.0, 1.0);
+
+    let max_lum = target_peak / source_peak;
+    let ks = 1.5 * max_lum - 0.5;
+
+    if (e1 < ks || ks >= 1.0) {
+        return e1 * source_peak;
+    }
+
+    let t = (e1 - ks) / (1.0 - ks);
+    let t2 = t * t;
+    let t3 = t2 * t;
+
+    let e2 = (2.0 * t3 - 3.0 * t2 + 1.0) * ks
+        + (t3 - 2.0 * t2 + t) * (1.0 - ks)
+        + (-2.0 * t3 + 3.0 * t2) * max_lum;
+
+    return e2 * source_peak;
+}
+    `
+);

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

@@ -0,0 +1,16 @@
+/**
+ * The encoding of a tone-mapping LUT, on both of its sides.
+ *
+ * - `tonemap_lut_pq_encode`: linear light with 1 at the paper white to its ST 2084 (PQ) signal, per channel. A
+ *   negative component reads as zero. 10000 cd/m², 49.3 × the paper white, encodes to 1.
+ * - `tonemap_lut_pq_decode`: the inverse, clamping the signal to [0, 1].
+ * - `tonemap_lut_coordinate`: where a LUT of `resolution`³ texels holds exposed scene colour `scene`, as a texture
+ *   coordinate. Texel i holds the signal i / (resolution - 1); a colour past 10000 cd/m² lands on the last texel.
+ *
+ * A LUT maps the PQ signal of exposed scene-linear Rec.709 to the PQ signal of linear Rec.2020 display light.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_lut: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_tonemap_lut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_tonemap_lut.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_lut.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,gCAFU,SAAS,CAwBjB;0BAxCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_lut.js

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_eotfSt2084 } from "../iCtCp/chunk_eotf_st2084.js";
+import { chunk_inverseEotfSt2084 } from "../iCtCp/chunk_inverse_eotf_st2084.js";
+import { chunk_PAPER_WHITE_NITS } from "./chunk_PAPER_WHITE_NITS.js";
+
+/**
+ * The encoding of a tone-mapping LUT, on both of its sides.
+ *
+ * - `tonemap_lut_pq_encode`: linear light with 1 at the paper white to its ST 2084 (PQ) signal, per channel. A
+ *   negative component reads as zero. 10000 cd/m², 49.3 × the paper white, encodes to 1.
+ * - `tonemap_lut_pq_decode`: the inverse, clamping the signal to [0, 1].
+ * - `tonemap_lut_coordinate`: where a LUT of `resolution`³ texels holds exposed scene colour `scene`, as a texture
+ *   coordinate. Texel i holds the signal i / (resolution - 1); a colour past 10000 cd/m² lands on the last texel.
+ *
+ * A LUT maps the PQ signal of exposed scene-linear Rec.709 to the PQ signal of linear Rec.2020 display light.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_lut = CodeChunk.from(
+    //language=WGSL
+    `
+fn tonemap_lut_pq_encode(v: vec3<f32>) -> vec3<f32> {
+    // the ST 2084 chunks count in units of 100 cd/m²
+    let n = max(v, vec3<f32>(0.0)) * (PAPER_WHITE_NITS / 100.0);
+    return vec3<f32>(inverseEotfSt2084(n.x), inverseEotfSt2084(n.y), inverseEotfSt2084(n.z));
+}
+
+fn tonemap_lut_pq_decode(e: vec3<f32>) -> vec3<f32> {
+    return vec3<f32>(eotfSt2084(e.x), eotfSt2084(e.y), eotfSt2084(e.z)) * (100.0 / PAPER_WHITE_NITS);
+}
+
+fn tonemap_lut_coordinate(scene: vec3<f32>, resolution: f32) -> vec3<f32> {
+    let e = min(tonemap_lut_pq_encode(scene), vec3<f32>(1.0));
+    return e * ((resolution - 1.0) / resolution) + 0.5 / resolution;
+}
+    `, [
+        chunk_eotfSt2084,
+        chunk_inverseEotfSt2084,
+        chunk_PAPER_WHITE_NITS,
+    ]
+);

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#282@#execute"(pass: any, resources: any, context: any): void;
+    static "__#285@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -3141,7 +3141,7 @@ const INTEGER_TYPED_BUILTIN = new Set(['abs', 'firstLeadingBit', 'firstTrailingB
  */
 const ELEMENT_WISE_BUILTIN = new Set([
     'abs', 'sign', 'floor', 'ceil', 'round', 'trunc', 'fract', 'sqrt', 'inverseSqrt',
-    'exp', 'exp2', 'log', 'log2', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
+    'exp', 'exp2', 'log', 'log2', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'degrees', 'radians',
     'pow', 'atan2', 'min', 'max', 'step', 'clamp', 'saturate', 'mix', 'smoothstep',
     'normalize', 'reflect', 'fma', 'quantizeToF16',
     'subgroupBroadcastFirst', 'subgroupAdd', 'subgroupMul', 'subgroupMin', 'subgroupMax',
@@ -3232,13 +3232,13 @@ function inferBuiltinReturnType(name, args) {
     // Both gathers return the four texels of a 2x2 footprint. Saying so here matters more than
     // for most builtins: the shadow chunks immediately swizzle the result (`samples.wzxy`), and
     // an unknown type degrades swizzle codegen downstream.
-    if (name === 'textureGather') {
-        const first = args[0] !== undefined ? args[0].type : null;
-        const texture = first !== null && first.kind === 'texture' ? first : (args[1] !== undefined ? args[1].type : null);
-        const scalar = texture !== null && texture.kind === 'texture' ? texture.scalar : 'f32';
-        return { kind: 'vec', size: 4, scalar: scalar === 'u32' || /uint$/.test(scalar) ? 'u32'
-            : scalar === 'i32' || /sint$/.test(scalar) ? 'i32' : 'f32' };
-    }
+    if (name === 'textureGather') {
+        const first = args[0] !== undefined ? args[0].type : null;
+        const texture = first !== null && first.kind === 'texture' ? first : (args[1] !== undefined ? args[1].type : null);
+        const scalar = texture !== null && texture.kind === 'texture' ? texture.scalar : 'f32';
+        return { kind: 'vec', size: 4, scalar: scalar === 'u32' || /uint$/.test(scalar) ? 'u32'
+            : scalar === 'i32' || /sint$/.test(scalar) ? 'i32' : 'f32' };
+    }
     if (name === 'textureGatherCompare') {
         return { kind: 'vec', size: 4, scalar: 'f32' };
     }

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAk6DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAo6DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -883,6 +883,8 @@ export const WGSLLanguageCore = {
     asin: (a) => unop(a, Math.asin),
     acos: (a) => unop(a, Math.acos),
     atan: (a) => unop(a, Math.atan),
+    degrees: (a) => unop(a, x => x * (180 / Math.PI)),
+    radians: (a) => unop(a, x => x * (Math.PI / 180)),
 
     pow: (a, b) => binop(a, b, Math.pow),
     atan2: (a, b) => binop(a, b, Math.atan2),

package/src/shade/renderer/ShadeToneMappingMode.d.ts

@@ -1,15 +0,0 @@
-/**
- * How the exposed scene colour becomes display colour.
- *
- * One choice for every display. The same mode runs on an SDR and an HDR output, so a scene looks the same on both up
- * to the SDR display's limits. That is the reason Polyphony give for GT7's operator, and Epic's for how Unreal 5.8
- * takes its Filmic picture to HDR, and there is no per-output setting on purpose.
- */
-export type ShadeToneMappingMode = number;
-export namespace ShadeToneMappingMode {
-    let GT7: number;
-    let NONE: number;
-    let PBR_NEUTRAL: number;
-    let ACES: number;
-}
-//# sourceMappingURL=ShadeToneMappingMode.d.ts.map

package/src/shade/renderer/ShadeToneMappingMode.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ShadeToneMappingMode.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/ShadeToneMappingMode.js"],"names":[],"mappings":";;;;;;;mCAOU,MAAM"}