@es3d/es3d 0.0.0-stage → 1.0.1

package/src/pipeline.js

@@ -0,0 +1,74 @@
+// The ES3D processing pipeline used by the application, the benchmark, the CLI
+// and the tests:
+//
+//   text/binary --parse--> AST --validate--> typed AST --build--> scene graph
+//               --flatten--> RenderScene (instance table) --lazy--> meshes
+//
+// Each stage is timed so the benchmark and the statistics panel can report
+// where time is spent.
+
+import { parse } from './format/parse.js';
+import { Diagnostic } from './format/errors.js';
+import { buildSceneGraph } from './scene/scene-graph.js';
+import { flattenScene } from './scene/flatten.js';
+import { GeometryCache } from './geometry/geometry-cache.js';
+
+export const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
+
+/** Convert an element-attached diagnostic into a located Diagnostic. */
+export function elementDiagnostic(doc, d) {
+  const el = d.element;
+  const diag = new Diagnostic({
+    severity: d.severity,
+    phase: d.phase || 'geometry',
+    code: d.code,
+    message: el ? `<${el.name}${el.values && el.values.id ? ` id="${el.values.id}"` : ''}>: ${d.message}` : d.message,
+    offset: el && el.nameStart >= 0 ? el.nameStart : -1,
+    length: el && el.nameStart >= 0 ? el.nameEnd - el.nameStart : 0,
+    uid: el ? el.uid : 0,
+  });
+  diag.locate(doc && doc.lineIndex);
+  return diag;
+}
+
+/**
+ * Parse, validate, build and flatten a document.
+ * @param {string|ArrayBuffer|Uint8Array} input
+ * @param {{cache?: GeometryCache, time?: number, progress?: number, maxInstances?: number}} [opts]
+ */
+export function compile(input, opts = {}) {
+  const t0 = now();
+  const doc = parse(input);
+  const t1 = now();
+  const timings = { parse: t1 - t0, build: 0, flatten: 0 };
+  if (!doc.ok) {
+    return { ok: false, doc, graph: null, scene: null, cache: opts.cache || null, diagnostics: doc.diagnostics, timings };
+  }
+  const cache = opts.cache || new GeometryCache();
+  const graph = buildSceneGraph(doc, cache, opts);
+  const t2 = now();
+  const scene = flattenScene(graph, { time: opts.time || 0, progress: opts.progress || 0 });
+  const t3 = now();
+  timings.build = t2 - t1;
+  timings.flatten = t3 - t2;
+  const extra = graph.diagnostics.map((d) => elementDiagnostic(doc, d));
+  const diagnostics = [...doc.diagnostics, ...extra];
+  const ok = !diagnostics.some((d) => d.severity === 'error');
+  return { ok, doc, graph, scene, cache, diagnostics, timings };
+}
+
+/** Generate every mesh needed for LOD 0 of a compiled scene (benchmarks, exports). */
+export function generateGeometry(result, lod = 0) {
+  const t0 = now();
+  const { scene, cache } = result;
+  let triangles = 0;
+  let vertices = 0;
+  for (const entry of scene.geometries) {
+    const m = cache.mesh(entry, lod);
+    vertices += m.vertexCount;
+    triangles += m.kind === 'triangles' ? m.primitiveCount : 0;
+  }
+  return { ms: now() - t0, uniqueVertices: vertices, uniqueTriangles: triangles };
+}
+
+export { GeometryCache };

package/src/render/camera.js

