Rendered picture: mixing, post and color

export function post(lin, w, h, p, { exposure = 0, wb = null, lut = null, float = false } = {}) {
  p = p || POST_DEFAULTS;
  const n = w * h, k = Math.pow(2, exposure);
  let img = new Float32Array(n * 3);
  for (let i = 0; i < n; i++) {
    const a = [lin[i * 3] * (wb ? wb[0] : 1), lin[i * 3 + 1] * (wb ? wb[1] : 1), lin[i * 3 + 2] * (wb ? wb[2] : 1)];
    const c = mul3(AP1_TO_REC709, a);
    for (let j = 0; j < 3; j++) img[i * 3 + j] = Number.isFinite(c[j]) ? Math.max(0, c[j]) * k : 0;
  }
  if (p.bloom > 0) img = bloomPass(img, w, h, p.bloom, p.bloomSize);
  if (p.glare > 0) img = glarePass(img, w, h, p.glare, p.streaks);
  const out = float ? new Float32Array(n * 3) : new Uint8ClampedArray(n * 4), cx = (w - 1) / 2, cy = (h - 1) / 2, rmax = Math.hypot(cx, cy) || 1, px = [0, 0, 0], lo = [0, 0, 0];
  const knee = 1, hs = p.highlights * 2;
  for (let i = 0; i < n; i++) {
    px[0] = img[i * 3]; px[1] = img[i * 3 + 1]; px[2] = img[i * 3 + 2];
    if (p.vignette > 0) {
      const r = Math.hypot((i % w) - cx, Math.floor(i / w) - cy) / rmax, t = Math.min(1, Math.max(0, (r - 0.2) / 0.8)), f = 1 - p.vignette * t * t * (3 - 2 * t);
      px[0] *= f; px[1] *= f; px[2] *= f;
    }
    if (hs > 0) {
      const L = 0.2126 * px[0] + 0.7152 * px[1] + 0.0722 * px[2];
      if (L > knee) { const L2 = knee + (L - knee) / (1 + (L - knee) * hs), s = L2 / L; px[0] *= s; px[1] *= s; px[2] *= s; }
    }
    if (p.contrast) for (let j = 0; j < 3; j++) px[j] = 0.18 * Math.pow(px[j] / 0.18, 1 + p.contrast);
    // ACES keeps its own 1/0.6 pre-scale (acesFilmic), so the default path is displayPixel's, number for number
    const t = p.view === 'aces' ? acesFilmic(px, 0) : viewTransform(p.view, px);
    let r = linearToSrgb(t[0]), g = linearToSrgb(t[1]), b = linearToSrgb(t[2]);
    if (lut && p.lutStrength > 0) {
      applyCube(lut, r, g, b, lo);
      const s = p.lutStrength;
      r += (lo[0] - r) * s; g += (lo[1] - g) * s; b += (lo[2] - b) * s;
    }
    if (float) { out[i * 3] = Math.min(1, Math.max(0, r)); out[i * 3 + 1] = Math.min(1, Math.max(0, g)); out[i * 3 + 2] = Math.min(1, Math.max(0, b)); continue; }
    out[i * 4] = Math.round(Math.min(1, Math.max(0, r)) * 255); out[i * 4 + 1] = Math.round(Math.min(1, Math.max(0, g)) * 255); out[i * 4 + 2] = Math.round(Math.min(1, Math.max(0, b)) * 255); out[i * 4 + 3] = 255;
  }
  return out;
}

/** Three box blurs per axis ≈ a Gaussian of standard deviation σ (pixels); edges clamp. */
function blur(src, w, h, sigma) {
  const r = Math.max(1, Math.round(Math.sqrt((12 * sigma * sigma) / 3 + 1) / 2));
  let a = Float32Array.from(src), b = new Float32Array(src.length);
  const pass = (from, to, horiz) => {
    const n = horiz ? w : h, m = horiz ? h : w, inv = 1 / (2 * r + 1);
    for (let j = 0; j < m; j++) for (let c = 0; c < 3; c++) {
      const at = (i) => (horiz ? (j * w + Math.min(n - 1, Math.max(0, i))) : (Math.min(n - 1, Math.max(0, i)) * w + j)) * 3 + c;
      let s = 0;
      for (let i = -r; i <= r; i++) s += from[at(i)];
      for (let i = 0; i < n; i++) { to[at(i)] = s * inv; s += from[at(i + r + 1)] - from[at(i - r)]; }
    }
  };
  for (let k = 0; k < 3; k++) { pass(a, b, true); [a, b] = [b, a]; }
  for (let k = 0; k < 3; k++) { pass(a, b, false); [a, b] = [b, a]; }
  return a;
}

