@needle-tools/gltf-progressive 3.6.0 → 3.6.2

package/lib/extension.js

@@ -796,6 +796,8 @@ export class NEEDLE_progressive {
             }
         }
         else {
+            // Requests already waiting for a queue slot must not populate a new cache lifetime.
+            this.cacheGeneration++;
             this.lodInfos.clear();
             for (const [, entryRef] of this.lowresCache) {
                 const entry = entryRef.deref();
@@ -840,6 +842,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)) {
@@ -938,8 +941,11 @@ export class NEEDLE_progressive {
         }
     }
     static workers = [];
+    static cacheGeneration = 0;
+    static disposedRequests = new WeakSet();
     static _workersIndex = 0;
     static async getOrLoadLOD(current, level, options) {
+        const generation = this.cacheGeneration;
         const debugverbose = debug == "verbose";
         /** this key is used to lookup the LOD information */
         const LOD = this.getAssignedLODInformation(current);
@@ -1010,6 +1016,8 @@ export class NEEDLE_progressive {
                 const KEY = lod_url + "_" + lodInfo.guid;
                 // check if the requested file is currently being loaded or was previously loaded
                 const cached = await this.tryResolveLODCacheEntry(this.cache.get(KEY), KEY, lod_url, current, level, debugverbose);
+                if (generation !== this.cacheGeneration)
+                    return null;
                 if (cached.found)
                     return cached.value;
                 if (options?.isCurrent?.() === false) {
@@ -1018,6 +1026,8 @@ export class NEEDLE_progressive {
                     return null;
                 }
                 const slot = await this.queue.slot(lod_url);
+                if (generation !== this.cacheGeneration)
+                    return null;
                 if (options?.isCurrent?.() === false) {
                     if (debugverbose)
                         console.log(`Skipping stale LOD ${level} request after queue: ${lod_url}`);
@@ -1026,8 +1036,20 @@ export class NEEDLE_progressive {
                 // 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);
+                if (generation !== this.cacheGeneration)
+                    return null;
                 if (cachedAfterQueue.found)
                     return cachedAfterQueue.value;
+                // Even a cache miss above yields a microtask. Another slot holder can
+                // start this same request before that continuation resumes.
+                const startedMeanwhile = this.cache.get(KEY);
+                if (startedMeanwhile !== undefined) {
+                    const cached = await this.tryResolveLODCacheEntry(startedMeanwhile, KEY, lod_url, current, level, debugverbose);
+                    if (generation !== this.cacheGeneration)
+                        return null;
+                    if (cached.found)
+                        return cached.value;
+                }
                 // #region loading
                 if (!slot.use) {
                     if (debug)
@@ -1175,6 +1197,10 @@ export class NEEDLE_progressive {
                 this.cache.set(KEY, request);
                 slot.use(request);
                 const res = await request;
+                // dispose() owns cleanup of removed pending entries. Do not return their
+                // disposed resources to callers 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) {
@@ -1212,7 +1238,7 @@ export class NEEDLE_progressive {
                         console.log("Load texture from uri: " + lod_url);
                     const loader = new TextureLoader();
                     const tex = await loader.loadAsync(lod_url);
-                    if (options?.isCurrent?.() === false) {
+                    if (generation !== this.cacheGeneration || options?.isCurrent?.() === false) {
                         tex?.dispose();
                         return null;
                     }
@@ -1269,6 +1295,8 @@ export class NEEDLE_progressive {
             console.error(`Error loading LOD ${level} from ${lodUrl}\n`, err);
             return null;
         });
+        if (this.disposedRequests.has(existing))
+            return { found: true, value: null };
         let resourceIsDisposed = false;
         if (res == null) {
             // Failed loads stay cached as null so we don't retry the same missing resource forever.

package/lib/index.d.ts

@@ -2,7 +2,7 @@ export { version as VERSION } from "./version.js";
 export * from "./extension.js";
 export * from "./plugins/index.js";
 export { LODsManager, calculateMeshLODLevel, getLODColor, lodDebugColors, type LOD_Results, type MeshLODSelectionOptions, type MeshLODSelectionResult } from "./lods.manager.js";
-export { setDracoDecoderLocation, setKTX2TranscoderLocation, createLoaders, addDracoAndKTX2Loaders, configureLoader } from "./loaders.js";
+export { setDracoDecoderLocation, setKTX2TranscoderLocation, createLoaders, disposeLoaders, 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";

package/lib/index.js

@@ -2,7 +2,7 @@ export { version as VERSION } from "./version.js";
 export * from "./extension.js";
 export * from "./plugins/index.js";
 export { LODsManager, calculateMeshLODLevel, getLODColor, lodDebugColors } from "./lods.manager.js";
-export { setDracoDecoderLocation, setKTX2TranscoderLocation, createLoaders, addDracoAndKTX2Loaders, configureLoader } from "./loaders.js";
+export { setDracoDecoderLocation, setKTX2TranscoderLocation, createLoaders, disposeLoaders, 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";

package/lib/loaders.d.ts

@@ -37,6 +37,8 @@ export declare function createLoaders(renderer: WebGLRenderer | null): {
         decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string) => void;
     };
 };
+/** Release the shared Draco and KTX2 workers when no engine context uses them. */
+export declare function disposeLoaders(): void;
 export declare function addDracoAndKTX2Loaders(loader: GLTFLoader): void;
 /**
  * Smart loading hints can be used by needle infrastructure to deliver assets optimized for a specific usecase.

package/lib/loaders.js

@@ -40,7 +40,8 @@ fetch(_remoteDracoDecoderUrl, {
     }
 })
     .finally(() => {
-    prepareLoaders();
+    if (preloadLoaders)
+        prepareLoaders();
 });
 // #region Loader Configuration
 /**
@@ -89,15 +90,25 @@ export function setKTX2TranscoderLocation(location) {
  * @returns The loaders/decoders.
  */
 export function createLoaders(renderer) {
-    prepareLoaders();
+    preloadLoaders = true;
+    const loaders = prepareLoaders();
     if (renderer) {
-        ktx2Loader.detectSupport(renderer);
+        loaders.ktx2Loader.detectSupport(renderer);
     }
     else if (renderer !== null)
         console.warn("No renderer provided to detect ktx2 support - loading KTX2 textures might fail");
-    return { dracoLoader, ktx2Loader, meshoptDecoder };
+    return loaders;
+}
+/** Release the shared Draco and KTX2 workers when no engine context uses them. */
+export function disposeLoaders() {
+    preloadLoaders = false;
+    dracoLoader?.dispose();
+    ktx2Loader?.dispose();
+    dracoLoader = undefined;
+    ktx2Loader = undefined;
 }
 export function addDracoAndKTX2Loaders(loader) {
+    const { dracoLoader, ktx2Loader, meshoptDecoder } = prepareLoaders();
     if (!loader.dracoLoader)
         loader.setDRACOLoader(dracoLoader);
     if (!loader.ktx2Loader)
@@ -107,6 +118,7 @@ export function addDracoAndKTX2Loaders(loader) {
 }
 // #region internal
 const $dracoDecoderPath = Symbol("dracoDecoderPath");
+let preloadLoaders = true;
 let dracoLoader;
 let meshoptDecoder;
 let ktx2Loader;
@@ -127,6 +139,7 @@ function prepareLoaders() {
     if (!meshoptDecoder) {
         meshoptDecoder = MeshoptDecoder;
     }
+    return { dracoLoader, ktx2Loader, meshoptDecoder };
 }
 const gltfLoaderConfigurations = new WeakMap();
 export function configureLoader(loader, opts) {

package/lib/version.js

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