@downdraft/engine 0.0.0 → 0.1.0

package/libraries/models/src/stl.ts

@@ -0,0 +1,149 @@
+import type { MeshData, ModelData } from "./types";
+
+function isBinarySTL(data: ArrayBuffer): boolean {
+  // Binary STL: 80-byte header + 4-byte face count + face data
+  // ASCII STL starts with "solid" but some binary files also start with "solid"
+  // Check: if file size matches binary format, it's binary
+  if (data.byteLength < 84) return false;
+
+  const view = new DataView(data);
+  const numFaces = view.getUint32(80, true);
+  const expectedSize = 84 + numFaces * 50; // 50 bytes per triangle
+
+  // If size matches binary format, it's binary
+  if (expectedSize === data.byteLength) return true;
+
+  // Check for "facet" keyword in first 2048 bytes (ASCII indicator)
+  // This takes priority over the "solid" prefix check, since some ASCII STL
+  // files have comments before the "solid" keyword
+  const checkLen = Math.min(2048, data.byteLength);
+  const text = new TextDecoder().decode(new Uint8Array(data, 0, checkLen));
+  if (text.includes("facet")) return false;
+
+  // If no "facet" keyword found, check if it starts with "solid"
+  if (text.startsWith("solid")) return false;
+
+  // No ASCII indicators found, assume binary
+  return true;
+}
+
+function parseBinarySTL(data: ArrayBuffer, name: string): ModelData {
+  const view = new DataView(data);
+  const numFaces = view.getUint32(80, true);
+
+  const vertices: number[] = [];
+  const indices: number[] = [];
+  const normals: number[] = [];
+  const vertexMap = new Map<string, number>();
+
+  let offset = 84;
+  for (let i = 0; i < numFaces; i++) {
+    // 12 bytes normal, then 3 * 12 bytes vertices, then 2 bytes attribute
+    const nx = view.getFloat32(offset, true);
+    const ny = view.getFloat32(offset + 4, true);
+    const nz = view.getFloat32(offset + 8, true);
+
+    for (let v = 0; v < 3; v++) {
+      const voff = offset + 12 + v * 12;
+      const px = view.getFloat32(voff, true);
+      const py = view.getFloat32(voff + 4, true);
+      const pz = view.getFloat32(voff + 8, true);
+
+      const key = `${px},${py},${pz}`;
+      let idx = vertexMap.get(key);
+      if (idx === undefined) {
+        idx = vertices.length / 6;
+        vertices.push(px, py, pz, nx, ny, nz);
+        normals.push(nx, ny, nz);
+        vertexMap.set(key, idx);
+      }
+      indices.push(idx);
+    }
+
+    offset += 50; // 12 normal + 36 vertices + 2 attribute
+  }
+
+  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: null,
+    colors: null,
+  };
+
+  return { meshes: [mesh], name, format: "stl" };
+}
+
+function parseASCIISTL(data: ArrayBuffer, name: string): ModelData {
+  const text = new TextDecoder().decode(data);
+  const lines = text.split("\n");
+
+  const vertices: number[] = [];
+  const indices: number[] = [];
+  const vertexMap = new Map<string, number>();
+
+  let currentNormal: [number, number, number] = [0, 1, 0];
+  let faceVerts: number[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+
+    if (trimmed.startsWith("facet normal")) {
+      const parts = trimmed.split(/\s+/);
+      currentNormal = [parseFloat(parts[2]), parseFloat(parts[3]), parseFloat(parts[4])];
+      faceVerts = [];
+    } else if (trimmed.startsWith("vertex")) {
+      const parts = trimmed.split(/\s+/);
+      const px = parseFloat(parts[1]);
+      const py = parseFloat(parts[2]);
+      const pz = parseFloat(parts[3]);
+
+      const key = `${px},${py},${pz}`;
+      let idx = vertexMap.get(key);
+      if (idx === undefined) {
+        idx = vertices.length / 6;
+        vertices.push(px, py, pz, currentNormal[0], currentNormal[1], currentNormal[2]);
+        vertexMap.set(key, idx);
+      }
+      faceVerts.push(idx);
+    } else if (trimmed === "endfacet" || trimmed === "endloop") {
+      // Triangulate face (usually 3 verts, but handle n-gons)
+      // Some STL files omit "endfacet" and only use "endloop"
+      if (faceVerts.length >= 3) {
+        for (let j = 1; j < faceVerts.length - 1; j++) {
+          indices.push(faceVerts[0], faceVerts[j], faceVerts[j + 1]);
+        }
+      }
+      faceVerts = [];
+    }
+  }
+
+  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: null,
+    colors: null,
+  };
+
+  return { meshes: [mesh], name, format: "stl" };
+}
+
+export function parseSTL(data: ArrayBuffer, name: string): ModelData {
+  if (isBinarySTL(data)) {
+    return parseBinarySTL(data, name);
+  }
+  return parseASCIISTL(data, name);
+}

