@downdraft/engine 0.0.0 → 0.1.0

package/core/src/assets/manifest.ts

@@ -0,0 +1,81 @@
+/**
+ * Asset manifest format for declaring remote asset packs.
+ * Each game project has a `downdraft.assets.json` that lists
+ * required asset packs with versions and storage backends.
+ */
+
+import type { BlobStoreConfig } from "./blob-store";
+
+export interface AssetPackEntry {
+  name: string;
+  version: string;
+  store: string;
+  path: string;
+  files?: string[];
+}
+
+/**
+ * A plugin pack entry in a workshop asset manifest. Additive to `AssetManifest`
+ * (the `plugins` section) — backwards compatible: manifests without it are
+ * still valid.
+ */
+export interface PluginPackEntry {
+  /** Plugin id (must match the plugin's plugin.json id). */
+  id: string;
+  version: string;
+  store: string;
+  /** Path within the store to the plugin pack root (containing plugin.json). */
+  path: string;
+  /** Optional SHA-256 checksum of the pack archive for integrity verification. */
+  checksum?: string;
+}
+
+export interface AssetManifest {
+  version: string;
+  packs: AssetPackEntry[];
+  stores: Record<string, BlobStoreConfig>;
+  cacheDir?: string;
+  /** Workshop plugin packs (additive, optional). */
+  plugins?: PluginPackEntry[];
+}
+
+export const DEFAULT_CACHE_DIR = ".downdraft-cache";
+export const MANIFEST_FILENAME = "downdraft.assets.json";
+
+export function createEmptyManifest(): AssetManifest {
+  return {
+    version: "1.0.0",
+    packs: [],
+    stores: {},
+    cacheDir: DEFAULT_CACHE_DIR,
+  };
+}
+
+export function validateManifest(manifest: unknown): manifest is AssetManifest {
+  if (!manifest || typeof manifest !== "object") return false;
+  const m = manifest as Record<string, unknown>;
+  if (typeof m.version !== "string") return false;
+  if (!Array.isArray(m.packs)) return false;
+  if (!m.stores || typeof m.stores !== "object") return false;
+  for (let _i = 0, _it = m.packs, _n = _it.length; _i < _n; _i++) { const pack = _it[_i];
+    if (typeof pack.name !== "string") return false;
+    if (typeof pack.version !== "string") return false;
+    if (typeof pack.store !== "string") return false;
+    if (typeof pack.path !== "string") return false;
+  }
+  // plugins section is optional; validate if present.
+  if (m.plugins !== undefined) {
+    if (!Array.isArray(m.plugins)) return false;
+    for (let _i = 0, _it = m.plugins, _n = _it.length; _i < _n; _i++) { const p = _it[_i];
+      if (typeof p.id !== "string") return false;
+      if (typeof p.version !== "string") return false;
+      if (typeof p.store !== "string") return false;
+      if (typeof p.path !== "string") return false;
+    }
+  }
+  return true;
+}
+
+export function packCacheKey(pack: AssetPackEntry, filePath: string): string {
+  return `${pack.name}@${pack.version}/${filePath}`;
+}

package/core/src/assets/material-bridge.ts