export function bloomPass(img, w, h, amount, size) {
  const d = Math.hypot(w, h) * size, out = new Float32Array(img.length);
  const blurs = [[d, 0.5], [d * 2, 0.3], [d * 4, 0.2]].map(([s, wt]) => [blur(img, w, h, s), wt]);
  for (let i = 0; i < img.length; i++) { let b = 0; for (const [bl, wt] of blurs) b += bl[i] * wt; out[i] = img[i] * (1 - amount) + b * amount; }
  return out;
}

export function mixedLinear(L, mix) {
  const { w, h, accum, aux, stride, nElements: nE, groups } = L, lin = new Float32Array(w * h * 3), gains = mixGains(mix, groups);
  for (let i = 0; i < w * h; i++) {
    const n = accum[i * 4 + 3] || 1;
    for (let k = 0; k < groups.length; k++) { const o = (i * stride + nE + k) * 4; lin[i * 3] += aux[o] * gains[k * 3] / n; lin[i * 3 + 1] += aux[o + 1] * gains[k * 3 + 1] / n; lin[i * 3 + 2] += aux[o + 2] * gains[k * 3 + 2] / n; }
  }
  return lin;
}

const lin = new Float32Array(w * h * 3);
const gains = useMix ? mixGains(mix, groups) : null, slot = show === 'beauty' || show === 'noisy' || !aux ? -1 : el(show);
for (let i = 0; i < w * h; i++) {
  const n = accum[i * 4 + 3] || 1;
  if (gains) {
    let r = 0, g = 0, b = 0;
    for (let k = 0; k < groups.length; k++) { const o = (i * stride + nE + k) * 4; r += aux[o] * gains[k * 3]; g += aux[o + 1] * gains[k * 3 + 1]; b += aux[o + 2] * gains[k * 3 + 2]; }
    lin[i * 3] = r / n; lin[i * 3 + 1] = g / n; lin[i * 3 + 2] = b / n;
  } else if (slot >= 0) { const o = (i * stride + slot) * 4; lin[i * 3] = aux[o] / n; lin[i * 3 + 1] = aux[o + 1] / n; lin[i * 3 + 2] = aux[o + 2] / n; }
  else { lin[i * 3] = accum[i * 4] / n; lin[i * 3 + 1] = accum[i * 4 + 1] / n; lin[i * 3 + 2] = accum[i * 4 + 2] / n; }
}
return postImage(lin, w, h, post, { exposure, wb, lut, float });

fn finite3(c: vec3f) -> bool { return all(c == c) && all(abs(c) < vec3f(1e30)); }
fn causticsOn() -> bool { let V = hw(${HW.VOL_OFF}u); return V != 0u && (ldu(V + 1u) & ${VOL.CAUSTIC_FLAG}u) != 0u; }
fn addPixel(pix: u32, c: vec3f) {
  if (finite3(c)) { ACC[pix] += vec4f(max(c, vec3f(0.0)), 0.0); }
}

export function prepare(rgb, alb, nrm, w, h, scale = autoexposure(rgb, w, h)) {
  const N = w * h, input = new Float32Array(9 * N);
  const fin = (x) => (Number.isFinite(x) ? x : 0);
  for (let p = 0; p < N; p++) for (let k = 0; k < 3; k++) {
    input[k * N + p] = puForward(Math.min(65504, Math.max(0, fin(rgb[p * 3 + k]) * scale))) * PU_NORM;
    input[(3 + k) * N + p] = Math.min(1, Math.max(0, fin(alb[p * 3 + k])));
    input[(6 + k) * N + p] = Math.min(1, Math.max(-1, fin(nrm[p * 3 + k]))) * 0.5 + 0.5;
  }
  return { input, scale };
}

export function finish(out3, w, h, scale) {
  const N = w * h, res = new Float32Array(N * 3), inv = scale > 0 ? 1 / scale : 0;
  for (let p = 0; p < N; p++) for (let k = 0; k < 3; k++) { const x = out3[k * N + p]; res[p * 3 + k] = puInverse(Number.isFinite(x) ? Math.max(0, x) / PU_NORM : 0) * inv; }
  return res;
}