ldr 0.27.3 → 0.29.0

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

@@ -1,13 +1,16 @@
 import type { Compiler, Compiled } from "./compile.js";
-/** [absolute error cap (LDU), target triangle fraction]; each is tried with free and with locked borders. 2 LDU = a quarter of a plate's height. */
-export declare const LOW_DETAIL_STEPS: readonly (readonly [err: number, ratio: number])[];
-/** Raster size of the see-through gate (per view). */
+/** [absolute error cap (LDU), target triangle fraction]; each is tried with free and locked borders, as-is and seam-closed, and with
+ *  and without vertex updates. 2 LDU = a quarter of a plate's height. The fine steps matter: the shape gate is a threshold, and the
+ *  coarsest cap under it is what saves triangles (Round 57: with 6 caps instead of these 14, 42115 stays over the phone budget). */
+export declare const LOW_DETAIL_CAPS: readonly (readonly [err: number, ratio: number])[];
+/** Most shape error (shape-error.ts: fraction of pixels covered or shaded differently from full detail, 42 views) a phone-tier part may
+ *  have. 0.3 is about where the Round 51 tier's 2 LDU Technic beams already sat (22-30%): coarse up close (holes go polygonal), still
+ *  clearly the part. At 0.35-0.4 pins and axle pins turn into lumps (bench/results/r57-shots). */
+export declare const LOW_DETAIL_MAX_ERR = 0.3;
+/** Raster size of the see-through and shape gates (per view). */
 export declare const LOW_DETAIL_RES = 128;
 /** 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;
@@ -15,8 +18,10 @@ type Group = {
 };
 /** 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): {
+/** Simplify welded colour groups (`weldBody`) at absolute error cap `err` (LDU) and target triangle fraction `ratio`; back to a stride-9 soup.
+ *  `update` (Round 57): `simplifyWithUpdate`, which also moves the kept vertices to fit the original surface (on a copy).
+ *  `regularize` (Round 57): meshoptimizer's `Regularize`, which favours even-sized triangles over slivers. */
+export declare function simplifyGroups(groups: Group[], err: number, ratio: number, lockBorder?: boolean, update?: boolean, regularize?: boolean): {
     pos: number[];
     col: number[];
 };
@@ -25,8 +30,8 @@ export declare function simplifyBody(pos: ArrayLike<number>, col: ArrayLike<numb
     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`;
+/** Candidate name: `s<cap>`, `L` = locked borders, `S` = seams closed first (`closeSeams`, Round 54), `U` = vertices updated, `R` = regularized (Round 57). */
+export type LowDetailLevel = `s${number}${"" | "L"}${"" | "S"}${"" | "U"}${"" | "R"}`;
 export interface LowDetailResult {
     compiled: Compiled;
     level: "full" | LowDetailLevel;
@@ -34,10 +39,17 @@ export interface LowDetailResult {
     tris: number;
     fullSee: number;
     see: number;
+    shapeErr: number;
 }
-/** The phone-tier version of compiled part `c`. `comp` compiles (or looks up) its stud kinds, placed for the gate. Textured bodies stay full. */
+/** The phone-tier version of compiled part `c`. `comp` compiles (or looks up) its stud kinds, placed for the gates. Textured bodies stay
+ *  full. For comparisons, `{ seams: false, update: false, regularize: false, maxErr: Infinity, caps: [[2, 0.05], [1, 0.1], [0.5, 0.2], [0.25, 0.3], [0.1, 0.5],
+ *  [0.05, 0.6]] }` is the Round 51 tier exactly. */
 export declare function lowDetail(comp: Compiler | ((kind: string) => Compiled), c: Compiled, o?: {
     seams?: boolean;
+    update?: boolean;
+    regularize?: boolean;
+    maxErr?: number;
+    caps?: readonly (readonly [number, number])[];
 }): 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

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

@@ -4,6 +4,8 @@ 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. `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[];
+/** The 42 view directions of the see-through gate (and shape-error.ts). */
+export declare const DIRS: 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/node/shape-error.d.ts

@@ -0,0 +1,14 @@
+/** Shade difference (0..1, |cos| of the face normal to the view direction) that counts a pixel as wrong: ~8.6 degrees of facet tilt at normal incidence. */
+export declare const SHADE_TOL = 0.15;
+export interface ShapeRef {
+    c: number[];
+    r: number;
+    res: number;
+    views: Float32Array[];
+    cover: number[];
+}
+/** Flat-shaded views of a part (stride-9 triangles), the reference the candidates are compared to. */
+export declare function shapeRef(tris: ArrayLike<number>, res?: number): ShapeRef;
+/** Fraction of pixels (over all views) where `tris` looks different from `ref`. With `limit`, stops as soon as the error is known to exceed
+ *  it (the result is then only a lower bound above `limit`). */
+export declare function shapeError(ref: ShapeRef, tris: ArrayLike<number>, limit?: number): number;

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.3",
+  "version": "0.29.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",