ldr 0.2.0 → 0.3.0

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

@@ -16,6 +16,12 @@ export interface BuildPackOptions {
     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;

package/dist/node/compile.d.ts

@@ -1,19 +1,32 @@
 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;
@@ -27,6 +40,10 @@ export type Compiled = {
         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 {
@@ -37,7 +54,17 @@ export declare class Compiler {
     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>): void;
+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>): Uint8Array;
+export declare function encodePack(parts: Map<string, Compiled>, studKinds: Map<string, Compiled>, weld: boolean, extra?: Record<string, unknown>, options?: EncodeOptions): Uint8Array;