Real-time view

export function projectL1(accum, dirs, w, h, out = new Float32Array(12), at = 0) {
  const cell = ((2 * Math.PI) / w) * (Math.PI / h);
  const c = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  for (let i = 0; i < w * h; i++) {
    const n = accum[i * 4 + 3];
    if (!(n > 0)) continue;
    const dx = dirs[i * 3], dy = dirs[i * 3 + 1], dz = dirs[i * 3 + 2];
    // dΩ from the pixel's latitude: every panorama row is a band of equal height in θ (RENDER-SPEC § 1)
    const row = Math.floor(i / w), sinT = Math.sin((Math.PI * (row + 0.5)) / h);
    const wgt = (cell * sinT) / n;
    const a = [accum[i * 4], accum[i * 4 + 1], accum[i * 4 + 2]];
    for (let k = 0; k < 3; k++) {
      const L = (AP1_TO_REC709[k][0] * a[0] + AP1_TO_REC709[k][1] * a[1] + AP1_TO_REC709[k][2] * a[2]) * wgt;
      c[k] += L * Y0; c[3 + k] += L * Y1 * dy; c[6 + k] += L * Y1 * dz; c[9 + k] += L * Y1 * dx;
    }
  }
  for (let k = 0; k < 12; k++) out[at + k] = c[k];
  return out;
}

export function cubeToEquirect(faceImgs, fr, W, H) {
  const F = faces(fr), out = new Uint8ClampedArray(W * H * 4);
  for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) {
    const d = dirOf(x, y, W, H, fr);
    // the face this direction leaves through: the largest component along a face's look direction
    let best = 0, bi = 0;
    for (let i = 0; i < 6; i++) { const v = dot(d, F[i].a); if (v > best) { best = v; bi = i; } }
    const Fi = F[bi], img = faceImgs[bi], n = img.n;
    const u = dot(d, Fi.b) / best, v = dot(d, Fi.c) / best;
    const px = Math.min(n - 1, Math.max(0, ((u + 1) / 2) * n - 0.5)), py = Math.min(n - 1, Math.max(0, ((1 - v) / 2) * n - 0.5));
    const x0 = Math.floor(px), y0 = Math.floor(py), x1 = Math.min(n - 1, x0 + 1), y1 = Math.min(n - 1, y0 + 1), tx = px - x0, ty = py - y0;
    const o = (y * W + x) * 4;
    for (let k = 0; k < 4; k++) {
      const a = img.data[(y0 * n + x0) * 4 + k], b = img.data[(y0 * n + x1) * 4 + k], c = img.data[(y1 * n + x0) * 4 + k], e = img.data[(y1 * n + x1) * 4 + k];
      out[o + k] = (a * (1 - tx) + b * tx) * (1 - ty) + (c * (1 - tx) + e * tx) * ty;
    }
  }
  return out;
}

/** The per-pixel chain in JS (no bloom, no vignette: those need neighbours / the pixel's place) → display-linear rgb. */
export function displayPixel709(rgb, d) {
  let c = mul3(d.wb, rgb).map((x) => Math.max(0, x) * d.exposure);
  if (d.highlights > 0) {
    const L = lum(c), hs = d.highlights * 2;
    if (L > 1) { const s = (1 + (L - 1) / (1 + (L - 1) * hs)) / L; c = c.map((x) => x * s); }
  }
  if (d.contrast) c = c.map((x) => 0.18 * Math.pow(x / 0.18, 1 + d.contrast));
  return viewTransform(d.view, c);
}

const want = fl + o.height, now = dot(pos, U);
if (now < want) { for (let k = 0; k < 3; k++) pos[k] += U[k] * (want - now); vy = 0; }   // a step up
else if (now > want + 1e-3) {
  vy -= 9.81 * dt;
  const next = Math.max(want, now + vy * dt);
  for (let k = 0; k < 3; k++) pos[k] += U[k] * (next - now);
  if (next === want) vy = 0;