Function parseOBJ

src/models/index.ts:64–126

(text: string)

// OBJ parser (pure TypeScript)
function parseOBJ(text: string): { vertices: number[]; indices: number[] } | null {
  const positions: number[][] = [];
  const normals: number[][] = [];
  const texcoords: number[][] = [];
  const vertexMap = new Map<string, number>();
  const vertices: number[] = [];
  const indices: number[] = [];
  let vertexCount = 0;

  const lines = text.split('\n');
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i].trim();
    if (line.length === 0 || line[0] === '#') continue;

    const parts = line.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) {
      texcoords.push([parseFloat(parts[1]), parseFloat(parts[2])]);
    } else if (cmd === 'f') {
      // Triangulate face (fan from first vertex)
      const faceIndices: number[] = [];
      for (let j = 1; j < parts.length; j++) {
        const key = parts[j];
        if (vertexMap.has(key)) {
          faceIndices.push(vertexMap.get(key)!);
        } else {
          const segs = key.split('/');
          const pi = parseInt(segs[0]) - 1;
          const ti = segs.length > 1 && segs[1] !== '' ? parseInt(segs[1]) - 1 : -1;
          const ni = segs.length > 2 ? parseInt(segs[2]) - 1 : -1;

          const pos = pi >= 0 && pi < positions.length ? positions[pi] : [0, 0, 0];
          const norm = ni >= 0 && ni < normals.length ? normals[ni] : [0, 1, 0];
          const uv = ti >= 0 && ti < texcoords.length ? texcoords[ti] : [0, 0];

          // Format: x,y,z, nx,ny,nz, r,g,b,a, u,v (12 floats per vertex)
          vertices.push(pos[0], pos[1], pos[2]);
          vertices.push(norm[0], norm[1], norm[2]);
          vertices.push(1, 1, 1, 1); // white color
          vertices.push(uv[0], uv[1]);

          const idx = vertexCount;
          vertexCount++;
          vertexMap.set(key, idx);
          faceIndices.push(idx);
        }
      }

      // Fan triangulation
      for (let j = 2; j < faceIndices.length; j++) {
        indices.push(faceIndices[0], faceIndices[j - 1], faceIndices[j]);
      }
    }