@downdraft/engine 0.0.0 → 0.1.0

package/core/src/render/gpu-driven/indirect-draw-pass.ts

@@ -0,0 +1,324 @@
+import { type Mat4 } from "wgpu-matrix";
+import type { FrameGraphBuilder, GraphRenderContext } from "../frame-graph";
+import { PassType } from "../frame-graph";
+import { RenderPass } from "../render-pass";
+import { destroyMapValues } from "../resource-tracker";
+import { createValidatedShaderModule } from "../shader-validator";
+import { TrackedRenderPass } from "../tracked-render-pass";
+import type { GpuMeshTable, MeshTableGroup } from "./mesh-table";
+
+export class IndirectDrawPass extends RenderPass {
+  name = "indirect-draw";
+  passType = PassType.Custom;
+
+  private device: GPUDevice | null = null;
+  private colorFormat: GPUTextureFormat;
+  private depthFormat: GPUTextureFormat;
+  private sampleCount: number;
+
+  private cameraBuffer: GPUBuffer | null = null;
+  private cameraUniformData = new Float32Array(64); // 2 mat4x4 + cameraPos
+  private bindGroupLayout: GPUBindGroupLayout | null = null;
+  private pipelineLayout: GPUPipelineLayout | null = null;
+  private cameraBindGroup: GPUBindGroup | null = null;
+  private pipelines = new Map<number, GPURenderPipeline>();
+
+  private meshTable: GpuMeshTable | null = null;
+  private drawArgsBuffer: GPUBuffer | null = null;
+  private visibleBuffer: GPUBuffer | null = null;
+  private instanceBuffer: GPUBuffer | null = null;
+  private colorAttachments: GPURenderPassColorAttachment[] | null = null;
+  private depthAttachment: GPURenderPassDepthStencilAttachment | null = null;
+  private width = 0;
+  private height = 0;
+
+  constructor(colorFormat: GPUTextureFormat = "bgra8unorm", depthFormat: GPUTextureFormat = "depth32float", sampleCount = 1) {
+    super();
+    this.colorFormat = colorFormat;
+    this.depthFormat = depthFormat;
+    this.sampleCount = sampleCount;
+  }
+
+  setMeshTable(table: GpuMeshTable): void {
+    this.meshTable = table;
+    destroyMapValues(this.pipelines);
+  }
+
+  setDrawArgsBuffer(buffer: GPUBuffer): void {
+    this.drawArgsBuffer = buffer;
+  }
+
+  setVisibleBuffer(buffer: GPUBuffer): void {
+    this.visibleBuffer = buffer;
+    this.updateCameraBindGroup();
+  }
+
+  setInstanceBuffer(buffer: GPUBuffer): void {
+    this.instanceBuffer = buffer;
+    this.updateCameraBindGroup();
+  }
+
+  setCamera(viewProj: Mat4, prevViewProj: Mat4, cameraPos: [number, number, number]): void {
+    for (let i = 0; i < 16; i++) this.cameraUniformData[i] = viewProj[i];
+    for (let i = 0; i < 16; i++) this.cameraUniformData[16 + i] = prevViewProj[i];
+    this.cameraUniformData[32] = cameraPos[0];
+    this.cameraUniformData[33] = cameraPos[1];
+    this.cameraUniformData[34] = cameraPos[2];
+    this.device?.queue.writeBuffer(this.cameraBuffer!, 0, this.cameraUniformData as unknown as BufferSource);
+  }
+
+  setRenderTargets(width: number, height: number, colorAttachments: GPURenderPassColorAttachment[], depthAttachment: GPURenderPassDepthStencilAttachment): void {
+    this.width = width;
+    this.height = height;
+    this.colorAttachments = colorAttachments;
+    this.depthAttachment = depthAttachment;
+  }
+
+  prepare(device: GPUDevice): void {
+    this.device = device;
+    this.cameraBuffer = device.createBuffer({
+      size: 256,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+
+    this.bindGroupLayout = device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        { binding: 1, visibility: GPUShaderStage.VERTEX, buffer: { type: "read-only-storage" } },
+        { binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: "read-only-storage" } },
+      ],
+    });
+
+    this.pipelineLayout = device.createPipelineLayout({
+      bindGroupLayouts: [this.bindGroupLayout],
+    });
+  }
+
+  setup(_builder: FrameGraphBuilder): void {
+    // Custom pass: creates its own render pass; no graph attachment declarations here.
+  }
+
+  execute(ctx: GraphRenderContext): void {
+    if (!this.device || !this.meshTable || !this.drawArgsBuffer || !this.visibleBuffer || !this.instanceBuffer) return;
+    if (!this.colorAttachments || !this.depthAttachment) return;
+
+    const encoder = this.device.createCommandEncoder({ label: "indirect-draw" });
+    const renderPass = encoder.beginRenderPass({
+      colorAttachments: this.colorAttachments,
+      depthStencilAttachment: this.depthAttachment,
+    });
+    const tracked = new TrackedRenderPass(renderPass);
+
+    tracked.setBindGroup(0, this.cameraBindGroup!);
+
+    const batches = this.meshTable.getBatches();
+    for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+      const batch = batches[batchIdx]!;
+      const group = this.meshTable.getGroup(batch);
+      if (!group.vertexBuffer || !group.indexBuffer) continue;
+
+      const pipeline = this.getPipeline(group);
+      tracked.setPipeline(pipeline);
+      tracked.setVertexBuffer(0, group.vertexBuffer);
+      tracked.setIndexBuffer(group.indexBuffer, batch.indexFormat);
+      tracked.drawIndexedIndirect(this.drawArgsBuffer, batchIdx * 20);
+    }
+
+    tracked.end();
+    ctx.addDrawCalls(tracked.drawCalls);
+    this.device.queue.submit([encoder.finish()]);
+  }
+
+  destroy(): void {
+    this.cameraBuffer?.destroy();
+    destroyMapValues(this.pipelines);
+    this.cameraBuffer = null;
+    this.bindGroupLayout = null;
+    this.pipelineLayout = null;
+    this.cameraBindGroup = null;
+  }
+
+  private updateCameraBindGroup(): void {
+    if (!this.device || !this.bindGroupLayout || !this.cameraBuffer || !this.visibleBuffer || !this.instanceBuffer) return;
+    this.cameraBindGroup = this.device.createBindGroup({
+      layout: this.bindGroupLayout,
+      entries: [
+        { binding: 0, resource: { buffer: this.cameraBuffer } },
+        { binding: 1, resource: { buffer: this.instanceBuffer } },
+        { binding: 2, resource: { buffer: this.visibleBuffer } },
+      ],
+    });
+  }
+
+  private getPipeline(group: MeshTableGroup): GPURenderPipeline {
+    const key = group.layoutStride;
+    let pipeline = this.pipelines.get(key);
+    if (pipeline) return pipeline;
+
+    const vertexAttributes: GPUVertexAttribute[] = [];
+    const mesh = group.meshes[0]!;
+    const layout = mesh.layout;
+    for (let i = 0; i < layout.attributes.length; i++) {
+        const a = layout.attributes[i]!;
+        vertexAttributes.push({
+          shaderLocation: i,
+          offset: a.offset,
+          format: a.format as GPUVertexFormat,
+        });
+      }
+
+    const desc: GPURenderPipelineDescriptor = {
+      layout: this.pipelineLayout ?? "auto",
+      vertex: {
+        module: createValidatedShaderModule(this.device!, { code: INDIRECT_DRAW_WGSL, label: "IndirectDrawPass.vs" }),
+        entryPoint: "vs_main",
+        buffers: [{
+          arrayStride: group.layoutStride,
+          attributes: vertexAttributes,
+        }],
+      },
+      fragment: {
+        module: createValidatedShaderModule(this.device!, { code: INDIRECT_DRAW_WGSL, label: "IndirectDrawPass.fs" }),
+        entryPoint: "fs_main",
+        targets: [
+          { format: this.colorFormat },
+          { format: this.colorFormat },
+          { format: this.colorFormat },
+          { format: this.colorFormat },
+        ],
+      },
+      primitive: { topology: "triangle-list", cullMode: "back" },
+      depthStencil: {
+        format: this.depthFormat,
+        depthWriteEnabled: true,
+        depthCompare: "less",
+      },
+      multisample: { count: this.sampleCount },
+    };
+
+    pipeline = this.device!.createRenderPipeline(desc);
+    this.pipelines.set(key, pipeline);
+    return pipeline;
+  }
+}
+
+const INDIRECT_DRAW_WGSL = /* wgsl */ `
+struct CameraUniforms {
+  viewProj: mat4x4<f32>,
+  prevViewProj: mat4x4<f32>,
+  cameraPos: vec3<f32>,
+  _pad: f32,
+};
+
+struct InstanceRecord {
+  pos: vec3<f32>,
+  scale: f32,
+  rot: vec4<f32>,
+  aabbMin: vec3<f32>,
+  _pad0: f32,
+  aabbMax: vec3<f32>,
+  _pad1: f32,
+  meshIdx: u32,
+  materialIdx: u32,
+  flags: u32,
+  _pad2: u32,
+};
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<storage, read> instances: array<InstanceRecord>;
+@group(0) @binding(2) var<storage, read> visibleBuffer: array<u32>;
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+  @location(3) aux: vec4<f32>,
+};
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) worldPos: vec3<f32>,
+  @location(1) worldNormal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+  @location(3) color: vec4<f32>,
+  @location(5) prevClipPosition: vec4<f32>,
+};
+
+fn quatToMat(q: vec4<f32>) -> mat4x4<f32> {
+  let c0 = vec4<f32>(
+    1.0 - 2.0 * (q.y * q.y + q.z * q.z),
+    2.0 * (q.x * q.y + q.w * q.z),
+    2.0 * (q.x * q.z - q.w * q.y),
+    0.0,
+  );
+  let c1 = vec4<f32>(
+    2.0 * (q.x * q.y - q.w * q.z),
+    1.0 - 2.0 * (q.x * q.x + q.z * q.z),
+    2.0 * (q.y * q.z + q.w * q.x),
+    0.0,
+  );
+  let c2 = vec4<f32>(
+    2.0 * (q.x * q.z + q.w * q.y),
+    2.0 * (q.y * q.z - q.w * q.x),
+    1.0 - 2.0 * (q.x * q.x + q.y * q.y),
+    0.0,
+  );
+  let c3 = vec4<f32>(0.0, 0.0, 0.0, 1.0);
+  return mat4x4<f32>(c0, c1, c2, c3);
+}
+
+@vertex
+fn vs_main(input: VertexInput, @builtin(instance_index) instanceIdx: u32) -> VertexOutput {
+  var out: VertexOutput;
+  let srcIdx = visibleBuffer[instanceIdx];
+  let inst = instances[srcIdx];
+
+  let s = mat4x4<f32>(
+    vec4<f32>(inst.scale, 0.0, 0.0, 0.0),
+    vec4<f32>(0.0, inst.scale, 0.0, 0.0),
+    vec4<f32>(0.0, 0.0, inst.scale, 0.0),
+    vec4<f32>(0.0, 0.0, 0.0, 1.0),
+  );
+
+  let r = quatToMat(inst.rot);
+  let t = mat4x4<f32>(
+    vec4<f32>(1.0, 0.0, 0.0, 0.0),
+    vec4<f32>(0.0, 1.0, 0.0, 0.0),
+    vec4<f32>(0.0, 0.0, 1.0, 0.0),
+    vec4<f32>(inst.pos, 1.0),
+  );
+
+  let model = t * r * s;
+  let worldPos = (model * vec4<f32>(input.position, 1.0)).xyz;
+  out.clipPosition = camera.viewProj * vec4<f32>(worldPos, 1.0);
+  out.worldPos = worldPos;
+  out.worldNormal = normalize((model * vec4<f32>(input.normal, 0.0)).xyz);
+  out.uv = input.uv;
+  out.color = input.aux;
+  out.prevClipPosition = out.clipPosition; // velocity = 0 for v1
+  return out;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) ->
+  @location(0) vec4<f32>,
+  @location(1) vec4<f32>,
+  @location(2) vec4<f32>,
+  @location(3) vec2<f32> {
+  let albedo = input.color.rgb;
+  let ao = 1.0;
+  let N = normalize(input.worldNormal);
+  let encodedN = N * 0.5 + 0.5;
+  let roughness = 0.5;
+  let metallic = 0.0;
+  let emissive = vec3<f32>(0.0);
+  let currNDC = input.clipPosition.xy / input.clipPosition.w;
+  let prevNDC = input.prevClipPosition.xy / input.prevClipPosition.w;
+  let velocity = (currNDC - prevNDC) * 0.5;
+
+  return vec4<f32>(albedo, ao),
+         vec4<f32>(encodedN, roughness),
+         vec4<f32>(metallic, emissive),
+         velocity;
+}
+`;

