@woosh/meep-engine 3.50.0 → 3.52.0

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

@@ -0,0 +1,25 @@
+/**
+ * The ACES 2.0 output transform, forward and inverse, for a display whose parameters and gamut tables sit in
+ * `aces2_tables` from float `block` on, as {@link aces2_transform_block_write} lays them out.
+ *
+ * This is OpenColorIO v2.6.0's `ACES_OUTPUT_TRANSFORM_20` (ops/fixedfunction/ACES2/Transform.cpp), which implements the
+ * Academy's reference, with what OCIO's builtin output transforms put around it: a clamp of the input to the AP1
+ * gamut and to the tone scale's reach, and a clamp of the output to the display's peak. Units on the display side are
+ * 100 cd/m² to 1.0.
+ *
+ * - `aces2_forward(block, aces)`: ACES2065-1 (AP0) in, display-linear RGB in the block's limiting primaries out.
+ * - `aces2_inverse(block, rgb)`: the way back, which needs the same block.
+ *
+ * One difference from OCIO, where OCIO produces a NaN: the gamut boundary's power is taken of a base clamped at zero.
+ * A colour at the display's peak white can put the J intersection a rounding error past the upper hull, and OCIO's
+ * `powf` of the negative base returns NaN there.
+ *
+ * Reads a storage binding `aces2_tables: array<f32>`, declared by the pass.
+ *
+ * @see https://github.com/ampas/aces-core
+ * @see https://github.com/AcademySoftwareFoundation/OpenColorIO/tree/main/src/OpenColorIO/ops/fixedfunction/ACES2
+ * @type {CodeChunk}
+ */
+export const chunk_aces2_output_transform: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_aces2_output_transform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_aces2_output_transform.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces2_output_transform.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,2CAFU,SAAS,CA2ZjB;0BA7bwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces2_output_transform.js

