ldr 0.3.0 → 0.4.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { parse, parseColor, isDirectColor, mul, I as IDENTITY, norm, smoothNormals, parseTexMap, texmapUV, texmapTriangleUV, transformTexMap, resolveTexture } from "./spec.js";
-export type { M as Matrix12, Doc, LFile, Cmd, RotStep, BufExchg, TexMap, TexMapCmd, TexMapMethod, TexAnno, DataBlock, PartMesh } from "./spec.js";
+export { parse, parseColor, isDirectColor, mul, I as IDENTITY, norm, smoothNormals, parseTexMap, texmapUV, texmapTriangleUV, transformTexMap, resolveTexture, fileKind, looseSteps, looseSource, looseFile, loosePartName, texWrapper, invert, hash32, colorToken, rotStepMatrix, stepViewMatrix, fileStepViews } from "./spec.js";
+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";

package/dist/index.js

@@ -6,6 +6,17 @@ function parseColor(tok) {
   return +tok;
 }
 var MOVED_RE = /^~?\s*moved\s+to\s+(.+)$/i;
+var SPECIAL0 = new Set(["FILE", "NOFILE", "!DATA", "!:", "STEP", "BFC", "ROTSTEP", "BUFEXCHG", "!TEXMAP"]);
+var PART_ORG = new Set(["part", "subpart", "primitive", "8_primitive", "48_primitive", "shortcut", "helper"]);
+var MODEL_ORG = new Set(["model", "submodel", "configuration"]);
+var ORG_RE = /^(?:!?LDRAW_ORG|Unofficial|Official\s+LCAD)\s+(\S+)/i;
+function orgType(text) {
+  const m = ORG_RE.exec(text);
+  if (!m)
+    return;
+  const t = m[1].toLowerCase().replace(/^unofficial_/, "");
+  return PART_ORG.has(t) || MODEL_ORG.has(t) ? t : undefined;
+}
 function texNames(rest) {
   const out = [];
   let i = 0;
@@ -91,7 +102,8 @@ function geomLine(tk) {
     return { t: 4, color, p: nums.slice(0, 12) };
   return { t: 5, color, p: nums.slice(0, 12) };
 }
-function parse(src, name = "main.ldr") {
+function parse(src, name = "main.ldr", popts = {}) {
+  const gtext = !!popts.geometryText;
   const files = new Map;
   let cur = null;
   let main = "";
@@ -107,6 +119,7 @@ function parse(src, name = "main.ldr") {
     (data ??= new Map).set(norm(dataCur.name), { name: dataCur.name, bytes, ...png ? { mime: "image/png" } : {} });
     dataCur = null;
   };
+  let inHeader = true;
   const start = (n) => {
     closeData();
     cur = { name: norm(n), cmds: [] };
@@ -115,6 +128,7 @@ function parse(src, name = "main.ldr") {
       main = cur.name;
     texStack = [];
     texNext = null;
+    inHeader = true;
   };
   let skip = false, sawBlock = false;
   const firstBlock = () => {
@@ -144,6 +158,53 @@ function parse(src, name = "main.ldr") {
     const line = raw.trim();
     if (!line)
       continue;
+    if (gtext && line.charCodeAt(0) >= 50 && line.charCodeAt(0) <= 53 && (line.charCodeAt(1) === 32 || line.charCodeAt(1) === 9)) {
+      if (dataCur || skip)
+        continue;
+      if (!cur)
+        start(name);
+      const sp = line.slice(2).trimStart();
+      const e = sp.search(/\s/);
+      const g = { t: line.charCodeAt(0) - 48, color: parseColor(e < 0 ? sp : sp.slice(0, e)), p: [], src: line };
+      annotate(g, false);
+      cur.cmds.push(g);
+      inHeader = false;
+      continue;
+    }
+    if (line.charCodeAt(0) === 48 && (line.charCodeAt(1) === 32 || line.charCodeAt(1) === 9)) {
+      let a = 2;
+      while (line.charCodeAt(a) === 32 || line.charCodeAt(a) === 9)
+        a++;
+      let b = a;
+      while (b < line.length && line.charCodeAt(b) !== 32 && line.charCodeAt(b) !== 9)
+        b++;
+      const kw = line.slice(a, b);
+      if (!SPECIAL0.has(kw)) {
+        if (skip || dataCur)
+          continue;
+        if (!cur)
+          start(name);
+        const text = line.slice(a);
+        const c = { t: 0, text };
+        if (kw.charCodeAt(0) === 33)
+          c.meta = kw;
+        texNext = null;
+        if (inHeader && !cur.org) {
+          const o = orgType(text);
+          if (o)
+            cur.org = o;
+        }
+        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;
+      }
+    }
     const tk = line.split(/\s+/);
     const t = +tk[0];
     if (t === 0) {
@@ -186,6 +247,9 @@ function parse(src, name = "main.ldr") {
         c.bfc = tk.slice(2).join(" ");
       else if (tk[1] === "ROTSTEP") {
         c.meta = "ROTSTEP";
+        c.step = true;
+        texStack = [];
+        texNext = null;
         if ((tk[2] ?? "").toUpperCase() === "END")
           c.rotstep = { x: 0, y: 0, z: 0, mode: "END" };
         else {
@@ -198,6 +262,11 @@ function parse(src, name = "main.ldr") {
         c.bufexchg = { op: op === "RETRIEVE" ? "RETRIEVE" : "STORE", buf: tk[3] ?? "A" };
       } else if (tk[1]?.startsWith("!"))
         c.meta = tk[1];
+      if (inHeader && !cur.org) {
+        const o = orgType(text);
+        if (o)
+          cur.org = o;
+      }
       if (tk[1] === "!TEXMAP") {
         const op = (tk[2] ?? "").toUpperCase();
         texNext = null;
@@ -248,6 +317,7 @@ function parse(src, name = "main.ldr") {
       continue;
     annotate(g, false);
     cur.cmds.push(g);
+    inHeader = false;
   }
   closeData();
   return data ? { main, files, data } : { main, files };
@@ -427,34 +497,249 @@ function smoothNormals(pos, edges, cond, creaseDeg = 35) {
   }
   return out;
 }
+var kindMemo = new WeakMap;
+var SUBREF_RE = /^(s|8|48)\//;
+function fileKind(doc, name) {
+  const f = doc.files.get(norm(name));
+  if (!f)
+    return "part";
+  let k = kindMemo.get(f);
+  if (k)
+    return k;
+  if (f.org)
+    k = PART_ORG.has(f.org) ? "part" : "model";
+  else if (f.name === doc.main)
+    k = "model";
+  else
+    k = f.cmds.some((c) => c.t >= 2 || c.t === 0 && !!c.geom || c.t === 1 && SUBREF_RE.test(c.file)) ? "part" : "model";
+  kindMemo.set(f, k);
+  return k;
+}
+var looseMemo = new WeakMap;
+function looseSteps(f) {
+  let r = looseMemo.get(f);
+  if (r)
+    return r;
+  r = [];
+  let s = 0;
+  for (const c of f.cmds) {
+    if (c.t === 0 && c.step) {
+      s++;
+      continue;
+    }
+    if ((c.t >= 2 || c.t === 0 && c.geom && c.geom.t >= 2) && r[r.length - 1] !== s)
+      r.push(s);
+  }
+  looseMemo.set(f, r);
+  return r;
+}
+var colorToken = (c) => c > 16777215 ? "0x" + c.toString(16).toUpperCase() : String(c);
+var lineOf = (c) => c.t === 0 ? "0 " + c.text : c.t === 1 ? `1 ${colorToken(c.color)} ${c.m.join(" ")} ${c.file}` : c.src ? c.src : `${c.t} ${colorToken(c.color)} ${c.p.join(" ")}`;
+var loosePartName = (file, step) => `${norm(file)}#${step}`;
+function looseFile(f, step) {
+  const out = [];
+  let s = 0;
+  const isNext = (c) => !!c && c.t === 0 && c.texmap?.op === "NEXT";
+  for (const c of f.cmds) {
+    if (c.t === 0) {
+      if (c.step) {
+        s++;
+        continue;
+      }
+      if (c.bfc !== undefined) {
+        out.push(c);
+        continue;
+      }
+      if (s !== step)
+        continue;
+      if (c.texmap)
+        out.push(c);
+      else if (c.geom) {
+        if (c.geom.t >= 2)
+          out.push(c);
+        else if (isNext(out[out.length - 1]))
+          out.pop();
+      }
+      continue;
+    }
+    if (s !== step)
+      continue;
+    if (c.t === 1) {
+      if (isNext(out[out.length - 1]))
+        out.pop();
+      continue;
+    }
+    out.push(c);
+  }
+  return { name: loosePartName(f.name, step), cmds: out };
+}
+function looseSource(f, step) {
+  return [`0 ldr: own geometry of ${f.name}, step ${step}`, ...looseFile(f, step).cmds.map(lineOf)].join(`
+`) + `
+`;
+}
+function hash32(s) {
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function invert(m) {
+  const [x, y, z, a, b, c, d, e, f, g, h, i] = m;
+  const A = e * i - f * h, B = -(d * i - f * g), C = d * h - e * g;
+  const det = a * A + b * B + c * C;
+  if (!Number.isFinite(det) || Math.abs(det) < 0.000000000001)
+    return null;
+  const k = 1 / det;
+  const r = [A * k, -(b * i - c * h) * k, (b * f - c * e) * k, B * k, (a * i - c * g) * k, -(a * f - c * d) * k, C * k, -(a * h - b * g) * k, (a * e - b * d) * k];
+  return [-(r[0] * x + r[1] * y + r[2] * z), -(r[3] * x + r[4] * y + r[5] * z), -(r[6] * x + r[7] * y + r[8] * z), ...r];
+}
+var num = (x) => String(+x.toFixed(6) || 0);
+var quote = (s) => '"' + s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"") + '"';
+function texWrapper(part, map) {
+  const v = [...map.p1, ...map.p2, ...map.p3, ...map.method !== "PLANAR" ? [map.a ?? 360] : [], ...map.method === "SPHERICAL" ? [map.b ?? 180] : []].map(num).join(" ");
+  const source = `0 ldr: ${part} with a model-level !TEXMAP
+0 BFC CERTIFY CCW
+0 !TEXMAP START ${map.method} ${v} ${quote(map.texture)}${map.glossmap ? " GLOSSMAP " + quote(map.glossmap) : ""}
+1 16 0 0 0 1 0 0 0 1 0 0 0 1 ${norm(part)}
+0 !TEXMAP END
+`;
+  return { name: `${norm(part)}#tex-${hash32(source)}`, source };
+}
+var mul3 = (a, b) => {
+  const r = new Array(9);
+  for (let i = 0;i < 3; i++)
+    for (let j = 0;j < 3; j++)
+      r[i * 3 + j] = a[i * 3] * b[j] + a[i * 3 + 1] * b[3 + j] + a[i * 3 + 2] * b[6 + j];
+  return r;
+};
+function rotStepMatrix(x, y, z) {
+  const D = Math.PI / 180, s1 = Math.sin(x * D), c1 = Math.cos(x * D), s2 = Math.sin(y * D), c2 = Math.cos(y * D), s3 = Math.sin(z * D), c3 = Math.cos(z * D);
+  return [c2 * c3, -c2 * s3, s2, c1 * s3 + s1 * s2 * c3, c1 * c3 - s1 * s2 * s3, -s1 * c2, s1 * s3 - c1 * s2 * c3, s1 * c3 + c1 * s2 * s3, c1 * c2];
+}
+function stepViewMatrix(view, defaultView = [1, 0, 0, 0, 1, 0, 0, 0, 1]) {
+  return !view ? [...defaultView] : view.abs ? [...view.m] : mul3(defaultView, view.m);
+}
+var viewMemo = new WeakMap;
+function fileStepViews(f) {
+  const hit = viewMemo.get(f);
+  if (hit)
+    return hit;
+  const out = [];
+  let cur = null;
+  for (const c of f.cmds) {
+    if (c.t !== 0 || !c.step)
+      continue;
+    const r = c.rotstep;
+    if (r) {
+      if (r.mode === "END")
+        cur = null;
+      else {
+        const R = rotStepMatrix(r.x, r.y, r.z);
+        cur = r.mode === "ABS" ? { abs: true, m: R, rotstep: r } : r.mode === "ADD" && cur ? { abs: cur.abs, m: mul3(cur.m, R), rotstep: r } : { abs: false, m: R, rotstep: r };
+      }
+    }
+    out.push(cur);
+  }
+  out.push(cur);
+  viewMemo.set(f, out);
+  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 loose = opts.looseGeometry !== false, tx = !!opts.textures;
+  const src = new Map;
+  const lazy = (f, k) => {
+    const key = f.name + "#" + k;
+    let fn = src.get(key);
+    if (!fn) {
+      let s;
+      fn = Object.assign(() => s ??= looseSource(f, k), { file: f, step: k });
+      src.set(key, fn);
+    }
+    return fn;
+  };
+  const walk = (d, fname, m, color, path, stepPath, depth, texIn) => {
     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)
+    const views = fileStepViews(f);
+    const ls = loose ? looseSteps(f) : [];
+    let li = 0;
+    const emit = (part, col, mm, sp, k, embedded, tex) => {
+      const i = { part, color: col, m: mm, step: sp[0], steps: sp, localStep: k, path };
+      if (embedded)
+        i.embedded = true;
+      if (tex) {
+        const w = texWrapper(part, tex);
+        i.texPart = w.name;
+        i.texSource = w.source;
+      }
+      const v = views[k];
+      if (v)
+        i.view = v;
+      out.push(i);
+      return i;
+    };
+    const flushLoose = (upTo) => {
+      while (li < ls.length && ls[li] <= upTo) {
+        const k = ls[li++];
+        emit(loosePartName(f.name, k), color, m, [...stepPath, k], k, false, null).source = lazy(f, k);
+      }
+    };
+    for (const c0 of f.cmds) {
+      if (c0.t === 0 && c0.step) {
         s++;
+        continue;
+      }
+      let c = c0;
+      if (c.t >= 2 || c.t === 0 && c.geom && c.geom.t >= 2) {
+        flushLoose(s);
+        continue;
+      }
+      if (c.t === 0) {
+        if (tx && c.geom?.t === 1)
+          c = c.geom;
+        else
+          continue;
+      }
       if (c.t !== 1)
         continue;
+      if (tx && c.fallback)
+        continue;
       const col = c.color === 16 ? color : c.color, mm = mul(m, c.m), sp = [...stepPath, s];
+      const tex = tx ? c.tex ?? texIn : null;
+      const local = tex ? invert(c.m) : null;
+      const lt = tex && local ? transformTexMap(tex, local) : null;
       if (d.files.has(c.file)) {
-        walk(d, c.file, mm, col, path + "/" + c.file, sp, depth + 1);
+        if (fileKind(d, c.file) === "model") {
+          walk(d, c.file, mm, col, path + "/" + c.file, sp, depth + 1, lt);
+          continue;
+        }
+        emit(c.file, col, mm, sp, s, true, lt);
         continue;
       }
       const ext = opts.resolveModel?.(c.file);
       if (ext) {
-        walk(ext, ext.main, mm, col, path + "/" + c.file, sp, depth + 1);
+        walk(ext, ext.main, mm, col, path + "/" + c.file, sp, depth + 1, lt);
         continue;
       }
-      out.push({ part: c.file, color: col, m: mm, step: sp[0], steps: sp, path });
+      emit(c.file, col, mm, sp, s, false, lt);
     }
+    flushLoose(Infinity);
   };
-  walk(doc, doc.main, I, 16, doc.main, [], 0);
+  if (fileKind(doc, doc.main) === "part") {
+    const f = doc.files.get(doc.main);
+    if (f)
+      out.push({ part: doc.main, color: 16, m: [...I], step: 0, steps: [0], localStep: 0, path: doc.main, embedded: true });
+    return out;
+  }
+  walk(doc, doc.main, I, 16, doc.main, [], 0, null);
   return out;
 }
 function parseModel(text, name = "main.ldr", opts) {
@@ -465,8 +750,14 @@ function sequenceSteps(insts) {
   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 };
+  const views = new Array(uniq.length).fill(null);
+  insts.forEach((i, k) => {
+    const r = rank.get(key(i));
+    stepOf[k] = r;
+    if (i.view)
+      views[r] = i.view;
+  });
+  return { count: uniq.length, stepOf, views };
 }
 function parseLDConfig(text) {
   const out = new Map;
@@ -830,7 +1121,7 @@ function buildLdrScene(insts, pack, P, color, mark) {
   mark("culling");
   const edgeObjs = [];
   const condObjs = [];
-  const wantCond = P.cond !== false && P.edges === "idx";
+  const wantCond = P.cond !== false && (P.edges === "idx" || P.edges === true);
   let condMat = null;
   const cmat = () => condMat ??= condLineMat();
   const condCache = new Map;
@@ -1098,11 +1389,18 @@ function toPlastic(old) {
 function createLdrObject(instances, pack, options = {}) {
   const o = { edges: true, conditionalLines: 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 useTex = o.textures !== false;
+  const pick = (i) => useTex && i.texPart && pack.header.parts[i.texPart] ? i.texPart : i.part;
+  const all = instances.map((i) => ({ part: pick(i), 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 stepViews = new Array(uniq.length).fill(null);
+  instances.forEach((i, k) => {
+    if (i.view)
+      stepViews[stepOf[k]] = i.view;
+  });
   const missing = [...new Set(all.filter((i) => !pack.header.parts[i.part]).map((i) => i.part))];
   const object = new THREE2.Group;
   object.name = "ldr";
@@ -1160,6 +1458,7 @@ function createLdrObject(instances, pack, options = {}) {
     object,
     stats,
     stepCount: uniq.length,
+    stepViews,
     setStep: (s) => build(s),
     setEdges: (v) => {
       edges = v;
@@ -1211,6 +1510,7 @@ async function decompressPack(data) {
 export {
   I as IDENTITY,
   buildLdrScene,
+  colorToken,
   computeCulling,
   conditionalLineVisible,
   conditionalLines,
@@ -1219,9 +1519,17 @@ export {
   createLdrObject,
   decodePack,
   decompressPack,
+  fileKind,
+  fileStepViews,
   flatten,
+  hash32,
+  invert,
   isDirectColor,
   loadPack,
+  looseFile,
+  loosePartName,
+  looseSource,
+  looseSteps,
   makeMaterial,
   mul,
   norm,
@@ -1231,8 +1539,11 @@ export {
   parseModel,
   parseTexMap,
   resolveTexture,
+  rotStepMatrix,
   sequenceSteps,
   smoothNormals,
+  stepViewMatrix,
+  texWrapper,
   texmapTriangleUV,
   texmapUV,
   transformTexMap

package/dist/model.d.ts

@@ -1,4 +1,4 @@
-import { parse, norm, type Doc, type M } from "./spec.js";
+import { parse, norm, type Doc, type M, type LFile, type StepView } from "./spec.js";
 /** A placed part. `color` is an LDraw colour code (or direct colour 0x2RRGGBB); `m` is the 12-number LDraw matrix `x y z a b c d e f g h i`. */
 export interface PartInstance {
     part: string;
@@ -8,28 +8,55 @@ export interface PartInstance {
     step: number;
     /** Step path through nested submodels, e.g. [3, 1] = top step 3, submodel step 1. */
     steps: number[];
+    /** Step within the file that places this instance (the last entry of `steps`). */
+    localStep: number;
     /** Submodel path, e.g. "main.ldr/wheel.ldr". */
     path: string;
+    /** The part is defined inside the document (an MPD-embedded part, see `fileKind`), not taken from the library. */
+    embedded?: boolean;
+    /** Set for synthetic parts (a model file's own type 2-5 lines, named `<file>#<step>`): returns the part's LDraw source
+     *  (`source.file` / `source.step` give the model file and step, see `looseFile`). */
+    source?: (() => string) & {
+        file?: LFile;
+        step?: number;
+    };
+    /** Only with `flatten(doc, { textures: true })`: the part is wrapped by a model-level `!TEXMAP`. `texPart` names the synthetic
+     *  textured part (`<part>#tex-<hash>`, in packs built with `textures: true`) and `texSource` is its LDraw source; `part` stays the plain part. */
+    texPart?: string;
+    texSource?: string;
+    /** View rotation of this instance's step from `0 ROTSTEP` (absent = default view). See `fileStepViews`. */
+    view?: StepView;
 }
 export interface FlattenOptions {
     /** Resolve an external reference that is not a submodel of this document (e.g. a model file you loaded separately). Return null to treat it as a part. */
     resolveModel?: (name: string) => Doc | null;
     /** Max submodel nesting (cycle guard). Default 64. */
     maxDepth?: number;
+    /** Emit a model file's own type 2-5 lines as synthetic parts `<file>#<step>` (LDraw allows geometry in any file). Default true. */
+    looseGeometry?: boolean;
+    /** TEXMAP-aware view of the model: references wrapped by a model-level `!TEXMAP` get `texPart`, `0 !:` type-1 lines are
+     *  included and `!TEXMAP FALLBACK` references are skipped. Use with packs built with `textures: true`. Default false. */
+    textures?: boolean;
 }
-/** Flatten a parsed LDraw document into part instances. Submodels (`0 FILE` blocks in an MPD) are expanded; everything else is treated as a part. */
+/**
+ * Flatten a parsed LDraw document into part instances. Model files (`0 FILE` blocks in an MPD that `fileKind` calls models) are
+ * expanded; MPD-embedded parts and library references become instances. A model file's own geometry becomes synthetic parts.
+ */
 export declare function flatten(doc: Doc, opts?: FlattenOptions): PartInstance[];
 /** Parse LDraw text (.ldr/.mpd/.dat) and flatten it in one call. */
 export declare function parseModel(text: string, name?: string, opts?: FlattenOptions): PartInstance[];
 /**
  * Assign each instance a global sequential build-step index, ordering by the full nested step path
- * (so submodel steps become their own steps). Returns the number of steps.
+ * (so submodel steps become their own steps). Returns the number of steps and, per global step, its ROTSTEP view
+ * (null = default view; the view of the innermost file's step, see `fileStepViews`).
  */
 export declare function sequenceSteps<T extends {
     steps: number[];
+    view?: StepView;
 }>(insts: T[]): {
     count: number;
     stepOf: Int32Array;
+    views: (StepView | null)[];
 };
 /** Colour table entry. */
 export interface LDrawColor {

package/dist/node/build-pack.d.ts

@@ -22,6 +22,9 @@ export interface BuildPackOptions {
     /** Keep textured (`!TEXMAP`) parts' TEXMAP-aware geometry + UVs and embed their PNGs (pack v2 "tex"). Off by default;
      *  packs without textured parts are byte-identical either way. Textures resolve from model `!DATA` blocks, then `textures/` in the library. */
     textures?: boolean;
+    /** Render a model file's own type 2-5 lines (as synthetic parts `<file>#<step>`). Default true (LDraw allows geometry in any file);
+     *  false reproduces packs from ldr <= 0.2.0, which dropped it. */
+    looseGeometry?: boolean;
     /** Embed the LDConfig colour table (code → hex) in the pack header. Default true. */
     colors?: boolean;
     onProgress?: (done: number, total: number) => void;
@@ -31,5 +34,7 @@ export interface BuildPackResult {
     parts: number;
     studKinds: number;
     missing: string[];
+    /** e.g. two models embedding different files under the same name (the first one is used). */
+    warnings?: string[];
 }
 export declare function buildPack(o: BuildPackOptions): BuildPackResult;