package/core/src/render/gpu-driven/instance-buffer.ts

@@ -0,0 +1,178 @@
+import { type Mat4, mat4, type Vec3, vec3 } from "wgpu-matrix";
+
+export interface InstanceRecord {
+  pos: Vec3;
+  scale: number;
+  rot: { x: number; y: number; z: number; w: number };
+  aabbMin: Vec3;
+  aabbMax: Vec3;
+  meshIdx: number;
+  materialIdx: number;
+  flags: number;
+}
+
+/** Packed per-instance data uploaded to the GPU for culling and indirect draw.
+ *  Record layout (std140-ish, 80 bytes):
+ *    0..12  pos.xyz, scale
+ *   16..28  rot.xyzw
+ *   32..44  aabbMin.xyz, pad
+ *   48..60  aabbMax.xyz, pad
+ *   64..76  meshIdx, materialIdx, flags, pad
+ */
+export const INSTANCE_RECORD_FLOATS = 20; // 80 bytes
+export const INSTANCE_RECORD_BYTES = INSTANCE_RECORD_FLOATS * 4;
+
+export class InstanceBuffer {
+  private maxInstances: number;
+  private staging: Float32Array;
+  private gpuBuffer: GPUBuffer | null = null;
+
+  constructor(maxInstances: number) {
+    this.maxInstances = maxInstances;
+    this.staging = new Float32Array(maxInstances * INSTANCE_RECORD_FLOATS);
+  }
+
+  /** Resize the staging buffer (destroys the existing GPU buffer). */
+  setMaxInstances(max: number): void {
+    this.maxInstances = max;
+    this.staging = new Float32Array(max * INSTANCE_RECORD_FLOATS);
+    this.gpuBuffer?.destroy();
+    this.gpuBuffer = null;
+  }
+
+  /** Write one instance into the staging buffer. */
+  writeInstance(index: number, r: InstanceRecord): void {
+    if (index < 0 || index >= this.maxInstances) return;
+    const off = index * INSTANCE_RECORD_FLOATS;
+    this.staging[off + 0] = r.pos[0];
+    this.staging[off + 1] = r.pos[1];
+    this.staging[off + 2] = r.pos[2];
+    this.staging[off + 3] = r.scale;
+    this.staging[off + 4] = r.rot.x;
+    this.staging[off + 5] = r.rot.y;
+    this.staging[off + 6] = r.rot.z;
+    this.staging[off + 7] = r.rot.w;
+    this.staging[off + 8] = r.aabbMin[0];
+    this.staging[off + 9] = r.aabbMin[1];
+    this.staging[off + 10] = r.aabbMin[2];
+    // pad at off+11
+    this.staging[off + 12] = r.aabbMax[0];
+    this.staging[off + 13] = r.aabbMax[1];
+    this.staging[off + 14] = r.aabbMax[2];
+    // pad at off+15
+    const u32 = new Uint32Array(this.staging.buffer);
+    const u32Off = index * INSTANCE_RECORD_FLOATS + 16;
+    u32[u32Off] = r.meshIdx;
+    u32[u32Off + 1] = r.materialIdx;
+    u32[u32Off + 2] = r.flags;
+  }
+
+  /** Convenience: write from a mat4 + aabb + mesh/material/flags. */
+  writeTransformInstance(
+    index: number,
+    model: Mat4,
+    aabbMin: Vec3,
+    aabbMax: Vec3,
+    meshIdx: number,
+    materialIdx: number,
+    flags: number,
+  ): void {
+    const pos = vec3.create(model[12], model[13], model[14]);
+    const q = this.extractQuaternion(model);
+    const scale = this.extractScale(model);
+    this.writeInstance(index, {
+      pos,
+      scale,
+      rot: q,
+      aabbMin,
+      aabbMax,
+      meshIdx,
+      materialIdx,
+      flags,
+    });
+  }
+
+  /** Upload the current staging data to the GPU. The returned buffer can be bound to the cull/draw passes. */
+  upload(device: GPUDevice): GPUBuffer {
+    if (!this.gpuBuffer || this.gpuBuffer.size !== this.staging.byteLength) {
+      this.gpuBuffer?.destroy();
+      this.gpuBuffer = device.createBuffer({
+        size: this.staging.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+      });
+    }
+    device.queue.writeBuffer(this.gpuBuffer, 0, this.staging as unknown as BufferSource);
+    return this.gpuBuffer;
+  }
+
+  getBuffer(): GPUBuffer | null {
+    return this.gpuBuffer;
+  }
+
+  getStaging(): Float32Array {
+    return this.staging;
+  }
+
+  getMaxInstances(): number {
+    return this.maxInstances;
+  }
+
+  /** Destroy the GPU buffer (does not affect staging data). */
+  destroy(): void {
+    this.gpuBuffer?.destroy();
+    this.gpuBuffer = null;
+  }
+
+  private extractQuaternion(model: Mat4): { x: number; y: number; z: number; w: number } {
+    // Decompose a 4x4 matrix into T * R * S. We use the upper 3x3 scaling logic from wgpu-matrix's quat.fromMat4.
+    // Reuse wgpu-matrix's getRotation is not in the public API, so we compute manually.
+    const m = mat4.getScaling(model);
+    const is1 = 1 / m[0];
+    const is2 = 1 / m[1];
+    const is3 = 1 / m[2];
+    const sm11 = model[0] * is1;
+    const sm12 = model[4] * is2;
+    const sm13 = model[8] * is3;
+    const sm21 = model[1] * is1;
+    const sm22 = model[5] * is2;
+    const sm23 = model[9] * is3;
+    const sm31 = model[2] * is1;
+    const sm32 = model[6] * is2;
+    const sm33 = model[10] * is3;
+    const trace = sm11 + sm22 + sm33;
+    let qx = 0, qy = 0, qz = 0, qw = 1;
+    if (trace > 0) {
+      const s = Math.sqrt(trace + 1) * 2;
+      qw = 0.25 * s;
+      qx = (sm32 - sm23) / s;
+      qy = (sm13 - sm31) / s;
+      qz = (sm21 - sm12) / s;
+    } else if (sm11 > sm22 && sm11 > sm33) {
+      const s = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+      qw = (sm32 - sm23) / s;
+      qx = 0.25 * s;
+      qy = (sm12 + sm21) / s;
+      qz = (sm13 + sm31) / s;
+    } else if (sm22 > sm33) {
+      const s = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+      qw = (sm13 - sm31) / s;
+      qx = (sm12 + sm21) / s;
+      qy = 0.25 * s;
+      qz = (sm23 + sm32) / s;
+    } else {
+      const s = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+      qw = (sm21 - sm12) / s;
+      qx = (sm13 + sm31) / s;
+      qy = (sm23 + sm32) / s;
+      qz = 0.25 * s;
+    }
+    return { x: qx, y: qy, z: qz, w: qw };
+  }
+
+  private extractScale(model: Mat4): number {
+    const sx = Math.sqrt(model[0] * model[0] + model[1] * model[1] + model[2] * model[2]);
+    const sy = Math.sqrt(model[4] * model[4] + model[5] * model[5] + model[6] * model[6]);
+    const sz = Math.sqrt(model[8] * model[8] + model[9] * model[9] + model[10] * model[10]);
+    return Math.max(sx, sy, sz);
+  }
+}

