ldr 0.0.0-alpha.1 → 0.3.0

package/dist/model.d.ts

@@ -0,0 +1,44 @@
+import { parse, norm, type Doc, type M } 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;
+    color: number;
+    m: M;
+    /** Build step of the top-level model this instance appears in (0-based). */
+    step: number;
+    /** Step path through nested submodels, e.g. [3, 1] = top step 3, submodel step 1. */
+    steps: number[];
+    /** Submodel path, e.g. "main.ldr/wheel.ldr". */
+    path: string;
+}
+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;
+}
+/** Flatten a parsed LDraw document into part instances. Submodels (`0 FILE` blocks in an MPD) are expanded; everything else is treated as a part. */
+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.
+ */
+export declare function sequenceSteps<T extends {
+    steps: number[];
+}>(insts: T[]): {
+    count: number;
+    stepOf: Int32Array;
+};
+/** Colour table entry. */
+export interface LDrawColor {
+    code: number;
+    name: string;
+    hex: string;
+    edge: string;
+    alpha: number;
+}
+/** Parse LDConfig.ldr (or any file with `!COLOUR` lines) into a code → colour map. */
+export declare function parseLDConfig(text: string): Map<number, LDrawColor>;
+export { parse, norm };

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

@@ -0,0 +1,35 @@
+export interface BuildPackOptions {
+    /** Root of an LDraw library (folder containing LDConfig.ldr, parts/, p/). Get it from https://library.ldraw.org (complete.zip). */
+    ldrawRoot: string;
+    /** Model files (.ldr/.mpd) or raw model text whose parts should be included. */
+    models?: (string | {
+        name: string;
+        text: string;
+    })[];
+    /** Extra part references to include, e.g. ["3001.dat"]. */
+    parts?: string[];
+    /** Include every part in parts/ (large: the full library is ~20k parts). */
+    allParts?: boolean;
+    /** Stud geometry: 'low' uses p/8 low-res primitives (default, ~visually lossless at distance); 'full' keeps full detail. */
+    studs?: "low" | "full";
+    /** Non-stud primitive detail. Default 'full'. */
+    primitives?: "low" | "full";
+    /** Weld + index vertices (smaller GPU buffers, faster). Default true. */
+    weld?: boolean;
+    /** Keep type-5 conditional lines so the renderer can draw curved-surface silhouettes (pack v2). Off by default:
+     *  Round 16 measured +7.5–13.6% zstd size and ~+25% build time on Datsville 10k/100k. Packs stay readable by ldr <= 0.2.0. */
+    cond?: boolean;
+    /** 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;
+    /** Embed the LDConfig colour table (code → hex) in the pack header. Default true. */
+    colors?: boolean;
+    onProgress?: (done: number, total: number) => void;
+}
+export interface BuildPackResult {
+    data: Uint8Array;
+    parts: number;
+    studKinds: number;
+    missing: string[];
+}
+export declare function buildPack(o: BuildPackOptions): BuildPackResult;

package/dist/node/compile.d.ts

@@ -0,0 +1,70 @@
+import { Library } from './resolver.js';
+/** `cond`: keep type-5 conditional lines (endpoints + control points) so the pack can draw them (pack v2). Default off.
+ *  `tex`: also compile the TEXMAP-aware view of parts that use `!TEXMAP` (textured triangles with UVs + PNGs; pack v2 "tex"). Default off. */
+export type Opts = {
+    studs: 'full' | 'low';
+    prims: 'full' | 'low';
+    weld: boolean;
+    separateStuds: boolean;
+    cond?: boolean;
+    tex?: boolean;
+};
+export type Bucket = {
+    pos: number[];
+    col: number[];
+};
+/** Textured triangles for one PNG: `uv` = 2 floats per vertex (LDraw !TEXMAP projection, v = 0 at the image's top row). */
+export type TexBucket = Bucket & {
+    uv: number[];
+    wrapU?: boolean;
+};
+export type Compiled = {
+    body: Bucket;
+    under: Bucket;
+    edges: number[];
+    condLines: number;
+    /** Type-5 lines in part space, stride 12 (p0, p1, control0, control1). Only filled when `opts.cond`.
+     *  `cond` = lines of the body; `condUnder` = lines inside underside (tube / anti-stud) subfiles, drawn with the underside batch so they follow underside culling. */
+    cond?: number[];
+    condUnder?: number[];
+    studs: {
+        kind: string;
+        color: string;
+        m: number[];
+    }[];
+    bbox: number[];
+    fullBottom: boolean;
+    uncertified?: boolean;
+    bottomMask?: {
+        nx: number;
+        nz: number;
+        bits: number[];
+    };
+    /** Only with `opts.tex`, for parts whose tree uses !TEXMAP: the untextured body a TEXMAP-aware renderer draws instead of
+     *  `body` (FALLBACK geometry dropped, `0 !:` geometry kept), plus textured triangles per texture name. Under/studs/edges are shared. */
+    tbody?: Bucket;
+    texb?: Map<string, TexBucket>;
+};
+export declare function loadColors(root: string): Map<string, number[]>;
+export declare class Compiler {
+    lib: Library;
+    opts: Opts;
+    colors: Map<string, number[]>;
+    cache: Map<string, Compiled>;
+    constructor(lib: Library, opts: Opts);
+    resolve(ref: string, isStud: boolean): string | null;
+    compile(key: string, separateStuds?: boolean): Compiled;
+    private texMemo;
+    /** True if `key` or any file it references contains a `!TEXMAP` meta. */
+    hasTex(key: string): boolean;
+    /** Texture PNG bytes by !TEXMAP name: `textures/<name>` under parts/, p/, models/, then `<name>` (case-insensitive). */
+    texture(name: string): Uint8Array | null;
+    private texPass;
+}
+export declare function writePack(file: string, parts: Map<string, Compiled>, studKinds: Map<string, Compiled>, weld: boolean, extra?: Record<string, unknown>, options?: EncodeOptions): void;
+/** `texture(name)`: PNG bytes for a !TEXMAP name used by a compiled part (e.g. `compiler.texture`, or an MPD `!DATA` block). */
+export type EncodeOptions = {
+    texture?: (name: string) => Uint8Array | null;
+};
+/** Serialize compiled parts into the binary pack format read by `decodePack`/`loadPack`. `extra` keys are merged into the JSON header (e.g. `colors`). */
+export declare function encodePack(parts: Map<string, Compiled>, studKinds: Map<string, Compiled>, weld: boolean, extra?: Record<string, unknown>, options?: EncodeOptions): Uint8Array;

package/dist/node/index.d.ts

@@ -0,0 +1,7 @@
+export * from "../index.js";
+export { Library } from "./library.js";
+export { buildPack } from "./build-pack.js";
+export type { BuildPackOptions, BuildPackResult } from "./build-pack.js";
+export { Compiler, encodePack, writePack, loadColors } from "./compile.js";
+export type { Compiled, Opts as CompileOptions, Bucket } from "./compile.js";
+export { Library as ResolverLibrary, splitModel, flatten as flattenWithLibrary, collectDeps } from "./resolver.js";