@driftengine/core 3.63.0 → 4.0.0

package/src/render/gi/traceField.ts

@@ -0,0 +1,223 @@
+/** The second level of the chain: march the world's own distance field, where the screen ran out. */
+
+import { sampleGlobalField } from './globalField.ts';
+
+import type { ReadonlyVec3 } from 'gl-matrix';
+import type { GlobalField, GlobalFieldCascade } from './globalField.ts';
+
+/**
+ * **This is the level that makes the one above it legitimate.**
+ *
+ * `ROADMAP.md` refused screen-space global illumination because its error is unbounded: a ray that
+ * leaves the frame has no answer at all, and every technique that ships one anyway invents it from
+ * whatever happened to be on screen. Here the screen is an accelerator with something behind it,
+ * and this is the something. Its error is bounded by the field's resolution — a number written
+ * down, measurable, and the same in every direction — rather than by what the camera is pointing
+ * at.
+ *
+ * **Sphere tracing, which is the only march a distance field admits.** Step by the field's own
+ * value: it is a distance nothing can be nearer than, so the step is as long as it can safely be
+ * and the march converges in a handful of steps rather than in a fixed grid walk. Every invariant
+ * that makes that true is tested where it is produced — `sdf.ts` measures the gradient's length,
+ * `globalField.ts` measures that the composed field never overestimates — because a march cannot
+ * tell a field that is a distance from one that merely has the right sign.
+ */
+
+/** How the march is shaped. */
+export interface FieldMarch {
+  /** The most samples one ray may take. A converging march uses a fraction of this. */
+  readonly steps: number;
+  /** How far the ray travels in world metres before it gives up. */
+  readonly reachM: number;
+  /**
+   * Half-angle of the cone, in radians. Zero is a pencil ray.
+   *
+   * **A rough surface reflects a lobe rather than a ray**, and a cone is how a distance field
+   * traces one: the radius grows with the distance travelled and a hit is where the field falls
+   * below *that* rather than below a constant. The blur is then correct by construction — a wide
+   * cone stops further from a surface, so what it gathers is a broader patch of it — instead of
+   * being a filter applied to a sharp answer afterwards.
+   */
+  readonly coneAngle: number;
+  /** How close to a surface counts as arriving, in metres, before the cone's own radius. */
+  readonly hitEpsilonM: number;
+}
+
+/**
+ * How far along the ray a march starts, in voxels of the finest cascade.
+ *
+ * **Proportional to the field's resolution and not a constant, because what it is escaping is the
+ * field's own error.** A trilinear read of a grid is wrong by something on the order of a voxel
+ * near a surface, so a ray leaving a surface is inside that error until it has travelled about
+ * that far — and a march that starts at zero reports a hit before it has moved, on every surface
+ * at once. A voxel is a different number in each cascade and in each scene, which is exactly why
+ * this is a count of them rather than a length.
+ */
+export const FIELD_START_VOXELS = 2;
+
+/** The march an indirect ray takes through the world field. */
+export const FIELD_MARCH: FieldMarch = {
+  steps: 64,
+  reachM: 20,
+  coneAngle: 0,
+  hitEpsilonM: 0.01,
+};
+
+/** Where a march ended. Reused rather than returned, because the chain runs this per ray. */
+export interface FieldHit {
+  hit: boolean;
+  /** Where it arrived, in world metres. */
+  x: number;
+  y: number;
+  z: number;
+  /**
+   * How far along the ray, world metres, from the **lifted** origin.
+   *
+   * The lift is `FIELD_START_VOXELS` voxels along the normal, so this differs from the distance to
+   * the point a caller passed in by at most that — and by nothing at all where the caller passed
+   * no normal, which is what a ray from open space does.
+   */
+  distanceM: number;
+  /** The cone's radius there, which is how broad a patch of surface this hit stands for. */
+  radiusM: number;
+  /** How many samples it took. Diagnostic, and the thing a convergence test asserts on. */
+  steps: number;
+  /**
+   * Whether it left the field rather than running out of reach.
+   *
+   * **The two misses are different and the chain acts on the difference.** A ray that escaped has
+   * gone somewhere this level has no information about, and the probe volume behind it is what
+   * answers. A ray that ran out of reach travelled its whole budget through open space, which is a
+   * statement about the world rather than about the field.
+   */
+  escaped: boolean;
+}
+
+export function newFieldHit(): FieldHit {
+  return { hit: false, x: 0, y: 0, z: 0, distanceM: 0, radiusM: 0, steps: 0, escaped: false };
+}
+
+/** The cone's radius after travelling `distance`, for a cone of this half-angle. */
+export function coneRadiusAt(distanceM: number, coneAngle: number): number {
+  return coneAngle <= 0 ? 0 : distanceM * Math.tan(coneAngle);
+}
+
+/**
+ * March a ray through the composed world field.
+ *
+ * Returns whether it arrived at a surface. A false is the chain's cue to go one level further
+ * down; `FieldHit.escaped` says which of the two misses it was.
+ */
+export function traceField(
+  field: GlobalField,
+  point: ReadonlyVec3,
+  normal: ReadonlyVec3,
+  direction: ReadonlyVec3,
+  march: FieldMarch,
+  out: FieldHit,
+): boolean {
+  out.hit = false;
+  out.x = 0;
+  out.y = 0;
+  out.z = 0;
+  out.distanceM = 0;
+  out.radiusM = 0;
+  out.steps = 0;
+  out.escaped = false;
+
+  const dx = direction[0] ?? 0;
+  const dy = direction[1] ?? 0;
+  const dz = direction[2] ?? 0;
+  const length = Math.hypot(dx, dy, dz);
+  if (!(length > 0)) {
+    throw new Error(
+      'traceField: the direction has no length, so every step would be the same point and the ' +
+        'march would spend its whole budget standing still.',
+    );
+  }
+  const ux = dx / length;
+  const uy = dy / length;
+  const uz = dz / length;
+
+  const finest = field.cascades[0] as GlobalFieldCascade;
+  const start = FIELD_START_VOXELS * finest.step;
+
+  /*
+   * **Lifted along the normal, and only along the normal.** Pushing the start along the *ray* as
+   * well double-counts — a ray leaving along its own normal would then begin two offsets out, and
+   * every distance it reported would carry the second one — and it does not help the case that
+   * needs help: a tangent ray pushed along itself is still on the surface, because a surface is
+   * what tangent means. The normal is the one direction that always leaves.
+   *
+   * A point with no normal, which is what a ray from open space has, is not lifted at all, so
+   * `distanceM` is measured from exactly where the caller asked.
+   */
+  const nx = normal[0] ?? 0;
+  const ny = normal[1] ?? 0;
+  const nz = normal[2] ?? 0;
+  const normalLength = Math.hypot(nx, ny, nz);
+  const lift = normalLength > 0 ? start / normalLength : 0;
+  const ox = (point[0] ?? 0) + nx * lift;
+  const oy = (point[1] ?? 0) + ny * lift;
+  const oz = (point[2] ?? 0) + nz * lift;
+
+  const steps = Math.max(1, Math.round(march.steps));
+  let travelled = 0;
+
+  for (let step = 0; step < steps; step++) {
+    const x = ox + ux * travelled;
+    const y = oy + uy * travelled;
+    const z = oz + uz * travelled;
+    out.steps = step + 1;
+
+    /*
+     * **Outside the outermost cascade the march stops rather than sampling.** There is no
+     * information out there at all: `sampleGlobalField` clamps to the edge, which is the right
+     * answer for a sample and the wrong one for a march — stepping on clamped values converges on
+     * the boundary of the cascade and reports a surface made of nothing.
+     */
+    if (!withinField(field, x, y, z)) {
+      out.escaped = true;
+      out.distanceM = travelled;
+      return false;
+    }
+
+    const distance = sampleGlobalField(field, x, y, z);
+    const radius = coneRadiusAt(travelled, march.coneAngle);
+    if (distance <= radius + march.hitEpsilonM) {
+      out.hit = true;
+      out.x = x;
+      out.y = y;
+      out.z = z;
+      out.distanceM = travelled;
+      out.radiusM = radius;
+      return true;
+    }
+
+    /*
+     * **Step by the distance, and by at least a fraction of a voxel.** A field whose value is
+     * genuinely tiny beside a surface the cone is not wide enough to accept would otherwise take
+     * ever-smaller steps and spend the whole budget arriving nowhere, which reads as a miss and
+     * costs a fallback. The floor makes that case terminate as a miss quickly instead.
+     */
+    travelled += Math.max(distance, finest.step * 0.25);
+    if (travelled > march.reachM) {
+      out.distanceM = march.reachM;
+      return false;
+    }
+  }
+
+  out.distanceM = travelled;
+  return false;
+}
+
+/** Whether a point is inside the outermost cascade, which is the whole of what the field knows. */
+function withinField(field: GlobalField, x: number, y: number, z: number): boolean {
+  const outer = field.cascades[field.cascades.length - 1] as GlobalFieldCascade;
+  const p = [x, y, z];
+  for (let axis = 0; axis < 3; axis++) {
+    if ((p[axis] as number) < (outer.bounds[axis] as number)) return false;
+    if ((p[axis] as number) > (outer.bounds[axis + 3] as number)) return false;
+  }
+  return true;
+}