package/core/src/render/gpu-driven/mesh-table.ts

@@ -0,0 +1,175 @@
+import type { MeshData } from "../../mesh/builder";
+
+export interface MeshBatch {
+  meshIdx: number;
+  vertexOffset: number;
+  indexOffset: number;
+  indexCount: number;
+  vertexCount: number;
+  baseVertex: number;
+  indexFormat: GPUIndexFormat;
+  layoutStride: number;
+}
+
+export interface MeshTableGroup {
+  layoutStride: number;
+  indexFormat: GPUIndexFormat;
+  meshes: MeshData[];
+  batches: MeshBatch[];
+  totalVertexCount: number;
+  totalIndexCount: number;
+  vertexBuffer: GPUBuffer | null;
+  indexBuffer: GPUBuffer | null;
+}
+
+/** Packs many MeshData into merged GPU vertex/index buffers, grouped by vertex layout and index format.
+ *  This is the "mesh binding table" for an indirect draw pipeline. */
+export class GpuMeshTable {
+  private sourceMeshes: { mesh: MeshData; group: number; batch: MeshBatch }[] = [];
+  private groups: MeshTableGroup[] = [];
+  private built = false;
+
+  /** Register a mesh for packing. Returns a mesh index (same as `batch.meshIdx`). */
+  addMesh(mesh: MeshData): number {
+    const meshIdx = this.sourceMeshes.length;
+
+    const layoutStride = mesh.layout.stride;
+    const indexFormat = mesh.indices instanceof Uint32Array ? "uint32" : "uint16";
+
+    // Find or create a group by (stride, indexFormat)
+    let groupIdx = this.groups.findIndex(
+      g => g.layoutStride === layoutStride && g.indexFormat === indexFormat,
+    );
+    if (groupIdx < 0) {
+      groupIdx = this.groups.length;
+      this.groups.push({
+        layoutStride,
+        indexFormat,
+        meshes: [],
+        batches: [],
+        totalVertexCount: 0,
+        totalIndexCount: 0,
+        vertexBuffer: null,
+        indexBuffer: null,
+      });
+    }
+
+    const group = this.groups[groupIdx]!;
+    const batch: MeshBatch = {
+      meshIdx,
+      vertexOffset: 0,
+      indexOffset: group.totalIndexCount,
+      indexCount: mesh.indexCount,
+      vertexCount: mesh.vertexCount,
+      baseVertex: group.totalVertexCount,
+      indexFormat,
+      layoutStride,
+    };
+    group.totalVertexCount += mesh.vertexCount;
+    group.totalIndexCount += mesh.indexCount;
+
+    this.sourceMeshes.push({ mesh, group: groupIdx, batch });
+    group.meshes.push(mesh);
+    group.batches.push(batch);
+    this.built = false;
+    return meshIdx;
+  }
+
+  /** Build (or rebuild) merged GPU buffers. Call after all addMesh / structural changes. */
+  build(device: GPUDevice): void {
+    this.groups.forEach((group) => {
+      // Pack vertices
+      let totalVertices = 0;
+      group.meshes.forEach((mesh) => {
+        totalVertices += mesh.vertexCount;
+      });
+      const vertexByteSize = totalVertices * group.layoutStride;
+
+      const vertexStaging = new Float32Array(totalVertices * (group.layoutStride / 4));
+      let vertexCursor = 0;
+      let baseVertex = 0;
+
+      for (let i = 0; i < group.meshes.length; i++) {
+        const mesh = group.meshes[i]!;
+        const batch = group.batches[i]!;
+        batch.baseVertex = baseVertex;
+        batch.vertexOffset = 0; // shared buffer, per-mesh baseVertex handles it
+        vertexStaging.set(new Float32Array(mesh.vertices.buffer), vertexCursor);
+        vertexCursor += mesh.vertexCount * (group.layoutStride / 4);
+        baseVertex += mesh.vertexCount;
+      }
+
+      if (group.vertexBuffer) group.vertexBuffer.destroy();
+      group.vertexBuffer = device.createBuffer({
+        size: vertexByteSize,
+        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+      });
+      device.queue.writeBuffer(group.vertexBuffer, 0, vertexStaging as unknown as BufferSource);
+
+      // Pack indices
+      const indexByteSize = group.indexFormat === "uint32" ? 4 : 2;
+      let totalIndices = 0;
+      group.meshes.forEach((mesh) => {
+        totalIndices += mesh.indexCount;
+      });
+      const indexByteTotal = totalIndices * indexByteSize;
+
+      const indexStaging = group.indexFormat === "uint32" ? new Uint32Array(totalIndices) : new Uint16Array(totalIndices);
+      let indexCursor = 0;
+
+      for (let i = 0; i < group.meshes.length; i++) {
+        const mesh = group.meshes[i]!;
+        const batch = group.batches[i]!;
+        batch.indexOffset = indexCursor;
+
+        const source = mesh.indices;
+        for (let j = 0; j < source.length; j++) {
+          indexStaging[indexCursor + j] = source[j] as number;
+        }
+        indexCursor += source.length;
+      }
+
+      if (group.indexBuffer) group.indexBuffer.destroy();
+      group.indexBuffer = device.createBuffer({
+        size: indexByteTotal,
+        usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+      });
+      device.queue.writeBuffer(group.indexBuffer, 0, indexStaging as unknown as BufferSource);
+    });
+
+    this.built = true;
+  }
+
+  /** Iterator over all batches, suitable for the indirect draw loop. */
+  getBatches(): readonly MeshBatch[] {
+    return this.sourceMeshes.map(s => s.batch);
+  }
+
+  getGroup(batch: MeshBatch): MeshTableGroup {
+    return this.groups[this.sourceMeshes[batch.meshIdx]!.group]!;
+  }
+
+  /** Look up a batch by mesh index. */
+  getBatch(meshIdx: number): MeshBatch | null {
+    const source = this.sourceMeshes[meshIdx];
+    return source ? source.batch : null;
+  }
+
+  getGroupCount(): number {
+    return this.groups.length;
+  }
+
+  /** Destroy all created GPU buffers. */
+  destroy(): void {
+    this.groups.forEach((group) => {
+      group.vertexBuffer?.destroy();
+      group.indexBuffer?.destroy();
+      group.vertexBuffer = null;
+      group.indexBuffer = null;
+    });
+  }
+
+  get isBuilt(): boolean {
+    return this.built;
+  }
+}