@downdraft/engine 0.0.0 → 0.1.0

package/libraries/models/src/mini-xml.ts

@@ -0,0 +1,174 @@
+// ============================================================================
+// mini-xml.ts — minimal XML parser for runtimes without a real DOMParser.
+//
+// The native runtime's DOMParser is a stub that returns empty results.
+// COLLADA (.dae) parsing needs a small DOM surface: getElementsByTagName,
+// getElementById, getAttribute, textContent, children, tagName. This parser
+// produces exactly that — it is not a general XML implementation (no
+// namespaces, DTDs, or mixed-content fidelity beyond text concatenation).
+// ============================================================================
+
+export interface MiniXmlElement {
+  tagName: string;
+  attributes: Map<string, string>;
+  children: MiniXmlElement[];
+  /** Concatenated character data of this element and its descendants. */
+  textContent: string;
+  ownerDocument: MiniXmlDocument | null;
+  getAttribute(name: string): string | null;
+  getElementsByTagName(name: string): MiniXmlElement[];
+}
+
+export interface MiniXmlDocument {
+  documentElement: MiniXmlElement;
+  getElementsByTagName(name: string): MiniXmlElement[];
+  getElementById(id: string): MiniXmlElement | null;
+}
+
+class El implements MiniXmlElement {
+  tagName: string;
+  attributes = new Map<string, string>();
+  children: El[] = [];
+  textParts: string[] = [];
+  parent: El | null = null;
+  ownerDocument: MiniXmlDocument | null = null;
+
+  constructor(tag: string) {
+    this.tagName = tag;
+  }
+
+  get textContent(): string {
+    let s = this.textParts.join("");
+    this.children.forEach((c) => { s += c.textContent;; });
+    return s;
+  }
+
+  getAttribute(name: string): string | null {
+    return this.attributes.get(name) ?? null;
+  }
+
+  getElementsByTagName(name: string): MiniXmlElement[] {
+    const out: MiniXmlElement[] = [];
+    const lower = name.toLowerCase();
+    const walk = (el: El) => {
+      el.children.forEach((c) => {
+        if (c.tagName.toLowerCase() === lower) out.push(c);
+        walk(c);
+      });
+    };
+    walk(this);
+    return out;
+  }
+}
+
+function decodeEntities(s: string): string {
+  return s
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+    .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+    .replace(/&amp;/g, "&");
+}
+
+const ATTR_RE = /([^\s=]+)\s*=\s*("[^"]*"|'[^']*')/g;
+
+/**
+ * Parse well-formed XML into a MiniXmlDocument. Throws on malformed input.
+ * Tag matching for getElementsByTagName is case-insensitive and ignores
+ * namespace prefixes (`x:foo` matches "foo").
+ */
+export function parseMiniXml(text: string): MiniXmlDocument {
+  const root = new El("#document");
+  const stack: El[] = [root];
+  const byId = new Map<string, El>();
+  let i = 0;
+  const n = text.length;
+
+  const top = () => stack[stack.length - 1];
+
+  while (i < n) {
+    const lt = text.indexOf("<", i);
+    if (lt < 0) {
+      top().textParts.push(decodeEntities(text.slice(i)));
+      break;
+    }
+    if (lt > i) top().textParts.push(decodeEntities(text.slice(i, lt)));
+
+    // Comments / CDATA / processing instructions / doctype.
+    if (text.startsWith("<!--", lt)) {
+      const end = text.indexOf("-->", lt);
+      i = end < 0 ? n : end + 3;
+      continue;
+    }
+    if (text.startsWith("<![CDATA[", lt)) {
+      const end = text.indexOf("]]>", lt);
+      top().textParts.push(text.slice(lt + 9, end < 0 ? n : end));
+      i = end < 0 ? n : end + 3;
+      continue;
+    }
+    if (text.startsWith("<?", lt)) {
+      const end = text.indexOf("?>", lt);
+      i = end < 0 ? n : end + 2;
+      continue;
+    }
+    if (text.startsWith("<!", lt)) {
+      const end = text.indexOf(">", lt);
+      i = end < 0 ? n : end + 1;
+      continue;
+    }
+
+    const gt = text.indexOf(">", lt);
+    if (gt < 0) throw new Error("mini-xml: unterminated tag");
+
+    const inner = text.slice(lt + 1, gt);
+    if (inner.startsWith("/")) {
+      const name = inner.slice(1).trim().toLowerCase();
+      // Pop to the matching open tag (tolerates mis-nested content).
+      for (let s = stack.length - 1; s > 0; s--) {
+        if (stack[s].tagName.toLowerCase() === name) {
+          stack.length = s;
+          break;
+        }
+      }
+      i = gt + 1;
+      continue;
+    }
+
+    const selfClose = inner.endsWith("/");
+    const body = selfClose ? inner.slice(0, -1) : inner;
+    const sp = body.search(/[\s]/);
+    const tag = (sp < 0 ? body : body.slice(0, sp)).trim();
+    // Strip namespace prefix so getElementsByTagName("source") matches <ns:source>.
+    const local = tag.includes(":") ? tag.slice(tag.indexOf(":") + 1) : tag;
+    const el = new El(local);
+    el.parent = top();
+
+    const attrText = sp < 0 ? "" : body.slice(sp + 1);
+    ATTR_RE.lastIndex = 0;
+    let am: RegExpExecArray | null;
+    while ((am = ATTR_RE.exec(attrText))) {
+      const key = am[1].includes(":") ? am[1].slice(am[1].indexOf(":") + 1) : am[1];
+      const val = decodeEntities(am[2].slice(1, -1));
+      el.attributes.set(key, val);
+      if (key === "id") byId.set(val, el);
+    }
+
+    top().children.push(el);
+    if (!selfClose) stack.push(el);
+    i = gt + 1;
+  }
+
+  const docEl = root.children[0];
+  if (!docEl) throw new Error("mini-xml: no document element");
+
+  const doc: MiniXmlDocument = {
+    documentElement: docEl,
+    getElementsByTagName: (name) => root.getElementsByTagName(name),
+    getElementById: (id) => byId.get(id) ?? null,
+  };
+  const attach = (el: El) => { el.ownerDocument = doc; el.children.forEach(attach); };
+  attach(docEl);
+  return doc;
+}

