ldr 0.27.2 → 0.28.0

package/dist/node/low-detail.d.ts

@@ -3,18 +3,50 @@ import type { Compiler, Compiled } from "./compile.js";
 export declare const LOW_DETAIL_STEPS: readonly (readonly [err: number, ratio: number])[];
 /** Raster size of the see-through gate (per view). */
 export declare const LOW_DETAIL_RES = 128;
-/** Simplify a stride-9 triangle soup with rgba-per-vertex colours, welding and simplifying each colour separately. */
-export declare function simplifyBody(pos: ArrayLike<number>, col: ArrayLike<number>, err: number, ratio: number, lockBorder?: boolean): {
+/** Seam closing tolerance (LDU) for `closeSeams`: well under a pixel at any phone zoom (1 LDU = 0.4 mm). */
+export declare const SEAM_EPS = 0.01;
+/** Steps for the seam-closed candidates: caps up to 0.5 LDU only, more finely spaced. Coarser, with the borders closed the simplifier
+ *  collapses across thin walls (pin slits, beam ends) and folds them: still closed, so the see-through gate passes it, but visibly crumpled. */
+export declare const SEAM_STEPS: readonly (readonly [err: number, ratio: number])[];
+type Group = {
+    c: number[];
+    idx: Uint32Array;
+    pos: Float32Array;
+};
+/** A stride-9 triangle soup with rgba-per-vertex colours, welded per colour (one indexed mesh each), optionally with `closeSeams` applied. */
+export declare function weldBody(pos: ArrayLike<number>, col: ArrayLike<number>, seams?: boolean): Group[];
+/** Simplify welded colour groups (`weldBody`) at absolute error cap `err` (LDU) and target triangle fraction `ratio`; back to a stride-9 soup. */
+export declare function simplifyGroups(groups: Group[], err: number, ratio: number, lockBorder?: boolean): {
+    pos: number[];
+    col: number[];
+};
+/** Simplify a stride-9 triangle soup with rgba-per-vertex colours, welding and simplifying each colour separately (`seams`: close its seams first). */
+export declare function simplifyBody(pos: ArrayLike<number>, col: ArrayLike<number>, err: number, ratio: number, lockBorder?: boolean, seams?: boolean): {
     pos: number[];
     col: number[];
 };
+/** Candidate name: `s<cap>`, `L` = locked borders, `S` = seams closed first (`closeSeams`, Round 54). */
+export type LowDetailLevel = `s${number}` | `s${number}L` | `s${number}S` | `s${number}LS`;
 export interface LowDetailResult {
     compiled: Compiled;
-    level: "full" | `s${number}` | `s${number}L`;
+    level: "full" | LowDetailLevel;
     fullTris: number;
     tris: number;
     fullSee: number;
     see: number;
 }
-/** The phone-tier version of compiled part `c` (compiled by `comp`, whose stud kinds it places for the gate). Textured bodies stay full. */
-export declare function lowDetail(comp: Compiler, c: Compiled): LowDetailResult;
+/** The phone-tier version of compiled part `c`. `comp` compiles (or looks up) its stud kinds, placed for the gate. Textured bodies stay full. */
+export declare function lowDetail(comp: Compiler | ((kind: string) => Compiled), c: Compiled, o?: {
+    seams?: boolean;
+}): LowDetailResult;
+/** Round 54: close the cracks LDraw leaves between sub-files before simplifying (one colour's welded mesh, indexed). LDraw parts join
+ *  primitives to hand-placed geometry with coordinates a few thousandths of an LDU apart (pins: 3.061 vs 3.062) and with T-junctions
+ *  (a vertex of one side lying inside an edge of the other). The simplifier sees both as open borders. Here (1) boundary vertices within
+ *  `eps` of an earlier boundary vertex snap to it (greedy, in index order; interior vertices never move) and triangles that collapse are
+ *  dropped, then (2) every open edge with boundary vertices lying on it (within `eps`, not at its ends) is split there, the triangle
+ *  re-triangulated (fan from the opposite corner; a centroid fan when more than one edge splits). Deterministic. */
+export declare function closeSeams(idx: ArrayLike<number>, p: number[], eps?: number): {
+    idx: Uint32Array;
+    pos: number[];
+};
+export {};

package/dist/node/see-through.d.ts

@@ -1,8 +1,9 @@
 import type { Compiler, Compiled } from "./compile.js";
 /** Part-space triangles (stride 9) of a compiled part with its separated studs placed: everything a viewer draws for it. */
 export declare function partTris(c: Compiler, key: string): number[];
-/** `partTris` of an already compiled part, optionally with `body` (stride-9 positions) drawn instead of its own body. */
-export declare function placedTris(c: Compiler, out: Compiled, body?: ArrayLike<number>): number[];
+/** `partTris` of an already compiled part, optionally with `body` (stride-9 positions) drawn instead of its own body. `c` compiles the
+ *  stud kinds (or is a lookup of already compiled ones). */
+export declare function placedTris(c: Compiler | ((kind: string) => Compiled), out: Compiled, body?: ArrayLike<number>): number[];
 /** { see, cover }: pixels covered by triangles of one orientation only (see-through when back faces are culled), and covered pixels,
  *  summed over 42 orthographic views at `res`² each, the part's bounding sphere filling the view. With `limit`, stops after the first
  *  view that takes `see` past it (`see` is then only known to exceed `limit`; `cover` is partial). */

package/dist/spec.d.ts

@@ -209,9 +209,10 @@ export declare const colorToken: (c: number) => string;
 /** Name of the synthetic part holding a model file's own geometry in local step `step`: `<file>#<step>`. */
 export declare const loosePartName: (file: string, step: number) => string;
 /**
- * The synthetic part for a model file's own type 2-5 lines in local step `step`, as a file: every `0 BFC` line of the file
- * (winding / certification state, in order), the step's `!TEXMAP` and `0 !:` lines, and the step's type 2-5 lines. Type-1 lines
- * are dropped (they are instances), together with a `!TEXMAP NEXT` that applied to one. Commands are shared with `f`.
+ * The synthetic part for a model file's own type 2-5 lines in local step `step`, as a file: every `0 BFC` and `0 !COLOUR` line of
+ * the file (winding / certification state and the file's own colour definitions, in order), the step's `!TEXMAP` and `0 !:` lines,
+ * and the step's type 2-5 lines. Type-1 lines are dropped (they are instances), together with a `!TEXMAP NEXT` that applied to one.
+ * Commands are shared with `f`.
  */
 export declare function looseFile(f: LFile, step: number): LFile;
 /** LDraw source text of `looseFile(f, step)`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldr",
-  "version": "0.27.2",
+  "version": "0.28.0",
   "description": "High-performance LEGO (LDraw) rendering for three.js: instanced parts packs, hidden stud/tube culling, low-detail studs, indexed edges, build steps.",
   "license": "MIT",
   "author": "Evan Bacon",