@needle-tools/gltf-progressive 3.4.0-beta.2 → 3.4.0-beta.4

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 { determineTextureMemoryInBytes, getParam, PromiseQueue, resolveUrl } from "./utils.internal.js";
+import { determineTextureMemoryInBytes, getParam, isMobileDevice, 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";
@@ -312,7 +312,7 @@ export class NEEDLE_progressive {
     }
     /**
      * Set the maximum number of concurrent loading tasks for LOD resources. This limits how many LOD resources (meshes or textures) can be loaded at the same time to prevent overloading the network or GPU. If the limit is reached, additional loading requests will be queued and processed as previous ones finish.
-     * @default 50
+     * @default 50 on desktop, 20 on mobile devices
      */
     static set maxConcurrentLoadingTasks(value) {
         NEEDLE_progressive.queue.maxConcurrent = value;
@@ -582,6 +582,8 @@ export class NEEDLE_progressive {
             }
         }
         else {
+            // Invalidate requests waiting for a queue slot as well as active loads.
+            this.cacheGeneration++;
             this.lodInfos.clear();
             for (const [, entryRef] of this.lowresCache) {
                 const entry = entryRef.deref();
@@ -622,6 +624,7 @@ export class NEEDLE_progressive {
         else {
             // Promise — may be in-flight or already resolved.
             // Attach disposal to run after resolution.
+            this.disposedRequests.add(entry);
             entry.then(resource => {
                 if (resource) {
                     if (Array.isArray(resource)) {
@@ -721,8 +724,11 @@ export class NEEDLE_progressive {
         }
     }
     static workers = [];
+    static cacheGeneration = 0;
+    static disposedRequests = new WeakSet();
     static _workersIndex = 0;
     static async getOrLoadLOD(current, level) {
+        const generation = this.cacheGeneration;
         const debugverbose = debug == "verbose";
         /** this key is used to lookup the LOD information */
         const LOD = this.getAssignedLODInformation(current);
@@ -792,6 +798,8 @@ export class NEEDLE_progressive {
                 // check if the requested file has already been loaded
                 const KEY = lod_url + "_" + lodInfo.guid;
                 const slot = await this.queue.slot(lod_url);
+                if (generation !== this.cacheGeneration)
+                    return null;
                 // check if the requested file is currently being loaded or was previously loaded
                 const existing = this.cache.get(KEY);
                 if (existing !== undefined) {
@@ -831,6 +839,8 @@ export class NEEDLE_progressive {
                             console.error(`Error loading LOD ${level} from ${lod_url}\n`, err);
                             return null;
                         });
+                        if (generation !== this.cacheGeneration || this.disposedRequests.has(existing))
+                            return null;
                         let resouceIsDisposed = false;
                         if (res == null) {
                             // if the resource is null the last loading result didnt succeed (maybe because the url doesnt exist)
@@ -1008,6 +1018,10 @@ export class NEEDLE_progressive {
                 this.cache.set(KEY, request);
                 slot.use(request);
                 const res = await request;
+                // dispose() cleans up removed pending entries when they resolve. Do not
+                // return those resources or overwrite a newer request for this key.
+                if (generation !== this.cacheGeneration || this.cache.get(KEY) !== request)
+                    return null;
                 // Optimize cache entry: replace loading promise with lightweight reference.
                 // This releases closure variables captured during the loading function.
                 if (res != null) {
@@ -1040,6 +1054,10 @@ export class NEEDLE_progressive {
                         console.log("Load texture from uri: " + lod_url);
                     const loader = new TextureLoader();
                     const tex = await loader.loadAsync(lod_url);
+                    if (generation !== this.cacheGeneration) {
+                        tex?.dispose();
+                        return null;
+                    }
                     if (tex) {
                         tex.guid = lodInfo.guid;
                         tex.flipY = false;
@@ -1056,7 +1074,7 @@ export class NEEDLE_progressive {
         }
         return null;
     }
-    static queue = new PromiseQueue(50, { debug: debug != false });
+    static queue = new PromiseQueue(isMobileDevice() ? 20 : 50, { debug: debug != false });
     static assignLODInformation(url, res, key, level, index) {
         if (!res)
             return;

package/lib/version.js

@@ -1,4 +1,4 @@
 // replaced at build time
-export const version = "3.4.0-beta.2";
+export const version = "3.4.0-beta.4";
 globalThis["GLTF_PROGRESSIVE_VERSION"] = version;
 console.debug(`[gltf-progressive] version ${version || "-"}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-progressive",
-  "version": "3.4.0-beta.2",
+  "version": "3.4.0-beta.4",
   "description": "three.js support for loading glTF or GLB files that contain progressive loading data",
   "homepage": "https://needle.tools",
   "author": {