ldr 0.0.0-alpha.1 → 0.2.0

package/dist/index.js

@@ -0,0 +1,717 @@
+// src/spec.ts
+var norm = (s) => s.trim().toLowerCase().replace(/\\/g, "/").replace(/\/+/g, "/");
+function parseColor(tok) {
+  if (/^0x/i.test(tok))
+    return parseInt(tok, 16);
+  return +tok;
+}
+var MOVED_RE = /^~?\s*moved\s+to\s+(.+)$/i;
+function parse(src, name = "main.ldr") {
+  const files = new Map;
+  let cur = null;
+  let main = "";
+  const start = (n) => {
+    cur = { name: norm(n), cmds: [] };
+    files.set(cur.name, cur);
+    if (!main)
+      main = cur.name;
+  };
+  for (const raw of src.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    const tk = line.split(/\s+/);
+    const t = +tk[0];
+    if (t === 0) {
+      const text = line.slice(1).trim();
+      if (tk[1] === "FILE") {
+        start(text.slice(5));
+        continue;
+      }
+      if (tk[1] === "NOFILE") {
+        cur = null;
+        continue;
+      }
+      if (!cur)
+        start(name);
+      const c = { t: 0, text };
+      if (tk[1] === "STEP")
+        c.step = true;
+      else if (tk[1] === "BFC")
+        c.bfc = tk.slice(2).join(" ");
+      else if (tk[1] === "ROTSTEP") {
+        c.meta = "ROTSTEP";
+        if ((tk[2] ?? "").toUpperCase() === "END")
+          c.rotstep = { x: 0, y: 0, z: 0, mode: "END" };
+        else {
+          const mode = (tk[5] ?? "REL").toUpperCase();
+          c.rotstep = { x: +tk[2] || 0, y: +tk[3] || 0, z: +tk[4] || 0, mode: ["REL", "ABS", "ADD"].includes(mode) ? mode : "REL" };
+        }
+      } else if (tk[1] === "BUFEXCHG") {
+        c.meta = "BUFEXCHG";
+        const op = (tk[2] ?? "").toUpperCase();
+        c.bufexchg = { op: op === "RETRIEVE" ? "RETRIEVE" : "STORE", buf: tk[3] ?? "A" };
+      } else if (tk[1]?.startsWith("!"))
+        c.meta = tk[1];
+      const moved = text.match(MOVED_RE);
+      if (moved && !cur.movedTo) {
+        let target = moved[1].trim().replace(/\\/g, "/");
+        if (!/\.(dat|ldr|mpd)$/i.test(target))
+          target += ".dat";
+        cur.movedTo = norm(target);
+      }
+      cur.cmds.push(c);
+      continue;
+    }
+    if (!cur)
+      start(name);
+    const color = parseColor(tk[1]);
+    const nums = tk.slice(2).map(Number);
+    if (t === 1)
+      cur.cmds.push({ t: 1, color, m: nums.slice(0, 12), file: norm(tk.slice(14).join(" ")) });
+    else if (t === 2)
+      cur.cmds.push({ t: 2, color, p: nums.slice(0, 6) });
+    else if (t === 3)
+      cur.cmds.push({ t: 3, color, p: nums.slice(0, 9) });
+    else if (t === 4)
+      cur.cmds.push({ t: 4, color, p: nums.slice(0, 12) });
+    else if (t === 5)
+      cur.cmds.push({ t: 5, color, p: nums.slice(0, 12) });
+  }
+  return { main, files };
+}
+function mul(a, b) {
+  const [ax, ay, az, a0, a1, a2, a3, a4, a5, a6, a7, a8] = a, [bx, by, bz, b0, b1, b2, b3, b4, b5, b6, b7, b8] = b;
+  return [
+    a0 * bx + a1 * by + a2 * bz + ax,
+    a3 * bx + a4 * by + a5 * bz + ay,
+    a6 * bx + a7 * by + a8 * bz + az,
+    a0 * b0 + a1 * b3 + a2 * b6,
+    a0 * b1 + a1 * b4 + a2 * b7,
+    a0 * b2 + a1 * b5 + a2 * b8,
+    a3 * b0 + a4 * b3 + a5 * b6,
+    a3 * b1 + a4 * b4 + a5 * b7,
+    a3 * b2 + a4 * b5 + a5 * b8,
+    a6 * b0 + a7 * b3 + a8 * b6,
+    a6 * b1 + a7 * b4 + a8 * b7,
+    a6 * b2 + a7 * b5 + a8 * b8
+  ];
+}
+var I = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1];
+var isDirectColor = (c) => c > 16777215;
+function smoothNormals(pos, edges, cond, creaseDeg = 35) {
+  const q = (i, a) => `${a[i].toFixed(2)},${a[i + 1].toFixed(2)},${a[i + 2].toFixed(2)}`;
+  const ek = (a, b) => a < b ? a + "|" + b : b + "|" + a;
+  const hard = new Set, soft = new Set;
+  for (let i = 0;i < edges.length; i += 6)
+    hard.add(ek(q(i, edges), q(i + 3, edges)));
+  const stride = cond.length > 0 && cond.length % 12 === 0 ? 12 : 6;
+  for (let i = 0;i < cond.length; i += stride)
+    soft.add(ek(q(i, cond), q(i + 3, cond)));
+  const nT = pos.length / 9, fn = [], vk = [];
+  for (let t = 0;t < nT; t++) {
+    const a = t * 9;
+    const u = [pos[a + 3] - pos[a], pos[a + 4] - pos[a + 1], pos[a + 5] - pos[a + 2]], v = [pos[a + 6] - pos[a], pos[a + 7] - pos[a + 1], pos[a + 8] - pos[a + 2]];
+    const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+    const l = Math.hypot(...n) || 1;
+    fn.push(n.map((x) => x / l));
+    for (let k = 0;k < 3; k++)
+      vk.push(q(a + k * 3, pos));
+  }
+  const byV = new Map;
+  vk.forEach((k, i) => (byV.get(k) ?? byV.set(k, []).get(k)).push(i));
+  const edgeFaces = new Map;
+  for (let t = 0;t < nT; t++)
+    for (let k = 0;k < 3; k++) {
+      const e = ek(vk[t * 3 + k], vk[t * 3 + (k + 1) % 3]);
+      (edgeFaces.get(e) ?? edgeFaces.set(e, []).get(e)).push(t);
+    }
+  const cosC = Math.cos(creaseDeg * Math.PI / 180), out = new Float32Array(pos.length);
+  const joinable = (e, a, b) => {
+    if (hard.has(e))
+      return false;
+    const d = fn[a][0] * fn[b][0] + fn[a][1] * fn[b][1] + fn[a][2] * fn[b][2];
+    return soft.has(e) ? d > -0.2 : d > cosC;
+  };
+  for (const [key, corners] of byV) {
+    const faces = corners.map((c) => c / 3 | 0), par = faces.map((_, i) => i);
+    const f = (i) => par[i] === i ? i : par[i] = f(par[i]);
+    for (let i = 0;i < faces.length; i++)
+      for (let j = i + 1;j < faces.length; j++) {
+        const A = faces[i], B = faces[j];
+        const va = [0, 1, 2].map((k) => vk[A * 3 + k]), vb = new Set([0, 1, 2].map((k) => vk[B * 3 + k]));
+        for (const o of va)
+          if (o !== key && vb.has(o)) {
+            const e = ek(key, o);
+            if ((edgeFaces.get(e)?.length ?? 0) >= 2 && joinable(e, A, B))
+              par[f(i)] = f(j);
+          }
+      }
+    const acc = new Map;
+    faces.forEach((F, i) => {
+      const r = f(i), s = acc.get(r) ?? [0, 0, 0];
+      s[0] += fn[F][0];
+      s[1] += fn[F][1];
+      s[2] += fn[F][2];
+      acc.set(r, s);
+    });
+    corners.forEach((c, i) => {
+      const s = acc.get(f(i)), l = Math.hypot(...s) || 1;
+      out[c * 3] = s[0] / l;
+      out[c * 3 + 1] = s[1] / l;
+      out[c * 3 + 2] = s[2] / l;
+    });
+  }
+  return out;
+}
+// src/model.ts
+function flatten(doc, opts = {}) {
+  const out = [];
+  const maxDepth = opts.maxDepth ?? 64;
+  const walk = (d, fname, m, color, path, stepPath, depth) => {
+    const f = d.files.get(fname);
+    if (!f || depth > maxDepth)
+      return;
+    let s = 0;
+    for (const c of f.cmds) {
+      if (c.t === 0 && c.step)
+        s++;
+      if (c.t !== 1)
+        continue;
+      const col = c.color === 16 ? color : c.color, mm = mul(m, c.m), sp = [...stepPath, s];
+      if (d.files.has(c.file)) {
+        walk(d, c.file, mm, col, path + "/" + c.file, sp, depth + 1);
+        continue;
+      }
+      const ext = opts.resolveModel?.(c.file);
+      if (ext) {
+        walk(ext, ext.main, mm, col, path + "/" + c.file, sp, depth + 1);
+        continue;
+      }
+      out.push({ part: c.file, color: col, m: mm, step: sp[0], steps: sp, path });
+    }
+  };
+  walk(doc, doc.main, I, 16, doc.main, [], 0);
+  return out;
+}
+function parseModel(text, name = "main.ldr", opts) {
+  return flatten(parse(text, name), opts);
+}
+function sequenceSteps(insts) {
+  const key = (i) => i.steps.map((x) => String(x).padStart(6, "0")).join(".");
+  const uniq = [...new Set(insts.map(key))].sort();
+  const rank = new Map(uniq.map((k, j) => [k, j]));
+  const stepOf = new Int32Array(insts.length);
+  insts.forEach((i, k) => stepOf[k] = rank.get(key(i)));
+  return { count: uniq.length, stepOf };
+}
+function parseLDConfig(text) {
+  const out = new Map;
+  for (const l of text.split(/\r?\n/)) {
+    const m = /!COLOUR\s+(\S+)\s+CODE\s+(\d+)\s+VALUE\s+(#[0-9A-Fa-f]{6})\s+EDGE\s+(\S+)(?:.*?ALPHA\s+(\d+))?/.exec(l);
+    if (m)
+      out.set(+m[2], { code: +m[2], name: m[1], hex: m[3].toUpperCase(), edge: m[4], alpha: m[5] ? +m[5] : 255 });
+  }
+  return out;
+}
+// src/render.ts
+import * as THREE from "three";
+async function loadPack(url) {
+  const res = await fetch(url);
+  const t0 = performance.now();
+  let buf;
+  if (url.endsWith(".gz"))
+    buf = await new Response(res.body.pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
+  else if (url.endsWith(".br"))
+    buf = await new Response(res.body.pipeThrough(new DecompressionStream("brotli"))).arrayBuffer();
+  else if (url.endsWith(".zst")) {
+    const raw = new Uint8Array(await res.arrayBuffer());
+    const t1 = performance.now();
+    const { decompress } = await import("fzstd");
+    const o = decompress(raw);
+    buf = o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength);
+    globalThis.__decodeMs = performance.now() - t1;
+  } else
+    buf = await res.arrayBuffer();
+  if (!url.endsWith(".zst"))
+    globalThis.__decodeMs = performance.now() - t0;
+  return decodePack(buf);
+}
+function decodePack(buf) {
+  const hl = new DataView(buf).getUint32(0, true);
+  const header = JSON.parse(new TextDecoder().decode(new Uint8Array(buf, 4, hl)));
+  const base = 4 + hl;
+  const arr = (r) => r && (r[2] === "f32" ? new Float32Array(buf, base + r[0], r[1]) : r[2] === "u16" ? new Uint16Array(buf, base + r[0], r[1]) : new Uint32Array(buf, base + r[0], r[1]));
+  return { header, arr, bytes: buf.byteLength };
+}
+function geom(b, arr) {
+  if (!b)
+    return null;
+  const g = new THREE.BufferGeometry;
+  g.setAttribute("position", new THREE.BufferAttribute(arr(b.pos), 3));
+  g.setAttribute("normal", new THREE.BufferAttribute(arr(b.nrm), 3));
+  g.setAttribute("ldrColor", new THREE.BufferAttribute(arr(b.col), 4));
+  if (b.idx)
+    g.setIndex(new THREE.BufferAttribute(arr(b.idx), 1));
+  return g;
+}
+function makeMaterial(side) {
+  const m = new THREE.MeshStandardMaterial({ vertexColors: true, roughness: 0.45, side });
+  m.onBeforeCompile = (s) => {
+    s.vertexShader = `attribute vec4 ldrColor;
+` + s.vertexShader.replace("#include <color_vertex>", `#ifdef USE_INSTANCING_COLOR
+ vColor = vec4(ldrColor.a > 0.5 ? pow(ldrColor.rgb, vec3(2.2)) : instanceColor.rgb, 1.0); // baked LDConfig colours are sRGB
+#else
+ vColor = vec4(pow(ldrColor.rgb, vec3(2.2)), 1.0);
+#endif`);
+  };
+  m.customProgramCacheKey = () => "ldrColor";
+  return m;
+}
+var lineMat = () => new THREE.ShaderMaterial({
+  vertexShader: `attribute vec4 im0; attribute vec4 im1; attribute vec4 im2; attribute vec4 im3;
+    void main(){ gl_Position = projectionMatrix * modelViewMatrix * mat4(im0,im1,im2,im3) * vec4(position,1.0); }`,
+  fragmentShader: `void main(){ gl_FragColor = vec4(0.13,0.13,0.13,1.0); }`
+});
+var sharedLineMat = () => new THREE.ShaderMaterial({
+  vertexShader: `attribute mat4 instanceMatrix; void main(){ gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4(position,1.0); }`,
+  fragmentShader: `void main(){ gl_FragColor = vec4(0.13,0.13,0.13,1.0); }`
+});
+var weldLines = (pos) => {
+  const map = new Map;
+  const P = [];
+  const I = [];
+  for (let i = 0;i < pos.length; i += 3) {
+    const k = pos[i].toFixed(2) + "," + pos[i + 1].toFixed(2) + "," + pos[i + 2].toFixed(2);
+    let j = map.get(k);
+    if (j === undefined) {
+      j = P.length / 3;
+      map.set(k, j);
+      P.push(pos[i], pos[i + 1], pos[i + 2]);
+    }
+    I.push(j);
+  }
+  return { P: new Float32Array(P), I: P.length / 3 < 65536 ? new Uint16Array(I) : new Uint32Array(I) };
+};
+function createInstancedEdges(pos, im, material = sharedLineMat()) {
+  return sharedLines(pos, im, material);
+}
+function sharedLines(pos, im, material = sharedLineMat()) {
+  const { P, I } = weldLines(pos);
+  const g = new THREE.InstancedBufferGeometry;
+  g.setAttribute("position", new THREE.BufferAttribute(P, 3));
+  g.setIndex(new THREE.BufferAttribute(I, 1));
+  g.setAttribute("instanceMatrix", im.instanceMatrix);
+  g.instanceCount = im.count;
+  const l = new THREE.LineSegments(g, material);
+  l.frustumCulled = false;
+  return l;
+}
+function instancedLines(pos, mats, count) {
+  const g = new THREE.InstancedBufferGeometry;
+  g.setAttribute("position", new THREE.BufferAttribute(pos, 3));
+  const ib = new THREE.InstancedInterleavedBuffer(mats, 16);
+  for (let i = 0;i < 4; i++)
+    g.setAttribute("im" + i, new THREE.InterleavedBufferAttribute(ib, 4, i * 4));
+  g.instanceCount = count;
+  const l = new THREE.LineSegments(g, lineMat());
+  l.frustumCulled = false;
+  return l;
+}
+var toM4 = (m, o = 0) => new THREE.Matrix4().set(m[o + 3], m[o + 4], m[o + 5], m[o], m[o + 6], m[o + 7], m[o + 8], m[o + 1], m[o + 9], m[o + 10], m[o + 11], m[o + 2], 0, 0, 0, 1);
+var mul12 = (a, b) => {
+  const r = (i, j) => a[3 + i * 3] * b[3 + j] + a[4 + i * 3] * b[6 + j] + a[5 + i * 3] * b[9 + j];
+  return [a[0] + a[3] * b[0] + a[4] * b[1] + a[5] * b[2], a[1] + a[6] * b[0] + a[7] * b[1] + a[8] * b[2], a[2] + a[9] * b[0] + a[10] * b[1] + a[11] * b[2], r(0, 0), r(0, 1), r(0, 2), r(1, 0), r(1, 1), r(1, 2), r(2, 0), r(2, 1), r(2, 2)];
+};
+function computeCulling(insts, H) {
+  const upright = (m) => Math.abs(m[7] - 1) < 0.001 && Math.abs(m[4]) < 0.001 && Math.abs(m[10]) < 0.001;
+  const CELL = 40;
+  const rects = new Map;
+  const lk = (y) => Math.round(y * 2) / 2;
+  insts.forEach((it, idx) => {
+    const p = H.parts[it.part];
+    if (!p || !p.mask || !upright(it.m))
+      return;
+    const b = p.bbox;
+    const xs = [], zs = [];
+    for (const x of [b[0], b[3]])
+      for (const z of [b[2], b[5]]) {
+        const w = [it.m[0] + it.m[3] * x + it.m[5] * z, it.m[2] + it.m[9] * x + it.m[11] * z];
+        xs.push(w[0]);
+        zs.push(w[1]);
+      }
+    const r = [Math.min(...xs), Math.max(...xs), Math.min(...zs), Math.max(...zs), idx];
+    const lv = lk(it.m[1] + b[4]);
+    for (let cx = Math.floor(r[0] / CELL);cx <= Math.floor(r[1] / CELL); cx++)
+      for (let cz = Math.floor(r[2] / CELL);cz <= Math.floor(r[3] / CELL); cz++) {
+        const k = lv + "|" + cx + "|" + cz;
+        (rects.get(k) || rects.set(k, []).get(k)).push(r);
+      }
+  });
+  const covered = (x, y, z, self) => {
+    const list = rects.get(lk(y) + "|" + Math.floor(x / CELL) + "|" + Math.floor(z / CELL));
+    if (!list)
+      return false;
+    for (const r of list) {
+      if (r[4] === self || !(x - 6 >= r[0] - 0.5 && x + 6 <= r[1] + 0.5 && z - 6 >= r[2] - 0.5 && z + 6 <= r[3] + 0.5))
+        continue;
+      const it = insts[r[4]];
+      const p = H.parts[it.part];
+      const m = it.m;
+      const dx = x - m[0], dy = y - m[1], dz = z - m[2];
+      const lx = m[3] * dx + m[6] * dy + m[9] * dz, lz = m[5] * dx + m[8] * dy + m[11] * dz;
+      const [nx, nz, bits] = p.mask;
+      let ok = true;
+      for (const [ox, oz] of [[0, 0], [5, 5], [-5, 5], [5, -5], [-5, -5]]) {
+        const ca = Math.floor((lx + ox - p.bbox[0]) / 20), cb = Math.floor((lz + oz - p.bbox[2]) / 20);
+        if (ca < 0 || cb < 0 || ca >= nx || cb >= nz || bits[ca * nz + cb] !== "1") {
+          ok = false;
+          break;
+        }
+      }
+      if (ok)
+        return true;
+    }
+    return false;
+  };
+  const studs = [];
+  const studTops = new Set;
+  const key3 = (x, y, z) => `${Math.round(x)},${Math.round(y)},${Math.round(z)}`;
+  insts.forEach((it, idx) => {
+    const p = H.parts[it.part];
+    if (!p)
+      return;
+    for (const s of p.studs) {
+      const w = mul12(it.m, s.slice(2));
+      const color = s[1] === "16" ? it.color : s[1];
+      const up = upright(w);
+      studs.push({ kind: s[0], color, w, hidden: up && covered(w[0], w[1], w[2], idx) });
+      if (up)
+        studTops.add(key3(w[0], w[1], w[2]));
+    }
+  });
+  const underHidden = insts.map((it) => {
+    const p = H.parts[it.part];
+    if (!p || !p.under || !upright(it.m))
+      return false;
+    const b = p.bbox;
+    const nx = Math.round((b[3] - b[0]) / 20), nz = Math.round((b[5] - b[2]) / 20);
+    if (!nx || !nz || nx * nz > 4096)
+      return false;
+    for (let a = 0;a < nx; a++)
+      for (let c = 0;c < nz; c++) {
+        const lx = b[0] + 10 + 20 * a, lz = b[2] + 10 + 20 * c;
+        const x = it.m[0] + it.m[3] * lx + it.m[5] * lz, z = it.m[2] + it.m[9] * lx + it.m[11] * lz;
+        if (!studTops.has(key3(x, it.m[1] + b[4], z)))
+          return false;
+      }
+    return true;
+  });
+  return { studs, underHidden };
+}
+function buildLdrScene(insts, pack, P, color, mark) {
+  const { header: H, arr } = pack;
+  const root = new THREE.Group;
+  const matF = makeMaterial(P.side === "front" ? THREE.FrontSide : THREE.DoubleSide), matB = makeMaterial(P.side === "front" ? THREE.BackSide : THREE.DoubleSide);
+  const matD = makeMaterial(THREE.DoubleSide);
+  let nUncert = 0;
+  const det = (m) => m[3] * (m[7] * m[11] - m[8] * m[10]) - m[4] * (m[6] * m[11] - m[8] * m[9]) + m[5] * (m[6] * m[10] - m[7] * m[9]);
+  const byPart = new Map;
+  insts.forEach((it, i) => {
+    if (H.parts[it.part]) {
+      const k = it.part + (det(it.m) < 0 ? "#m" : "");
+      (byPart.get(k) || byPart.set(k, []).get(k)).push(i);
+    }
+  });
+  const cull = computeCulling(insts, H);
+  mark("culling");
+  const edgeObjs = [];
+  const stats = { studsTotal: cull.studs.length, studsHidden: cull.studs.filter((s) => s.hidden).length, undersTotal: 0, undersHidden: 0 };
+  const toggles = [];
+  const studMeshes = [];
+  for (const [pk, ids] of byPart) {
+    const part = pk.replace(/#m$/, "");
+    const p = H.parts[part];
+    const mat = P.uncertDouble !== false && p.uncert ? (nUncert++, matD) : pk.endsWith("#m") ? matB : matF;
+    const body = geom(p.body, arr);
+    let bodyIm = null;
+    if (body) {
+      const im = bodyIm = new THREE.InstancedMesh(body, mat, ids.length);
+      ids.forEach((id, k) => {
+        im.setMatrixAt(k, toM4(insts[id].m));
+        im.setColorAt(k, color(insts[id].color));
+      });
+      im.computeBoundingSphere();
+      root.add(im);
+    }
+    if (P.edges === "idx" && p.edges && bodyIm) {
+      const l = sharedLines(arr(p.edges), bodyIm);
+      edgeObjs.push(l);
+      root.add(l);
+    }
+    const under = geom(p.under, arr);
+    if (under) {
+      const ord = [...ids.filter((i) => !cull.underHidden[i]), ...ids.filter((i) => cull.underHidden[i])];
+      const vis = ids.filter((i) => !cull.underHidden[i]).length;
+      stats.undersTotal += ids.length;
+      stats.undersHidden += ids.length - vis;
+      const im = new THREE.InstancedMesh(under, mat, ids.length);
+      ord.forEach((id, k) => {
+        im.setMatrixAt(k, toM4(insts[id].m));
+        im.setColorAt(k, color(insts[id].color));
+      });
+      im.computeBoundingSphere();
+      im.count = P.cullUnder ? vis : ids.length;
+      root.add(im);
+      toggles.push({ mesh: im, all: ids.length, visible: vis, flag: "under" });
+    }
+    if (P.edges === true && p.edges) {
+      const mats = new Float32Array(ids.length * 16);
+      ids.forEach((id, k) => toM4(insts[id].m).toArray(mats, k * 16));
+      {
+        const l = instancedLines(arr(p.edges), mats, ids.length);
+        edgeObjs.push(l);
+        root.add(l);
+      }
+    }
+  }
+  const byKind = new Map;
+  for (const s of cull.studs) {
+    const k = s.kind + (det(s.w) < 0 ? "#m" : "");
+    (byKind.get(k) || byKind.set(k, []).get(k)).push(s);
+  }
+  for (const [kk, list] of byKind) {
+    const kind = kk.replace(/#m$/, "");
+    const mat = kk.endsWith("#m") ? matB : matF;
+    const k = H.studKinds[kind];
+    const g = geom(k.body, arr);
+    if (!g)
+      continue;
+    const ord = [...list.filter((s) => !s.hidden), ...list.filter((s) => s.hidden)];
+    const vis = list.filter((s) => !s.hidden).length;
+    const im = new THREE.InstancedMesh(g, mat, ord.length);
+    ord.forEach((s, i) => {
+      im.setMatrixAt(i, toM4(s.w));
+      im.setColorAt(i, color(s.color));
+    });
+    im.computeBoundingSphere();
+    im.count = P.cullStuds ? vis : ord.length;
+    root.add(im);
+    toggles.push({ mesh: im, all: ord.length, visible: vis, flag: "studs" });
+    studMeshes.push({ im, kind });
+    if (P.edges === "idx" && k.edges) {
+      const l = sharedLines(arr(k.edges), im);
+      edgeObjs.push(l);
+      root.add(l);
+      toggles.push({ mesh: { set count(n) {
+        l.geometry.instanceCount = n;
+      } }, all: ord.length, visible: vis, flag: "studs" });
+      l.geometry.instanceCount = im.count;
+    }
+    if (P.edges === true && k.edges) {
+      const mats = new Float32Array(ord.length * 16);
+      ord.forEach((s, i) => toM4(s.w).toArray(mats, i * 16));
+      const l = instancedLines(arr(k.edges), mats, P.cullStuds ? vis : ord.length);
+      edgeObjs.push(l);
+      root.add(l);
+      toggles.push({ mesh: { set count(n) {
+        l.geometry.instanceCount = n;
+      } }, all: ord.length, visible: vis, flag: "studs" });
+    }
+  }
+  stats.uncertParts = Object.values(H.parts).filter((x) => x.uncert).length;
+  stats.uncertBatches = nUncert;
+  const setEdges = (v) => edgeObjs.forEach((o) => o.visible = v);
+  const setCull = (studs, under) => {
+    for (const t of toggles)
+      t.mesh.count = (t.flag === "studs" ? studs : under) ? t.visible : t.all;
+  };
+  const box = new THREE.Box3;
+  for (const it of insts) {
+    const p = H.parts[it.part];
+    if (!p)
+      continue;
+    box.expandByPoint(new THREE.Vector3(it.m[0], it.m[1], it.m[2]));
+  }
+  const setSide = (front) => {
+    matF.side = front ? THREE.FrontSide : THREE.DoubleSide;
+    matB.side = front ? THREE.BackSide : THREE.DoubleSide;
+    matF.needsUpdate = matB.needsUpdate = true;
+  };
+  const swapStuds = (alt) => {
+    const saved = studMeshes.map((s) => s.im.geometry);
+    for (const s of studMeshes) {
+      const k2 = alt.header.studKinds[s.kind] ? s.kind : Object.keys(alt.header.studKinds).find((k) => k.replace("p/8/", "p/") === s.kind.replace("p/8/", "p/"));
+      if (k2)
+        s.im.geometry = geom(alt.header.studKinds[k2].body, alt.arr);
+    }
+    return () => studMeshes.forEach((s, i) => s.im.geometry = saved[i]);
+  };
+  return { root, stats, setCull, setSide, setEdges, swapStuds, box };
+}
+// src/scene.ts
+import * as THREE2 from "three";
+function colorFn(src, pack, fallback) {
+  const table = new Map;
+  const put = (k, v) => table.set(String(k), new THREE2.Color(typeof v === "string" ? v : v.hex));
+  if (typeof src === "function") {
+    return (c) => {
+      let col = table.get(c);
+      if (!col) {
+        const v = src(+c);
+        col = v === undefined ? direct(c) ?? fallback : new THREE2.Color(v);
+        table.set(c, col);
+      }
+      return col;
+    };
+  }
+  const base = src ?? pack.header.colors ?? {};
+  if (base instanceof Map)
+    for (const [k, v] of base)
+      put(k, v);
+  else
+    for (const k in base)
+      put(k, base[k]);
+  return (c) => table.get(c) ?? direct(c) ?? fallback;
+}
+var direct = (c) => {
+  const n = +c;
+  return n > 16777215 && n >>> 24 === 2 ? new THREE2.Color(n & 16777215) : null;
+};
+var plasticCache = new WeakMap;
+function toPlastic(old) {
+  let m = plasticCache.get(old);
+  if (!m) {
+    const p = new THREE2.MeshPhysicalMaterial({ vertexColors: true, roughness: 0.3, clearcoat: 0.3, clearcoatRoughness: 0.2, specularIntensity: 0.6, side: old.side });
+    p.onBeforeCompile = old.onBeforeCompile;
+    p.customProgramCacheKey = () => "ldrColorPhys" + old.side;
+    plasticCache.set(old, m = p);
+  }
+  return m;
+}
+function createLdrObject(instances, pack, options = {}) {
+  const o = { edges: true, cullStuds: true, cullUndersides: true, side: "front", material: "plastic", ...options };
+  const color = colorFn(o.colors, pack, new THREE2.Color(o.fallbackColor ?? 10528169));
+  const all = instances.map((i) => ({ part: i.part, color: String(i.color), m: i.m, steps: i.steps }));
+  const key = (i) => i.steps.map((x) => String(x).padStart(6, "0")).join(".");
+  const uniq = [...new Set(all.map(key))].sort();
+  const rank = new Map(uniq.map((k, j) => [k, j]));
+  const stepOf = all.map((i) => rank.get(key(i)));
+  const missing = [...new Set(all.filter((i) => !pack.header.parts[i.part]).map((i) => i.part))];
+  const object = new THREE2.Group;
+  object.name = "ldr";
+  if (!o.ldrawSpace)
+    object.rotation.x = Math.PI;
+  if (o.scale && o.scale !== 1)
+    object.scale.setScalar(o.scale);
+  const pairs = new Map;
+  let cur = null;
+  let { edges, cullStuds: cs, cullUndersides: cu, side } = o;
+  const stats = { instances: all.length, drawn: 0, missing, studsTotal: 0, studsHidden: 0, undersTotal: 0, undersHidden: 0, buildMs: 0 };
+  const disposeCur = () => {
+    if (!cur)
+      return;
+    object.remove(cur.root);
+    const mats = new Set;
+    cur.root.traverse((x) => {
+      x.geometry?.dispose?.();
+      if (x.material)
+        mats.add(x.material);
+      if (x.dispose && x.isInstancedMesh)
+        x.dispose();
+    });
+    for (const m of mats)
+      m.dispose();
+    for (const old of pairs.values())
+      old.dispose();
+    cur = null;
+  };
+  const build = (step) => {
+    const t0 = performance.now();
+    disposeCur();
+    const insts = step == null ? all : all.filter((_, k) => stepOf[k] <= step);
+    cur = buildLdrScene(insts, pack, { pack: "", cullStuds: cs, cullUnder: cu, edges: edges ? "idx" : false, side }, color, () => {});
+    pairs.clear();
+    if (o.material === "plastic")
+      cur.root.traverse((x) => {
+        if (x.isMesh && x.material?.isMeshStandardMaterial) {
+          const old = x.material;
+          x.material = toPlastic(old);
+          pairs.set(x.material, old);
+        }
+      });
+    if (!edges)
+      cur.setEdges(false);
+    object.add(cur.root);
+    Object.assign(stats, { drawn: insts.filter((i) => pack.header.parts[i.part]).length, studsTotal: cur.stats.studsTotal, studsHidden: cur.stats.studsHidden, undersTotal: cur.stats.undersTotal, undersHidden: cur.stats.undersHidden, buildMs: performance.now() - t0 });
+  };
+  build(o.step ?? null);
+  return {
+    object,
+    stats,
+    stepCount: uniq.length,
+    setStep: (s) => build(s),
+    setEdges: (v) => {
+      edges = v;
+      cur.setEdges(v);
+    },
+    setCulling: (a, b) => {
+      cs = a;
+      cu = b;
+      cur.setCull(a, b);
+    },
+    setSide: (s) => {
+      side = s;
+      cur.setSide(s === "front");
+      for (const [p, old] of pairs) {
+        p.side = old.side;
+        p.needsUpdate = true;
+      }
+    },
+    getBox: (target = new THREE2.Box3) => {
+      object.updateMatrixWorld(true);
+      target.makeEmpty();
+      object.traverse((x) => {
+        if (x.isInstancedMesh && x.count) {
+          x.computeBoundingBox();
+          const b = x.boundingBox.clone().applyMatrix4(x.matrixWorld);
+          target.union(b);
+        }
+      });
+      return target;
+    },
+    dispose: disposeCur
+  };
+}
+// src/pack-io.ts
+import { decompress } from "fzstd";
+async function decompressPack(data) {
+  const u = data instanceof Uint8Array ? data : new Uint8Array(data);
+  const own = (o) => o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength);
+  if (u[0] === 40 && u[1] === 181 && u[2] === 47 && u[3] === 253)
+    return own(decompress(u));
+  if (u[0] === 31 && u[1] === 139)
+    return new Response(new Blob([u]).stream().pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
+  return own(u);
+}
+export {
+  I as IDENTITY,
+  buildLdrScene,
+  computeCulling,
+  createInstancedEdges,
+  createLdrObject,
+  decodePack,
+  decompressPack,
+  flatten,
+  isDirectColor,
+  loadPack,
+  makeMaterial,
+  mul,
+  norm,
+  parse,
+  parseColor,
+  parseLDConfig,
+  parseModel,
+  sequenceSteps,
+  smoothNormals
+};