@@ -0,0 +1,186 @@
+import { BlendMode, CullMode, Material } from "../material/material";
+import type { BindlessTextureRegistry, TextureBucketKey } from "../render/bindless";
+import { createBlackTextureView, createDefaultTextureView } from "../render/gpu-utils";
+import type { PBRMaterialResources } from "../render/passes/opaque";
+import type { TextureData } from "./loader-texture";
+import { createGPUTextureFromData, createSampler, loadTexture } from "./loader-texture";
+import type { PluginMaterialData } from "./model-to-mesh";
+
+export interface BridgedMaterial {
+  material: Material;
+  pbrResources: PBRMaterialResources | null;
+  textures: GPUTexture[];
+}
+
+/** Build a TextureBucketKey from a GPUTexture's properties. */
+function bucketKeyFromTexture(tex: GPUTexture): TextureBucketKey {
+  return {
+    format: tex.format,
+    width: tex.width,
+    height: tex.height,
+    mipCount: tex.mipLevelCount,
+    sampleCount: tex.sampleCount,
+  };
+}
+
+export async function bridgeMaterial(
+  device: GPUDevice,
+  pluginMaterial: PluginMaterialData,
+  textureBasePath?: string,
+  registry?: BindlessTextureRegistry | null,
+): Promise<BridgedMaterial> {
+  const textures: GPUTexture[] = [];
+  const sampler = createSampler(device, {
+    magFilter: "linear",
+    minFilter: "linear",
+    mipmapFilter: "linear",
+    addressModeU: "repeat",
+    addressModeV: "repeat",
+  });
+
+  // When a bindless registry is provided, register textures into it and track
+  // sourceIds for the PBRMaterialResources. Otherwise, create standalone GPU
+  // textures + views (legacy path, but the OpaquePass PBR path now requires
+  // bindless, so the legacy views are only used for non-PBR rendering).
+  const useBindless = !!registry;
+  let albedoSourceId: string | undefined;
+  let normalSourceId: string | undefined;
+  let metallicRoughnessSourceId: string | undefined;
+  let aoSourceId: string | undefined;
+  let emissiveSourceId: string | undefined;
+
+  // Load albedo texture
+  let albedoView: GPUTextureView;
+  if (pluginMaterial.textureUri) {
+    const uri = textureBasePath ? `${textureBasePath}/${pluginMaterial.textureUri}` : pluginMaterial.textureUri;
+    const texData = await loadTexture(uri);
+    const gpuTex = createGPUTextureFromData(device, texData);
+    textures.push(gpuTex);
+    albedoView = gpuTex.createView();
+    if (useBindless && registry) {
+      albedoSourceId = `bridge:albedo:${pluginMaterial.name || Math.random().toString(36)}`;
+      registry.registerFromTexture(albedoSourceId, gpuTex, bucketKeyFromTexture(gpuTex));
+    }
+  } else if (pluginMaterial.textureData) {
+    const texData: TextureData = {
+      width: 1,
+      height: 1,
+      data: new Uint8Array([255, 255, 255, 255]),
+      format: "rgba8unorm",
+      mipLevels: 1,
+      isHDR: false,
+    };
+    const gpuTex = createGPUTextureFromData(device, texData);
+    textures.push(gpuTex);
+    albedoView = gpuTex.createView();
+    if (useBindless && registry) {
+      albedoSourceId = `bridge:albedo:${pluginMaterial.name || Math.random().toString(36)}`;
+      registry.registerFromTexture(albedoSourceId, gpuTex, bucketKeyFromTexture(gpuTex));
+    }
+  } else {
+    albedoView = createDefaultTextureView(device);
+  }
+
+  // Load normal texture
+  let normalView: GPUTextureView;
+  if (pluginMaterial.normalTextureUri) {
+    const uri = textureBasePath ? `${textureBasePath}/${pluginMaterial.normalTextureUri}` : pluginMaterial.normalTextureUri;
+    const texData = await loadTexture(uri);
+    const gpuTex = createGPUTextureFromData(device, texData);
+    textures.push(gpuTex);
+    normalView = gpuTex.createView();
+    if (useBindless && registry) {
+      normalSourceId = `bridge:normal:${pluginMaterial.name || Math.random().toString(36)}`;
+      registry.registerFromTexture(normalSourceId, gpuTex, bucketKeyFromTexture(gpuTex));
+    }
+  } else {
+    normalView = createDefaultTextureView(device);
+  }
+
+  // Metallic-roughness: pack into a single texture (R=metallic, G=roughness)
+  // For now, use a 1x1 default texture
+  const metallicRoughnessView = createDefaultTextureView(device);
+
+  // AO and emissive defaults
+  const aoView = createDefaultTextureView(device);
+  let emissiveView: GPUTextureView;
+  if (pluginMaterial.emissiveColor && (pluginMaterial.emissiveColor[0] > 0 || pluginMaterial.emissiveColor[1] > 0 || pluginMaterial.emissiveColor[2] > 0)) {
+    const tex = device.createTexture({
+      size: [1, 1],
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+    });
+    const data = new Uint8Array([
+      Math.min(255, Math.round(pluginMaterial.emissiveColor[0] * 255)),
+      Math.min(255, Math.round(pluginMaterial.emissiveColor[1] * 255)),
+      Math.min(255, Math.round(pluginMaterial.emissiveColor[2] * 255)),
+      255,
+    ]);
+    device.queue.writeTexture({ texture: tex }, data, { bytesPerRow: 4 }, { width: 1, height: 1 });
+    textures.push(tex);
+    emissiveView = tex.createView();
+    if (useBindless && registry) {
+      emissiveSourceId = `bridge:emissive:${pluginMaterial.name || Math.random().toString(36)}`;
+      registry.registerFromTexture(emissiveSourceId, tex, bucketKeyFromTexture(tex));
+    }
+  } else {
+    emissiveView = createBlackTextureView(device);
+  }
+
+  const emissiveIntensity = pluginMaterial.emissiveColor
+    ? Math.max(pluginMaterial.emissiveColor[0], pluginMaterial.emissiveColor[1], pluginMaterial.emissiveColor[2])
+    : 0;
+
+  const pbrResources: PBRMaterialResources = {
+    albedoTextureSourceId: albedoSourceId,
+    normalTextureSourceId: normalSourceId,
+    metallicRoughnessTextureSourceId: metallicRoughnessSourceId,
+    aoTextureSourceId: aoSourceId,
+    emissiveTextureSourceId: emissiveSourceId,
+    baseColor: pluginMaterial.baseColor,
+    roughness: pluginMaterial.roughness,
+    metallic: pluginMaterial.metallic,
+    emissiveIntensity,
+    textureTransform: pluginMaterial.textureTransform,
+  };
+  // Keep sampler/views alive for non-PBR consumers; they're referenced by `textures`.
+  void sampler; void albedoView; void normalView; void metallicRoughnessView; void aoView; void emissiveView;
+
+  const material = new Material({
+    name: pluginMaterial.name || "pbr-material",
+    shader: "pbr",
+    uniforms: {
+      baseColor: { name: "baseColor", type: "vec4", binding: 0 },
+      roughness: { name: "roughness", type: "f32", binding: 1 },
+      metallic: { name: "metallic", type: "f32", binding: 2 },
+      emissiveIntensity: { name: "emissiveIntensity", type: "f32", binding: 3 },
+    },
+    textures: {
+      albedo: { name: "albedo", binding: 1, sampler: "linear-repeat" },
+      normal: { name: "normal", binding: 3, sampler: "linear-repeat" },
+      metallicRoughness: { name: "metallicRoughness", binding: 5, sampler: "linear-repeat" },
+      ao: { name: "ao", binding: 7, sampler: "linear-repeat" },
+      emissive: { name: "emissive", binding: 9, sampler: "linear-repeat" },
+    },
+    blendMode: BlendMode.Opaque,
+    cullMode: CullMode.Back,
+  });
+
+  material.setUniform("baseColor", pluginMaterial.baseColor);
+  material.setUniform("roughness", pluginMaterial.roughness);
+  material.setUniform("metallic", pluginMaterial.metallic);
+  material.setUniform("emissiveIntensity", emissiveIntensity);
+
+  return { material, pbrResources, textures };
+}
+
+export async function bridgeMaterials(
+  device: GPUDevice,
+  pluginMaterials: PluginMaterialData[],
+  textureBasePath?: string,
+  registry?: BindlessTextureRegistry | null,
+): Promise<BridgedMaterial[]> {
+  return Promise.all(
+    pluginMaterials.map((mat) => bridgeMaterial(device, mat, textureBasePath, registry)),
+  );
+}