@@ -0,0 +1,168 @@
+// Camera model shared by both GPU backends.
+
+import * as mat4 from '../math/mat4.js';
+
+export class Camera {
+  constructor() {
+    this.type = 'perspective';
+    this.position = [6, 4, 8];
+    this.target = [0, 0, 0];
+    this.up = [0, 1, 0];
+    this.fov = 45; // vertical, degrees
+    this.orthoHeight = 10;
+    this.near = null; // null = automatic from scene bounds
+    this.far = null;
+    // fov (or orthoHeight) is the vertical extent at this reference aspect ratio;
+    // fit says how other aspect ratios are derived from it (see verticalFov)
+    this.refAspect = 1;
+    this.fit = 'contain';
+    this.view = mat4.create();
+    this.proj = mat4.create();
+    this.viewProj = mat4.create();
+    this.invViewProj = mat4.create();
+    this.currentNear = 0.1;
+    this.currentFar = 1000;
+  }
+
+  /** Configure from a camera description produced by the flattener. */
+  fromSpec(c) {
+    this.type = c.type || 'perspective';
+    this.position = c.position.slice();
+    this.target = c.target.slice();
+    this.up = c.up.slice();
+    this.fov = c.fov || 45;
+    this.orthoHeight = c.height || 10;
+    this.near = c.near || null;
+    this.far = c.far || null;
+    this.refAspect = c.aspect || 1;
+    this.fit = c.fit || 'contain';
+    return this;
+  }
+
+  clone() {
+    const c = new Camera();
+    c.type = this.type;
+    c.position = this.position.slice();
+    c.target = this.target.slice();
+    c.up = this.up.slice();
+    c.fov = this.fov;
+    c.orthoHeight = this.orthoHeight;
+    c.near = this.near;
+    c.far = this.far;
+    c.refAspect = this.refAspect;
+    c.fit = this.fit;
+    return c;
+  }
+
+  /**
+   * Factor that turns the reference vertical extent into the one for a viewport
+   * aspect ratio. The reference view is refAspect wide and 1 high:
+   * contain shows all of it (like SVG's "meet"), cover fills the viewport with
+   * it ("slice"), width keeps its width and height keeps its height.
+   */
+  extentScale(aspect) {
+    const A = this.refAspect > 0 ? this.refAspect : 1;
+    const keepWidth = A / aspect; // vertical extent that keeps the reference width
+    switch (this.fit) {
+      case 'cover':
+        return Math.min(1, keepWidth);
+      case 'width':
+        return keepWidth;
+      case 'height':
+        return 1;
+      default:
+        return Math.max(1, keepWidth);
+    }
+  }
+
+  get distance() {
+    return Math.hypot(this.position[0] - this.target[0], this.position[1] - this.target[1], this.position[2] - this.target[2]);
+  }
+
+  /** Frame an axis aligned bounding box. */
+  frame(bounds, dir = [0.62, 0.5, 0.75]) {
+    const c = [(bounds.min[0] + bounds.max[0]) / 2, (bounds.min[1] + bounds.max[1]) / 2, (bounds.min[2] + bounds.max[2]) / 2];
+    const r = Math.max(1e-3, Math.hypot(bounds.max[0] - bounds.min[0], bounds.max[1] - bounds.min[1], bounds.max[2] - bounds.min[2]) / 2);
+    const l = Math.hypot(...dir);
+    const d = this.type === 'orthographic' ? r * 3 : (r / Math.sin(((this.fov / 2) * Math.PI) / 180)) * 1.05;
+    this.target = c;
+    this.position = [c[0] + (dir[0] / l) * d, c[1] + (dir[1] / l) * d, c[2] + (dir[2] / l) * d];
+    this.up = [0, 1, 0];
+    this.orthoHeight = r * 2.2;
+    // the distance above assumes fov applies to the shorter viewport side
+    this.refAspect = 1;
+    this.fit = 'contain';
+    return this;
+  }
+
+  /**
+   * Update view / projection matrices.
+   * @param {number} aspect
+   * @param {boolean} zeroToOne WebGPU depth range
+   * @param {{min:number[],max:number[]}} [bounds] scene bounds for automatic near/far
+   */
+  update(aspect, zeroToOne, bounds) {
+    mat4.lookAt(this.view, this.position, this.target, this.up);
+    let near = this.near;
+    let far = this.far;
+    if (near === null || far === null) {
+      let autoNear = 0.05;
+      let autoFar = 2000;
+      if (bounds) {
+        const c = [(bounds.min[0] + bounds.max[0]) / 2, (bounds.min[1] + bounds.max[1]) / 2, (bounds.min[2] + bounds.max[2]) / 2];
+        const R = Math.max(1e-3, Math.hypot(bounds.max[0] - bounds.min[0], bounds.max[1] - bounds.min[1], bounds.max[2] - bounds.min[2]) / 2);
+        const d = Math.hypot(this.position[0] - c[0], this.position[1] - c[1], this.position[2] - c[2]);
+        autoFar = (d + R) * 1.5 + 1e-3;
+        // outside the bounds the near plane can sit just before the scene;
+        // inside it is a small fraction of the scene size
+        autoNear = Math.max((d - R) * 0.5, R * 0.002, autoFar / 50000, 1e-4);
+      }
+      if (near === null) near = autoNear;
+      if (far === null) far = Math.max(autoFar, near * 10);
+    }
+    this.currentNear = near;
+    this.currentFar = far;
+    // Like SVG's preserveAspectRatio, the framed view (fov or the orthographic
+    // height at refAspect) is fitted to the viewport, so what the author framed
+    // stays framed on every screen shape. The default (contain, aspect 1)
+    // applies fov to the shorter side.
+    if (this.type === 'orthographic') {
+      const h = (this.orthoHeight * this.extentScale(aspect)) / 2;
+      const w = h * aspect;
+      mat4.ortho(this.proj, -w, w, -h, h, this.near === null ? -far : near, far, zeroToOne);
+    } else {
+      mat4.perspective(this.proj, this.verticalFov(aspect), aspect, near, far, zeroToOne);
+    }
+    this.aspect = aspect;
+    mat4.multiply(this.viewProj, this.proj, this.view);
+    mat4.invert(this.invViewProj, this.viewProj);
+  }
+
+  /** Vertical field of view in radians for a viewport aspect ratio. */
+  verticalFov(aspect) {
+    const f = (this.fov * Math.PI) / 180;
+    const s = this.extentScale(aspect);
+    return s === 1 ? f : 2 * Math.atan(Math.tan(f / 2) * s);
+  }
+
+  /** World-space ray through a pixel (x, y in CSS pixels from the top-left). */
+  ray(x, y, width, height, zeroToOne = false) {
+    const nx = (x / width) * 2 - 1;
+    const ny = 1 - (y / height) * 2;
+    const z0 = zeroToOne ? 0 : -1;
+    const a = [0, 0, 0];
+    const b = [0, 0, 0];
+    mat4.transformPoint(a, this.invViewProj, nx, ny, z0);
+    mat4.transformPoint(b, this.invViewProj, nx, ny, 1);
+    const d = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const l = Math.hypot(d[0], d[1], d[2]) || 1;
+    return { origin: a, dir: [d[0] / l, d[1] / l, d[2] / l] };
+  }
+
+  /** Pixels per world unit at a distance (used for level-of-detail selection). */
+  pixelsPerUnit(distance, viewportHeight) {
+    const aspect = this.aspect || 1;
+    if (this.type === 'orthographic') return viewportHeight / (this.orthoHeight * this.extentScale(aspect));
+    return viewportHeight / (2 * Math.max(distance, 1e-6) * Math.tan(this.verticalFov(aspect) / 2));
+  }
+}