@@ -0,0 +1,446 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import {
+    ACES2_AAB_TO_CONE,
+    ACES2_CONE_TO_AAB,
+    ACES2_CUSP_TABLE,
+    ACES2_IN_CAM_TO_RGB,
+    ACES2_IN_RGB_TO_CAM,
+    ACES2_OUT_CAM_TO_RGB,
+    ACES2_OUT_RGB_TO_CAM,
+    ACES2_REACH_TABLE,
+    ACES2_SCALARS
+} from "./aces2_transform_block.js";
+import { chunk_aces_ue_matrices } from "./chunk_aces_ue_matrices.js";
+
+/**
+ * The ACES 2.0 output transform, forward and inverse, for a display whose parameters and gamut tables sit in
+ * `aces2_tables` from float `block` on, as {@link aces2_transform_block_write} lays them out.
+ *
+ * This is OpenColorIO v2.6.0's `ACES_OUTPUT_TRANSFORM_20` (ops/fixedfunction/ACES2/Transform.cpp), which implements the
+ * Academy's reference, with what OCIO's builtin output transforms put around it: a clamp of the input to the AP1
+ * gamut and to the tone scale's reach, and a clamp of the output to the display's peak. Units on the display side are
+ * 100 cd/m² to 1.0.
+ *
+ * - `aces2_forward(block, aces)`: ACES2065-1 (AP0) in, display-linear RGB in the block's limiting primaries out.
+ * - `aces2_inverse(block, rgb)`: the way back, which needs the same block.
+ *
+ * One difference from OCIO, where OCIO produces a NaN: the gamut boundary's power is taken of a base clamped at zero.
+ * A colour at the display's peak white can put the J intersection a rounding error past the upper hull, and OCIO's
+ * `powf` of the negative base returns NaN there.
+ *
+ * Reads a storage binding `aces2_tables: array<f32>`, declared by the pass.
+ *
+ * @see https://github.com/ampas/aces-core
+ * @see https://github.com/AcademySoftwareFoundation/OpenColorIO/tree/main/src/OpenColorIO/ops/fixedfunction/ACES2
+ * @type {CodeChunk}
+ */
+export const chunk_aces2_output_transform = CodeChunk.from(
+    //language=WGSL
+    `
+const ACES2_CAM_NL_OFFSET: f32 = 27.13;
+const ACES2_J_SCALE: f32 = 100.0;
+const ACES2_SMOOTH_CUSPS: f32 = 0.12;
+const ACES2_CUSP_MID_BLEND: f32 = 1.3;
+const ACES2_FOCUS_GAIN_BLEND: f32 = 0.3;
+const ACES2_COMPRESSION_THRESHOLD: f32 = 0.75;
+const ACES2_DEGREES_PER_RADIAN: f32 = 57.29577951308232;
+// how far below the peak's J the inverse starts fading out its gamut decompression; see aces2_gamut_compress
+const ACES2_INVERSE_FADE_J: f32 = 1.0;
+// the most the inverse's gamut decompression multiplies colourfulness by; see aces2_gamut_compress
+const ACES2_INVERSE_GAIN_LIMIT: f32 = 5.0;
+
+fn aces2_scalar(block: u32, index: u32) -> f32 {
+    return aces2_tables[block + ${ACES2_SCALARS}u + index];
+}
+
+fn aces2_matrix(at: u32) -> mat3x3<f32> {
+    return mat3x3<f32>(
+        vec3<f32>(aces2_tables[at], aces2_tables[at + 1u], aces2_tables[at + 2u]),
+        vec3<f32>(aces2_tables[at + 3u], aces2_tables[at + 4u], aces2_tables[at + 5u]),
+        vec3<f32>(aces2_tables[at + 6u], aces2_tables[at + 7u], aces2_tables[at + 8u])
+    );
+}
+
+// post-adaptation cone response compression, odd in its argument
+fn aces2_compress_cone(v: vec3<f32>) -> vec3<f32> {
+    let F = pow(abs(v), vec3<f32>(0.42));
+    return sign(v) * F / (ACES2_CAM_NL_OFFSET + F);
+}
+
+fn aces2_compress_cone_inverse(v: vec3<f32>) -> vec3<f32> {
+    let a = min(abs(v), vec3<f32>(0.99));
+    let F = ACES2_CAM_NL_OFFSET * a / (1.0 - a);
+    return sign(v) * pow(F, vec3<f32>(1.0 / 0.42));
+}
+
+fn aces2_compress_cone_scalar(v: f32) -> f32 {
+    let F = pow(abs(v), 0.42);
+    return sign(v) * F / (ACES2_CAM_NL_OFFSET + F);
+}
+
+fn aces2_compress_cone_inverse_scalar(v: f32) -> f32 {
+    let a = min(abs(v), 0.99);
+    return sign(v) * pow(ACES2_CAM_NL_OFFSET * a / (1.0 - a), 1.0 / 0.42);
+}
+
+// RGB to (A, a, b), through the given primaries' adapted cone space
+fn aces2_rgb_to_Aab(block: u32, rgb_to_cam: u32, rgb: vec3<f32>) -> vec3<f32> {
+    let cone = aces2_matrix(block + rgb_to_cam) * rgb;
+    return aces2_matrix(block + ${ACES2_CONE_TO_AAB}u) * aces2_compress_cone(cone);
+}
+
+fn aces2_Aab_to_rgb(block: u32, cam_to_rgb: u32, Aab: vec3<f32>) -> vec3<f32> {
+    let cone = aces2_matrix(block + ${ACES2_AAB_TO_CONE}u) * Aab;
+    return aces2_matrix(block + cam_to_rgb) * aces2_compress_cone_inverse(cone);
+}
+
+fn aces2_Aab_to_JMh(block: u32, Aab: vec3<f32>) -> vec3<f32> {
+    if (Aab.x <= 0.0) {
+        return vec3<f32>(0.0);
+    }
+    let J = ACES2_J_SCALE * pow(Aab.x, aces2_scalar(block, 18u));
+    let M = length(Aab.yz);
+    var h = atan2(Aab.z, Aab.y) * ACES2_DEGREES_PER_RADIAN;
+    if (h < 0.0) {
+        h += 360.0;
+    }
+    return vec3<f32>(J, M, h);
+}
+
+fn aces2_J_to_A(block: u32, J: f32) -> f32 {
+    return pow(J / ACES2_J_SCALE, aces2_scalar(block, 19u));
+}
+
+// achromatic response to luminance, and luminance to lightness J, for the AP0 input
+fn aces2_A_to_Y(block: u32, A: f32) -> f32 {
+    return aces2_compress_cone_inverse_scalar(aces2_scalar(block, 20u) * A) / aces2_scalar(block, 17u);
+}
+
+fn aces2_Y_to_J(block: u32, Y: f32) -> f32 {
+    let Ra = aces2_compress_cone_scalar(Y * aces2_scalar(block, 17u));
+    return ACES2_J_SCALE * pow(Ra * aces2_scalar(block, 21u), aces2_scalar(block, 18u));
+}
+
+// the tone scale, in luminance, 1.0 = 100 cd/m² on the way out
+fn aces2_tonescale(block: u32, Y: f32) -> f32 {
+    let s_2 = aces2_scalar(block, 5u);
+    let m_2 = aces2_scalar(block, 6u);
+    let g = aces2_scalar(block, 7u);
+    let t_1 = aces2_scalar(block, 8u);
+    let n_r = aces2_scalar(block, 9u);
+
+    let f = m_2 * pow(Y / (Y + s_2), g);
+    return max(0.0, f * f / (f + t_1)) * n_r;
+}
+
+fn aces2_tonescale_inverse(block: u32, Y: f32) -> f32 {
+    let s_2 = aces2_scalar(block, 5u);
+    let m_2 = aces2_scalar(block, 6u);
+    let g = aces2_scalar(block, 7u);
+    let t_1 = aces2_scalar(block, 8u);
+    let inverse_limit = aces2_scalar(block, 10u);
+
+    let Z = clamp(Y / 100.0, 0.0, inverse_limit);
+    let f = (Z + sqrt(Z * (4.0 * t_1 + Z))) / 2.0;
+    return s_2 / (pow(m_2 / f, 1.0 / g) - 1.0);
+}
+
+fn aces2_chroma_compress_norm(cos_h: f32, sin_h: f32, scale: f32) -> f32 {
+    let cos_h2 = 2.0 * cos_h * cos_h - 1.0;
+    let sin_h2 = 2.0 * cos_h * sin_h;
+    let cos_h3 = 4.0 * cos_h * cos_h * cos_h - 3.0 * cos_h;
+    let sin_h3 = 3.0 * sin_h - 4.0 * sin_h * sin_h * sin_h;
+
+    let M = 11.34072 * cos_h + 16.46899 * cos_h2 + 7.88380 * cos_h3
+        + 14.66441 * sin_h - 6.37224 * sin_h2 + 9.19364 * sin_h3
+        + 77.12896;
+
+    return M * scale;
+}
+
+fn aces2_toe(x: f32, limit: f32, k1_in: f32, k2_in: f32) -> f32 {
+    if (x > limit) {
+        return x;
+    }
+    let k2 = max(k2_in, 0.001);
+    let k1 = sqrt(k1_in * k1_in + k2 * k2);
+    let k3 = (limit + k1) / (limit + k2);
+    let minus_b = k3 * x - k1;
+    let minus_ac = k2 * k3 * x;
+    return 0.5 * (minus_b + sqrt(minus_b * minus_b + 4.0 * minus_ac));
+}
+
+fn aces2_toe_inverse(x: f32, limit: f32, k1_in: f32, k2_in: f32) -> f32 {
+    if (x > limit) {
+        return x;
+    }
+    let k2 = max(k2_in, 0.001);
+    let k1 = sqrt(k1_in * k1_in + k2 * k2);
+    let k3 = (limit + k1) / (limit + k2);
+    return (x * x + k1 * x) / (k3 * (x + k2));
+}
+
+// M of the reach gamut at limit_J_max, one table entry a degree
+fn aces2_reach_M(block: u32, h: f32) -> f32 {
+    let base = u32(h);
+    let t = h - f32(base);
+    let at = block + ${ACES2_REACH_TABLE}u + 1u + base;
+    return mix(aces2_tables[at], aces2_tables[at + 1u], t);
+}
+
+fn aces2_cusp_entry(block: u32, i: i32) -> vec4<f32> {
+    let at = block + ${ACES2_CUSP_TABLE}u + u32(i) * 4u;
+    return vec4<f32>(aces2_tables[at], aces2_tables[at + 1u], aces2_tables[at + 2u], aces2_tables[at + 3u]);
+}
+
+// (cusp J, cusp M, upper hull 1 / gamma) at hue h, from the non-uniform hue table
+fn aces2_cusp(block: u32, h: f32) -> vec3<f32> {
+    var i = 1 + i32(h);
+    var i_lo = max(0, i + i32(aces2_scalar(block, 22u)));
+    var i_hi = min(361, i + i32(aces2_scalar(block, 23u)));
+
+    // a handful of steps: the table strays from one entry a degree by a few entries at most, and 9 halvings cover
+    // all 363
+    for (var step = 0; step < 9; step++) {
+        if (i_lo + 1 >= i_hi) {
+            break;
+        }
+        if (h > aces2_cusp_entry(block, i).x) {
+            i_lo = i;
+        } else {
+            i_hi = i;
+        }
+        i = (i_lo + i_hi) / 2;
+    }
+    i_hi = max(1, i_hi);
+
+    let lower = aces2_cusp_entry(block, i_hi - 1);
+    let upper = aces2_cusp_entry(block, i_hi);
+    let t = (h - lower.x) / (upper.x - lower.x);
+    return mix(lower.yzw, upper.yzw, t);
+}
+
+fn aces2_focus_gain(J: f32, threshold: f32, J_max: f32, focus_dist: f32) -> f32 {
+    var gain = J_max * focus_dist;
+    if (J > threshold) {
+        let adjustment = log2((J_max - threshold) / max(0.0001, J_max - J)) * 0.30102999566398120;
+        gain *= adjustment * adjustment + 1.0;
+    }
+    return gain;
+}
+
+fn aces2_solve_J_intersect(J: f32, M: f32, focusJ: f32, J_max: f32, slope_gain: f32) -> f32 {
+    let M_scaled = M / slope_gain;
+    let a = M_scaled / focusJ;
+    if (J < focusJ) {
+        let b = 1.0 - M_scaled;
+        let c = -J;
+        return -2.0 * c / (b + sqrt(b * b - 4.0 * a * c));
+    }
+    let b = -(1.0 + M_scaled + J_max * a);
+    let c = J_max * M_scaled + J;
+    return -2.0 * c / (b - sqrt(b * b - 4.0 * a * c));
+}
+
+fn aces2_line_boundary_M(J_axis_intersect: f32, slope: f32, inv_gamma: f32, J_max: f32, M_max: f32, J_reference: f32) -> f32 {
+    let shifted = J_reference * pow(max(J_axis_intersect / J_reference, 0.0), inv_gamma);
+    return shifted * M_max / (J_max - slope * M_max);
+}
+
+fn aces2_remap_M(M: f32, gamut_M: f32, reach_M: f32, inverse: bool) -> f32 {
+    let proportion = max(gamut_M / reach_M, ACES2_COMPRESSION_THRESHOLD);
+    let threshold = proportion * gamut_M;
+    if (M <= threshold || proportion >= 1.0) {
+        return M;
+    }
+
+    let m_offset = M - threshold;
+    let gamut_offset = gamut_M - threshold;
+    let reach_offset = reach_M - threshold;
+    let scale = reach_offset / ((reach_offset / gamut_offset) - 1.0);
+    let nd = m_offset / scale;
+
+    if (inverse) {
+        if (nd >= 1.0) {
+            return threshold + scale;
+        }
+        return threshold + scale * -(nd / (nd - 1.0));
+    }
+    return threshold + scale * nd / (1.0 + nd);
+}
+
+// compressGamut: pulls (J, M) toward the focus point onto the display's gamut, or back out of it
+fn aces2_gamut_compress(block: u32, JMh: vec3<f32>, Jx: f32, reach_M: f32, cusp: vec3<f32>, inverse: bool) -> vec3<f32> {
+    let J_max = aces2_scalar(block, 0u);
+    let model_gamma_inv = aces2_scalar(block, 1u);
+    let mid_J = aces2_scalar(block, 2u);
+    let focus_dist = aces2_scalar(block, 3u);
+    let gamma_bottom_inv = aces2_scalar(block, 4u);
+
+    let focusJ = mix(cusp.x, mid_J, min(1.0, ACES2_CUSP_MID_BLEND - cusp.x / J_max));
+    let threshold = mix(cusp.x, J_max, ACES2_FOCUS_GAIN_BLEND);
+
+    let slope_gain = aces2_focus_gain(Jx, threshold, J_max, focus_dist);
+    let J_intersect_source = aces2_solve_J_intersect(JMh.x, JMh.y, focusJ, J_max, slope_gain);
+    let direction = select(J_max - J_intersect_source, J_intersect_source, J_intersect_source < focusJ);
+    let slope = direction * (J_intersect_source - focusJ) / (focusJ * slope_gain);
+    let J_intersect_cusp = aces2_solve_J_intersect(cusp.x, cusp.y, focusJ, J_max, slope_gain);
+
+    // find_gamut_boundary_intersection: the lower hull, and the upper one flipped about J_max, smoothly minimised
+    let lower = aces2_line_boundary_M(J_intersect_source, slope, gamma_bottom_inv, cusp.x, cusp.y, J_intersect_cusp);
+    let upper = aces2_line_boundary_M(J_max - J_intersect_source, -slope, cusp.z, J_max - cusp.x, cusp.y, J_max - J_intersect_cusp);
+    let s = ACES2_SMOOTH_CUSPS * cusp.y;
+    let k = max(s - abs(lower - upper), 0.0) / s;
+    let gamut_M = min(lower, upper) - k * k * k * s * (1.0 / 6.0);
+
+    if (gamut_M <= 0.0) {
+        return vec3<f32>(JMh.x, 0.0, JMh.z);
+    }
+
+    let reach_boundary_M = aces2_line_boundary_M(J_intersect_source, slope, model_gamma_inv, J_max, reach_M, J_max);
+
+    // Going back, a colour past the estimated gamut boundary is one the forward transform never writes: the estimate
+    // lies inside the display's real gamut, and OCIO's inverse extrapolates from there toward infinity, then snaps.
+    // Clamped at the boundary it comes back as the reach boundary, which the forward transform takes to it.
+    var M_source = JMh.y;
+    if (inverse) {
+        M_source = min(M_source, gamut_M);
+    }
+    var M = aces2_remap_M(M_source, gamut_M, reach_boundary_M, inverse);
+
+    // In the last unit of J before the peak, the display's gamut closes on white while the reach does not, so the
+    // inverse multiplies colourfulness by hundreds to thousands, where everywhere below that unit it multiplies by
+    // under 4.9 (3,000 Filmic outputs), and white itself, past J_max, comes back neutral. So the gain is held to what
+    // the rest of the gamut sees, which keeps float32 rounding from being multiplied a thousandfold, and fades out
+    // over that unit, which takes a near-white colour continuously to the neutral that white goes to.
+    if (inverse) {
+        M = min(M, ACES2_INVERSE_GAIN_LIMIT * M_source);
+        M = mix(M, M_source, smoothstep(J_max - ACES2_INVERSE_FADE_J, J_max, JMh.x));
+    }
+
+    return vec3<f32>(J_intersect_source + M * slope, M, JMh.z);
+}
+
+fn aces2_clamp_to_ap1(block: u32, aces: vec3<f32>) -> vec3<f32> {
+    let upper_bound = aces2_scalar(block, 11u);
+    return UE_AP1_TO_AP0 * clamp(UE_AP0_TO_AP1 * aces, vec3<f32>(0.0), vec3<f32>(upper_bound));
+}
+
+fn aces2_forward(block: u32, aces_in: vec3<f32>) -> vec3<f32> {
+    let J_max = aces2_scalar(block, 0u);
+    let model_gamma_inv = aces2_scalar(block, 1u);
+
+    let aces = aces2_clamp_to_ap1(block, aces_in);
+
+    let Aab = aces2_rgb_to_Aab(block, ${ACES2_IN_RGB_TO_CAM}u, aces);
+    let JMh = aces2_Aab_to_JMh(block, Aab);
+    let h = JMh.z;
+
+    let reach_M = aces2_reach_M(block, h);
+    let h_rad = h / ACES2_DEGREES_PER_RADIAN;
+    let cos_h = cos(h_rad);
+    let sin_h = sin(h_rad);
+    let M_norm = aces2_chroma_compress_norm(cos_h, sin_h, aces2_scalar(block, 15u));
+
+    // the tone scale, applied to the achromatic response's luminance. A response at or under zero comes out at zero,
+    // which is where OCIO's max(0, NaN) lands it
+    var Y_ts = 0.0;
+    if (Aab.x > 0.0) {
+        Y_ts = aces2_tonescale(block, aces2_A_to_Y(block, Aab.x));
+    }
+    let J_ts = aces2_Y_to_J(block, Y_ts);
+
+    // chroma compression
+    var M = JMh.y;
+    if (M != 0.0) {
+        let sat = aces2_scalar(block, 12u);
+        let sat_thr = aces2_scalar(block, 13u);
+        let compr = aces2_scalar(block, 14u);
+
+        let nJ = J_ts / J_max;
+        let snJ = max(0.0, 1.0 - nJ);
+        let limit = pow(nJ, model_gamma_inv) * reach_M / M_norm;
+
+        M = M * pow(J_ts / JMh.x, model_gamma_inv) / M_norm;
+        M = limit - aces2_toe(limit - M, limit - 0.001, snJ * sat, sqrt(nJ * nJ + sat_thr));
+        M = aces2_toe(M, limit, nJ * compr, snJ);
+        M = M * M_norm;
+    }
+
+    // gamut compression
+    var compressed = vec3<f32>(J_ts, M, h);
+    if (J_ts <= 0.0) {
+        compressed = vec3<f32>(0.0, 0.0, h);
+    } else if (M <= 0.0 || J_ts > J_max) {
+        compressed = vec3<f32>(J_ts, 0.0, h);
+    } else {
+        compressed = aces2_gamut_compress(block, compressed, J_ts, reach_M, aces2_cusp(block, h), false);
+    }
+
+    let Aab_out = vec3<f32>(aces2_J_to_A(block, compressed.x), compressed.y * cos_h, compressed.y * sin_h);
+    let rgb = aces2_Aab_to_rgb(block, ${ACES2_OUT_CAM_TO_RGB}u, Aab_out);
+
+    return clamp(rgb, vec3<f32>(0.0), vec3<f32>(aces2_scalar(block, 16u)));
+}
+
+fn aces2_inverse(block: u32, rgb_in: vec3<f32>) -> vec3<f32> {
+    let J_max = aces2_scalar(block, 0u);
+    let model_gamma_inv = aces2_scalar(block, 1u);
+
+    let rgb = clamp(rgb_in, vec3<f32>(0.0), vec3<f32>(aces2_scalar(block, 16u)));
+
+    let JMh = aces2_Aab_to_JMh(block, aces2_rgb_to_Aab(block, ${ACES2_OUT_RGB_TO_CAM}u, rgb));
+    let h = JMh.z;
+
+    let reach_M = aces2_reach_M(block, h);
+    let h_rad = h / ACES2_DEGREES_PER_RADIAN;
+    let cos_h = cos(h_rad);
+    let sin_h = sin(h_rad);
+    let M_norm = aces2_chroma_compress_norm(cos_h, sin_h, aces2_scalar(block, 15u));
+
+    // gamut compression, undone; above the analytical threshold J itself is estimated by one compression first
+    var tonemapped = JMh;
+    if (JMh.x <= 0.0) {
+        tonemapped = vec3<f32>(0.0, 0.0, h);
+    } else if (JMh.y <= 0.0 || JMh.x > J_max) {
+        tonemapped = vec3<f32>(JMh.x, 0.0, h);
+    } else {
+        let cusp = aces2_cusp(block, h);
+        let threshold = mix(cusp.x, J_max, ACES2_FOCUS_GAIN_BLEND);
+        var Jx = JMh.x;
+        if (Jx > threshold) {
+            Jx = aces2_gamut_compress(block, JMh, Jx, reach_M, cusp, true).x;
+        }
+        tonemapped = aces2_gamut_compress(block, JMh, Jx, reach_M, cusp, true);
+    }
+
+    // the tone scale, undone
+    let J_ts = tonemapped.x;
+    let Y_in = aces2_A_to_Y(block, aces2_J_to_A(block, abs(J_ts)));
+    let J = sign(J_ts) * aces2_Y_to_J(block, aces2_tonescale_inverse(block, Y_in));
+
+    // chroma compression, undone
+    var M = tonemapped.y;
+    if (M != 0.0) {
+        let sat = aces2_scalar(block, 12u);
+        let sat_thr = aces2_scalar(block, 13u);
+        let compr = aces2_scalar(block, 14u);
+
+        let nJ = J_ts / J_max;
+        let snJ = max(0.0, 1.0 - nJ);
+        let limit = pow(nJ, model_gamma_inv) * reach_M / M_norm;
+
+        M = M / M_norm;
+        M = aces2_toe_inverse(M, limit, nJ * compr, snJ);
+        M = limit - aces2_toe_inverse(limit - M, limit - 0.001, snJ * sat, sqrt(nJ * nJ + sat_thr));
+        M = M * M_norm * pow(J_ts / J, -model_gamma_inv);
+    }
+
+    let Aab = vec3<f32>(aces2_J_to_A(block, J), M * cos_h, M * sin_h);
+    let aces = aces2_Aab_to_rgb(block, ${ACES2_IN_CAM_TO_RGB}u, Aab);
+
+    return aces2_clamp_to_ap1(block, aces);
+}
+`,
+    [chunk_aces_ue_matrices]
+);

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