package/src/render/gi/traceScreen.ts

@@ -0,0 +1,106 @@
+/** The first level of the chain: trace the frame, which is exact wherever the frame has the answer. */
+
+import { traceScreenSpaceRay } from '../screenSpaceReflection.ts';
+
+import type { ReadonlyVec3 } from 'gl-matrix';
+import type { ScreenSpaceHit, ScreenSpaceMarch } from '../screenSpaceReflection.ts';
+
+/**
+ * **This module is thin, and that is the finding rather than a shortcut.**
+ *
+ * The plan for this wave asked for a screen-space first hit whose hardest requirement is that *a
+ * ray leaving the screen returns a miss, never a clamped edge hit* — because a clamped edge hit is
+ * exactly the unbounded error `ROADMAP.md` refused screen-space global illumination over.
+ * `screenSpaceReflection.ts` already makes that refusal, in `projectToUv`, with the reasoning
+ * written out and a test beside it: a point behind the eye has a negative `w` and divides into a
+ * perfectly ordinary screen position somewhere else in the frame, and a point outside the frame
+ * has no pixel at all. `traceScreenSpaceRay` already treats a hit as a *crossing* rather than a
+ * comparison, which is the second requirement, and already carries a ray over a gap in the
+ * geometry rather than stopping at its edge, which is the third.
+ *
+ * So writing a second march would be a second thing to be wrong, and the two would disagree about
+ * a frame the day one of them was changed. What is here is the part global illumination owns that
+ * a reflection does not: **where the ray starts.**
+ *
+ * A reflection begins at a surface a caller declared reflective and leaves it at the mirror angle,
+ * so it moves away from that surface immediately. An indirect ray begins at whatever pixel is being
+ * shaded and leaves it in a direction drawn from the hemisphere — which means a good fraction of
+ * them leave nearly tangent, stay inside the depth buffer's own rounding of the surface for their
+ * whole length, and find a crossing made of quantisation noise. That is a hit on the surface the
+ * ray is standing on, taken by every pixel of a floor at once.
+ */
+
+/**
+ * How far along the normal an indirect ray starts, in metres.
+ *
+ * **It has to be larger than the depth buffer's quantum and smaller than anything it could hide.**
+ * Two centimetres is about twenty times the rounding of a 24-bit buffer over a hundred-metre range
+ * at close quarters, and is below the contact detail a viewer reads — the gap where an object meets
+ * a floor, which is the first thing indirect light is judged on.
+ *
+ * **What would make it wrong** is a scene whose unit is not the metre, which this engine's is; and
+ * a depth range far enough that the quantum grows past it, which is a reason to bias by a fraction
+ * of the sampled depth rather than by a constant. Nothing measured yet asks for that.
+ */
+export const SCREEN_TRACE_BIAS_M = 0.02;
+
+/**
+ * The march an indirect ray takes, which is not the one a mirror takes.
+ *
+ * **Shorter and coarser on purpose.** A reflection is read as a picture and wants the crossing
+ * placed precisely; indirect light is integrated over a hemisphere and then filtered, so a step
+ * that lands a few centimetres out is invisible and a step that is not taken at all is a miss that
+ * costs a whole fallback. The reach is short because what is further away than a few metres is the
+ * world-space field's question — that is the whole architecture of the chain.
+ */
+export const GI_SCREEN_MARCH: ScreenSpaceMarch = { steps: 16, reachM: 4, thicknessM: 0.5 };
+
+/** Scratch, so a per-pixel trace allocates nothing. */
+const ORIGIN = new Float32Array(3);
+
+/**
+ * Lift a point off the surface it stands on, along that surface's normal.
+ *
+ * A normal that is not unit length is normalised, because an interpolated one rarely is. A normal
+ * of zero length has no direction to lift along, so the point is returned unmoved rather than as
+ * three `NaN`s — which would reach the projection and come back as a miss for the wrong reason.
+ */
+export function screenRayOrigin(
+  point: ReadonlyVec3,
+  normal: ReadonlyVec3,
+  biasM: number,
+  out: Float32Array,
+): Float32Array {
+  const nx = normal[0] ?? 0;
+  const ny = normal[1] ?? 0;
+  const nz = normal[2] ?? 0;
+  const length = Math.hypot(nx, ny, nz);
+  const scale = length > 0 ? biasM / length : 0;
+  out[0] = (point[0] ?? 0) + nx * scale;
+  out[1] = (point[1] ?? 0) + ny * scale;
+  out[2] = (point[2] ?? 0) + nz * scale;
+  return out;
+}
+
+/**
+ * Trace an indirect ray against the frame the renderer has already drawn.
+ *
+ * Returns whether the screen could answer. **A false here is the chain's instruction to keep
+ * going**, not a statement that there is nothing there: the ray may have left the frame, gone
+ * behind something, or simply run out of reach, and in every one of those cases the world-space
+ * field has the next word. That is what makes this an accelerator rather than an answer, and it is
+ * the distinction the refusal in `ROADMAP.md` rests on.
+ */
+export function traceScreen(
+  point: ReadonlyVec3,
+  normal: ReadonlyVec3,
+  direction: ReadonlyVec3,
+  eye: ReadonlyVec3,
+  march: ScreenSpaceMarch,
+  project: (x: number, y: number, z: number, uv: Float32Array) => boolean,
+  sceneDistance: (u: number, v: number) => number,
+  out: ScreenSpaceHit,
+): boolean {
+  screenRayOrigin(point, normal, SCREEN_TRACE_BIAS_M, ORIGIN);
+  return traceScreenSpaceRay(ORIGIN, direction, eye, march, project, sceneDistance, out);
+}