package/core/src/assets/model-importer.ts

@@ -0,0 +1,72 @@
+import type { MeshData } from "../mesh/builder";
+import type { GPUMesh } from "./model-to-gpu";
+import { uploadMeshesToGPU, uploadMeshToGPU } from "./model-to-gpu";
+import type { BridgedMaterial } from "./material-bridge";
+import { bridgeMaterials, bridgeMaterial } from "./material-bridge";
+import { convertPluginModel, convertPluginMesh, type PluginModelData, type PluginMaterialData, type TargetLayout } from "./model-to-mesh";
+import type { GPUResourceCache } from "./cache";
+
+export interface ImportedModel {
+  meshes: GPUMesh[];
+  meshData: MeshData[];
+  materials: BridgedMaterial[];
+  animations?: unknown[];
+  nodes?: unknown[];
+  skin?: unknown;
+  name: string;
+}
+
+export interface ImportModelOptions {
+  device: GPUDevice;
+  targetLayout?: TargetLayout;
+  textureBasePath?: string;
+  cache?: GPUResourceCache;
+}
+
+export async function importModel(
+  model: PluginModelData,
+  options: ImportModelOptions,
+): Promise<ImportedModel> {
+  const target = options.targetLayout ?? "pbr";
+
+  // Convert plugin meshes to engine MeshData
+  const meshData = convertPluginModel(model, target);
+
+  // Upload to GPU
+  const meshes = uploadMeshesToGPU(options.device, meshData, options.cache);
+
+  // Bridge materials
+  let materials: BridgedMaterial[] = [];
+  if (model.materials && model.materials.length > 0) {
+    materials = await bridgeMaterials(options.device, model.materials, options.textureBasePath);
+  }
+
+  return {
+    meshes,
+    meshData,
+    materials,
+    animations: model.animations,
+    nodes: model.nodes,
+    skin: model.skin,
+    name: model.name,
+  };
+}
+
+export async function importSingleMesh(
+  mesh: PluginModelData["meshes"][0],
+  device: GPUDevice,
+  target: TargetLayout = "pbr",
+  cache?: GPUResourceCache,
+): Promise<{ mesh: GPUMesh; meshData: MeshData }> {
+  const meshData = convertPluginMesh(mesh, target);
+  const gpuMesh = uploadMeshToGPU(device, meshData, cache);
+  return { mesh: gpuMesh, meshData };
+}
+
+export async function importMaterial(
+  material: PluginMaterialData,
+  device: GPUDevice,
+  textureBasePath?: string,
+): Promise<BridgedMaterial> {
+  return bridgeMaterial(device, material, textureBasePath);
+}