@@ -0,0 +1,22 @@
+/**
+ * The colour matrices of Unreal Engine 5.4's default tone mapping, each the product UE forms from the constants in
+ * `Engine/Shaders/Private/ACES.ush`, taken in float64 and written out. `M * v` here is UE's `mul(M, v)`.
+ *
+ * - `UE_REC709_TO_AP1`, `UE_AP1_TO_REC709`: UE's default working space (sRGB primaries, D65) to ACEScg and back,
+ *   through XYZ with UE's Bradford D65/D60 adaptation (`XYZ_2_AP1_MAT · D65_2_D60_CAT · sRGB_2_XYZ_MAT`).
+ * - `UE_AP1_TO_AP0`, `UE_AP0_TO_AP1`: `AP1_2_AP0_MAT` and `AP0_2_AP1_MAT` as UE spells them.
+ * - `UE_EXPAND_GAMUT`: PostProcessCombineLUTs.usf's `ExpandMat`, from sRGB toward the "wide" primaries the file
+ *   lists, `(XYZ_2_AP1_MAT · Wide_2_XYZ_MAT) · AP1_2_sRGB`. UE applies no adaptation on the wide side, and nor does
+ *   this.
+ * - `UE_BLUE_CORRECT`, `UE_BLUE_CORRECT_INVERSE`: the file's `BlueCorrect` and `BlueCorrectInv`, both defined on
+ *   AP0, conjugated into AP1 (`AP0_2_AP1 · BlueCorrect · AP1_2_AP0`).
+ *
+ * `UE_AP1_LUMINANCE` is `AP1_RGB2Y`, the Y row of `AP1_2_XYZ_MAT`.
+ *
+ * @see chunk_tonemap_ue_filmic
+ * @see chunk_aces2_output_transform
+ * @type {CodeChunk}
+ */
+export const chunk_aces_ue_matrices: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_aces_ue_matrices.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_aces_ue_matrices.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces_ue_matrices.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qCAFU,SAAS,CAgDjB;0BAnEwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces_ue_matrices.js