package/libraries/models/src/normalize.ts

@@ -0,0 +1,216 @@
+// ============================================================================
+// Normalize Model — orchestrate the full import normalization pipeline
+// ============================================================================
+// Applies the resolved ImportSettings to a ModelData:
+//   1. Up-axis conversion (Z-up → Y-up)
+//   2. Unit scale (source units → meters)
+//   3. Node-transform baking (glTF/FBX node hierarchy → mesh vertices)
+//   4. Root pre-rotation (settings.rotation)
+//   5. User scale (settings.scale)
+//   6. Bounds computation
+//   7. Center to origin (if enabled)
+//   8. Auto-fit (if enabled)
+//
+// For skinned meshes, the same transforms (1, 2, 4, 5, 7, 8) are also applied
+// to the skin data (bone rest transforms + inverse bind matrices) so that
+// vertices and bone data stay in the same coordinate space. Step 3 (node-
+// transform baking) is skipped for skinned meshes — the skin matrices encode
+// the bone hierarchy and baking would double-transform the vertices.
+//
+// The transform math lives in @downdraft/engine (model-normalizer.ts).
+// This module orchestrates the pipeline and handles the plugin-level
+// concerns (node-transform baking, sidecar resolution, skin normalization).
+//
+
+import {
+    applyRootRotation,
+    applyRootScale,
+    applyUnitScale,
+    applyUpAxisConversion,
+    autoFit as autoFitMeshes,
+    centerToOrigin as centerMeshesToOrigin,
+    computeBounds,
+    isExtremeScale,
+    UNIT_TO_METERS,
+    type Bounds
+} from "@downdraft/engine";
+import { bakeNodeTransforms } from "./bake-node-transforms";
+import { resolveImportSettings, resolveImportSettingsSync, type ResolveOptions } from "./sidecar/resolver";
+import type { ImportSettings } from "./sidecar/types";
+import type { ModelData } from "./types";
+
+export { resolveImportSettings, resolveImportSettingsSync };
+export type { ResolveOptions };
+
+// Local tuple type (the core's Quat from sim/types is an object type, but
+// ImportSettings.rotation uses a tuple).
+type Quat = [number, number, number, number];
+
+// ── 4x4 matrix utilities (column-major, matching WebGPU convention) ──
+
+function matMultiply(a: Float32Array, b: Float32Array): Float32Array {
+  // Compute A * B in column-major layout.
+  // out[col=i, row=j] = sum_k A[col=k, row=j] * B[col=i, row=k]
+  const out = new Float32Array(16);
+  for (let i = 0; i < 4; i++) {
+    for (let j = 0; j < 4; j++) {
+      out[i * 4 + j] =
+        a[0 * 4 + j] * b[i * 4 + 0] +
+        a[1 * 4 + j] * b[i * 4 + 1] +
+        a[2 * 4 + j] * b[i * 4 + 2] +
+        a[3 * 4 + j] * b[i * 4 + 3];
+    }
+  }
+  return out;
+}
+
+function matTranslate(tx: number, ty: number, tz: number): Float32Array {
+  return new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, tx,ty,tz,1]);
+}
+
+function matScale(s: number): Float32Array {
+  return new Float32Array([s,0,0,0, 0,s,0,0, 0,0,s,0, 0,0,0,1]);
+}
+
+function matFromQuat(q: Quat): Float32Array {
+  const x = q[0], y = q[1], z = q[2], w = q[3];
+  const x2 = x + x, y2 = y + y, z2 = z + z;
+  const xx = x * x2, xy = x * y2, xz = x * z2;
+  const yy = y * y2, yz = y * z2, zz = z * z2;
+  const wx = w * x2, wy = w * y2, wz = w * z2;
+  return new Float32Array([
+    1 - (yy + zz), xy + wz, xz - wy, 0,
+    xy - wz, 1 - (xx + zz), yz + wx, 0,
+    xz + wy, yz - wx, 1 - (xx + yy), 0,
+    0, 0, 0, 1,
+  ]);
+}
+
+/**
+ * Normalize a ModelData using the given ImportSettings.
+ * Mutates modelData in place (matching existing parser patterns).
+ *
+ * Returns the mutated ModelData with `bounds` and `normalizationWarnings`
+ * populated.
+ */
+export function normalizeModel(modelData: ModelData, settings: ImportSettings): ModelData {
+  const warnings: string[] = [];
+
+  // Track the accumulated normalization transform for skin data. This is the
+  // combined transform T such that v' = T * v for vertices. The same transform
+  // is applied to bone rest data and inverse bind matrices at the end.
+  const hasSkin = !!modelData.skin && modelData.skin.bones.length > 0;
+  let skinTransform: Float32Array | null = null;
+  function accumulateTransform(t: Float32Array): void {
+    skinTransform = skinTransform ? matMultiply(t, skinTransform) : t;
+  }
+
+  // 1. Up-axis conversion (Z-up → Y-up): (x,y,z) → (x,z,-y)
+  if (settings.upAxis === "z") {
+    applyUpAxisConversion(modelData.meshes, "z");
+    if (hasSkin) {
+      // -90° rotation around X: column-major [1,0,0,0, 0,0,-1,0, 0,1,0,0, 0,0,0,1]
+      accumulateTransform(new Float32Array([1,0,0,0, 0,0,-1,0, 0,1,0,0, 0,0,0,1]));
+    }
+  }
+
+  // 2. Unit scale (source units → meters)
+  const unitFactor = UNIT_TO_METERS[settings.units] ?? 1.0;
+  if (unitFactor !== 1.0) {
+    applyUnitScale(modelData.meshes, settings.units);
+    if (hasSkin) accumulateTransform(matScale(unitFactor));
+  }
+
+  // 3. Node-transform baking (skipped for skinned meshes inside bakeNodeTransforms)
+  if (settings.nodeTransforms === "apply") {
+    bakeNodeTransforms(modelData);
+  }
+
+  // 4. Root pre-rotation
+  if (settings.rotation) {
+    applyRootRotation(modelData.meshes, settings.rotation);
+    if (hasSkin) accumulateTransform(matFromQuat(settings.rotation));
+  }
+
+  // 5. User scale multiplier
+  if (settings.scale && settings.scale !== 1.0) {
+    applyRootScale(modelData.meshes, settings.scale);
+    if (hasSkin) accumulateTransform(matScale(settings.scale));
+  }
+
+  // 6. Compute bounds
+  const bounds: Bounds = computeBounds(modelData.meshes);
+  modelData.bounds = bounds;
+
+  // Check for extreme scale (for dev-mode auto-fit prompt)
+  if (isExtremeScale(bounds)) {
+    const maxDim = Math.max(
+      bounds.max[0] - bounds.min[0],
+      bounds.max[1] - bounds.min[1],
+      bounds.max[2] - bounds.min[2],
+    );
+    warnings.push(`Model has extreme scale: max dimension = ${maxDim.toFixed(4)}m. Consider auto-fit or adjusting scale in .ddmeta.json.`);
+  }
+
+  // 7. Center to origin
+  if (settings.centerToOrigin) {
+    centerMeshesToOrigin(modelData.meshes, bounds);
+    // Recompute bounds after centering
+    modelData.bounds = computeBounds(modelData.meshes);
+    if (hasSkin) {
+      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;
+      accumulateTransform(matTranslate(-cx, -cy, -cz));
+    }
+  }
+
+  // 8. Auto-fit
+  if (settings.autoFit !== null && settings.autoFit > 0) {
+    const currentBounds = modelData.bounds;
+    const currentMax = Math.max(
+      currentBounds.max[0] - currentBounds.min[0],
+      currentBounds.max[1] - currentBounds.min[1],
+      currentBounds.max[2] - currentBounds.min[2],
+    );
+    if (currentMax > 0) {
+      const fitFactor = settings.autoFit / currentMax;
+      autoFitMeshes(modelData.meshes, currentBounds, settings.autoFit);
+      modelData.bounds = computeBounds(modelData.meshes);
+      if (hasSkin) accumulateTransform(matScale(fitFactor));
+      warnings.push(`Auto-fit applied: scaled to ${settings.autoFit}m max dimension (was ${currentMax.toFixed(4)}m).`);
+    }
+  }
+
+  // Store the accumulated normalization transform on the skin data. The
+  // animator will conjugate skin matrices with it (T * skinMatrix * T^-1) so
+  // that skinned vertices — which were transformed by T — map to the correct
+  // normalized world positions. Bone rest data stays in its original coordinate
+  // space; only the final skin matrices are transformed.
+  if (hasSkin && skinTransform) {
+    modelData.skin!.normalizationMatrix = skinTransform;
+  }
+
+  if (warnings.length > 0) {
+    modelData.normalizationWarnings = warnings;
+  }
+
+  return modelData;
+}
+
+/**
+ * Full normalization pipeline: resolve import settings, then normalize.
+ * Convenience function that combines resolveImportSettings + normalizeModel.
+ */
+export async function normalizeModelWithResolution(
+  modelData: ModelData,
+  modelPath: string,
+  opts?: Omit<ResolveOptions, "modelPath" | "modelData">,
+): Promise<ModelData> {
+  const settings = await resolveImportSettings({
+    ...opts,
+    modelPath,
+    modelData,
+  });
+  return normalizeModel(modelData, settings);
+}

