@needle-tools/gltf-progressive 3.6.0-canary.5401de9 → 3.6.1

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/loaders.d.ts

@@ -28,7 +28,14 @@ export declare function setKTX2TranscoderLocation(location: string): void;
 export declare function createLoaders(renderer: WebGLRenderer | null): {
     dracoLoader: DRACOLoader;
     ktx2Loader: KTX2Loader;
-    meshoptDecoder: any;
+    meshoptDecoder: {
+        supported: boolean;
+        ready: Promise<void>;
+        decodeVertexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, filter?: string) => void;
+        decodeIndexBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+        decodeIndexSequence: (target: Uint8Array, count: number, size: number, source: Uint8Array) => void;
+        decodeGltfBuffer: (target: Uint8Array, count: number, size: number, source: Uint8Array, mode: string, filter?: string) => void;
+    };
 };
 export declare function addDracoAndKTX2Loaders(loader: GLTFLoader): void;
 /**

package/lib/lods.manager.js

@@ -88,8 +88,10 @@ export function calculateMeshLODLevel(options) {
     result.screenCoverage = 0;
     result.screenspaceVolume.set(0, 0, 0);
     result.centrality = 1;
-    if (!meshLods?.length)
-        return result;
+    // Note: we intentionally do NOT early-return when there are no mesh LODs.
+    // The screen coverage / screenspace volume computed below is also consumed by
+    // the texture LOD selection, which must keep working for meshes that only have
+    // texture LODs (no mesh LODs). Only the mesh LOD-level selection loop is skipped.
     let boundingBox = options.boundingBox ?? geometry.boundingBox;
     if (!boundingBox) {
         geometry.computeBoundingBox();
@@ -165,16 +167,18 @@ export function calculateMeshLODLevel(options) {
         debugDrawLine(_meshLODCorner1, _meshLODCorner3, 0x0000ff);
         debugDrawLine(_meshLODCorner2, _meshLODCorner3, 0x0000ff);
     }
-    for (let i = 0; i < meshLods.length; i++) {
-        const lod = meshLods[i];
-        const density = lod.densities?.[primitiveIndex] || lod.density || .00001;
-        if (primitiveIndex > 0 && warnMissingPrimitiveDensities && isDevelopmentServer() && !lod.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"]) {
-            globalThis["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 (density / screenCoverage < desiredDensity) {
-            result.level = i;
-            break;
+    if (meshLods?.length) {
+        for (let i = 0; i < meshLods.length; i++) {
+            const lod = meshLods[i];
+            const density = lod.densities?.[primitiveIndex] || lod.density || .00001;
+            if (primitiveIndex > 0 && warnMissingPrimitiveDensities && isDevelopmentServer() && !lod.densities && !globalThis["NEEDLE:MISSING_LOD_PRIMITIVE_DENSITIES"]) {
+                globalThis["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 (density / screenCoverage < desiredDensity) {
+                result.level = i;
+                break;
+            }
         }
     }
     return result;

package/lib/utils.d.ts

@@ -5,7 +5,7 @@ export declare const isSSR: boolean;
  * @param obj the object to get the raycast mesh from
  * @returns the raycast mesh or null if not set
  */
-export declare function getRaycastMesh(obj: Object3D): BufferGeometry<any, any> | null;
+export declare function getRaycastMesh(obj: Object3D): BufferGeometry<any> | null;
 /**
  * Set the raycast mesh for an object.
  * The raycast mesh is a low poly version of the mesh used for raycasting. It is set when a mesh that has LOD level with more vertices is discovered for the first time

package/lib/utils.internal.js

@@ -106,8 +106,14 @@ export class PromiseQueue {
     constructor(maxConcurrent, opts = {}) {
         this.maxConcurrent = maxConcurrent;
         this.debug = opts.debug ?? false;
-        if (typeof window !== "undefined")
-            window.requestAnimationFrame(this.tick);
+        // Dedicated workers can have requestAnimationFrame when they are owned by a window.
+        // Other worker-like scopes do not, so keep the frame-based tick when available and fall back to timers otherwise.
+        if (typeof globalThis.requestAnimationFrame === "function") {
+            globalThis.requestAnimationFrame(this.tick);
+        }
+        else {
+            setTimeout(this.tick, 0);
+        }
     }
     tick = () => {
         this.internalUpdate();

package/lib/version.js

@@ -1,4 +1,4 @@
 // replaced at build time
-export const version = "3.6.0-alpha.3";
+export const version = "3.6.1";
 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-canary.5401de9",
+  "version": "3.6.1",
   "description": "three.js support for loading glTF or GLB files that contain progressive loading data",
   "homepage": "https://needle.tools",
   "author": {
@@ -62,7 +62,7 @@
     "@needle-tools/engine": "^5.1.0-alpha.6",
     "@needle-tools/three-test-matrix": "^0.1.0",
     "@stylistic/eslint-plugin-ts": "^1.5.4",
-    "@types/three": "0.183.1",
+    "@types/three": "0.169.0",
     "@typescript-eslint/eslint-plugin": "^6.2.0",
     "@typescript-eslint/parser": "^6.2.0",
     "@vitest/browser-playwright": "^4.1.8",
@@ -80,4 +80,4 @@
     "vitest": "^4.1.8"
   },
   "types": "./lib/index.d.ts"
-}
+}