@needle-tools/gltf-progressive 3.0.0 → 3.0.1

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,4 @@ 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;

package/lib/utils.internal.js

@@ -50,3 +50,11 @@ export function isMobileDevice() {
         console.log("[glTF Progressive]: isMobileDevice", _ismobile);
     return _ismobile;
 }
+export function isDevelopmentServer() {
+    if (typeof window === "undefined")
+        return false;
+    const url = new URL(window.location.href);
+    const isLocalhostOrIpAddress = url.hostname === "localhost" || /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(url.hostname);
+    const isDevelopment = url.hostname === "127.0.0.1" || isLocalhostOrIpAddress;
+    return isDevelopment;
+}

package/lib/version.js

@@ -1,4 +1,4 @@
 // replaced at build time
-export const version = "3.0.0-alpha";
+export const version = "3.0.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.0.0",
+  "version": "3.0.1",
   "description": "three.js support for loading glTF or GLB files that contain progressive loading data",
   "homepage": "https://needle.tools",
   "author": {
@@ -72,4 +72,4 @@
     "vite": "<= 4.3.9"
   },
   "types": "./lib/index.d.ts"
-}
+}