package/libraries/models/src/obj.ts

@@ -0,0 +1,264 @@
+import type { MaterialData, MeshData, ModelData } from "./types";
+
+interface OBJMaterial {
+  name: string;
+  ambient: [number, number, number];
+  diffuse: [number, number, number];
+  specular: [number, number, number];
+  shininess: number;
+  opacity: number;
+  diffuseTexture?: string;
+  normalTexture?: string;
+}
+
+function parseMTL(text: string): Map<string, OBJMaterial> {
+  const materials = new Map<string, OBJMaterial>();
+  let current: OBJMaterial | null = null;
+
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith("#") || trimmed.length === 0) continue;
+
+    const parts = trimmed.split(/\s+/);
+    const cmd = parts[0];
+
+    if (cmd === "newmtl") {
+      current = {
+        name: parts[1] ?? "default",
+        ambient: [1, 1, 1],
+        diffuse: [0.7, 0.7, 0.7],
+        specular: [0, 0, 0],
+        shininess: 0,
+        opacity: 1,
+      };
+      materials.set(current.name, current);
+    } else if (current) {
+      if (cmd === "Ka" && parts.length >= 4) {
+        current.ambient = [parseFloat(parts[1]), parseFloat(parts[2]), parseFloat(parts[3])];
+      } else if (cmd === "Kd" && parts.length >= 4) {
+        current.diffuse = [parseFloat(parts[1]), parseFloat(parts[2]), parseFloat(parts[3])];
+      } else if (cmd === "Ks" && parts.length >= 4) {
+        current.specular = [parseFloat(parts[1]), parseFloat(parts[2]), parseFloat(parts[3])];
+      } else if (cmd === "Ns" && parts.length >= 2) {
+        current.shininess = parseFloat(parts[1]);
+      } else if (cmd === "d" && parts.length >= 2) {
+        current.opacity = parseFloat(parts[1]);
+      } else if (cmd === "Tr" && parts.length >= 2) {
+        current.opacity = 1 - parseFloat(parts[1]);
+      } else if (cmd === "map_Kd" && parts.length >= 2) {
+        current.diffuseTexture = parts.slice(1).join(" ");
+      } else if (cmd === "map_Bump" && parts.length >= 2) {
+        current.normalTexture = parts.slice(1).join(" ");
+      } else if (cmd === "bump" && parts.length >= 2) {
+        current.normalTexture = parts.slice(1).join(" ");
+      }
+    }
+  }
+
+  return materials;
+}
+
+export function parseOBJ(
+  data: ArrayBuffer,
+  name: string,
+  mtlData?: ArrayBuffer | null,
+  mtlFilename?: string,
+): ModelData {
+  const text = new TextDecoder().decode(data);
+  const lines = text.split("\n");
+
+  const positions: number[][] = [];
+  const normals: number[][] = [];
+  const uvs: number[][] = [];
+  const faces: { posIdx: number; normIdx: number; uvIdx: number; matIdx: number }[][] = [];
+  let currentMatIdx = 0;
+  const materialNameToIdx = new Map<string, number>();
+  const materialList: OBJMaterial[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed.startsWith("#") || trimmed.length === 0) continue;
+
+    const parts = trimmed.split(/\s+/);
+    const cmd = parts[0];
+
+    if (cmd === "v" && parts.length >= 4) {
+      positions.push([parseFloat(parts[1]), parseFloat(parts[2]), parseFloat(parts[3])]);
+    } else if (cmd === "vn" && parts.length >= 4) {
+      normals.push([parseFloat(parts[1]), parseFloat(parts[2]), parseFloat(parts[3])]);
+    } else if (cmd === "vt" && parts.length >= 3) {
+      uvs.push([parseFloat(parts[1]), parseFloat(parts[2])]);
+    } else if (cmd === "usemtl" && parts.length >= 2) {
+      const matName = parts[1];
+      if (materialNameToIdx.has(matName)) {
+        currentMatIdx = materialNameToIdx.get(matName)!;
+      } else {
+        currentMatIdx = materialList.length;
+        materialNameToIdx.set(matName, currentMatIdx);
+        materialList.push({
+          name: matName,
+          ambient: [1, 1, 1],
+          diffuse: [0.7, 0.7, 0.7],
+          specular: [0, 0, 0],
+          shininess: 0,
+          opacity: 1,
+        });
+      }
+    } else if (cmd === "f" && parts.length >= 4) {
+      const face: { posIdx: number; normIdx: number; uvIdx: number; matIdx: number }[] = [];
+      for (let j = 1; j < parts.length; j++) {
+        const indices = parts[j].split("/");
+        const posIdx = parseInt(indices[0]) - 1;
+        const uvIdx = indices[1] ? parseInt(indices[1]) - 1 : -1;
+        const normIdx = indices[2] ? parseInt(indices[2]) - 1 : -1;
+        if (posIdx < 0 || posIdx >= positions.length) {
+          throw new RangeError(`OBJ face vertex index out of bounds: ${posIdx + 1} (positions: ${positions.length})`);
+        }
+        if (uvIdx >= 0 && uvIdx >= uvs.length) {
+          throw new RangeError(`OBJ face uv index out of bounds: ${uvIdx + 1} (uvs: ${uvs.length})`);
+        }
+        if (normIdx >= 0 && normIdx >= normals.length) {
+          throw new RangeError(`OBJ face normal index out of bounds: ${normIdx + 1} (normals: ${normals.length})`);
+        }
+        face.push({ posIdx, normIdx, uvIdx, matIdx: currentMatIdx });
+      }
+      for (let j = 1; j < face.length - 1; j++) {
+        faces.push([face[0], face[j], face[j + 1]]);
+      }
+    }
+  }
+
+  // Parse MTL if provided
+  let materials: MaterialData[] | undefined;
+  if (mtlData) {
+    const mtlText = new TextDecoder().decode(mtlData);
+    const mtlMaterials = parseMTL(mtlText);
+    materials = [];
+    const mtlEntries = Array.from(mtlMaterials.entries());
+    for (let mi = 0; mi < mtlEntries.length; mi++) {
+      const matName = mtlEntries[mi][0];
+      const mat = mtlEntries[mi][1];
+      materials.push({
+        name: matName,
+        baseColor: [mat.diffuse[0], mat.diffuse[1], mat.diffuse[2], mat.opacity],
+        metallic: 0,
+        roughness: mat.shininess > 0 ? Math.max(0.1, 1 - mat.shininess / 1000) : 1,
+        textureUri: mat.diffuseTexture,
+        textureData: null,
+        normalTextureUri: mat.normalTexture,
+      });
+    }
+    // Rebuild material index mapping and update materialList with MTL colors
+    materialNameToIdx.clear();
+    for (let mi = 0; mi < mtlEntries.length; mi++) {
+      const matName = mtlEntries[mi][0];
+      const mat = mtlEntries[mi][1];
+      materialNameToIdx.set(matName, mi);
+      // Update existing materialList entry or add new one
+      if (mi < materialList.length) {
+        materialList[mi] = {
+          name: matName,
+          ambient: mat.ambient,
+          diffuse: mat.diffuse,
+          specular: mat.specular,
+          shininess: mat.shininess,
+          opacity: mat.opacity,
+          diffuseTexture: mat.diffuseTexture,
+          normalTexture: mat.normalTexture,
+        };
+      } else {
+        materialList.push({
+          name: matName,
+          ambient: mat.ambient,
+          diffuse: mat.diffuse,
+          specular: mat.specular,
+          shininess: mat.shininess,
+          opacity: mat.opacity,
+          diffuseTexture: mat.diffuseTexture,
+          normalTexture: mat.normalTexture,
+        });
+      }
+    }
+  } else {
+    // No MTL file — build materials from the OBJ's internal material list
+    if (materialList.length > 0) {
+      materials = [];
+      for (let mi = 0; mi < materialList.length; mi++) {
+        const mat = materialList[mi];
+        materials.push({
+          name: mat.name,
+          baseColor: [mat.diffuse[0], mat.diffuse[1], mat.diffuse[2], mat.opacity],
+          metallic: 0,
+          roughness: mat.shininess > 0 ? Math.max(0.1, 1 - mat.shininess / 1000) : 1,
+          textureData: null,
+        });
+      }
+    }
+  }
+
+  const hasUVs = uvs.length > 0;
+
+  // Build interleaved vertex data
+  const vertexMap = new Map<string, number>();
+  const vertices: number[] = [];
+  const indices: number[] = [];
+  const uvArray: number[] = [];
+  const colorArray: number[] = [];
+  const vertMatIndices: number[] = [];
+
+  for (let f = 0; f < faces.length; f++) {
+    const face = faces[f];
+    for (let v = 0; v < face.length; v++) {
+      const vert = face[v];
+      const key = `${vert.posIdx}/${vert.normIdx}/${vert.uvIdx}`;
+      let idx = vertexMap.get(key);
+      if (idx === undefined) {
+        idx = vertices.length / 6;
+        const pos = positions[vert.posIdx] ?? [0, 0, 0];
+        const norm = vert.normIdx >= 0 ? (normals[vert.normIdx] ?? [0, 1, 0]) : [0, 1, 0];
+        vertices.push(pos[0], pos[1], pos[2], norm[0], norm[1], norm[2]);
+
+        if (hasUVs && vert.uvIdx >= 0) {
+          const uv = uvs[vert.uvIdx] ?? [0, 0];
+          uvArray.push(uv[0], 1.0 - uv[1]);
+        } else {
+          uvArray.push(0, 0);
+        }
+
+        // Vertex color from material diffuse
+        const mat = materialList[vert.matIdx];
+        if (mat) {
+          colorArray.push(mat.diffuse[0], mat.diffuse[1], mat.diffuse[2]);
+        } else {
+          colorArray.push(0.7, 0.7, 0.75);
+        }
+        vertMatIndices.push(vert.matIdx);
+
+        vertexMap.set(key, idx);
+      }
+      indices.push(idx);
+    }
+  }
+
+  const vertArray = new Float32Array(vertices);
+  const idxArray = indices.length > 65535
+    ? new Uint32Array(indices)
+    : new Uint16Array(indices);
+
+  const mesh: MeshData = {
+    vertices: vertArray,
+    indices: idxArray,
+    vertexCount: vertices.length / 6,
+    indexCount: indices.length,
+    uvs: hasUVs ? new Float32Array(uvArray) : null,
+    colors: colorArray.length > 0 ? new Float32Array(colorArray) : null,
+  };
+
+  return {
+    meshes: [mesh],
+    name,
+    format: "obj",
+    materials,
+  };
+}