package/src/render/frame-builder.js

@@ -0,0 +1,362 @@
+// Backend-independent per-frame work: explicit LOD switches, frustum culling,
+// automatic level-of-detail selection, batching and GPU instance data.
+//
+// Visible instances are grouped by (geometry, LOD level, material, mirrored)
+// and every group becomes ONE instanced draw call. Instance matrices are
+// written contiguously per batch into a single Float32Array, which the
+// backend uploads with one buffer write per frame.
+
+import { colorToLinear } from '../format/colors.js';
+
+// A level is used only while its surface stays within this many pixels of the
+// true shape. Each geometry carries that distance in canonical units
+// (lodDeviation); the frame scales it by the instance and the projection.
+export const SURFACE_ERROR_PX = 1;
+
+// Math.hypot is variadic. V8 builds an argument list for every call, about
+// 100 bytes, which at 1e5 instances is ~10 MB of garbage per frame. Scene
+// distances are nowhere near the overflow range hypot exists to protect, and
+// the level-of-detail use below already clamps tiny distances.
+function length3(x, y, z) {
+  return Math.sqrt(x * x + y * y + z * z);
+}
+
+/**
+ * The level to draw while `lod` is not generated yet: the nearest coarser
+ * level that exists, else the nearest finer one, else the coarsest level
+ * (the cheapest to generate now).
+ */
+function standIn(meshes, lod) {
+  for (let l = lod + 1; l < meshes.length; l++) if (meshes[l]) return l;
+  for (let l = lod - 1; l >= 0; l--) if (meshes[l]) return l;
+  return meshes.length - 1;
+}
+
+/** Longest column of an instance matrix: a conservative world scale. */
+function axisScale(M, i) {
+  const o = i * 16;
+  let m = 0;
+  for (let c = 0; c < 3; c++) {
+    const s = length3(M[o + c * 4], M[o + c * 4 + 1], M[o + c * 4 + 2]);
+    if (s > m) m = s;
+  }
+  return m || 1;
+}
+
+/**
+ * Coarsest level whose chordal error projects to at most one pixel.
+ * `deviation[level]` is the error in canonical units. `pixelsPerUnit` is the
+ * projected size of one canonical unit after the instance scale is applied
+ * separately via `scale`. `bias` above 1 tightens the budget.
+ */
+export function selectLod(deviation, lods, scale, pixelsPerUnit, bias) {
+  if (!(lods > 1) || !deviation) return 0;
+  const budget = SURFACE_ERROR_PX / (bias > 0 ? bias : 1);
+  const k = scale * pixelsPerUnit;
+  let lod = 0;
+  const last = Math.min(lods, deviation.length) - 1;
+  for (let level = last; level >= 1; level--) {
+    if (deviation[level] * k <= budget) {
+      lod = level;
+      break;
+    }
+  }
+  return lod;
+}
+
+function planesFrom(m) {
+  // rows of the column-major view-projection matrix
+  const r = (i) => [m[i], m[4 + i], m[8 + i], m[12 + i]];
+  const r0 = r(0), r1 = r(1), r3 = r(3), r2 = r(2);
+  const planes = [
+    [r3[0] + r0[0], r3[1] + r0[1], r3[2] + r0[2], r3[3] + r0[3]],
+    [r3[0] - r0[0], r3[1] - r0[1], r3[2] - r0[2], r3[3] - r0[3]],
+    [r3[0] + r1[0], r3[1] + r1[1], r3[2] + r1[2], r3[3] + r1[3]],
+    [r3[0] - r1[0], r3[1] - r1[1], r3[2] - r1[2], r3[3] - r1[3]],
+    [r3[0] - r2[0], r3[1] - r2[1], r3[2] - r2[2], r3[3] - r2[3]],
+  ];
+  for (const p of planes) {
+    const l = Math.hypot(p[0], p[1], p[2]) || 1;
+    p[0] /= l;
+    p[1] /= l;
+    p[2] /= l;
+    p[3] /= l;
+  }
+  return planes;
+}
+
+export class FrameBuilder {
+  constructor() {
+    this.instanceData = new Float32Array(16 * 1024);
+    this.keys = new Int32Array(1024);
+    this.lods = new Uint8Array(1024);
+    this.last = null;
+    this.lastSignature = '';
+  }
+
+  ensure(n) {
+    if (this.instanceData.length < n * 16) {
+      let cap = this.instanceData.length / 16;
+      while (cap < n) cap *= 2;
+      this.instanceData = new Float32Array(cap * 16);
+    }
+    if (this.keys.length < n) {
+      let cap = this.keys.length;
+      while (cap < n) cap *= 2;
+      this.keys = new Int32Array(cap);
+      this.lods = new Uint8Array(cap);
+    }
+  }
+
+  /** Explicit <lod> switch states for the camera position. */
+  lodStates(scene, camPos, dist) {
+    const sw = scene.lodSwitches;
+    const active = new Int32Array(sw.length);
+    const visible = new Uint8Array(sw.length);
+    for (let s = 0; s < sw.length; s++) {
+      const w = sw[s];
+      const d = dist(w.pos);
+      let c = 0;
+      while (c < w.distances.length && d >= w.distances[c]) c++;
+      active[s] = c;
+      visible[s] = w.parent < 0 ? 1 : visible[w.parent] && active[w.parent] === w.parentChild ? 1 : 0;
+    }
+    return { active, visible };
+  }
+
+  /**
+   * @param {object} p
+   * @param {import('../scene/flatten.js').RenderScene} p.scene
+   * @param {import('./camera.js').Camera} p.camera (matrices already updated)
+   * @param {number} p.viewportHeight
+   * @param {(entry:object, lod:number)=>object} p.meshOf
+   * @param {import('./geometry-pool.js').GeometryPool} p.pool
+   * @param {object} p.options {autoLod, fixedLod, culling, lodBias, bbox, wireframe, normals, selection:Set<number>,
+   *   tessellationBudget: ms of mesh generation per frame before levels are drawn coarser and refined later}
+   */
+  build(p) {
+    const { scene, camera, pool, meshOf, options } = p;
+    const n = scene.count;
+    // reserve instance rows for: batches (<= n), bounding boxes (<= n), selection boxes
+    let selCount = 0;
+    if (options.selection && options.selection.size) {
+      for (let i = 0; i < n; i++) if (options.selection.has(scene.uid[i])) selCount++;
+    }
+    this.ensure(n + (options.bbox ? n : 0) + selCount + 64);
+    const camPos = camera.position;
+    const dist = (c) => Math.hypot(c[0] - camPos[0], c[1] - camPos[1], c[2] - camPos[2]);
+    const sw = this.lodStates(scene, camPos, dist);
+    const planes = options.culling === false ? null : planesFrom(camera.viewProj);
+    const S = scene.spheres;
+    const keys = this.keys;
+    const lods = this.lods;
+    const batchMap = new Map();
+    const batches = [];
+    const nMat = Math.max(1, scene.materials.length);
+    const lodHist = [0, 0, 0, 0];
+    let visibleCount = 0;
+    let culled = 0;
+    const vh = p.viewportHeight;
+    const bias = options.lodBias || 1;
+    const fixedLod = options.autoLod === false ? options.fixedLod || 0 : -1;
+    // pixels per world unit at distance 1 (perspective) or everywhere (orthographic)
+    const ppuFactor = camera.pixelsPerUnit(1, vh);
+
+    for (let i = 0; i < n; i++) {
+      keys[i] = -1;
+      const ln = scene.lodNode[i];
+      if (ln >= 0 && !(sw.visible[ln] && sw.active[ln] === scene.lodChild[i])) continue;
+      const cx = S[i * 4], cy = S[i * 4 + 1], cz = S[i * 4 + 2], r = S[i * 4 + 3];
+      if (planes) {
+        let out = false;
+        for (let k = 0; k < 5; k++) {
+          const pl = planes[k];
+          if (pl[0] * cx + pl[1] * cy + pl[2] * cz + pl[3] < -r) {
+            out = true;
+            break;
+          }
+        }
+        if (out) {
+          culled++;
+          continue;
+        }
+      }
+      const gi = scene.geom[i];
+      const entry = scene.geometries[gi];
+      let lod = 0;
+      if (entry.lods > 1) {
+        if (fixedLod >= 0) lod = Math.min(fixedLod, entry.lods - 1);
+        else {
+          const dx = cx - camPos[0], dy = cy - camPos[1], dz = cz - camPos[2];
+          const d = length3(dx, dy, dz);
+          const ppu = camera.type === 'orthographic' ? ppuFactor : ppuFactor / Math.max(d, 1e-6);
+          lod = selectLod(entry.lodDeviation, entry.lods, axisScale(scene.matrices, i), ppu, bias);
+        }
+      }
+      lods[i] = lod;
+      lodHist[lod]++;
+      const mirrored = scene.flags[i] & 1;
+      const mi = scene.mat[i];
+      const key = ((gi * 4 + lod) * nMat + mi) * 2 + mirrored;
+      let b = batchMap.get(key);
+      if (b === undefined) {
+        b = batches.length;
+        batchMap.set(key, b);
+        const material = scene.materials[mi];
+        batches.push({ gi, entry, lod, mi, material, mirrored: !!mirrored, count: 0, firstInstance: 0, depth: 0, instances: null });
+      }
+      batches[b].count++;
+      keys[i] = b;
+      visibleCount++;
+    }
+
+    // resolve meshes / pool ranges. Once this frame has spent its tessellation
+    // budget, a level that is not generated yet is drawn with a stand-in and
+    // refined on a later frame: the first frame comes at once, full detail
+    // follows within a few frames (each frame generates at least one).
+    const budget = options.tessellationBudget;
+    const progressive = budget >= 0 && budget < Infinity;
+    const start = progressive ? performance.now() : 0;
+    let generated = 0;
+    let refining = 0;
+    let triangles = 0;
+    for (const b of batches) {
+      let lod = b.lod;
+      const have = b.entry.meshes;
+      if (progressive && have && !have[lod]) {
+        if (generated && performance.now() - start >= budget) {
+          lod = standIn(have, lod);
+          refining++;
+        } else generated++;
+      }
+      const mesh = meshOf(b.entry, lod);
+      b.mesh = mesh;
+      b.kind = mesh.kind;
+      b.range = pool.meshRange(mesh);
+      b.doubleSided = !!(b.entry.doubleSided || b.material.doubleSided);
+      b.transparent = b.material.transparent;
+      if (b.kind === 'triangles') triangles += (b.range.indexCount / 3) * b.count;
+    }
+
+    // order: opaque by pipeline then material, transparent back to front
+    let offset = 0;
+    const order = batches.slice().sort((a, b) => {
+      if (a.transparent !== b.transparent) return a.transparent ? 1 : -1;
+      if (a.kind !== b.kind) return a.kind === 'triangles' ? -1 : 1;
+      if (a.doubleSided !== b.doubleSided) return a.doubleSided ? 1 : -1;
+      if (a.mirrored !== b.mirrored) return a.mirrored ? 1 : -1;
+      return a.mi - b.mi;
+    });
+    for (const b of order) {
+      b.firstInstance = offset;
+      offset += b.count;
+      b.cursor = b.firstInstance;
+    }
+    const data = this.instanceData;
+    const M = scene.matrices;
+    const transparentInstances = [];
+    for (let i = 0; i < n; i++) {
+      const k = keys[i];
+      if (k < 0) continue;
+      const b = batches[k];
+      if (b.transparent) {
+        transparentInstances.push(i);
+        continue;
+      }
+      const o = b.cursor++ * 16;
+      for (let j = 0; j < 16; j++) data[o + j] = M[i * 16 + j];
+    }
+    if (transparentInstances.length) {
+      const depthOf = (i) => -length3(S[i * 4] - camPos[0], S[i * 4 + 1] - camPos[1], S[i * 4 + 2] - camPos[2]);
+      transparentInstances.sort((a, b) => depthOf(a) - depthOf(b));
+      for (const i of transparentInstances) {
+        const b = batches[keys[i]];
+        const o = b.cursor++ * 16;
+        for (let j = 0; j < 16; j++) data[o + j] = M[i * 16 + j];
+        b.depth = Math.max(b.depth, -depthOf(i));
+      }
+      // farthest transparent batches first
+      const opaque = order.filter((b) => !b.transparent);
+      const transp = order.filter((b) => b.transparent).sort((a, b) => b.depth - a.depth);
+      order.length = 0;
+      order.push(...opaque, ...transp);
+    }
+
+    // overlays
+    const overlays = { wireframe: [], normals: [], bbox: null, selection: null };
+    if (options.wireframe || options.normals) {
+      for (const b of order) {
+        if (b.kind !== 'triangles') continue;
+        if (options.wireframe) overlays.wireframe.push({ range: pool.edgeRange(b.mesh), firstInstance: b.firstInstance, count: b.count, mirrored: b.mirrored });
+        if (options.normals) overlays.normals.push({ range: pool.normalRange(b.mesh), firstInstance: b.firstInstance, count: b.count });
+      }
+    }
+    const boxMatrix = (i, o) => {
+      const e = scene.geometries[scene.geom[i]];
+      const bb = e.bounds;
+      const cx = (bb.min[0] + bb.max[0]) / 2, cy = (bb.min[1] + bb.max[1]) / 2, cz = (bb.min[2] + bb.max[2]) / 2;
+      const sx = Math.max(bb.max[0] - bb.min[0], 1e-4), sy = Math.max(bb.max[1] - bb.min[1], 1e-4), sz = Math.max(bb.max[2] - bb.min[2], 1e-4);
+      const m = M.subarray(i * 16, i * 16 + 16);
+      // world * T(c) * S(s)
+      for (let k = 0; k < 3; k++) {
+        data[o + k] = m[k] * sx;
+        data[o + 4 + k] = m[4 + k] * sy;
+        data[o + 8 + k] = m[8 + k] * sz;
+        data[o + 12 + k] = m[k] * cx + m[4 + k] * cy + m[8 + k] * cz + m[12 + k];
+      }
+      data[o + 3] = 0;
+      data[o + 7] = 0;
+      data[o + 11] = 0;
+      data[o + 15] = 1;
+    };
+    if (options.bbox) {
+      const first = offset;
+      for (let i = 0; i < n; i++) {
+        if (keys[i] < 0) continue;
+        boxMatrix(i, offset * 16);
+        offset++;
+      }
+      overlays.bbox = { firstInstance: first, count: offset - first };
+    }
+    if (selCount) {
+      const first = offset;
+      const sel = options.selection;
+      for (let i = 0; i < n; i++) {
+        if (!sel.has(scene.uid[i])) continue;
+        // hidden level-of-detail alternatives are not highlighted
+        if (keys[i] < 0 && scene.lodNode[i] >= 0) continue;
+        boxMatrix(i, offset * 16);
+        offset++;
+      }
+      overlays.selection = { firstInstance: first, count: offset - first };
+    }
+
+    const result = {
+      batches: order,
+      overlays,
+      instanceData: this.instanceData,
+      instanceCount: offset,
+      lights: scene.lights,
+      environment: scene.environment,
+      stats: {
+        instances: n,
+        visible: visibleCount,
+        culled,
+        batches: order.length,
+        drawCalls: order.length + overlays.wireframe.length + overlays.normals.length + (overlays.bbox ? 1 : 0) + (overlays.selection ? 1 : 0),
+        triangles,
+        lodHistogram: lodHist,
+        refining,
+      },
+    };
+    this.last = result;
+    return result;
+  }
+}
+
+/** Environment defaults in linear space for the shaders. */
+export function environmentUniforms(env) {
+  const sky = colorToLinear(env.sky);
+  const ground = colorToLinear(env.ground);
+  return { sky, ground, intensity: env.intensity, exposure: env.exposure, background: env.background };
+}