Real-time view and render bench

// Hable's curve (John Hable, GDC 2010) with pt-post.js's constants: A 0.15, B 0.50, C 0.10, D 0.20, E 0.02, F 0.30, white 11.2
const hableJs = (x) => ((x * (0.15 * x + 0.1 * 0.5) + 0.2 * 0.02) / (x * (0.15 * x + 0.5) + 0.2 * 0.3)) - 0.02 / 0.3;

const sh = new Float32Array(grid.n * 12);
let done = 0;
const runs = [];
for (let a = 0; a < grid.n; a += per) {
  const k = Math.min(per, grid.n - a);
  runs.push(pool.run(job, 'bakeProbes', { headers: headers.slice(a * 128, (a + k) * 128), w, h, spp: preset.probeSpp, dirs }, { priority: 0, signal, units: k * w * h * preset.probeSpp })
    .then((out) => { sh.set(out, a * 12); done += k; onProgress?.(done / grid.n); }));
}
await Promise.all(runs);
const { sky, envK } = skyFor(plain, settings);
const sk = skyL1(sky, up, envK);
for (let i = 0; i < grid.n; i++) for (let k = 0; k < 12; k++) sh[i * 12 + k] -= sk[k];

const mean3 = (acc, w, h) => {
  const out = new Float32Array(w * h * 3);
  for (let i = 0; i < w * h; i++) { const n = acc[i * 4 + 3] || 1; out[i * 3] = acc[i * 4] / n; out[i * 3 + 1] = acc[i * 4 + 1] / n; out[i * 3 + 2] = acc[i * 4 + 2] / n; }
  return out;
};

export async function exportScene({ rt, plain, settings = {}, views = [], title = '', words = {}, maxScatter = 250000 }) {
  const geos = new Map(), geometries = [];
  const items = [];
  for (const it of plain.items) {
    if (!it.geometry) continue;
    let gi = geos.get(it.geometry);
    if (gi === undefined) {
      const g = it.geometry, P = g.getAttribute('position'), N = g.getAttribute('normal'), U = g.getAttribute('uv');
      geometries.push({ position: toB64(Float32Array.from(P.array)), normal: N ? toB64(Float32Array.from(N.array)) : null, uv: U ? toB64(Float32Array.from(U.array)) : null, index: g.index ? toB64(Uint32Array.from(g.index.array)) : null });
      gi = geometries.length - 1;
      geos.set(it.geometry, gi);
    }
    items.push({ g: gi, m: it.matrix ? Array.from(it.matrix) : null, look: it.look || 'default', lines: !!it.lines });
  }
  const resolved = {};
  for (const k of new Set(['__ground', 'default', ...items.filter((x) => !x.lines).map((x) => x.look)])) resolved[k] = await resolveMaterial(k, settings, plain);
  let left = maxScatter;
  const scatter = [], used = new Set();
  for (const s of plain.scatter || []) {
    const n = Math.min(s.result.count, Math.max(0, left));
    if (!n) continue;
    left -= n;
    for (let i = 0; i < n; i++) used.add(s.slugs[s.result.item[i]]);
    scatter.push({ count: n, matrices: toB64(s.result.matrices.subarray(0, n * 16)), item: toB64(s.result.item.subarray(0, n)), slugs: s.slugs });
  }
  const scatterLibrary = (plain.scatterLibrary || []).filter((e) => used.has(e.slug)).map((e) => ({ slug: e.slug, parts: e.parts.map((p) => ({ color: p.color, alpha: p.alpha ?? 1, P: toB64(Float32Array.from(p.P)), I: toB64(Uint32Array.from(p.I)) })) }));
  const g = rt.giProbes && rt.giProbes.data;
  const cam = rt.camera;
  return {
    format: 'cadcraft-live-scene', version: VERSION, title, words,
    up: plain.up, bounds: plain.bounds, groundAt: plain.groundAt ?? 0, sun: plain.sun || null, clip: plain.clip || [], defaultColor: plain.defaultColor,
    settings: { sky: settings.sky, ground: settings.ground, edges: settings.edges, exposure: settings.exposure, exposureMode: settings.exposureMode, fstop: settings.fstop, shutter: settings.shutter, iso: settings.iso, whiteBalance: settings.whiteBalance, post: settings.post },
    geometries, items, resolved, lights: plain.lights || [], scatter, scatterLibrary,
    gi: g ? { min: g.min, max: g.max, res: g.res, sh: toB64(g.sh) } : null,
    views: views.map((v) => ({ name: v.name, world: Array.from(v.world), proj: Array.from(v.proj) })),
    start: { world: cam.matrixWorld.elements.slice(), proj: cam.projectionMatrix.elements.slice() },
  };
}