ldr 0.14.0 → 0.16.0

package/dist/render.d.ts

@@ -70,29 +70,30 @@ export declare function computeCulling(insts: Inst[], H: any): {
     }[];
     underHidden: boolean[];
 };
-export declare function buildLdrScene(insts: Inst[], pack: Pack, P: LdrParams, color: (c: string) => THREE.Color, mark: (k: string) => void): {
-    root: THREE.Group;
-    stats: any;
-    setCull: (studs: boolean, under: boolean) => void;
-    setSide: (front: boolean) => void;
-    setEdges: (v: boolean) => void;
-    setCond: (v: boolean) => void;
-    setLod: (on: boolean) => void;
-    setStep: (s: number | null, mask?: ArrayLike<number | boolean> | null) => {
-        studsTotal: number;
-        studsHidden: number;
-        undersTotal: number;
-        undersHidden: number;
-    };
-    box: THREE.Box3;
-    texturesReady: Promise<void>;
-    trimmed: {
-        studs: boolean;
-        under: boolean;
-    };
-};
 /**
  * Builds (and caches on the pack) the shared BufferGeometries `buildLdrScene` will use, in time slices of about `sliceMs` that yield
  * to the event loop, until done or `stop()` returns true. Lets the main thread do this useful work while the load worker culls.
  */
+/** Drive buildLdrSceneGen to completion without yielding (same as pre-Round-33 sync build). */
+export declare function buildLdrScene(insts: Inst[], pack: Pack, P: LdrParams, color: (c: string) => THREE.Color, mark: (k: string) => void): any;
+export type BuildLdrSceneAsyncOptions = {
+    /** Soft cap on contiguous main-thread work between yields while mid-build paints are active (ms). Default 8. */
+    sliceMs?: number;
+    /**
+     * Soft cap after mid-build paints stop (onSlice returned false, or no onSlice). Default max(sliceMs, 24).
+     * Larger slices cut yield/timer overhead on the remaining build without changing the sync path.
+     */
+    postPaintSliceMs?: number;
+    /**
+     * Called after each yield while paints are enabled; live root already holds finished batches (paint for TTFP).
+     * Return `false` to stop further onSlice calls (keeps yielding with postPaintSliceMs) — use after first frame.
+     */
+    onSlice?: (root: THREE.Object3D) => void | boolean | Promise<void | boolean>;
+};
+/**
+ * Same scene as buildLdrScene, but yields to the event loop about every sliceMs so the main thread stays responsive
+ * and onSlice can render partial geometry for a fast time-to-first-pixel. Meshes are added to root as they are built.
+ * After onSlice returns false (TTFP done), slices coarsen to postPaintSliceMs and paints stop — cuts total loadMs.
+ */
+export declare function buildLdrSceneAsync(insts: Inst[], pack: Pack, P: LdrParams, color: (c: string) => THREE.Color, mark: (k: string) => void, opts?: BuildLdrSceneAsyncOptions): Promise<any>;
 export declare function warmPackGeometry(pack: Pack, stop?: () => boolean, sliceMs?: number): Promise<void>;

package/dist/scene.d.ts

@@ -51,6 +51,15 @@ export interface LdrObjectOptions {
     /** LOD: skip undersides that can't be seen: while the camera is behind every bottom face of a cluster's (same-orientation) parts and
      *  studs are under 4 px, or where the body is drawn as its closed bounding box. Default true. */
     lodUnder?: boolean;
+    /** Progressive build (createLdrObjectAsync / loadModel): soft cap while mid-build paints are active, ms. Default 8. */
+    sliceMs?: number;
+    /** Progressive build: soft cap after paints stop (onSlice returned false / no onSlice). Default max(sliceMs, 24). */
+    postPaintSliceMs?: number;
+    /**
+     * Progressive build: called after each yield while paints are enabled; live object holds finished batches — render for TTFP.
+     * Return `false` to stop further onSlice calls (keeps yielding with postPaintSliceMs).
+     */
+    onSlice?: () => void | boolean | Promise<void | boolean>;
 }
 export interface LdrStats {
     instances: number;
@@ -61,6 +70,10 @@ export interface LdrStats {
     undersTotal: number;
     undersHidden: number;
     buildMs: number;
+    /** Progressive build: longest contiguous main-thread slice (ms). */
+    longestSliceMs?: number;
+    /** Progressive build: number of yields during scene construction. */
+    buildYields?: number;
     /** Conditional-line batches (draw calls) created; 0 for packs without conditional lines. */
     condBatches?: number;
     /** Textured batches (one per part x texture) and distinct textures; 0 for packs without textures. */
@@ -97,8 +110,18 @@ export interface LdrObject {
     getBox(target?: THREE.Box3): THREE.Box3;
     dispose(): void;
 }
+/**
+ * Build a three.js object for a flattened model using a parts pack.
+ * Instances whose part is not in the pack are skipped and listed in `stats.missing`.
+ */
 /**
  * Build a three.js object for a flattened model using a parts pack.
  * Instances whose part is not in the pack are skipped and listed in `stats.missing`.
  */
 export declare function createLdrObject(instances: PartInstance[], pack: Pack, options?: LdrObjectOptions): LdrObject;
+/**
+ * Progressive/async variant of `createLdrObject`: yields about every `sliceMs` (default 8) so the main thread stays responsive.
+ * Meshes land on `object` as batches finish; pass `onSlice` to render for a fast time-to-first-pixel.
+ * Final visuals and stats match the sync path (same generator).
+ */
+export declare function createLdrObjectAsync(instances: PartInstance[], pack: Pack, options?: LdrObjectOptions): Promise<LdrObject>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ldr",
-  "version": "0.14.0",
+  "version": "0.16.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",