@@ -0,0 +1,68 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+
+/**
+ * The colour matrices of Unreal Engine 5.4's default tone mapping, each the product UE forms from the constants in
+ * `Engine/Shaders/Private/ACES.ush`, taken in float64 and written out. `M * v` here is UE's `mul(M, v)`.
+ *
+ * - `UE_REC709_TO_AP1`, `UE_AP1_TO_REC709`: UE's default working space (sRGB primaries, D65) to ACEScg and back,
+ *   through XYZ with UE's Bradford D65/D60 adaptation (`XYZ_2_AP1_MAT · D65_2_D60_CAT · sRGB_2_XYZ_MAT`).
+ * - `UE_AP1_TO_AP0`, `UE_AP0_TO_AP1`: `AP1_2_AP0_MAT` and `AP0_2_AP1_MAT` as UE spells them.
+ * - `UE_EXPAND_GAMUT`: PostProcessCombineLUTs.usf's `ExpandMat`, from sRGB toward the "wide" primaries the file
+ *   lists, `(XYZ_2_AP1_MAT · Wide_2_XYZ_MAT) · AP1_2_sRGB`. UE applies no adaptation on the wide side, and nor does
+ *   this.
+ * - `UE_BLUE_CORRECT`, `UE_BLUE_CORRECT_INVERSE`: the file's `BlueCorrect` and `BlueCorrectInv`, both defined on
+ *   AP0, conjugated into AP1 (`AP0_2_AP1 · BlueCorrect · AP1_2_AP0`).
+ *
+ * `UE_AP1_LUMINANCE` is `AP1_RGB2Y`, the Y row of `AP1_2_XYZ_MAT`.
+ *
+ * @see chunk_tonemap_ue_filmic
+ * @see chunk_aces2_output_transform
+ * @type {CodeChunk}
+ */
+export const chunk_aces_ue_matrices = CodeChunk.from(
+    //language=WGSL
+    `
+const UE_AP1_LUMINANCE = vec3<f32>(0.2722287168, 0.6740817658, 0.0536895174);
+
+const UE_REC709_TO_AP1 = mat3x3<f32>(
+    vec3<f32>( 0.6130974024,  0.0701937225,  0.0206155929),
+    vec3<f32>( 0.3395231461,  0.9163538791,  0.1095697729),
+    vec3<f32>( 0.0473794514,  0.0134523986,  0.8698146341)
+);
+
+const UE_AP1_TO_REC709 = mat3x3<f32>(
+    vec3<f32>( 1.7050509926, -0.1302564175, -0.0240033568),
+    vec3<f32>(-0.6217921205,  1.1408047365, -0.1289689761),
+    vec3<f32>(-0.0832588722, -0.0105483190,  1.1529723328)
+);
+
+const UE_AP1_TO_AP0 = mat3x3<f32>(
+    vec3<f32>( 0.6954522414,  0.0447945634, -0.0055258826),
+    vec3<f32>( 0.1406786965,  0.8596711185,  0.0040252103),
+    vec3<f32>( 0.1638690622,  0.0955343182,  1.0015006723)
+);
+
+const UE_AP0_TO_AP1 = mat3x3<f32>(
+    vec3<f32>( 1.4514393161, -0.0765537734,  0.0083161484),
+    vec3<f32>(-0.2365107469,  1.1762296998, -0.0060324498),
+    vec3<f32>(-0.2149285693, -0.0996759264,  0.9977163014)
+);
+
+const UE_EXPAND_GAMUT = mat3x3<f32>(
+    vec3<f32>( 1.3704123718, -0.0834334917, -0.0257933209),
+    vec3<f32>(-0.3292921877,  1.0970927480, -0.0986257988),
+    vec3<f32>(-0.0636831194, -0.0108613795,  1.2036949526)
+);
+
+const UE_BLUE_CORRECT = mat3x3<f32>(
+    vec3<f32>( 0.9386393778,  0.0000000001,  0.0000000000),
+    vec3<f32>( 0.0000000001,  0.8307941329,  0.0000000000),
+    vec3<f32>( 0.0613606221,  0.1692058671,  1.0000000000)
+);
+
+const UE_BLUE_CORRECT_INVERSE = mat3x3<f32>(
+    vec3<f32>( 1.0653748754, -0.0000003455,  0.0000000199),
+    vec3<f32>( 0.0000014468,  1.2036635244,  0.0000000212),
+    vec3<f32>(-0.0653710053, -0.2036677199,  0.9999996001)
+);`
+);

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

