@woosh/meep-engine 3.51.0 → 3.53.0

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

@@ -0,0 +1,692 @@
+import { m3_invert } from "../../../../../../../core/geom/mat3/m3_invert.js";
+import { m3_multiply } from "../../../../../../../core/geom/mat3/m3_multiply.js";
+import { m3_rgb_to_xyz_from_primaries } from "../../../../../../../core/color/xyz/m3_rgb_to_xyz_from_primaries.js";
+
+/*
+ The CPU half of the ACES 2.0 output transform: everything OpenColorIO's `init_*` functions compute from a display's
+ peak and limiting primaries, written as one block of floats that `chunk_aces2_output_transform` reads.
+
+ Ported from OpenColorIO v2.6.0 (BSD-3-Clause), src/OpenColorIO/ops/fixedfunction/ACES2/Transform.cpp, which is the
+ Academy's reference (ampas/aces-core, Lib.Academy.OutputTransform.ctl) with its gamut tables. Matrices are row-major
+ here and `M · v` everywhere, as in that file.
+*/
+
+/** hue tables: 360 one-degree entries, one lower and two upper wrap entries */
+const NOMINAL = 360;
+const TOTAL = NOMINAL + 3;
+const FIRST_NOMINAL = 1;
+const UPPER_WRAP = FIRST_NOMINAL + NOMINAL;
+const LAST_NOMINAL = UPPER_WRAP - 1;
+const LOWER_WRAP = 0;
+
+const REFERENCE_LUMINANCE = 100;
+const L_A = 100;
+const Y_B = 20;
+const SURROUND = [0.9, 0.59, 0.9];
+const J_SCALE = 100;
+const CAM_NL_OFFSET = 0.2713 * 100;
+const CAM_NL_SCALE = 4 * 100;
+
+const CHROMA_COMPRESS = 2.4;
+const CHROMA_COMPRESS_FACT = 3.3;
+const CHROMA_EXPAND = 1.3;
+const CHROMA_EXPAND_FACT = 0.69;
+const CHROMA_EXPAND_THR = 0.5;
+
+const SMOOTH_CUSPS = 0.12;
+const SMOOTH_M = 0.27;
+const CUSP_MID_BLEND = 1.3;
+const FOCUS_GAIN_BLEND = 0.3;
+const FOCUS_DISTANCE = 1.35;
+const FOCUS_DISTANCE_SCALING = 1.75;
+
+const GAMMA_MINIMUM = 0;
+const GAMMA_MAXIMUM = 5;
+const GAMMA_SEARCH_STEP = 0.4;
+const GAMMA_ACCURACY = 1e-5;
+const REACH_CUSP_TOLERANCE = 1e-3;
+const DISPLAY_CUSP_TOLERANCE = 1e-7;
+
+/** red, green, blue and white xy */
+const PRIMARIES_CAM16 = [0.8336, 0.1735, 2.3854, -1.4659, 0.087, -0.125, 0.333, 0.333];
+const PRIMARIES_AP0 = [0.7347, 0.2653, 0.0, 1.0, 0.0001, -0.0770, 0.32168, 0.33767];
+const PRIMARIES_AP1 = [0.713, 0.293, 0.165, 0.830, 0.128, 0.044, 0.32168, 0.33767];
+
+/**
+ * Rec.709's red, green, blue and white xy: the limiting primaries the ACES tone mapping uses.
+ * @type {number[]}
+ */
+export const ACES2_LIMITING_REC709 = [0.64, 0.33, 0.30, 0.60, 0.15, 0.06, 0.3127, 0.3290];
+
+/*
+ The block, in floats. Matrices are three columns of three, so WGSL reads a column with three loads.
+*/
+/** limiting primaries to the CAM16 cone space, white-adapted */
+export const ACES2_OUT_RGB_TO_CAM = 0;
+export const ACES2_OUT_CAM_TO_RGB = 9;
+/** ACES2065-1 (AP0) to the cone space and back */
+export const ACES2_IN_RGB_TO_CAM = 18;
+export const ACES2_IN_CAM_TO_RGB = 27;
+/** compressed cone response to achromatic and opponent (A, a, b) and back; the same for every set of primaries */
+export const ACES2_CONE_TO_AAB = 36;
+export const ACES2_AAB_TO_CONE = 45;
+/**
+ * scalars, in this order: limit_J_max, model_gamma_inv, mid_J, focus_dist, lower_hull_gamma_inv, s_2, m_2, g, t_1,
+ * n_r, inverse_limit, AP1 upper bound, sat, sat_thr, compr, chroma_compress_scale, peak / 100, F_L_n, cz, inv_cz,
+ * A_w_J, inv_A_w_J, the hue search range's lower and upper offsets
+ */
+export const ACES2_SCALARS = 54;
+export const ACES2_SCALAR_COUNT = 24;
+/** TOTAL entries of (hue, cusp J, cusp M, upper hull inverse gamma) */
+export const ACES2_CUSP_TABLE = ACES2_SCALARS + ACES2_SCALAR_COUNT;
+/** TOTAL entries of the reach gamut's M at limit_J_max, one per degree from the first nominal entry */
+export const ACES2_REACH_TABLE = ACES2_CUSP_TABLE + TOTAL * 4;
+/** floats in one block */
+export const ACES2_BLOCK_FLOATS = ACES2_REACH_TABLE + TOTAL;
+
+// ---------------------------------------------------------------------------------------------------------------
+// matrices, row-major
+
+function rgb_to_xyz(out, P) {
+    m3_rgb_to_xyz_from_primaries(out, P.slice(0, 6), P[6], P[7]);
+    return out;
+}
+
+function mul_m3_v3(out, M, x, y, z) {
+    out[0] = M[0] * x + M[1] * y + M[2] * z;
+    out[1] = M[3] * x + M[4] * y + M[5] * z;
+    out[2] = M[6] * x + M[7] * y + M[8] * z;
+    return out;
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// the colour appearance model (CAM16 in Hellwig's 2022 form)
+
+function model_gamma() {
+    return SURROUND[1] * (1.48 + Math.sqrt(Y_B / REFERENCE_LUMINANCE));
+}
+
+function pacrc_fwd(v) {
+    const F = Math.pow(Math.abs(v), 0.42);
+    const Ra = F / (CAM_NL_OFFSET + F);
+    return v < 0 ? -Ra : Ra;
+}
+
+function pacrc_inv(v) {
+    const a = Math.min(Math.abs(v), 0.99);
+    const F = CAM_NL_OFFSET * a / (1 - a);
+    const Rc = Math.pow(F, 1 / 0.42);
+    return v < 0 ? -Rc : Rc;
+}
+
+/**
+ * OCIO's JMhParams for one set of primaries.
+ */
+class JMhParams {
+    rgb_to_cam = new Float64Array(9);
+    cam_to_rgb = new Float64Array(9);
+    cone_to_Aab = new Float64Array(9);
+    Aab_to_cone = new Float64Array(9);
+    F_L_n = 0;
+    cz = 0;
+    inv_cz = 0;
+    A_w_J = 0;
+    inv_A_w_J = 0;
+
+    /**
+     * @param {number[]} P red, green, blue and white xy
+     */
+    constructor(P) {
+        const base = [2, 1, 1 / 20, 1, -12 / 11, 1 / 11, 1 / 9, 1 / 9, -2 / 9];
+
+        const m16 = rgb_to_xyz(new Float64Array(9), PRIMARIES_CAM16);
+        m3_invert(m16, m16);
+
+        const to_xyz = rgb_to_xyz(new Float64Array(9), P);
+        const XYZ_w = mul_m3_v3([0, 0, 0], to_xyz, REFERENCE_LUMINANCE, REFERENCE_LUMINANCE, REFERENCE_LUMINANCE);
+        const Y_W = XYZ_w[1];
+        const RGB_w = mul_m3_v3([0, 0, 0], m16, XYZ_w[0], XYZ_w[1], XYZ_w[2]);
+
+        const K = 1 / (5 * L_A + 1);
+        const K4 = K * K * K * K;
+        const F_L = 0.2 * K4 * (5 * L_A) + 0.1 * Math.pow(1 - K4, 2) * Math.pow(5 * L_A, 1 / 3);
+
+        this.F_L_n = F_L / REFERENCE_LUMINANCE;
+        this.cz = model_gamma();
+        this.inv_cz = 1 / this.cz;
+
+        const D = [0, 1, 2].map(i => this.F_L_n * Y_W / RGB_w[i]);
+        const RGB_AW = [0, 1, 2].map(i => pacrc_fwd(D[i] * RGB_w[i]));
+
+        const A_w = CAM_NL_SCALE * (base[0] * RGB_AW[0] + base[1] * RGB_AW[1] + base[2] * RGB_AW[2]);
+
+        this.A_w_J = pacrc_fwd(F_L);
+        this.inv_A_w_J = 1 / this.A_w_J;
+
+        // limiting primaries to CAM16, prescaled by the reference luminance and the white's discount
+        const xyz_to_cam = m16;
+        const to_cam = new Float64Array(9);
+        m3_multiply(to_cam, xyz_to_cam, to_xyz);
+        for (let row = 0; row < 3; row++) {
+            for (let column = 0; column < 3; column++) {
+                this.rgb_to_cam[row * 3 + column] = D[row] * to_cam[row * 3 + column] * REFERENCE_LUMINANCE;
+            }
+        }
+        m3_invert(this.cam_to_rgb, this.rgb_to_cam);
+
+        for (let column = 0; column < 3; column++) {
+            this.cone_to_Aab[column] = CAM_NL_SCALE * base[column] / A_w;
+            this.cone_to_Aab[3 + column] = CAM_NL_SCALE * base[3 + column] * 43 * SURROUND[2];
+            this.cone_to_Aab[6 + column] = CAM_NL_SCALE * base[6 + column] * 43 * SURROUND[2];
+        }
+        m3_invert(this.Aab_to_cone, this.cone_to_Aab);
+    }
+}
+
+const scratch_v = [0, 0, 0];
+const scratch_c = [0, 0, 0];
+
+function RGB_to_Aab(out, r, g, b, p) {
+    mul_m3_v3(scratch_c, p.rgb_to_cam, r, g, b);
+    return mul_m3_v3(out, p.cone_to_Aab, pacrc_fwd(scratch_c[0]), pacrc_fwd(scratch_c[1]), pacrc_fwd(scratch_c[2]));
+}
+
+/** JMh from Aab, in place */
+function Aab_to_JMh(v, p) {
+    if (v[0] <= 0) {
+        v[0] = 0;
+        v[1] = 0;
+        v[2] = 0;
+        return v;
+    }
+    const J = J_SCALE * Math.pow(v[0], p.cz);
+    const M = Math.sqrt(v[1] * v[1] + v[2] * v[2]);
+    let h = 180 * Math.atan2(v[2], v[1]) / Math.PI;
+    if (h < 0) {
+        h += 360;
+    }
+    v[0] = J;
+    v[1] = M;
+    v[2] = h;
+    return v;
+}
+
+function RGB_to_JMh(out, r, g, b, p) {
+    return Aab_to_JMh(RGB_to_Aab(out, r, g, b, p), p);
+}
+
+function JMh_to_RGB(out, J, M, h, p) {
+    const hr = h * Math.PI / 180;
+    const A = Math.pow(J / J_SCALE, p.inv_cz);
+    mul_m3_v3(scratch_c, p.Aab_to_cone, A, M * Math.cos(hr), M * Math.sin(hr));
+    return mul_m3_v3(out, p.cam_to_rgb, pacrc_inv(scratch_c[0]), pacrc_inv(scratch_c[1]), pacrc_inv(scratch_c[2]));
+}
+
+function Y_to_J(Y, p) {
+    const abs_Y = Math.abs(Y);
+    const J = J_SCALE * Math.pow(pacrc_fwd(abs_Y * p.F_L_n) * p.inv_A_w_J, p.cz);
+    return Y < 0 ? -J : J;
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// gamut compression helpers the table search evaluates
+
+function get_focus_gain(J, threshold, J_max, focus_dist) {
+    let gain = J_max * focus_dist;
+    if (J > threshold) {
+        const adjustment = Math.log10((J_max - threshold) / Math.max(0.0001, J_max - J));
+        gain *= adjustment * adjustment + 1;
+    }
+    return gain;
+}
+
+function solve_J_intersect(J, M, focusJ, maxJ, slope_gain) {
+    const M_scaled = M / slope_gain;
+    const a = M_scaled / focusJ;
+    if (J < focusJ) {
+        const b = 1 - M_scaled;
+        const c = -J;
+        return -2 * c / (b + Math.sqrt(b * b - 4 * a * c));
+    }
+    const b = -(1 + M_scaled + maxJ * a);
+    const c = maxJ * M_scaled + J;
+    return -2 * c / (b - Math.sqrt(b * b - 4 * a * c));
+}
+
+function smin_scaled(a, b, reference) {
+    const s = SMOOTH_CUSPS * reference;
+    const h = Math.max(s - Math.abs(a - b), 0) / s;
+    return Math.min(a, b) - h * h * h * s / 6;
+}
+
+function compression_vector_slope(J_intersect, focusJ, J_max, slope_gain) {
+    const direction = J_intersect < focusJ ? J_intersect : J_max - J_intersect;
+    return direction * (J_intersect - focusJ) / (focusJ * slope_gain);
+}
+
+function line_boundary_M(J_axis_intersect, slope, inv_gamma, J_max, M_max, J_reference) {
+    const shifted = J_reference * Math.pow(J_axis_intersect / J_reference, inv_gamma);
+    return shifted * M_max / (J_max - slope * M_max);
+}
+
+function gamut_boundary_M(cusp_J, cusp_M, J_max, gamma_top_inv, gamma_bottom_inv, J_intersect_source, slope, J_intersect_cusp) {
+    const lower = line_boundary_M(J_intersect_source, slope, gamma_bottom_inv, cusp_J, cusp_M, J_intersect_cusp);
+    const upper = line_boundary_M(J_max - J_intersect_source, -slope, gamma_top_inv, J_max - cusp_J, cusp_M, J_max - J_intersect_cusp);
+    return smin_scaled(lower, upper, cusp_M);
+}
+
+function compute_focusJ(cusp_J, mid_J, J_max) {
+    const t = Math.min(1, CUSP_MID_BLEND - cusp_J / J_max);
+    return cusp_J + (mid_J - cusp_J) * t;
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// tables
+
+function unit_cube_corner(out, i) {
+    out[0] = ((i + 1) % 6) < 3 ? 1 : 0;
+    out[1] = ((i + 5) % 6) < 3 ? 1 : 0;
+    out[2] = ((i + 3) % 6) < 3 ? 1 : 0;
+    return out;
+}
+
+/**
+ * Six corners, lowest hue at [1], wrapped at [0] and [7] with their hues taken out of [0, 360).
+ * @returns {{rgb: number[][], jmh: number[][]}}
+ */
+function cycle_corners(rgb6, jmh6) {
+    let lowest = 0;
+    for (let i = 0; i < 6; i++) {
+        if (jmh6[i][2] < jmh6[lowest][2]) {
+            lowest = i;
+        }
+    }
+    const rgb = new Array(8);
+    const jmh = new Array(8);
+    for (let i = 0; i < 6; i++) {
+        rgb[i + 1] = rgb6[(i + lowest) % 6];
+        jmh[i + 1] = jmh6[(i + lowest) % 6].slice();
+    }
+    rgb[0] = rgb[6];
+    rgb[7] = rgb[1];
+    jmh[0] = jmh[6].slice();
+    jmh[7] = jmh[1].slice();
+    jmh[0][2] -= 360;
+    jmh[7][2] += 360;
+    return { rgb, jmh };
+}
+
+function limiting_corners(p, peak) {
+    const rgb6 = [];
+    const jmh6 = [];
+    for (let i = 0; i < 6; i++) {
+        const c = unit_cube_corner([0, 0, 0], i).map(v => v * peak / REFERENCE_LUMINANCE);
+        rgb6.push(c);
+        jmh6.push(RGB_to_JMh([0, 0, 0], c[0], c[1], c[2], p));
+    }
+    return cycle_corners(rgb6, jmh6);
+}
+
+function reach_corners(p, limit_J, maximum_source) {
+    const limit_A = Math.pow(limit_J / J_SCALE, p.inv_cz);
+    const jmh6 = [];
+    const corner = [0, 0, 0];
+    for (let i = 0; i < 6; i++) {
+        unit_cube_corner(corner, i);
+        let lower = 0;
+        let upper = maximum_source;
+        while (upper - lower > REACH_CUSP_TOLERANCE) {
+            const test = (lower + upper) / 2;
+            const A = RGB_to_Aab(scratch_v, test * corner[0], test * corner[1], test * corner[2], p)[0];
+            if (A < limit_A) {
+                lower = test;
+            } else {
+                upper = test;
+            }
+            if (A === limit_A) {
+                break;
+            }
+        }
+        jmh6.push(RGB_to_JMh([0, 0, 0], upper * corner[0], upper * corner[1], upper * corner[2], p));
+    }
+    return cycle_corners(jmh6, jmh6).jmh;
+}
+
+function sorted_cube_hues(reach, display) {
+    const out = [];
+    let r = 1;
+    let d = 1;
+    while (r < 7 || d < 7) {
+        const reach_hue = reach[r][2];
+        const display_hue = display[d][2];
+        if (reach_hue === display_hue) {
+            out.push(reach_hue);
+            r++;
+            d++;
+        } else if (reach_hue < display_hue) {
+            out.push(reach_hue);
+            r++;
+        } else {
+            out.push(display_hue);
+            d++;
+        }
+    }
+    return out;
+}
+
+function build_hue_table(hues) {
+    const table = new Float64Array(TOTAL);
+    const counts = new Array(14).fill(0);
+    let last = -1;
+    let min_index = hues[0] === 0 ? 0 : 1;
+
+    for (let k = 0; k < hues.length; k++) {
+        // std::round, half away from zero
+        let nominal = Math.min(Math.max(Math.floor(hues[k] * (NOMINAL / 360) + 0.5), min_index), NOMINAL - 1);
+        if (last === nominal) {
+            if (k > 1 && counts[k - 2] !== counts[k - 1] - 1) {
+                counts[k - 1] -= 1;
+            } else {
+                nominal += 1;
+            }
+        }
+        counts[k] = Math.min(nominal, NOMINAL - 1);
+        last = min_index = nominal;
+    }
+
+    let total = 0;
+    const interval = (samples, lower, upper, base) => {
+        const delta = (upper - lower) / samples;
+        for (let i = 0; i < samples; i++) {
+            table[base + i] = lower + i * delta;
+        }
+    };
+
+    interval(counts[0], 0, hues[0], total + 1);
+    total += counts[0];
+    let i = 1;
+    for (; i < hues.length; i++) {
+        const samples = counts[i] - counts[i - 1];
+        interval(samples, hues[i - 1], hues[i], total + 1);
+        total += samples;
+    }
+    interval(NOMINAL - total, hues[i - 1], 360, total + 1);
+
+    table[LOWER_WRAP] = table[LAST_NOMINAL] - 360;
+    table[UPPER_WRAP] = table[FIRST_NOMINAL] + 360;
+    table[UPPER_WRAP + 1] = table[FIRST_NOMINAL + 1] + 360;
+    return table;
+}
+
+function find_display_cusp(out, hue, rgb, jmh, p, previous) {
+    let upper = 1;
+    for (let i = 1; i < 8; i++) {
+        if (jmh[i][2] > hue) {
+            upper = i;
+            break;
+        }
+    }
+    const lower = upper - 1;
+    if (jmh[lower][2] === hue) {
+        out[0] = jmh[lower][0];
+        out[1] = jmh[lower][1];
+        return out;
+    }
+
+    const a = rgb[lower];
+    const b = rgb[upper];
+    let lower_t = upper === previous[0] ? previous[1] : 0;
+    let upper_t = 1;
+    const sample = [0, 0, 0];
+
+    while (upper_t - lower_t > DISPLAY_CUSP_TOLERANCE) {
+        const t = (lower_t + upper_t) / 2;
+        RGB_to_JMh(sample, a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t, p);
+        if (sample[2] < jmh[lower][2]) {
+            upper_t = t;
+        } else if (sample[2] >= jmh[upper][2]) {
+            lower_t = t;
+        } else if (sample[2] > hue) {
+            upper_t = t;
+        } else {
+            lower_t = t;
+        }
+    }
+
+    const t = (lower_t + upper_t) / 2;
+    RGB_to_JMh(sample, a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t, p);
+    previous[0] = upper;
+    previous[1] = t;
+    out[0] = sample[0];
+    out[1] = sample[1];
+    return out;
+}
+
+function make_reach_table(table, p, limit_J_max) {
+    const rgb = [0, 0, 0];
+    const outside = (M, hue) => {
+        JMh_to_RGB(rgb, limit_J_max, M, hue, p);
+        return rgb[0] < 0 || rgb[1] < 0 || rgb[2] < 0;
+    };
+    for (let i = 0; i < NOMINAL; i++) {
+        const hue = i;
+        let low = 0;
+        let high = 50;
+        let is_outside = false;
+        while (!is_outside && high < 1300) {
+            is_outside = outside(high, hue);
+            if (!is_outside) {
+                low = high;
+                high += 50;
+            }
+        }
+        while (high - low > 1e-2) {
+            const M = (high + low) / 2;
+            if (outside(M, hue)) {
+                high = M;
+            } else {
+                low = M;
+            }
+        }
+        table[i + FIRST_NOMINAL] = high;
+    }
+    table[LOWER_WRAP] = table[LAST_NOMINAL];
+    table[UPPER_WRAP] = table[FIRST_NOMINAL];
+    table[UPPER_WRAP + 1] = table[FIRST_NOMINAL + 1];
+}
+
+const GAMMA_TEST_POSITIONS = [0.01, 0.1, 0.5, 0.8, 0.99];
+
+function gamma_fits(cusp_J, cusp_M, hue, J_max, mid_J, focus_dist, gamma_top_inv, peak, gamma_bottom_inv, p) {
+    const threshold = cusp_J + (J_max - cusp_J) * FOCUS_GAIN_BLEND;
+    const focusJ = compute_focusJ(cusp_J, mid_J, J_max);
+    const luminance_limit = peak / REFERENCE_LUMINANCE;
+    const rgb = [0, 0, 0];
+
+    for (let i = 0; i < GAMMA_TEST_POSITIONS.length; i++) {
+        const test_J = cusp_J + (J_max - cusp_J) * GAMMA_TEST_POSITIONS[i];
+        const gain = get_focus_gain(test_J, threshold, J_max, focus_dist);
+        const J_intersect_source = solve_J_intersect(test_J, cusp_M, focusJ, J_max, gain);
+        const slope = compression_vector_slope(J_intersect_source, focusJ, J_max, gain);
+        const J_intersect_cusp = solve_J_intersect(cusp_J, cusp_M, focusJ, J_max, gain);
+
+        const M = gamut_boundary_M(cusp_J, cusp_M, J_max, gamma_top_inv, gamma_bottom_inv, J_intersect_source, slope, J_intersect_cusp);
+        const J = J_intersect_source + slope * M;
+
+        JMh_to_RGB(rgb, J, M, hue, p);
+        if (!(rgb[0] > luminance_limit || rgb[1] > luminance_limit || rgb[2] > luminance_limit)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+
+const PARAMS_AP0 = new JMhParams(PRIMARIES_AP0);
+const PARAMS_AP1 = new JMhParams(PRIMARIES_AP1);
+
+/**
+ * @param {Float32Array} out
+ * @param {number} offset
+ * @param {Float64Array} M row-major
+ */
+function write_columns(out, offset, M) {
+    for (let column = 0; column < 3; column++) {
+        for (let row = 0; row < 3; row++) {
+            out[offset + column * 3 + row] = M[row * 3 + column];
+        }
+    }
+}
+
+/**
+ * Fill one block of the ACES 2.0 output transform for a display: its peak and the primaries it limits to.
+ *
+ * Matches OpenColorIO's `ACES_OUTPUT_TRANSFORM_20` set up with the same two values, and the builtin transforms' AP1
+ * clamp before it and clamp at the peak after it. Takes a few tens of milliseconds, so it is for a display that
+ * changed, not for a frame.
+ *
+ * @param {Float32Array} out
+ * @param {number} offset first float of the block
+ * @param {number} peak_nits the display's peak, cd/m², where 100 is what an exposed 1.0 shows at
+ * @param {number[]} limiting red, green, blue and white xy
+ */
+export function aces2_transform_block_write(out, offset, peak_nits, limiting) {
+    const p_out = new JMhParams(limiting);
+    const p_in = PARAMS_AP0;
+    const reach = PARAMS_AP1;
+
+    // tone scale, init_ToneScaleParams
+    const n = peak_nits;
+    const n_r = 100;
+    const g = 1.15;
+    const c = 0.18;
+    const c_d = 10.013;
+    const w_g = 0.14;
+    const t_1 = 0.04;
+    const r_hit = 128 + (896 - 128) * (Math.log(n / n_r) / Math.log(10000 / 100));
+    const m_0 = n / n_r;
+    const m_1 = 0.5 * (m_0 + Math.sqrt(m_0 * (m_0 + 4 * t_1)));
+    const u = Math.pow((r_hit / m_1) / ((r_hit / m_1) + 1), g);
+    const m = m_1 / u;
+    const w_i = Math.log(n / 100) / Math.log(2);
+    const c_t = c_d / n_r * (1 + w_i * w_g);
+    const g_ip = 0.5 * (c_t + Math.sqrt(c_t * (c_t + 4 * t_1)));
+    const g_ipp2 = -(m_1 * Math.pow(g_ip / m, 1 / g)) / (Math.pow(g_ip / m, 1 / g) - 1);
+    const w_2 = c / g_ipp2;
+    const s_2 = w_2 * m_1 * REFERENCE_LUMINANCE;
+    const u_2 = Math.pow((r_hit / m_1) / ((r_hit / m_1) + w_2), g);
+    const m_2 = m_1 / u_2;
+    const inverse_limit = n / (u_2 * n_r);
+    const forward_limit = 8 * r_hit;
+    const log_peak = Math.log10(n / n_r);
+
+    // shared, chroma and gamut parameters
+    const limit_J_max = Y_to_J(peak_nits, p_in);
+    const model_gamma_inv = 1 / model_gamma();
+
+    const compr = CHROMA_COMPRESS + CHROMA_COMPRESS * CHROMA_COMPRESS_FACT * log_peak;
+    const sat = Math.max(0.2, CHROMA_EXPAND - CHROMA_EXPAND * CHROMA_EXPAND_FACT * log_peak);
+    const sat_thr = CHROMA_EXPAND_THR / n;
+    const chroma_compress_scale = Math.pow(0.03379 * peak_nits, 0.30596) - 0.45135;
+
+    const mid_J = Y_to_J(c_t * REFERENCE_LUMINANCE, p_in);
+    const focus_dist = FOCUS_DISTANCE + FOCUS_DISTANCE * FOCUS_DISTANCE_SCALING * log_peak;
+    const lower_hull_gamma_inv = 1 / (1.14 + 0.07 * log_peak);
+
+    // reach table
+    const reach_table = new Float64Array(TOTAL);
+    make_reach_table(reach_table, reach, limit_J_max);
+
+    // hue and cusp tables
+    const reach_jmh = reach_corners(reach, limit_J_max, forward_limit);
+    const corners = limiting_corners(p_out, peak_nits);
+    const hue_table = build_hue_table(sorted_cube_hues(reach_jmh, corners.jmh));
+
+    const cusp = new Float64Array(TOTAL * 3);
+    const previous = [0, 0];
+    const JM = [0, 0];
+    for (let i = FIRST_NOMINAL; i < UPPER_WRAP; i++) {
+        find_display_cusp(JM, hue_table[i], corners.rgb, corners.jmh, p_out, previous);
+        cusp[i * 3] = JM[0];
+        cusp[i * 3 + 1] = JM[1] * (1 + SMOOTH_M * SMOOTH_CUSPS);
+        cusp[i * 3 + 2] = hue_table[i];
+    }
+    for (const [to, from] of [[LOWER_WRAP, LAST_NOMINAL], [UPPER_WRAP, FIRST_NOMINAL], [UPPER_WRAP + 1, FIRST_NOMINAL + 1]]) {
+        cusp[to * 3] = cusp[from * 3];
+        cusp[to * 3 + 1] = cusp[from * 3 + 1];
+        cusp[to * 3 + 2] = hue_table[to];
+    }
+
+    // how far the searched hue table strays from one entry a degree
+    let search_lower = 0;
+    let search_upper = 1;
+    for (let i = FIRST_NOMINAL; i < UPPER_WRAP; i++) {
+        const position = FIRST_NOMINAL + Math.trunc(cusp[i * 3 + 2]);
+        const delta = i - position;
+        search_lower = Math.min(search_lower, delta);
+        search_upper = Math.max(search_upper, delta + 1);
+    }
+
+    // upper hull gamma, make_upper_hull_gamma; overwrites the hue in the third column
+    for (let i = FIRST_NOMINAL; i < UPPER_WRAP; i++) {
+        const hue = hue_table[i];
+        const cusp_J = cusp[i * 3];
+        const cusp_M = cusp[i * 3 + 1];
+        const fits = gamma => gamma_fits(cusp_J, cusp_M, hue, limit_J_max, mid_J, focus_dist, 1 / gamma, peak_nits, lower_hull_gamma_inv, p_out);
+
+        let low = GAMMA_MINIMUM;
+        let high = low + GAMMA_SEARCH_STEP;
+        let found = false;
+        while (!found && high < GAMMA_MAXIMUM) {
+            if (fits(high)) {
+                found = true;
+            } else {
+                low = high;
+                high += GAMMA_SEARCH_STEP;
+            }
+        }
+        while (high - low > GAMMA_ACCURACY) {
+            const test = (high + low) / 2;
+            if (fits(test)) {
+                high = test;
+            } else {
+                low = test;
+            }
+        }
+        cusp[i * 3 + 2] = 1 / high;
+    }
+    cusp[LOWER_WRAP * 3 + 2] = cusp[LAST_NOMINAL * 3 + 2];
+    cusp[UPPER_WRAP * 3 + 2] = cusp[FIRST_NOMINAL * 3 + 2];
+    cusp[(UPPER_WRAP + 1) * 3 + 2] = cusp[(FIRST_NOMINAL + 1) * 3 + 2];
+
+    // write
+    write_columns(out, offset + ACES2_OUT_RGB_TO_CAM, p_out.rgb_to_cam);
+    write_columns(out, offset + ACES2_OUT_CAM_TO_RGB, p_out.cam_to_rgb);
+    write_columns(out, offset + ACES2_IN_RGB_TO_CAM, p_in.rgb_to_cam);
+    write_columns(out, offset + ACES2_IN_CAM_TO_RGB, p_in.cam_to_rgb);
+    write_columns(out, offset + ACES2_CONE_TO_AAB, p_in.cone_to_Aab);
+    write_columns(out, offset + ACES2_AAB_TO_CONE, p_in.Aab_to_cone);
+
+    const ap1_upper_bound = 8 * (128 + 768 * (Math.log(peak_nits / 100) / Math.log(10000 / 100)));
+
+    const scalars = [
+        limit_J_max, model_gamma_inv, mid_J, focus_dist,
+        lower_hull_gamma_inv, s_2, m_2, g,
+        t_1, n_r, inverse_limit, ap1_upper_bound,
+        sat, sat_thr, compr, chroma_compress_scale,
+        peak_nits / REFERENCE_LUMINANCE, p_in.F_L_n, p_in.cz, p_in.inv_cz,
+        p_in.A_w_J, p_in.inv_A_w_J, search_lower, search_upper,
+    ];
+    for (let i = 0; i < ACES2_SCALAR_COUNT; i++) {
+        out[offset + ACES2_SCALARS + i] = scalars[i];
+    }
+
+    for (let i = 0; i < TOTAL; i++) {
+        out[offset + ACES2_CUSP_TABLE + i * 4] = hue_table[i];
+        out[offset + ACES2_CUSP_TABLE + i * 4 + 1] = cusp[i * 3];
+        out[offset + ACES2_CUSP_TABLE + i * 4 + 2] = cusp[i * 3 + 1];
+        out[offset + ACES2_CUSP_TABLE + i * 4 + 3] = cusp[i * 3 + 2];
+        out[offset + ACES2_REACH_TABLE + i] = reach_table[i];
+    }
+}