ldr 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 
-// src/cli.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/cli.ts
 import fs4 from "node:fs";
 import zlib from "node:zlib";
 
-// src/node/build-pack.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/node/build-pack.ts
 import fs3 from "node:fs";
 import path3 from "node:path";
 
-// src/node/resolver.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/node/resolver.ts
 import fs from "node:fs";
 import path from "node:path";
 
-// src/spec.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/spec.ts
 var norm = (s) => s.trim().toLowerCase().replace(/\\/g, "/").replace(/\/+/g, "/");
 function parseColor(tok) {
   if (/^0x/i.test(tok))
@@ -662,7 +662,7 @@ function fileStepViews(f) {
   return out;
 }
 
-// src/model.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/model.ts
 function flatten(doc, opts = {}) {
   const out = [];
   const maxDepth = opts.maxDepth ?? 64;
@@ -784,7 +784,7 @@ function parseLDConfig(text) {
   return out;
 }
 
-// src/node/resolver.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/node/resolver.ts
 var TOP_STUD_RE = /^(stud|studa|stud2|stud2a|stud6|stud6a|stud10|stud15|stud2s|stud2s2|stud-logo\d*|stud2-logo\d*)\.dat$/i;
 var UNDER_STUD_RE = /^(stud3|stud3a|stud4.*|stud12|stud16.*|stud18a)\.dat$/i;
 var norm2 = (ref) => ref.trim().replace(/\\/g, "/").toLowerCase();
@@ -1054,9 +1054,118 @@ function collectDeps(lib, refs) {
   return out;
 }
 
-// src/node/compile.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/node/compile.ts
 import fs2 from "node:fs";
 import path2 from "node:path";
+
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/node/lod.ts
+import { MeshoptSimplifier, MeshoptEncoder } from "meshoptimizer";
+await Promise.all([MeshoptSimplifier.ready, MeshoptEncoder.ready]);
+function reorderMesh(P, N, C, I) {
+  const idx = Uint32Array.from(I);
+  const n = P.length / 3;
+  const [remap] = MeshoptEncoder.reorderMesh(idx, true, false);
+  const P2 = new Float32Array(P.length), N2 = new Float32Array(N.length), C2 = new Float32Array(C.length);
+  for (let v = 0;v < n; v++) {
+    const r = remap[v];
+    if (r === 4294967295)
+      continue;
+    P2[r * 3] = P[v * 3];
+    P2[r * 3 + 1] = P[v * 3 + 1];
+    P2[r * 3 + 2] = P[v * 3 + 2];
+    N2[r * 3] = N[v * 3];
+    N2[r * 3 + 1] = N[v * 3 + 1];
+    N2[r * 3 + 2] = N[v * 3 + 2];
+    for (let k = 0;k < 4; k++)
+      C2[r * 4 + k] = C[v * 4 + k];
+  }
+  return { P: P2, N: N2, C: C2, I: idx };
+}
+var TARGETS = [0.25, 0.08];
+var MIN_TRIS = 64;
+function flatMesh(tris) {
+  const map = new Map;
+  const P = [], N = [], C = [], I = [];
+  for (const { p, i: idx, col } of tris)
+    for (let t = 0;t < idx.length; t += 3) {
+      const a = idx[t] * 3, b = idx[t + 1] * 3, c = idx[t + 2] * 3;
+      const ux = p[b] - p[a], uy = p[b + 1] - p[a + 1], uz = p[b + 2] - p[a + 2], vx = p[c] - p[a], vy = p[c + 1] - p[a + 1], vz = p[c + 2] - p[a + 2];
+      let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+      const l = Math.hypot(nx, ny, nz);
+      if (!(l > 0.000000001))
+        continue;
+      nx /= l;
+      ny /= l;
+      nz /= l;
+      for (const o of [a, b, c]) {
+        const k = `${p[o].toFixed(3)},${p[o + 1].toFixed(3)},${p[o + 2].toFixed(3)},${nx.toFixed(3)},${ny.toFixed(3)},${nz.toFixed(3)},${col.join()}`;
+        let j = map.get(k);
+        if (j === undefined) {
+          j = P.length / 3;
+          map.set(k, j);
+          P.push(p[o], p[o + 1], p[o + 2]);
+          N.push(nx, ny, nz);
+          C.push(...col);
+        }
+        I.push(j);
+      }
+    }
+  return { P: new Float32Array(P), N: new Float32Array(N), C: new Float32Array(C), I: new Uint32Array(I) };
+}
+function lodChain(P, C, I) {
+  const nTris = I.length / 3;
+  if (nTris < MIN_TRIS)
+    return [];
+  const groups = new Map;
+  for (let t = 0;t < I.length; t += 3) {
+    const v = I[t] * 4;
+    const col = [C[v], C[v + 1], C[v + 2], C[v + 3]];
+    const k = col.join();
+    let g = groups.get(k);
+    if (!g)
+      groups.set(k, g = { col, tri: [] });
+    g.tri.push(I[t], I[t + 1], I[t + 2]);
+  }
+  const welded = [...groups.values()].map(({ col, tri }) => {
+    const map = new Map;
+    const pos = [];
+    const idx = new Uint32Array(tri.length);
+    for (let i = 0;i < tri.length; i++) {
+      const o = tri[i] * 3;
+      const k = `${P[o].toFixed(3)},${P[o + 1].toFixed(3)},${P[o + 2].toFixed(3)}`;
+      let j = map.get(k);
+      if (j === undefined) {
+        j = pos.length / 3;
+        map.set(k, j);
+        pos.push(P[o], P[o + 1], P[o + 2]);
+      }
+      idx[i] = j;
+    }
+    return { col, p: new Float32Array(pos), i: idx };
+  });
+  const out = [];
+  let prevTris = nTris;
+  for (let li = 0;li < TARGETS.length; li++) {
+    let err = 0;
+    const parts = [];
+    for (const g of welded) {
+      const target = Math.max(3, Math.floor(g.i.length * TARGETS[li] / 3) * 3);
+      const [idx, e] = MeshoptSimplifier.simplify(g.i, g.p, 3, target, 1e9, li ? ["ErrorAbsolute", "Prune"] : ["ErrorAbsolute"]);
+      err = Math.max(err, e);
+      if (idx.length)
+        parts.push({ p: g.p, i: idx, col: g.col });
+    }
+    const m = flatMesh(parts);
+    const t = m.I.length / 3;
+    if (t > prevTris * 0.7 || !t)
+      continue;
+    out.push({ ...m, err: +Math.max(err, 0.001).toFixed(3) });
+    prevTris = t;
+  }
+  return out;
+}
+
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/node/compile.ts
 function loadColors(root) {
   const map = new Map;
   for (const l of fs2.readFileSync(path2.join(root, "LDConfig.ldr"), "latin1").split(/\r?\n/)) {
@@ -1473,7 +1582,8 @@ function encodePack(parts, studKinds, weld, extra, options = {}) {
     return r;
   };
   let lastPos = [];
-  const bucket = (b) => {
+  let anyLod = false;
+  const bucket = (b, lod = false) => {
     const n = b.pos.length / 3;
     lastPos = [];
     if (!n)
@@ -1512,9 +1622,20 @@ function encodePack(parts, studKinds, weld, extra, options = {}) {
       }
       I.push(j);
     }
-    const vcount = P.length / 3;
-    lastPos = P;
-    return { pos: put(new Float32Array(P)), nrm: put(new Float32Array(N)), col: put(new Float32Array(C)), idx: put(vcount < 65536 ? new Uint16Array(I) : new Uint32Array(I)), tris: n / 3 };
+    let m = { P, N, C, I };
+    if (options.reorder && I.length >= 3)
+      m = reorderMesh(P, N, C, I);
+    const vcount = m.P.length / 3;
+    lastPos = m.P;
+    const out = { pos: put(Float32Array.from(m.P)), nrm: put(Float32Array.from(m.N)), col: put(Float32Array.from(m.C)), idx: put(vcount < 65536 ? Uint16Array.from(m.I) : Uint32Array.from(m.I)), tris: n / 3 };
+    if (lod && options.lod) {
+      const chain = lodChain(P, C, I).map((l) => options.reorder ? { ...l, ...reorderMesh(l.P, l.N, l.C, l.I) } : l);
+      if (chain.length) {
+        anyLod = true;
+        out.lod = chain.map((l) => ({ pos: put(l.P), col: put(Uint8Array.from(l.C, (x) => Math.round(x * 255))), idx: put(l.P.length / 3 < 65536 ? new Uint16Array(l.I) : l.I), tris: l.I.length / 3, err: l.err }));
+      }
+    }
+    return out;
   };
   let anyCond = false;
   const condl = (a, pools) => {
@@ -1605,18 +1726,18 @@ function encodePack(parts, studKinds, weld, extra, options = {}) {
     });
     return { tbody: bucket(c.tbody), tex };
   };
-  const enc = (c) => {
-    const body = bucket(c.body), bodyP = lastPos, under = bucket(c.under), underP = lastPos;
+  const enc = (c, lod = false) => {
+    const body = bucket(c.body, lod), bodyP = lastPos, under = bucket(c.under, lod), underP = lastPos;
     const edges = c.edges.length ? put(new Float32Array(c.edges)) : null;
     const condlB = condl(c.cond, [bodyP, underP, c.edges]), condlU = condl(c.condUnder, [bodyP, underP, c.edges]);
     return { body, under, edges, cond: c.condLines, condl: condlB, condlu: condlU, studs: c.studs.map((s) => [s.kind, s.color, ...s.m.map((x) => +x.toFixed(4))]), bbox: c.bbox, fullBottom: c.fullBottom, uncert: !!c.uncertified, mask: c.bottomMask ? [c.bottomMask.nx, c.bottomMask.nz, c.bottomMask.bits.join("")] : null, ...encTex(c) };
   };
-  const encParts = Object.fromEntries([...parts].map(([k, c]) => [k, enc(c)])), encKinds = Object.fromEntries([...studKinds].map(([k, c]) => [k, enc(c)]));
+  const encParts = Object.fromEntries([...parts].map(([k, c]) => [k, enc(c, true)])), encKinds = Object.fromEntries([...studKinds].map(([k, c]) => [k, enc(c)]));
   const textures = texNames.map((name) => {
     const b = options.texture?.(name);
     return b ? { name, mime: "image/png", data: put(b) } : { name, missing: true };
   });
-  const features = [...anyCond ? ["cond"] : [], ...texNames.length ? ["tex"] : []];
+  const features = [...anyCond ? ["cond"] : [], ...texNames.length ? ["tex"] : [], ...anyLod ? ["lod"] : []];
   const header = { version: features.length ? 2 : 1, ...features.length ? { features } : {}, weld, parts: encParts, studKinds: encKinds, ...texNames.length ? { textures } : {}, ...extra };
   const hj = new TextEncoder().encode(JSON.stringify(header));
   const hpad = (4 - (4 + hj.length) % 4) % 4;
@@ -1627,7 +1748,7 @@ function encodePack(parts, studKinds, weld, extra, options = {}) {
   return Buffer.concat([head, ...chunks.map((c) => new Uint8Array(c.buffer, c.byteOffset, c.byteLength))]);
 }
 
-// src/node/build-pack.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/node/build-pack.ts
 function buildPack(o) {
   const lib = new Library(o.ldrawRoot);
   const refs = new Map;
@@ -1687,10 +1808,10 @@ function buildPack(o) {
     return b ? new Uint8Array(Buffer.from(b, "base64")) : comp.texture(n);
   };
   const warnings = [...lib.conflicts].map((n) => `${n}: defined differently by two models; the first definition is used`);
-  return { data: encodePack(parts, kinds, comp.opts.weld, extra, { texture }), parts: parts.size, studKinds: kinds.size, missing: [...missing], ...warnings.length ? { warnings } : {} };
+  return { data: encodePack(parts, kinds, comp.opts.weld, extra, { texture, lod: o.lod !== false, reorder: !!o.reorder }), parts: parts.size, studKinds: kinds.size, missing: [...missing], ...warnings.length ? { warnings } : {} };
 }
 
-// src/cli.ts
+// ../../../../../../../tmp/ldr-build-qIdKSv/src/cli.ts
 var HELP = `ldr pack — build a parts pack for the ldr three.js renderer
 
 Usage:
@@ -1707,6 +1828,8 @@ Options:
   --cond              Keep conditional (type-5) lines for curved-surface outlines (pack v2, ~+8-14% zstd)
   --textures          Keep printed/sticker parts' !TEXMAP geometry + UVs and embed their PNGs (pack v2; packs without
                       textured parts are unchanged). Textures come from model !DATA blocks, then <ldraw>/parts/textures
+  --no-lod            Skip distance-LOD meshes (simplified bodies drawn only where their error is under a pixel)
+  --reorder           Reorder triangles/vertices for vertex-cache reuse (~-3% frame time without LOD, +1% size)
   --no-colors         Don't embed the LDConfig colour table
   --no-loose-geometry Skip a model file's own type 2-5 lines (drawn in the model, not in a part). By default they become
                       synthetic parts "<file>#<step>" so the model renders as the LDraw spec says
@@ -1729,6 +1852,8 @@ var all = false;
 var cond = false;
 var textures = false;
 var loose = true;
+var lod = true;
+var reorder = false;
 for (let i = 0;i < a.length; i++) {
   const k = a[i];
   const v = () => {
@@ -1761,6 +1886,10 @@ for (let i = 0;i < a.length; i++) {
     loose = false;
   else if (k === "--all-parts")
     all = true;
+  else if (k === "--no-lod")
+    lod = false;
+  else if (k === "--reorder")
+    reorder = true;
   else if (k.startsWith("-")) {
     console.error(`unknown option ${k}
 
@@ -1778,7 +1907,7 @@ if (!fs4.existsSync(ldraw + "/LDConfig.ldr")) {
   process.exit(1);
 }
 var t0 = performance.now();
-var r = buildPack({ ldrawRoot: ldraw, models, parts, allParts: all, studs, primitives: prims, weld, colors, cond, textures, looseGeometry: loose });
+var r = buildPack({ ldrawRoot: ldraw, models, parts, allParts: all, studs, primitives: prims, weld, colors, cond, textures, looseGeometry: loose, lod, reorder });
 var data = r.data;
 if (out.endsWith(".gz"))
   data = zlib.gzipSync(data, { level: 9 });

package/dist/index.d.ts

@@ -2,8 +2,10 @@ export { parse, parseColor, isDirectColor, mul, I as IDENTITY, norm, smoothNorma
 export type { M as Matrix12, Doc, LFile, Cmd, RotStep, BufExchg, TexMap, TexMapCmd, TexMapMethod, TexAnno, DataBlock, PartMesh, FileKind, StepView } from "./spec.js";
 export { flatten, parseModel, sequenceSteps, parseLDConfig } from "./model.js";
 export type { PartInstance, FlattenOptions, LDrawColor } from "./model.js";
-export { loadPack, decodePack, buildLdrScene, makeMaterial, createInstancedEdges, computeCulling, conditionalLines, createInstancedConditionalEdges, conditionalLineVisible } from "./render.js";
-export type { Pack, LdrParams, Inst } from "./render.js";
+export { loadPack, decodePack, buildLdrScene, makeMaterial, createInstancedEdges, computeCulling, cullCore, forEachStud, conditionalLines, createInstancedConditionalEdges, conditionalLineVisible } from "./render.js";
+export type { Pack, LdrParams, Inst, CullResult } from "./render.js";
 export { createLdrObject } from "./scene.js";
 export type { LdrObject, LdrObjectOptions, LdrStats, ColorSource } from "./scene.js";
 export { decompressPack } from "./pack-io.js";
+export { loadModel, loadParts, loadPartsIndex, mergePacks, DEFAULT_PARTS_CDN } from "./cdn.js";
+export type { LoadModelOptions, LoadedModel, LoadPartsOptions, PartsCdnIndex } from "./cdn.js";