package/src/render/gpuScene.ts

@@ -0,0 +1,80 @@
+/**
+ * The scene as the GPU sees it: one transform, one bounding sphere and one material index per
+ * instance, in buffers that persist across frames.
+ *
+ * **Uploaded by dirty range rather than rebuilt.** A GPU-driven frame reads these every frame and
+ * reads the processor-side scene not at all, so the cost of keeping them current is the cost of
+ * the pipeline. A world of a hundred thousand instances in which four moved must upload four.
+ *
+ * **One range rather than a list of them**, which is a deliberate approximation: instances that
+ * move together are overwhelmingly adjacent in a world partitioned by space, so one
+ * first-to-last span costs a few wasted bytes and saves keeping a set. The case it is wrong for
+ * — two objects moving at opposite ends of a large world — uploads the whole span between them,
+ * and that is the trade being made rather than an oversight.
+ *
+ * Allocates nothing per write. Every setter fills existing storage.
+ */
+export interface GpuScene {
+  /** Sixteen floats per instance, in the renderer's existing matrix convention. */
+  transforms: Float32Array;
+  /** Four floats per instance: centre x, y, z then radius. */
+  bounds: Float32Array;
+  /** One material index per instance. */
+  materials: Uint32Array;
+  /** Lowest instance written since the last clear, or -1. */
+  dirtyFirst: number;
+  /** Highest instance written since the last clear, or -1. */
+  dirtyLast: number;
+}
+
+export function createGpuScene(capacity: number): GpuScene {
+  return {
+    transforms: new Float32Array(capacity * 16),
+    bounds: new Float32Array(capacity * 4),
+    materials: new Uint32Array(capacity),
+    dirtyFirst: -1,
+    dirtyLast: -1,
+  };
+}
+
+function touch(scene: GpuScene, index: number): void {
+  if (scene.dirtyFirst === -1 || index < scene.dirtyFirst) scene.dirtyFirst = index;
+  if (index > scene.dirtyLast) scene.dirtyLast = index;
+}
+
+export function setInstanceTransform(scene: GpuScene, index: number, m: Float32Array): void {
+  scene.transforms.set(m, index * 16);
+  touch(scene, index);
+}
+
+export function setInstanceBounds(
+  scene: GpuScene,
+  index: number,
+  cx: number,
+  cy: number,
+  cz: number,
+  radius: number,
+): void {
+  const at = index * 4;
+  scene.bounds[at] = cx;
+  scene.bounds[at + 1] = cy;
+  scene.bounds[at + 2] = cz;
+  scene.bounds[at + 3] = radius;
+  touch(scene, index);
+}
+
+export function setInstanceMaterial(scene: GpuScene, index: number, material: number): void {
+  scene.materials[index] = material;
+  touch(scene, index);
+}
+
+export function dirtyRange(scene: GpuScene): { first: number; count: number } {
+  if (scene.dirtyFirst === -1) return { first: 0, count: 0 };
+  return { first: scene.dirtyFirst, count: scene.dirtyLast - scene.dirtyFirst + 1 };
+}
+
+/** Forget what moved. The data stays; only the record of which part of it is unsent is cleared. */
+export function clearDirty(scene: GpuScene): void {
+  scene.dirtyFirst = -1;
+  scene.dirtyLast = -1;
+}

