@needle-tools/gltf-progressive 3.0.0 → 3.1.0-next.f550970

package/lib/extension.js

@@ -1,7 +1,7 @@
 import { BufferGeometry, Mesh, Texture, TextureLoader } from "three";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { addDracoAndKTX2Loaders } from "./loaders.js";
-import { resolveUrl } from "./utils.internal.js";
+import { PromiseQueue, resolveUrl } from "./utils.internal.js";
 import { getRaycastMesh, registerRaycastMesh } from "./utils.js";
 // All of this has to be removed
 // import { getRaycastMesh, setRaycastMesh } from "../../engine_physics.js";
@@ -309,8 +309,10 @@ export class NEEDLE_progressive {
         }
         return NEEDLE_progressive.getOrLoadLOD(current, level).then(tex => {
             // this can currently not happen
-            if (Array.isArray(tex))
+            if (Array.isArray(tex)) {
+                console.warn("Progressive: Got an array of textures for a texture slot, this should not happen", tex);
                 return null;
+            }
             if (tex?.isTexture === true) {
                 if (tex != current) {
                     if (material && slot) {
@@ -375,6 +377,20 @@ export class NEEDLE_progressive {
             return mesh;
         });
     };
+    // private _isLoadingTexture;
+    // loadTexture = (textureIndex: number) => {
+    //     if (this._isLoadingTexture) return null;
+    //     const ext = this.parser.json.textures[textureIndex]?.extensions?.[EXTENSION_NAME] as NEEDLE_ext_progressive_texture;
+    //     if (!ext) return null;
+    //     this._isLoadingTexture = true;
+    //     return this.parser.getDependency("texture", textureIndex).then(tex => {
+    //         this._isLoadingTexture = false;
+    //         if (tex) {
+    //             NEEDLE_progressive.registerTexture(this.url, tex as Texture, ext.lods?.length, textureIndex, ext);
+    //         }
+    //         return tex;
+    //     });
+    // }
     afterRoot(gltf) {
         if (debug)
             console.log("AFTER", this.url, gltf);
@@ -440,13 +456,16 @@ export class NEEDLE_progressive {
      * Register a texture with LOD information
      */
     static registerTexture = (url, tex, level, index, ext) => {
-        if (debug)
-            console.log("> Progressive: register texture", index, tex.name, tex.uuid, tex, ext);
         if (!tex) {
             if (debug)
-                console.error("gltf-progressive: Register texture without texture");
+                console.error("gltf-progressive: Called register texture without texture");
             return;
         }
+        if (debug) {
+            const width = tex.image?.width || tex.source?.data?.width || 0;
+            const height = tex.image?.height || tex.source?.data?.height || 0;
+            console.log(`> Progressive: register texture[${index}] "${tex.name || tex.uuid}", Current: ${width}x${height}, Max: ${ext.lods[0]?.width}x${ext.lods[0]?.height}, uuid: ${tex.uuid}`, ext, tex);
+        }
         // Put the extension info into the source (seems like tiled textures are cloned and the userdata etc is not properly copied BUT the source of course is not cloned)
         // see https://github.com/needle-tools/needle-engine-support/issues/133
         if (tex.source)
@@ -494,25 +513,27 @@ export class NEEDLE_progressive {
     static async getOrLoadLOD(current, level) {
         const debugverbose = debug == "verbose";
         /** this key is used to lookup the LOD information */
-        const LOD = current.userData.LODS;
+        const LOD = this.getAssignedLODInformation(current);
         if (!LOD) {
+            if (debug)
+                console.warn(`[gltf-progressive] No LOD information found: ${current.name}, uuid: ${current.uuid}, type: ${current.type}`, current);
             return null;
         }
         const LODKEY = LOD?.key;
-        let progressiveInfo;
+        let lodInfo;
         // See https://github.com/needle-tools/needle-engine-support/issues/133
         if (current.isTexture === true) {
             const tex = current;
             if (tex.source && tex.source[$progressiveTextureExtension])
-                progressiveInfo = tex.source[$progressiveTextureExtension];
+                lodInfo = tex.source[$progressiveTextureExtension];
         }
-        if (!progressiveInfo)
-            progressiveInfo = NEEDLE_progressive.lodInfos.get(LODKEY);
-        if (progressiveInfo) {
+        if (!lodInfo)
+            lodInfo = NEEDLE_progressive.lodInfos.get(LODKEY);
+        if (lodInfo) {
             if (level > 0) {
                 let useLowRes = false;
-                const hasMultipleLevels = Array.isArray(progressiveInfo.lods);
-                if (hasMultipleLevels && level >= progressiveInfo.lods.length) {
+                const hasMultipleLevels = Array.isArray(lodInfo.lods);
+                if (hasMultipleLevels && level >= lodInfo.lods.length) {
                     useLowRes = true;
                 }
                 else if (!hasMultipleLevels) {
@@ -524,12 +545,12 @@ export class NEEDLE_progressive {
                 }
             }
             /** the unresolved LOD url */
-            const unresolved_lod_url = Array.isArray(progressiveInfo.lods) ? progressiveInfo.lods[level]?.path : progressiveInfo.lods;
+            const unresolved_lod_url = Array.isArray(lodInfo.lods) ? lodInfo.lods[level]?.path : lodInfo.lods;
             // check if we have a uri
             if (!unresolved_lod_url) {
-                if (debug && !progressiveInfo["missing:uri"]) {
-                    progressiveInfo["missing:uri"] = true;
-                    console.warn("Missing uri for progressive asset for LOD " + level, progressiveInfo);
+                if (debug && !lodInfo["missing:uri"]) {
+                    lodInfo["missing:uri"] = true;
+                    console.warn("Missing uri for progressive asset for LOD " + level, lodInfo);
                 }
                 return null;
             }
@@ -537,12 +558,12 @@ export class NEEDLE_progressive {
             const lod_url = resolveUrl(LOD.url, unresolved_lod_url);
             // check if the requested file needs to be loaded via a GLTFLoader
             if (lod_url.endsWith(".glb") || lod_url.endsWith(".gltf")) {
-                if (!progressiveInfo.guid) {
-                    console.warn("missing pointer for glb/gltf texture", progressiveInfo);
+                if (!lodInfo.guid) {
+                    console.warn("missing pointer for glb/gltf texture", lodInfo);
                     return null;
                 }
                 // check if the requested file has already been loaded
-                const KEY = lod_url + "_" + progressiveInfo.guid;
+                const KEY = lod_url + "_" + lodInfo.guid;
                 // check if the requested file is currently being loaded
                 const existing = this.previouslyLoaded.get(KEY);
                 if (existing !== undefined) {
@@ -581,7 +602,13 @@ export class NEEDLE_progressive {
                         return res;
                     }
                 }
-                const ext = progressiveInfo;
+                const slot = await this.queue.slot(lod_url);
+                if (!slot.use) {
+                    if (debug)
+                        console.log(`LOD ${level} was aborted: ${lod_url}`);
+                    return null; // the request was aborted, we don't load it again
+                }
+                const ext = lodInfo;
                 const request = new Promise(async (resolve, _) => {
                     const loader = new GLTFLoader();
                     addDracoAndKTX2Loaders(loader);
@@ -599,10 +626,11 @@ export class NEEDLE_progressive {
                     }
                     const gltf = await loader.loadAsync(url).catch(err => {
                         console.error(`Error loading LOD ${level} from ${lod_url}\n`, err);
-                        return null;
+                        return resolve(null);
                     });
-                    if (!gltf)
-                        return null;
+                    if (!gltf) {
+                        return resolve(null);
+                    }
                     const parser = gltf.parser;
                     if (debugverbose)
                         console.log("Loading finished " + lod_url, ext.guid);
@@ -687,6 +715,7 @@ export class NEEDLE_progressive {
                     return resolve(null);
                 });
                 this.previouslyLoaded.set(KEY, request);
+                slot.use(request);
                 const res = await request;
                 return res;
             }
@@ -697,12 +726,12 @@ export class NEEDLE_progressive {
                     const loader = new TextureLoader();
                     const tex = await loader.loadAsync(lod_url);
                     if (tex) {
-                        tex.guid = progressiveInfo.guid;
+                        tex.guid = lodInfo.guid;
                         tex.flipY = false;
                         tex.needsUpdate = true;
                         tex.colorSpace = current.colorSpace;
                         if (debugverbose)
-                            console.log(progressiveInfo, tex);
+                            console.log(lodInfo, tex);
                     }
                     else if (debug)
                         console.warn("failed loading", lod_url);
@@ -716,6 +745,7 @@ export class NEEDLE_progressive {
         }
         return null;
     }
+    static queue = new PromiseQueue(100, { debug: debug != false });
     static assignLODInformation(url, res, key, level, index) {
         if (!res)
             return;
@@ -723,9 +753,17 @@ export class NEEDLE_progressive {
             res.userData = {};
         const info = new LODInformation(url, key, level, index);
         res.userData.LODS = info;
+        if ("source" in res && typeof res.source === "object")
+            res.source.LODS = info; // for tiled textures
     }
     static getAssignedLODInformation(res) {
-        return res?.userData?.LODS || null;
+        if (!res)
+            return null;
+        if (res.userData?.LODS)
+            return res.userData.LODS;
+        if ("source" in res && res.source?.LODS)
+            return res.source.LODS;
+        return null;
     }
     // private static readonly _copiedTextures: WeakMap<Texture, Texture> = new Map();
     static copySettings(source, target) {

package/lib/index.d.ts

@@ -1,13 +1,13 @@
 export { version as VERSION } from "./version.js";
 export * from "./extension.js";
 export * from "./plugins/index.js";
-export { LODsManager, type LOD_Results } from "./lods_manager.js";
+export { LODsManager, type LOD_Results } from "./lods.manager.js";
 export { setDracoDecoderLocation, setKTX2TranscoderLocation, createLoaders, addDracoAndKTX2Loaders, configureLoader } from "./loaders.js";
 export { getRaycastMesh, registerRaycastMesh, useRaycastMeshes } from "./utils.js";
 import { WebGLRenderer } from "three";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
 import { SmartLoadingHints } from "./loaders.js";
-import { LODsManager } from "./lods_manager.js";
+import { LODsManager } from "./lods.manager.js";
 declare type UseNeedleGLTFProgressiveOptions = {
     /**
      * When set to true the LODs manager will automatically be enabled

package/lib/index.js

@@ -1,12 +1,12 @@
 export { version as VERSION } from "./version.js";
 export * from "./extension.js";
 export * from "./plugins/index.js";
-export { LODsManager } from "./lods_manager.js";
+export { LODsManager } from "./lods.manager.js";
 export { setDracoDecoderLocation, setKTX2TranscoderLocation, createLoaders, addDracoAndKTX2Loaders, configureLoader } from "./loaders.js";
 export { getRaycastMesh, registerRaycastMesh, useRaycastMeshes } from "./utils.js";
 import { addDracoAndKTX2Loaders, configureLoader, createLoaders } from "./loaders.js";
 import { NEEDLE_progressive } from "./extension.js";
-import { LODsManager } from "./lods_manager.js";
+import { LODsManager } from "./lods.manager.js";
 /** Use this function to enable progressive loading of gltf models.
  * @param url The url of the gltf model.
  * @param renderer The renderer of the scene.

package/lib/{lods_manager.d.ts → lods.manager.d.ts}

@@ -1,5 +1,6 @@
-import { Camera, Material, Matrix4, Object3D, Scene, Texture, Vector3, WebGLRenderer } from "three";
+import { Camera, Material, Object3D, Scene, Texture, Vector3, WebGLRenderer } from "three";
 import { NEEDLE_progressive_plugin } from "./plugins/plugin.js";
+import { PromiseGroupOptions } from "./lods.promise.js";
 export type LODManagerContext = {
     engine: "three" | "needle-engine" | "model-viewer" | "react-three-fiber" | "unknown";
 };
@@ -61,9 +62,9 @@ export declare class LODsManager {
      * @returns The LODsManager instance.
      */
     static get(renderer: WebGLRenderer, context?: LODManagerContext): LODsManager;
-    private readonly context;
     readonly renderer: WebGLRenderer;
-    readonly projectionScreenMatrix: Matrix4;
+    private readonly context;
+    private readonly projectionScreenMatrix;
     /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
     get plugins(): NEEDLE_progressive_plugin[];
     /**
@@ -93,6 +94,17 @@ export declare class LODsManager {
      * @default false
      */
     manual: boolean;
+    private readonly _newPromiseGroups;
+    private _promiseGroupIds;
+    /**
+     * Call to await LODs loading during the next render cycle.
+     */
+    awaitLoading(opts?: PromiseGroupOptions): Promise<{
+        cancelled: boolean;
+        awaited_count: number;
+        resolved_count: number;
+    }>;
+    private _postprocessPromiseGroups;
     private readonly _lodchangedlisteners;
     addEventListener(evt: "changed", listener: LODChangedEventListener): void;
     removeEventListener(evt: "changed", listener: LODChangedEventListener): void;
@@ -137,6 +149,8 @@ export declare class LODsManager {
     private static corner3;
     private static readonly _tempPtInside;
     private static isInside;
+    private static skinnedMeshBoundsFrameOffsetCounter;
+    private static $skinnedMeshBoundsOffset;
     private calculateLodLevel;
 }
 declare class LOD_state {

package/lib/{lods_manager.js → lods.manager.js}

@@ -1,10 +1,11 @@
 import { Box3, Clock, Matrix4, Mesh, MeshStandardMaterial, Sphere, Vector3 } from "three";
 import { NEEDLE_progressive } from "./extension.js";
 import { createLoaders } from "./loaders.js";
-import { getParam, isMobileDevice } from "./utils.internal.js";
+import { getParam, isDevelopmentServer, isMobileDevice } from "./utils.internal.js";
 import { plugins } from "./plugins/plugin.js";
 import { getRaycastMesh } from "./utils.js";
 import { applyDebugSettings, debug, debug_OverrideLodLevel } from "./lods.debug.js";
+import { PromiseGroup } from "./lods.promise.js";
 const debugProgressiveLoading = getParam("debugprogressive");
 const suppressProgressiveLoading = getParam("noprogressive");
 const $lodsManager = Symbol("Needle:LODSManager");
@@ -78,8 +79,8 @@ export class LODsManager {
         renderer[$lodsManager] = lodsManager;
         return lodsManager;
     }
-    context;
     renderer;
+    context;
     projectionScreenMatrix = new Matrix4();
     /** @deprecated use static `LODsManager.addPlugin()` method. This getter will be removed in later versions */
     get plugins() { return plugins; }
@@ -111,6 +112,37 @@ export class LODsManager {
      * @default false
      */
     manual = false;
+    _newPromiseGroups = [];
+    _promiseGroupIds = 0;
+    /**
+     * Call to await LODs loading during the next render cycle.
+     */
+    awaitLoading(opts) {
+        const id = this._promiseGroupIds++;
+        const newGroup = new PromiseGroup(this.#frame, { ...opts, });
+        this._newPromiseGroups.push(newGroup);
+        const start = performance.now();
+        newGroup.ready.finally(() => {
+            const index = this._newPromiseGroups.indexOf(newGroup);
+            if (index >= 0) {
+                this._newPromiseGroups.splice(index, 1);
+                if (isDevelopmentServer())
+                    performance.measure("LODsManager:awaitLoading", {
+                        start,
+                        detail: { id, name: opts?.name, awaited: newGroup.awaitedCount, resolved: newGroup.resolvedCount }
+                    });
+            }
+        });
+        return newGroup.ready;
+    }
+    _postprocessPromiseGroups() {
+        if (this._newPromiseGroups.length === 0)
+            return;
+        for (let i = this._newPromiseGroups.length - 1; i >= 0; i--) {
+            const group = this._newPromiseGroups[i];
+            group.update(this.#frame);
+        }
+    }
     _lodchangedlisteners = [];
     addEventListener(evt, listener) {
         if (evt === "changed") {
@@ -232,6 +264,7 @@ export class LODsManager {
                 return;
             }
             this.internalUpdate(scene, camera);
+            this._postprocessPromiseGroups();
         }
     }
     /**
@@ -368,9 +401,10 @@ export class LODsManager {
         }
         if (update) {
             material[$currentLOD] = level;
-            NEEDLE_progressive.assignTextureLOD(material, level).then(_ => {
+            const promise = NEEDLE_progressive.assignTextureLOD(material, level).then(_ => {
                 this._lodchangedlisteners.forEach(l => l({ type: "texture", level, object: material }));
             });
+            PromiseGroup.addPromise("texture", material, promise, this._newPromiseGroups);
         }
     }
     /** Load progressive meshes for the given mesh
@@ -391,19 +425,14 @@ export class LODsManager {
         if (update) {
             mesh[$currentLOD] = level;
             const originalGeometry = mesh.geometry;
-            return NEEDLE_progressive.assignMeshLOD(mesh, level).then(res => {
+            const promise = NEEDLE_progressive.assignMeshLOD(mesh, level).then(res => {
                 if (res && mesh[$currentLOD] == level && originalGeometry != mesh.geometry) {
                     this._lodchangedlisteners.forEach(l => l({ type: "mesh", level, object: mesh }));
-                    // if (this.handles) {
-                    //     for (const inst of this.handles) {
-                    //         // if (inst["LOD"] < level) continue;
-                    //         // inst["LOD"] = level;
-                    //         inst.setGeometry(mesh.geometry);
-                    //     }
-                    // }
                 }
                 return res;
             });
+            PromiseGroup.addPromise("mesh", mesh, promise, this._newPromiseGroups);
+            return promise;
         }
         return Promise.resolve(null);
     }
@@ -428,6 +457,8 @@ export class LODsManager {
         const pt1 = this._tempPtInside.set(centerx, centery, min.z).applyMatrix4(matrix);
         return pt1.z < 0;
     }
+    static skinnedMeshBoundsFrameOffsetCounter = 0;
+    static $skinnedMeshBoundsOffset = Symbol("gltf-progressive-skinnedMeshBoundsOffset");
     calculateLodLevel(camera, mesh, state, desiredDensity, result) {
         if (!mesh) {
             result.mesh_lod = -1;
@@ -473,16 +504,25 @@ export class LODsManager {
                 skinnedMesh.computeBoundingBox();
             }
             // Fix: https://linear.app/needle/issue/NE-5264
-            else if (this.skinnedMeshAutoUpdateBoundsInterval > 0
-                && state.frames % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
-                // use lowres geometry for bounding box calculation
-                const raycastmesh = getRaycastMesh(skinnedMesh);
-                const originalGeometry = skinnedMesh.geometry;
-                if (raycastmesh) {
-                    skinnedMesh.geometry = raycastmesh;
+            else if (this.skinnedMeshAutoUpdateBoundsInterval > 0) {
+                // Save a frame offset per object to stagger updates of skinned meshes across multiple frames
+                // This isn't a perfect solution to improve perf impact of skinned mesh updates (e.g. large skinned meshes would still be costly)
+                // But for many smaller meshes it helps to avoid spikes in performance
+                if (!skinnedMesh[LODsManager.$skinnedMeshBoundsOffset]) {
+                    const offset = LODsManager.skinnedMeshBoundsFrameOffsetCounter++;
+                    skinnedMesh[LODsManager.$skinnedMeshBoundsOffset] = offset;
+                }
+                const frameOffset = skinnedMesh[LODsManager.$skinnedMeshBoundsOffset];
+                if ((state.frames + frameOffset) % this.skinnedMeshAutoUpdateBoundsInterval === 0) {
+                    // use lowres geometry for bounding box calculation
+                    const raycastmesh = getRaycastMesh(skinnedMesh);
+                    const originalGeometry = skinnedMesh.geometry;
+                    if (raycastmesh) {
+                        skinnedMesh.geometry = raycastmesh;
+                    }
+                    skinnedMesh.computeBoundingBox();
+                    skinnedMesh.geometry = originalGeometry;
                 }
-                skinnedMesh.computeBoundingBox();
-                skinnedMesh.geometry = originalGeometry;
             }
             boundingBox = skinnedMesh.boundingBox;
         }
@@ -608,6 +648,10 @@ export class LODsManager {
                     const lod = mesh_lods[l];
                     const densityForThisLevel = lod.densities?.[primitive_index] || lod.density || .00001;
                     const resultingDensity = densityForThisLevel / state.lastScreenCoverage;
+                    if (primitive_index > 0 && isDevelopmentServer() && !lod.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"]) {
+                        window["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"] = true;
+                        console.warn(`[Needle Progressive] Detected usage of mesh without primitive densities. This might cause incorrect LOD level selection: Consider re-optimizing your model by updating your Needle Integration, Needle glTF Pipeline or running optimization again on Needle Cloud.`);
+                    }
                     if (resultingDensity < desiredDensity) {
                         expectedLevel = l;
                         break;

package/lib/lods.promise.d.ts

@@ -0,0 +1,61 @@
+type PromiseType = "texture" | "mesh";
+export type PromiseGroupOptions = {
+    /** Name for debugging purposes */
+    name?: string;
+    /** Define many frames new LOD promises will be captured and awaited. The group will resolve after all promises captured during this time have resolved (or when the abort signal is triggered).
+     * @default 2 frames, which means the group will capture promises for 2 frames before resolving.
+    */
+    frames?: number;
+    /** An optional signal to abort the promise */
+    signal?: AbortSignal;
+    /**
+     * If set to true, the group will only await one promise per object.
+     * @default 1
+     */
+    maxPromisesPerObject?: number;
+};
+type PromiseGroupResolveResult = {
+    /**
+     * `true` if the group was cancelled, `false` if it was resolved normally.
+     */
+    cancelled: boolean;
+    /**
+     * The number of promises that started to being awaited
+     */
+    awaited_count: number;
+    /**
+     * The number of promises that were resolved
+    */
+    resolved_count: number;
+};
+/**
+ * A group of promises that can be awaited together.
+ * This is used for awaiting LOD
+ */
+export declare class PromiseGroup {
+    static readonly addPromise: (type: PromiseType, object: object, promise: Promise<any>, groups: PromiseGroup[]) => void;
+    readonly frame_start: number;
+    readonly frame_capture_end: number;
+    readonly ready: Promise<PromiseGroupResolveResult>;
+    private _resolve;
+    private readonly _signal?;
+    /**
+     * The number of promises that have been added to this group so far.
+     */
+    get awaitedCount(): number;
+    get resolvedCount(): number;
+    get currentlyAwaiting(): number;
+    private _resolved;
+    private _addedCount;
+    private _resolvedCount;
+    /** These promises are currently being awaited */
+    private readonly _awaiting;
+    private _maxPromisesPerObject;
+    constructor(frame: number, options: PromiseGroupOptions);
+    private _currentFrame;
+    update(frame: number): void;
+    private readonly _seen;
+    private add;
+    private resolveNow;
+}
+export {};

package/lib/lods.promise.js

@@ -0,0 +1,101 @@
+import { debug } from "./lods.debug";
+/**
+ * A group of promises that can be awaited together.
+ * This is used for awaiting LOD
+ */
+export class PromiseGroup {
+    static addPromise = (type, object, promise, groups) => {
+        groups.forEach(group => {
+            group.add(type, object, promise);
+        });
+    };
+    frame_start;
+    frame_capture_end;
+    ready;
+    _resolve;
+    _signal;
+    /**
+     * The number of promises that have been added to this group so far.
+     */
+    get awaitedCount() {
+        return this._addedCount;
+    }
+    get resolvedCount() {
+        return this._resolvedCount;
+    }
+    get currentlyAwaiting() {
+        return this._awaiting.length;
+    }
+    _resolved = false;
+    _addedCount = 0;
+    _resolvedCount = 0;
+    /** These promises are currently being awaited */
+    _awaiting = [];
+    _maxPromisesPerObject = 1;
+    constructor(frame, options) {
+        const minFrames = 2; // wait at least 2 frames to capture promises
+        const framesToCapture = Math.max(options.frames ?? minFrames, minFrames); // default to 2 frames and make sure it's at least 2 frames
+        this.frame_start = frame;
+        this.frame_capture_end = frame + framesToCapture;
+        this.ready = new Promise((resolve) => {
+            this._resolve = resolve;
+        });
+        this.ready.finally(() => {
+            this._resolved = true;
+            this._awaiting.length = 0;
+        });
+        this._signal = options.signal;
+        this._signal?.addEventListener("abort", () => {
+            this.resolveNow();
+        });
+        this._maxPromisesPerObject = Math.max(1, options.maxPromisesPerObject ?? 1);
+    }
+    _currentFrame = 0;
+    update(frame) {
+        this._currentFrame = frame;
+        // If we've passes the frame capture end frame and didn't add any promises, we resolve immediately
+        if (this._signal?.aborted || (this._currentFrame > this.frame_capture_end && this._awaiting.length === 0)) {
+            this.resolveNow();
+        }
+    }
+    _seen = new WeakMap();
+    add(_type, object, promise) {
+        if (this._resolved) {
+            if (debug)
+                console.warn("PromiseGroup: Trying to add a promise to a resolved group, ignoring.");
+            return;
+        }
+        if (this._currentFrame > this.frame_capture_end) {
+            return; // we are not capturing any more promises
+        }
+        if (this._maxPromisesPerObject >= 1) {
+            if (this._seen.has(object)) {
+                let count = this._seen.get(object);
+                if (count >= this._maxPromisesPerObject) {
+                    if (debug)
+                        console.warn(`PromiseGroup: Already awaiting object ignoring new promise for it.`);
+                    return;
+                }
+                this._seen.set(object, count + 1);
+            }
+            else {
+                this._seen.set(object, 1);
+            }
+        }
+        this._awaiting.push(promise);
+        this._addedCount++;
+        promise.finally(() => {
+            this._resolvedCount++;
+            this._awaiting.splice(this._awaiting.indexOf(promise), 1);
+        });
+    }
+    resolveNow() {
+        if (this._resolved)
+            return;
+        this._resolve?.({
+            awaited_count: this._addedCount,
+            resolved_count: this._resolvedCount,
+            cancelled: this._signal?.aborted ?? false,
+        });
+    }
+}

package/lib/plugins/modelviewer.js

@@ -1,4 +1,4 @@
-import { LODsManager } from "../lods_manager.js";
+import { LODsManager } from "../lods.manager.js";
 import { EXTENSION_NAME, NEEDLE_progressive } from "../extension.js";
 const $meshLODSymbol = Symbol("NEEDLE_mesh_lod");
 const $textureLODSymbol = Symbol("NEEDLE_texture_lod");

package/lib/utils.internal.d.ts

@@ -3,3 +3,24 @@ export declare function getParam(name: string): boolean | string;
 export declare function resolveUrl(source: string | undefined, uri: string): string;
 /** @returns `true` if it's a phone or tablet */
 export declare function isMobileDevice(): boolean;
+export declare function isDevelopmentServer(): boolean;
+type SlotReturnValue = {
+    use?: ((promise: Promise<any>) => void);
+};
+export declare class PromiseQueue {
+    readonly maxConcurrent: number;
+    private readonly _running;
+    private readonly _queue;
+    debug: boolean;
+    constructor(maxConcurrent?: number, opts?: {
+        debug?: boolean;
+    });
+    private tick;
+    /**
+     * Request a slot for a promise with a specific key. This function returns a promise with a `use` method that can be called to add the promise to the queue.
+     */
+    slot(key: string): Promise<SlotReturnValue>;
+    private add;
+    private internalUpdate;
+}
+export {};