package/libraries/models/src/threeds.ts

@@ -0,0 +1,363 @@
+import { assertBounds, assertCount, MAX_FACE_COUNT, MAX_VERTEX_COUNT } from "@downdraft/engine";
+import type { MaterialData, MeshData, ModelData } from "./types";
+
+// 3DS chunk IDs
+const CHUNK_MAIN = 0x4d4d;
+const CHUNK_EDIT = 0x3d3d;
+const CHUNK_OBJECT = 0x4000;
+const CHUNK_TRIMESH = 0x4100;
+const CHUNK_VERTICES = 0x4110;
+const CHUNK_FACES = 0x4120;
+const CHUNK_MAPPING = 0x4140;
+const CHUNK_MATERIAL = 0xafff;
+const CHUNK_MAT_NAME = 0xa000;
+const CHUNK_MAT_TEXMAP = 0xa200;
+const CHUNK_MAT_MAPFILE = 0xa300;
+const CHUNK_MAT_DIFFUSE = 0xa020;
+const CHUNK_MAT_SHININESS = 0xa040;
+const CHUNK_MAT_SHIN_STRENGTH = 0xa041;
+const CHUNK_FACE_MATERIAL = 0x4130;
+
+interface FaceMaterial {
+  materialName: string;
+  faceIndices: number[];
+}
+
+function readString(view: DataView, offset: number): [string, number] {
+  const bytes: number[] = [];
+  let pos = offset;
+  while (pos < view.byteLength && view.getUint8(pos) !== 0) {
+    bytes.push(view.getUint8(pos));
+    pos++;
+  }
+  pos++; // skip null terminator
+  const str = new TextDecoder().decode(new Uint8Array(bytes));
+  return [str, pos - offset];
+}
+
+function readChunkHeader(view: DataView, offset: number): [number, number] {
+  const id = view.getUint16(offset, true);
+  const size = view.getUint32(offset + 2, true);
+  return [id, size];
+}
+
+interface ParsedMesh {
+  name: string;
+  vertices: Float32Array;
+  indices: Uint16Array | Uint32Array;
+  vertexCount: number;
+  indexCount: number;
+  uvs: Float32Array | null;
+  faceMaterials: FaceMaterial[];
+}
+
+function parseTriMesh(view: DataView, chunkStart: number, chunkEnd: number, name: string): ParsedMesh {
+  let offset = chunkStart;
+
+  let positions: number[] = [];
+  let indices: number[] = [];
+  let uvs: number[] = [];
+  let faceMaterials: FaceMaterial[] = [];
+
+  while (offset < chunkEnd) {
+    const [id, size] = readChunkHeader(view, offset);
+    const childEnd = offset + size;
+
+    // Validate chunk size doesn't exceed remaining file bounds
+    if (childEnd > chunkEnd || childEnd > view.byteLength) {
+      break;
+    }
+
+    if (id === CHUNK_VERTICES) {
+      const count = view.getUint16(offset + 6, true);
+      assertCount("3ds vertices", count, MAX_VERTEX_COUNT);
+      // Validate count × stride fits within chunk data
+      assertBounds("3ds vertex data", offset + 8, count * 12, childEnd);
+      positions = [];
+      let pos = offset + 8;
+      for (let i = 0; i < count; i++) {
+        const x = view.getFloat32(pos, true);
+        const y = view.getFloat32(pos + 4, true);
+        const z = view.getFloat32(pos + 8, true);
+        // 3DS uses Z-up, convert to Y-up
+        positions.push(x, z, -y);
+        pos += 12;
+      }
+    } else if (id === CHUNK_FACES) {
+      const count = view.getUint16(offset + 6, true);
+      assertCount("3ds faces", count, MAX_FACE_COUNT);
+      // Validate count × stride fits within chunk data
+      assertBounds("3ds face data", offset + 8, count * 8, childEnd);
+      indices = [];
+      let pos = offset + 8;
+      for (let i = 0; i < count; i++) {
+        const a = view.getUint16(pos, true);
+        const b = view.getUint16(pos + 2, true);
+        const c = view.getUint16(pos + 4, true);
+        // Skip face flags (2 bytes)
+        indices.push(a, b, c);
+        pos += 8;
+      }
+
+      // Check for face material sub-chunks
+      let subOffset = pos;
+      while (subOffset < childEnd) {
+        const [subId, subSize] = readChunkHeader(view, subOffset);
+        const subChildEnd = subOffset + subSize;
+
+        if (subId === CHUNK_FACE_MATERIAL) {
+          const [matName, nameLen] = readString(view, subOffset + 6);
+          const numFaces = view.getUint16(subOffset + 6 + nameLen, true);
+          const faceIdx: number[] = [];
+          let fPos = subOffset + 6 + nameLen + 2;
+          for (let f = 0; f < numFaces; f++) {
+            faceIdx.push(view.getUint16(fPos, true));
+            fPos += 2;
+          }
+          faceMaterials.push({ materialName: matName, faceIndices: faceIdx });
+        }
+
+        subOffset = subChildEnd;
+      }
+    } else if (id === CHUNK_MAPPING) {
+      const count = view.getUint16(offset + 6, true);
+      uvs = [];
+      let pos = offset + 8;
+      for (let i = 0; i < count; i++) {
+        const u = view.getFloat32(pos, true);
+        const v = view.getFloat32(pos + 4, true);
+        uvs.push(u, 1.0 - v); // Flip V
+        pos += 8;
+      }
+    }
+
+    offset = childEnd;
+  }
+
+  const vertexCount = positions.length / 3;
+  const indexCount = indices.length;
+
+  // Build interleaved vertices (pos + normal = 6 floats)
+  // 3DS doesn't store normals, so we compute them
+  const vertices = new Float32Array(vertexCount * 6);
+  for (let i = 0; i < vertexCount; i++) {
+    vertices[i * 6] = positions[i * 3];
+    vertices[i * 6 + 1] = positions[i * 3 + 1];
+    vertices[i * 6 + 2] = positions[i * 3 + 2];
+    // normals will be filled below
+  }
+
+  // Compute face normals and assign to vertices
+  const normals = new Float32Array(vertexCount * 3);
+  for (let i = 0; i < indexCount; i += 3) {
+    const a = indices[i], b = indices[i + 1], c = indices[i + 2];
+    const ax = positions[a * 3], ay = positions[a * 3 + 1], az = positions[a * 3 + 2];
+    const bx = positions[b * 3], by = positions[b * 3 + 1], bz = positions[b * 3 + 2];
+    const cx = positions[c * 3], cy = positions[c * 3 + 1], cz = positions[c * 3 + 2];
+
+    const ux = bx - ax, uy = by - ay, uz = bz - az;
+    const vx = cx - ax, vy = cy - ay, vz = cz - az;
+    const nx = uy * vz - uz * vy;
+    const ny = uz * vx - ux * vz;
+    const nz = ux * vy - uy * vx;
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+
+    normals[a * 3] += nx / len; normals[a * 3 + 1] += ny / len; normals[a * 3 + 2] += nz / len;
+    normals[b * 3] += nx / len; normals[b * 3 + 1] += ny / len; normals[b * 3 + 2] += nz / len;
+    normals[c * 3] += nx / len; normals[c * 3 + 1] += ny / len; normals[c * 3 + 2] += nz / len;
+  }
+
+  for (let i = 0; i < vertexCount; i++) {
+    const nx = normals[i * 3], ny = normals[i * 3 + 1], nz = normals[i * 3 + 2];
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    vertices[i * 6 + 3] = nx / len;
+    vertices[i * 6 + 4] = ny / len;
+    vertices[i * 6 + 5] = nz / len;
+  }
+
+  const indexArray = indexCount > 65535
+    ? new Uint32Array(indices)
+    : new Uint16Array(indices);
+
+  const uvArray = uvs.length > 0 ? new Float32Array(uvs) : null;
+
+  return {
+    name,
+    vertices,
+    indices: indexArray,
+    vertexCount,
+    indexCount,
+    uvs: uvArray,
+    faceMaterials,
+  };
+}
+
+interface ParsedMaterial {
+  name: string;
+  diffuseColor: [number, number, number];
+  shininess: number;
+  shininessStrength: number;
+  textureFile?: string;
+}
+
+function parseMaterial(view: DataView, chunkStart: number, chunkEnd: number): ParsedMaterial {
+  let offset = chunkStart;
+  const mat: ParsedMaterial = {
+    name: "default",
+    diffuseColor: [0.7, 0.7, 0.7],
+    shininess: 0,
+    shininessStrength: 0,
+  };
+
+  while (offset < chunkEnd) {
+    const [id, size] = readChunkHeader(view, offset);
+    const childEnd = offset + size;
+
+    if (id === CHUNK_MAT_NAME) {
+      const [name] = readString(view, offset + 6);
+      mat.name = name;
+    } else if (id === CHUNK_MAT_DIFFUSE) {
+      // Color sub-chunk: skip header, read RGB floats
+      const colorEnd = childEnd;
+      let pos = offset + 6;
+      // Skip past any sub-chunks to find the actual color data
+      // Typically there's a 24-bit color sub-chunk (0x0011) or float color (0x0013)
+      while (pos < colorEnd) {
+        const [subId, subSize] = readChunkHeader(view, pos);
+        if (subId === 0x0011) {
+          // 24-bit color: 3 bytes
+          const r = view.getUint8(pos + 6) / 255;
+          const g = view.getUint8(pos + 7) / 255;
+          const b = view.getUint8(pos + 8) / 255;
+          mat.diffuseColor = [r, g, b];
+          break;
+        } else if (subId === 0x0013) {
+          // Float color: 3 floats
+          mat.diffuseColor = [
+            view.getFloat32(pos + 6, true),
+            view.getFloat32(pos + 10, true),
+            view.getFloat32(pos + 14, true),
+          ];
+          break;
+        }
+        pos += subSize;
+      }
+    } else if (id === CHUNK_MAT_SHININESS) {
+      let pos = offset + 6;
+      while (pos < childEnd) {
+        const [subId, subSize] = readChunkHeader(view, pos);
+        if (subId === 0x0030) {
+          mat.shininess = view.getFloat32(pos + 6, true) * 100;
+          break;
+        }
+        pos += subSize;
+      }
+    } else if (id === CHUNK_MAT_SHIN_STRENGTH) {
+      let pos = offset + 6;
+      while (pos < childEnd) {
+        const [subId, subSize] = readChunkHeader(view, pos);
+        if (subId === 0x0030) {
+          mat.shininessStrength = view.getFloat32(pos + 6, true);
+          break;
+        }
+        pos += subSize;
+      }
+    } else if (id === CHUNK_MAT_TEXMAP) {
+      let pos = offset + 6;
+      while (pos < childEnd) {
+        const [subId, subSize] = readChunkHeader(view, pos);
+        if (subId === CHUNK_MAT_MAPFILE) {
+          const [filename] = readString(view, pos + 6);
+          mat.textureFile = filename;
+          break;
+        }
+        pos += subSize;
+      }
+    }
+
+    offset = childEnd;
+  }
+
+  return mat;
+}
+
+export function parse3DS(data: ArrayBuffer, name: string): ModelData {
+  const view = new DataView(data);
+  const meshes: ParsedMesh[] = [];
+  const materials: ParsedMaterial[] = [];
+
+  let offset = 0;
+
+  // Find main chunk
+  const [mainId, mainSize] = readChunkHeader(view, 0);
+  if (mainId !== CHUNK_MAIN) {
+    throw new Error("3DS: Invalid file, missing main chunk");
+  }
+
+  // Iterate through main chunk children
+  offset = 6;
+  while (offset < mainSize) {
+    const [id, size] = readChunkHeader(view, offset);
+    const childEnd = offset + size;
+
+    if (id === CHUNK_EDIT) {
+      let editOffset = offset + 6;
+
+      while (editOffset < childEnd) {
+        const [editId, editSize] = readChunkHeader(view, editOffset);
+        const editChildEnd = editOffset + editSize;
+
+        if (editId === CHUNK_OBJECT) {
+          const [objName, nameLen] = readString(view, editOffset + 6);
+          let objOffset = editOffset + 6 + nameLen;
+
+          while (objOffset < editChildEnd) {
+            const [objSubId, objSubSize] = readChunkHeader(view, objOffset);
+            const objSubEnd = objOffset + objSubSize;
+
+            if (objSubId === CHUNK_TRIMESH) {
+              const mesh = parseTriMesh(view, objOffset + 6, objSubEnd, objName);
+              meshes.push(mesh);
+            }
+
+            objOffset = objSubEnd;
+          }
+        } else if (editId === CHUNK_MATERIAL) {
+          const mat = parseMaterial(view, editOffset + 6, editChildEnd);
+          materials.push(mat);
+        }
+
+        editOffset = editChildEnd;
+      }
+    }
+
+    offset = childEnd;
+  }
+
+  // Convert to ModelData
+  const modelMeshes: MeshData[] = meshes.map((m) => ({
+    vertices: m.vertices,
+    indices: m.indices,
+    vertexCount: m.vertexCount,
+    indexCount: m.indexCount,
+    uvs: m.uvs,
+    colors: null,
+  }));
+
+  const modelMaterials: MaterialData[] | undefined = materials.length > 0
+    ? materials.map((m) => ({
+        name: m.name,
+        baseColor: [m.diffuseColor[0], m.diffuseColor[1], m.diffuseColor[2], 1],
+        metallic: 0,
+        roughness: m.shininess > 0 ? Math.max(0.05, 1 - m.shininess / 100) : 1,
+        textureUri: m.textureFile,
+      }))
+    : undefined;
+
+  return {
+    meshes: modelMeshes,
+    name,
+    format: "3ds",
+    materials: modelMaterials,
+  };
+}