@needle-tools/gltf-progressive 3.6.0-alpha.2 → 3.6.0-alpha.3

package/lib/extension.js

@@ -223,13 +223,19 @@ export class NEEDLE_progressive {
             }
             // const info = this.onProgressiveLoadStart(context, source, mesh, null);
             mesh["LOD:requested level"] = level;
-            return NEEDLE_progressive.getOrLoadLOD(currentGeometry, level).then(geo => {
+            const shouldLoad = () => mesh["LOD:requested level"] === level || this.shouldApplyStaleMeshLOD(mesh, level);
+            return NEEDLE_progressive.getOrLoadLOD(currentGeometry, level, {
+                isCurrent: shouldLoad,
+            }).then(geo => {
                 if (Array.isArray(geo)) {
                     const index = lodinfo.index || 0;
                     geo = geo[index];
                 }
-                if (mesh["LOD:requested level"] === level) {
-                    delete mesh["LOD:requested level"];
+                const isLatestRequest = mesh["LOD:requested level"] === level;
+                if (isLatestRequest || this.shouldApplyStaleMeshLOD(mesh, level)) {
+                    if (isLatestRequest) {
+                        delete mesh["LOD:requested level"];
+                    }
                     if (geo && currentGeometry != geo) {
                         const isGeometry = geo?.isBufferGeometry;
                         // if (debug == "verbose") console.log("Progressive Mesh " + mesh.name + " loaded", currentGeometry, "→", geo, "\n", mesh)
@@ -373,7 +379,14 @@ export class NEEDLE_progressive {
                 return pending.promise;
             }
         }
-        const promise = NEEDLE_progressive.getOrLoadLOD(current, level).then(tex => {
+        const requestId = material && slot ? this.nextTextureSlotRequestId(material, slot, level, force) : 0;
+        const isCurrentRequest = () => !material || !slot || this.getLatestTextureSlotRequest(material, slot)?.id === requestId;
+        const shouldLoad = () => isCurrentRequest() || this.shouldApplyStaleTextureSlotLOD(material, slot, level, force);
+        const promise = NEEDLE_progressive.getOrLoadLOD(current, level, {
+            isCurrent: shouldLoad,
+        }).then(tex => {
+            if (!isCurrentRequest() && !this.shouldApplyStaleTextureSlotLOD(material, slot, level, force))
+                return null;
             // this can currently not happen
             if (Array.isArray(tex)) {
                 console.warn("Progressive: Got an array of textures for a texture slot, this should not happen...");
@@ -415,7 +428,7 @@ export class NEEDLE_progressive {
             return null;
         });
         if (material && slot) {
-            this.setPendingTextureSlotRequest(material, slot, level, force, promise);
+            this.setPendingTextureSlotRequest(material, slot, level, force, requestId, promise);
         }
         return promise;
     }
@@ -423,6 +436,8 @@ export class NEEDLE_progressive {
     // referenced by many slots and should only be disposed after every slot moved away.
     static trackedTextureSlots = new WeakMap();
     static pendingTextureSlotRequests = new WeakMap();
+    static latestTextureSlotRequests = new WeakMap();
+    static textureSlotRequestId = 0;
     static trackCurrentMaterialTextureSlots(material) {
         if (material.uniforms && (material.isRawShaderMaterial || material.isShaderMaterial === true)) {
             const shaderMaterial = material;
@@ -444,17 +459,52 @@ export class NEEDLE_progressive {
     static getPendingTextureSlotRequest(material, slot) {
         return this.pendingTextureSlotRequests.get(material)?.get(slot);
     }
-    static setPendingTextureSlotRequest(material, slot, level, force, promise) {
+    static nextTextureSlotRequestId(material, slot, level, force) {
+        let slots = this.latestTextureSlotRequests.get(material);
+        if (!slots) {
+            slots = new Map();
+            this.latestTextureSlotRequests.set(material, slots);
+        }
+        const id = ++this.textureSlotRequestId;
+        slots.set(slot, { id, level, force });
+        return id;
+    }
+    static getLatestTextureSlotRequest(material, slot) {
+        return this.latestTextureSlotRequests.get(material)?.get(slot);
+    }
+    static shouldApplyStaleTextureSlotLOD(material, slot, level, force) {
+        if (!material || !slot)
+            return false;
+        const latest = this.getLatestTextureSlotRequest(material, slot);
+        const assigned = this.getMaterialTextureSlot(material, slot);
+        const assignedLODLevel = this.getAssignedLODInformation(assigned)?.level ?? Infinity;
+        if (level >= assignedLODLevel)
+            return false;
+        if (force) {
+            if (!latest)
+                return false;
+            return level >= latest.level;
+        }
+        return true;
+    }
+    static shouldApplyStaleMeshLOD(mesh, level) {
+        const latestLevel = mesh["LOD:requested level"];
+        if (typeof latestLevel !== "number")
+            return false;
+        const assignedLODLevel = this.getAssignedLODInformation(mesh.geometry)?.level ?? Infinity;
+        return level < assignedLODLevel && level >= latestLevel;
+    }
+    static setPendingTextureSlotRequest(material, slot, level, force, id, promise) {
         let slots = this.pendingTextureSlotRequests.get(material);
         if (!slots) {
             slots = new Map();
             this.pendingTextureSlotRequests.set(material, slots);
         }
-        const request = { level, force, promise };
+        const request = { level, force, id, promise };
         slots.set(slot, request);
         promise.finally(() => {
             const current = slots.get(slot);
-            if (current === request) {
+            if (current?.id === id) {
                 slots.delete(slot);
             }
         });
@@ -771,6 +821,8 @@ export class NEEDLE_progressive {
             this.textureRefCounts.clear();
             this.trackedTextureSlots = new WeakMap();
             this.pendingTextureSlotRequests = new WeakMap();
+            this.latestTextureSlotRequests = new WeakMap();
+            this.textureSlotRequestId = 0;
         }
     }
     /** Dispose a single cache entry's three.js resource(s) to free GPU memory. */
@@ -889,7 +941,7 @@ export class NEEDLE_progressive {
     }
     static workers = [];
     static _workersIndex = 0;
-    static async getOrLoadLOD(current, level) {
+    static async getOrLoadLOD(current, level, options) {
         const debugverbose = debug == "verbose";
         /** this key is used to lookup the LOD information */
         const LOD = this.getAssignedLODInformation(current);
@@ -962,7 +1014,17 @@ export class NEEDLE_progressive {
                 const cached = await this.tryResolveLODCacheEntry(this.cache.get(KEY), KEY, lod_url, current, level, debugverbose);
                 if (cached.found)
                     return cached.value;
+                if (options?.isCurrent?.() === false) {
+                    if (debugverbose)
+                        console.log(`Skipping stale LOD ${level} request before queue: ${lod_url}`);
+                    return null;
+                }
                 const slot = await this.queue.slot(lod_url);
+                if (options?.isCurrent?.() === false) {
+                    if (debugverbose)
+                        console.log(`Skipping stale LOD ${level} request after queue: ${lod_url}`);
+                    return null;
+                }
                 // Another request can fill the cache while this one waits for a queue slot.
                 // Re-checking here avoids duplicate loads for heavily instanced assets.
                 const cachedAfterQueue = await this.tryResolveLODCacheEntry(this.cache.get(KEY), KEY, lod_url, current, level, debugverbose);
@@ -1143,10 +1205,19 @@ export class NEEDLE_progressive {
             }
             else {
                 if (current instanceof Texture) {
+                    if (options?.isCurrent?.() === false) {
+                        if (debugverbose)
+                            console.log(`Skipping stale texture LOD ${level} request: ${lod_url}`);
+                        return null;
+                    }
                     if (debugverbose)
                         console.log("Load texture from uri: " + lod_url);
                     const loader = new TextureLoader();
                     const tex = await loader.loadAsync(lod_url);
+                    if (options?.isCurrent?.() === false) {
+                        tex?.dispose();
+                        return null;
+                    }
                     if (tex) {
                         tex.guid = lodInfo.guid;
                         tex.flipY = false;

package/lib/version.js

@@ -1,4 +1,4 @@
 // replaced at build time
-export const version = "3.6.0-alpha.2";
+export const version = "3.6.0-alpha.3";
 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.6.0-alpha.2",
+  "version": "3.6.0-alpha.3",
   "description": "three.js support for loading glTF or GLB files that contain progressive loading data",
   "homepage": "https://needle.tools",
   "author": {