package/src/render/gpudriven/alphaTest.ts

@@ -0,0 +1,33 @@
+/**
+ * Whether a fragment survives its material's alpha test.
+ *
+ * **The reference the raster's WGSL is checked against**, which is `gpu-parity.mjs`'s pattern and
+ * is not about the arithmetic being hard: a term that exists only as a shader is a term nothing
+ * can disagree with. The rule here is four lines; the boundary conditions are where every alpha
+ * test goes wrong, and they are what the tests beside this are about.
+ *
+ * **`>=` rather than `>`**, which is GLSL's own convention and the boundary every alpha test gets
+ * wrong. At `>` a texel exactly at the cutoff is discarded, which puts a one-texel seam around
+ * every leaf and reads as a mipmap problem rather than as a comparison.
+ *
+ * **The zero case is a branch and not just an arithmetic identity.** It is what lets a material
+ * that says nothing about cutout skip the base-colour fetch entirely, which is the promise every
+ * term in this pipeline has made since it was four lines: a frame that asked for nothing draws
+ * exactly the frame it drew before, and pays for nothing.
+ *
+ * **The guard is written as a negated `>` rather than as `<=`, and a device is why.** WGSL does not
+ * require an implementation to support NaN, so a shader may assume one never arrives; written
+ * `cutoff <= 0` this file discarded every fragment of a material whose cutoff was not a number and
+ * the device kept every one of them, which `scripts/gpu-parity.mjs` reported as four disagreements
+ * the first time it ran. Negating the comparison makes both keep it, and keeping is also the right
+ * answer: a cutoff that is not a number is not a test, and a surface a consumer can see is
+ * findable where one that silently vanished is not.
+ */
+
+/** A material that never asked for a test. Zero, so an unset field is off. */
+export const ALPHA_TEST_OFF = 0;
+
+export function alphaKept(alpha: number, cutoff: number): boolean {
+  if (!(cutoff > ALPHA_TEST_OFF)) return true;
+  return alpha >= cutoff;
+}