@@ -0,0 +1,32 @@
+/**
+ * Unreal Engine's default SDR tone mapping, "Filmic", with every setting at its default.
+ *
+ * A line-for-line port of UE 5.4's `CombineLUTsCommon` (PostProcessCombineLUTs.usf) for the sRGB output device and
+ * `FilmToneMap` (TonemapCommon.ush), as UE evaluates them into its colour grading LUT, here evaluated per pixel:
+ *
+ * 1. into ACEScg (AP1) from UE's default sRGB working space;
+ * 2. Expand Gamut at its default 1.0, which pushes bright saturated colours toward wider primaries;
+ * 3. the colour corrections at their defaults, which only clamp AP1 at zero;
+ * 4. Blue Correction at its default 0.6, a matrix that turns bright blue toward cyan rather than violet, before the
+ *    curve, and its inverse after;
+ * 5. `FilmToneMap` with Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (`FPostProcessSettings`'
+ *    defaults, Scene.cpp). It is the ACES reference rendering's glow and red modifier and its 0.96 desaturation, then a
+ *    parametric toe-straight-shoulder curve on log10 of each AP1 channel, solved so that 0.18 comes out at 0.18, then a
+ *    0.93 desaturation;
+ * 6. back to the working space, clamped at zero, and clipped at 1 as the sRGB target clips it.
+ *
+ * UE 5.8 keeps Filmic as its default method and its SDR output unchanged. What it does on an HDR display is in
+ * shader_tonemap_HDR_aces.
+ *
+ * Where UE divides 0 by 0 (gamut expansion of black) or takes log10(0), this takes the limit, so black stays black.
+ * UE's LUT also limits its input to 43.7, the top of its log encoding; this does not, which moves a few saturated
+ * highlights over 43.7 by a few codes.
+ *
+ * Input: exposed linear Rec.709. Output: display-linear Rec.709 in [0, 1].
+ *
+ * @see "Color Grading and the Filmic Tonemapper in Unreal Engine", Epic Games
+ * @type {CodeChunk}
+ */
+export const chunk_tonemap_ue_filmic: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_tonemap_ue_filmic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_tonemap_ue_filmic.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_tonemap_ue_filmic.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,sCAFU,SAAS,CAoIjB;0BAlKwB,mCAAmC"}