package/core/src/assets/model-normalizer.ts

@@ -0,0 +1,248 @@
+// ============================================================================
+// Model Normalizer — pure transform math for model import normalization
+// ============================================================================
+// These functions operate on plugin MeshData (interleaved pos+normal, 6 floats
+// per vertex: [px, py, pz, nx, ny, nz, ...]). They mutate in place, matching
+// the existing convertZUpToYUp pattern.
+//
+// Higher-level orchestration (sidecar resolution, node-transform baking, the
+// full normalize pipeline) lives in @downdraft/engine/libraries/models/normalize.
+//
+
+// The normalizer works on the plugin's interleaved [pos(3) + normal(3)] layout
+// (6 floats/vertex), NOT the engine's PBR/skinned layouts. We define a minimal
+// mesh interface here to avoid coupling core to plugin-models.
+type PluginMesh = {
+  vertices: Float32Array;
+  vertexCount: number;
+};
+
+type Vec3 = [number, number, number];
+type Quat = [number, number, number, number];
+
+const VERTEX_STRIDE = 6; // pos(3) + normal(3)
+
+/** Unit conversion factors: source unit → meters. */
+export const UNIT_TO_METERS: Record<string, number> = {
+  meters: 1.0,
+  centimeters: 0.01,
+  inches: 0.0254,
+  millimeters: 0.001,
+  units: 1.0, // unknown — no conversion
+};
+
+/**
+ * Rotate vertices and normals from Z-up to Y-up.
+ * Transformation: (x, y, z) → (x, z, -y)  [-90° rotation around X]
+ * No-op if already Y-up.
+ */
+export function applyUpAxisConversion(meshes: PluginMesh[], fromAxis: "y" | "z"): void {
+  if (fromAxis === "y") return;
+
+  meshes.forEach((mesh) => {
+    const verts = mesh.vertices;
+    for (let v = 0; v < mesh.vertexCount; v++) {
+      const base = v * VERTEX_STRIDE;
+      // Position: (x, y, z) → (x, z, -y)
+      const py = verts[base + 1];
+      const pz = verts[base + 2];
+      verts[base + 1] = pz;
+      verts[base + 2] = -py;
+      // Normal: same rotation
+      const ny = verts[base + 4];
+      const nz = verts[base + 5];
+      verts[base + 4] = nz;
+      verts[base + 5] = -ny;
+    }
+  });
+}
+
+/**
+ * Scale all vertex positions by a unit conversion factor (source → meters).
+ * Normals are unchanged (direction vectors are not affected by uniform scale).
+ */
+export function applyUnitScale(meshes: PluginMesh[], fromUnits: string): void {
+  const factor = UNIT_TO_METERS[fromUnits] ?? 1.0;
+  if (factor === 1.0) return;
+
+  meshes.forEach((mesh) => {
+    const verts = mesh.vertices;
+    for (let v = 0; v < mesh.vertexCount; v++) {
+      const base = v * VERTEX_STRIDE;
+      verts[base] *= factor;
+      verts[base + 1] *= factor;
+      verts[base + 2] *= factor;
+    }
+  });
+}
+
+/**
+ * Apply a uniform scale factor to all vertex positions.
+ * Used for user scale overrides and auto-fit.
+ */
+export function applyRootScale(meshes: PluginMesh[], scaleFactor: number): void {
+  if (scaleFactor === 1.0) return;
+
+  meshes.forEach((mesh) => {
+    const verts = mesh.vertices;
+    for (let v = 0; v < mesh.vertexCount; v++) {
+      const base = v * VERTEX_STRIDE;
+      verts[base] *= scaleFactor;
+      verts[base + 1] *= scaleFactor;
+      verts[base + 2] *= scaleFactor;
+    }
+  });
+}
+
+/** Quaternion multiply: a * b (Hamilton product). */
+function qmul(a: Quat, b: Quat): Quat {
+  return [
+    a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
+    a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
+    a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
+    a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2],
+  ];
+}
+
+/** Rotate vector v by quaternion q. */
+function qrotate(q: Quat, v: Vec3): Vec3 {
+  const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+  const vx = v[0], vy = v[1], vz = v[2];
+  // v + 2*cross(q.xyz, cross(q.xyz, v) + q.w * v)
+  const c1x = qy * vz - qz * vy + qw * vx;
+  const c1y = qz * vx - qx * vz + qw * vy;
+  const c1z = qx * vy - qy * vx + qw * vz;
+  const c2x = qy * c1z - qz * c1y;
+  const c2y = qz * c1x - qx * c1z;
+  const c2z = qx * c1y - qy * c1x;
+  return [vx + 2 * c2x, vy + 2 * c2y, vz + 2 * c2z];
+}
+
+/** Check if a quaternion is identity [0,0,0,1]. */
+function isIdentityQuat(q: Quat): boolean {
+  return q[0] === 0 && q[1] === 0 && q[2] === 0 && q[3] === 1;
+}
+
+/**
+ * Rotate all vertices and normals by a quaternion (root pre-rotation).
+ * Normals are rotated by the same quaternion (correct for uniform scale;
+ * for non-uniform scale the inverse-transpose would be needed, but root
+ * rotations are typically uniform).
+ */
+export function applyRootRotation(meshes: PluginMesh[], rotation: Quat): void {
+  if (isIdentityQuat(rotation)) return;
+
+  meshes.forEach((mesh) => {
+    const verts = mesh.vertices;
+    for (let v = 0; v < mesh.vertexCount; v++) {
+      const base = v * VERTEX_STRIDE;
+      // Position
+      const pos: Vec3 = [verts[base], verts[base + 1], verts[base + 2]];
+      const rotated = qrotate(rotation, pos);
+      verts[base] = rotated[0];
+      verts[base + 1] = rotated[1];
+      verts[base + 2] = rotated[2];
+      // Normal
+      const norm: Vec3 = [verts[base + 3], verts[base + 4], verts[base + 5]];
+      const rotatedN = qrotate(rotation, norm);
+      verts[base + 3] = rotatedN[0];
+      verts[base + 4] = rotatedN[1];
+      verts[base + 5] = rotatedN[2];
+    }
+  });
+}
+
+export interface Bounds {
+  min: [number, number, number];
+  max: [number, number, number];
+}
+
+/**
+ * Compute the axis-aligned bounding box of all meshes.
+ * Returns {min, max} corners. Returns degenerate bounds if no vertices.
+ */
+export function computeBounds(meshes: PluginMesh[]): Bounds {
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+
+  meshes.forEach((mesh) => {
+    const verts = mesh.vertices;
+    for (let v = 0; v < mesh.vertexCount; v++) {
+      const base = v * VERTEX_STRIDE;
+      const x = verts[base];
+      const y = verts[base + 1];
+      const z = verts[base + 2];
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      if (y > maxY) maxY = y;
+      if (z < minZ) minZ = z;
+      if (z > maxZ) maxZ = z;
+    }
+  });
+
+  if (minX === Infinity) {
+    return { min: [0, 0, 0], max: [0, 0, 0] };
+  }
+  return { min: [minX, minY, minZ], max: [maxX, maxY, maxZ] };
+}
+
+/** Get the max dimension (largest axis extent) of a bounding box. */
+export function maxDimension(bounds: Bounds): number {
+  return Math.max(
+    bounds.max[0] - bounds.min[0],
+    bounds.max[1] - bounds.min[1],
+    bounds.max[2] - bounds.min[2],
+    0,
+  );
+}
+
+/**
+ * Subtract the bounding-box center from all vertex positions, placing the
+ * model at the origin. Normals are unchanged.
+ */
+export function centerToOrigin(meshes: PluginMesh[], bounds: Bounds): void {
+  const cx = (bounds.min[0] + bounds.max[0]) / 2;
+  const cy = (bounds.min[1] + bounds.max[1]) / 2;
+  const cz = (bounds.min[2] + bounds.max[2]) / 2;
+
+  if (cx === 0 && cy === 0 && cz === 0) return;
+
+  meshes.forEach((mesh) => {
+    const verts = mesh.vertices;
+    for (let v = 0; v < mesh.vertexCount; v++) {
+      const base = v * VERTEX_STRIDE;
+      verts[base] -= cx;
+      verts[base + 1] -= cy;
+      verts[base + 2] -= cz;
+    }
+  });
+}
+
+/**
+ * Uniformly scale the model so its max dimension equals targetMaxDim.
+ * Returns the scale factor applied (or 1.0 if no scaling needed).
+ */
+export function autoFit(meshes: PluginMesh[], bounds: Bounds, targetMaxDim: number): number {
+  const currentMax = maxDimension(bounds);
+  if (currentMax <= 0 || currentMax === targetMaxDim) return 1.0;
+
+  const scaleFactor = targetMaxDim / currentMax;
+  applyRootScale(meshes, scaleFactor);
+  return scaleFactor;
+}
+
+/**
+ * Check if a model's max dimension is outside a sane range.
+ * Used to trigger the dev-mode auto-fit prompt.
+ * Threshold: < 0.01m (microscopic) or > 100m (massive).
+ */
+export function isExtremeScale(bounds: Bounds): boolean {
+  const maxDim = maxDimension(bounds);
+  return maxDim > 0 && (maxDim < 0.01 || maxDim > 100);
+}
+
+// Re-export quaternion helpers for the node-transform baking module
+export { isIdentityQuat, qmul, qrotate };
+export type { Quat, Vec3 };
+