package/src/render/gpudriven/clusterUpload.ts

@@ -0,0 +1,123 @@
+/**
+ * Every cluster in the scene, packed into one set of buffers.
+ *
+ * **One dispatch over every cluster is the whole point of the pipeline.** A buffer per mesh means
+ * a dispatch per mesh, which is the draw-call bound this exists to remove — so the packing rebases
+ * each mesh's index offsets by the indices already written and gives every cluster an identifier
+ * that is unique across the scene rather than within its mesh.
+ *
+ * **A cluster says which mesh it came from**, because a cluster that cannot name its mesh cannot
+ * find the transform it is drawn with. The number is the mesh's position in the list handed in,
+ * which is what a caller's own transform array is indexed by — so an empty mesh still takes a slot.
+ * Skipping empty meshes shifts every index after them and every cluster past the gap draws
+ * somewhere else.
+ *
+ * **Bounds and cones are interleaved as vec4s.** A storage buffer read as `array<vec4<f32>>` wants
+ * sixteen-byte stride, and three floats followed by one is exactly the sphere and exactly the cone,
+ * so the packing costs nothing and the shader indexes without arithmetic.
+ */
+
+import { cullCutoff } from './cullClusters.ts';
+
+/** Floats per cluster in `bounds` and in `cones`: a vec4 each. */
+export const CLUSTER_FLOATS = 8;
+
+/** What packing needs of one mesh's clusters. `MeshletLevel` from `MSHL` satisfies it. */
+export interface ClusterSource {
+  readonly count: number;
+  readonly triangleOffsets: Uint32Array;
+  readonly triangleCounts: Uint32Array;
+  readonly boundsCentre: Float32Array;
+  readonly boundsRadius: Float32Array;
+  readonly coneAxis: Float32Array;
+  /**
+   * The minimum dot product of any face normal against the axis — the cosine of the cone's
+   * half-angle, as `buildClusters` writes it and `MSHL` stores it. Packing turns it into the sine
+   * the cull is written in; see `cullCutoff`.
+   */
+  readonly coneCutoff: Float32Array;
+  readonly ownError: Float32Array;
+  readonly parentError: Float32Array;
+  readonly indices: Uint32Array;
+}
+
+export interface ClusterBuffers {
+  /** Four floats a cluster: centre and radius. */
+  bounds: Float32Array;
+  /** Four floats a cluster: cone axis and cutoff. */
+  cones: Float32Array;
+  /** Two floats a cluster: its own error and its parent's. */
+  errors: Float32Array;
+  /** Where this cluster's indices begin, in the packed index buffer. */
+  indexOffsets: Uint32Array;
+  /** How many indices it has. */
+  indexCounts: Uint32Array;
+  /** Unique across the scene, and equal to the cluster's position here. */
+  clusterId: Uint32Array;
+  /** Which mesh of the input list this cluster came from. */
+  meshOf: Uint32Array;
+  indices: Uint32Array;
+  count: number;
+}
+
+/** Floats a shader steps by to reach the next cluster's bounds or cone. */
+export function clusterStride(): number {
+  return CLUSTER_FLOATS;
+}
+
+export function packClusters(meshes: readonly ClusterSource[]): ClusterBuffers {
+  let clusters = 0;
+  let indices = 0;
+  for (const mesh of meshes) {
+    clusters += mesh.count;
+    indices += mesh.indices.length;
+  }
+
+  const packed: ClusterBuffers = {
+    bounds: new Float32Array(clusters * 4),
+    cones: new Float32Array(clusters * 4),
+    errors: new Float32Array(clusters * 2),
+    indexOffsets: new Uint32Array(clusters),
+    indexCounts: new Uint32Array(clusters),
+    clusterId: new Uint32Array(clusters),
+    meshOf: new Uint32Array(clusters),
+    indices: new Uint32Array(indices),
+    count: clusters,
+  };
+
+  let cluster = 0;
+  let indexAt = 0;
+  for (let meshIndex = 0; meshIndex < meshes.length; meshIndex += 1) {
+    const mesh = meshes[meshIndex] as ClusterSource;
+    packed.indices.set(mesh.indices, indexAt);
+
+    for (let c = 0; c < mesh.count; c += 1) {
+      packed.bounds[cluster * 4] = mesh.boundsCentre[c * 3] as number;
+      packed.bounds[cluster * 4 + 1] = mesh.boundsCentre[c * 3 + 1] as number;
+      packed.bounds[cluster * 4 + 2] = mesh.boundsCentre[c * 3 + 2] as number;
+      packed.bounds[cluster * 4 + 3] = mesh.boundsRadius[c] as number;
+
+      packed.cones[cluster * 4] = mesh.coneAxis[c * 3] as number;
+      packed.cones[cluster * 4 + 1] = mesh.coneAxis[c * 3 + 1] as number;
+      packed.cones[cluster * 4 + 2] = mesh.coneAxis[c * 3 + 2] as number;
+      /* Carried as a cosine, read by the cull as a sine: see `cullCutoff`. */
+      packed.cones[cluster * 4 + 3] = cullCutoff(mesh.coneCutoff[c] as number);
+
+      packed.errors[cluster * 2] = mesh.ownError[c] as number;
+      packed.errors[cluster * 2 + 1] = mesh.parentError[c] as number;
+
+      /*
+       * `MSHL` stores a cluster's span in *triangles*; the packed buffer stores it in *indices*,
+       * because a shader fetching indices counts indices. Three of one is one of the other, and
+       * mixing them is a cluster that draws a third of itself.
+       */
+      packed.indexOffsets[cluster] = indexAt + (mesh.triangleOffsets[c] as number) * 3;
+      packed.indexCounts[cluster] = (mesh.triangleCounts[c] as number) * 3;
+      packed.clusterId[cluster] = cluster;
+      packed.meshOf[cluster] = meshIndex;
+      cluster += 1;
+    }
+    indexAt += mesh.indices.length;
+  }
+  return packed;
+}