package/core/src/assets/model-to-gpu.ts

@@ -0,0 +1,70 @@
+import type { MeshData } from "../mesh/builder";
+import type { GPUResourceCache } from "./cache";
+
+export interface GPUMesh {
+  vertexBuffer: GPUBuffer;
+  indexBuffer: GPUBuffer;
+  vertexCount: number;
+  indexCount: number;
+  layout: MeshData["layout"];
+  indexFormat: GPUIndexFormat;
+}
+
+export function uploadMeshToGPU(
+  device: GPUDevice,
+  mesh: MeshData,
+  cache?: GPUResourceCache,
+): GPUMesh {
+  const vertexBuffer = device.createBuffer({
+    size: mesh.vertices.byteLength,
+    usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+  });
+  device.queue.writeBuffer(vertexBuffer, 0, mesh.vertices.buffer);
+
+  const indexByteLen = mesh.indices.byteLength;
+  const paddedIndexSize = Math.ceil(indexByteLen / 4) * 4;
+  const indexBuffer = device.createBuffer({
+    size: paddedIndexSize,
+    usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
+  });
+  if (paddedIndexSize === indexByteLen) {
+    device.queue.writeBuffer(indexBuffer, 0, mesh.indices.buffer);
+  } else {
+    const padded = new Uint8Array(paddedIndexSize);
+    padded.set(new Uint8Array(mesh.indices.buffer, mesh.indices.byteOffset, indexByteLen));
+    device.queue.writeBuffer(indexBuffer, 0, padded);
+  }
+
+  const indexFormat: GPUIndexFormat = mesh.indices instanceof Uint32Array ? "uint32" : "uint16";
+
+  const gpuMesh: GPUMesh = {
+    vertexBuffer,
+    indexBuffer,
+    vertexCount: mesh.vertexCount,
+    indexCount: mesh.indexCount,
+    layout: mesh.layout,
+    indexFormat,
+  };
+
+  if (cache) {
+    cache.register(`gpuMesh:${vertexBuffer.label || "mesh"}`, gpuMesh, async () => {
+      vertexBuffer.destroy();
+      indexBuffer.destroy();
+    });
+  }
+
+  return gpuMesh;
+}
+
+export function uploadMeshesToGPU(
+  device: GPUDevice,
+  meshes: MeshData[],
+  cache?: GPUResourceCache,
+): GPUMesh[] {
+  return meshes.map((mesh) => uploadMeshToGPU(device, mesh, cache));
+}
+
+export function destroyGPUMesh(mesh: GPUMesh): void {
+  mesh.vertexBuffer.destroy();
+  mesh.indexBuffer.destroy();
+}