@needle-tools/gltf-progressive 3.4.0-next.dbcee85 → 3.5.0-canary.4d42385

package/lib/utils.internal.js

@@ -71,10 +71,11 @@ export class PromiseQueue {
     _running = new Map();
     _queue = [];
     debug = false;
-    constructor(maxConcurrent = 100, opts = {}) {
+    constructor(maxConcurrent, opts = {}) {
         this.maxConcurrent = maxConcurrent;
         this.debug = opts.debug ?? false;
-        window.requestAnimationFrame(this.tick);
+        if (typeof window !== "undefined")
+            window.requestAnimationFrame(this.tick);
     }
     tick = () => {
         this.internalUpdate();
@@ -115,3 +116,95 @@ export class PromiseQueue {
         }
     }
 }
+// #region Texture Memory
+export function determineTextureMemoryInBytes(texture) {
+    const width = texture.image?.width ?? 0;
+    const height = texture.image?.height ?? 0;
+    const depth = texture.image?.depth ?? 1;
+    const mipLevels = Math.floor(Math.log2(Math.max(width, height, depth))) + 1;
+    const bytesPerPixel = getBytesPerPixel(texture);
+    const totalBytes = (width * height * depth * bytesPerPixel * (1 - Math.pow(0.25, mipLevels))) / (1 - 0.25);
+    return totalBytes;
+}
+function getBytesPerPixel(texture) {
+    // Determine channel count from format
+    let channels = 4; // Default RGBA
+    const format = texture.format;
+    if (format === 1024)
+        channels = 1; // RedFormat
+    else if (format === 1025)
+        channels = 1; // RedIntegerFormat
+    else if (format === 1026)
+        channels = 2; // RGFormat
+    else if (format === 1027)
+        channels = 2; // RGIntegerFormat
+    else if (format === 1022)
+        channels = 3; // RGBFormat
+    else if (format === 1029)
+        channels = 3; // RGBIntegerFormat
+    else if (format === 1023)
+        channels = 4; // RGBAFormat
+    else if (format === 1033)
+        channels = 4; // RGBAIntegerFormat
+    // Determine bytes per channel from type
+    let bytesPerChannel = 1; // UnsignedByteType default
+    const type = texture.type;
+    if (type === 1009)
+        bytesPerChannel = 1; // UnsignedByteType
+    else if (type === 1010)
+        bytesPerChannel = 1; // ByteType
+    else if (type === 1011)
+        bytesPerChannel = 2; // ShortType
+    else if (type === 1012)
+        bytesPerChannel = 2; // UnsignedShortType
+    else if (type === 1013)
+        bytesPerChannel = 4; // IntType
+    else if (type === 1014)
+        bytesPerChannel = 4; // UnsignedIntType
+    else if (type === 1015)
+        bytesPerChannel = 4; // FloatType
+    else if (type === 1016)
+        bytesPerChannel = 2; // HalfFloatType
+    const bytesPerPixel = channels * bytesPerChannel;
+    return bytesPerPixel;
+}
+// #region GPU
+let rendererInfo;
+/**
+ * Detect the GPU memory of the current device. This is a very rough estimate based on the renderer information, and may not be accurate. It returns the estimated memory in MB, or `undefined` if it cannot be detected.
+ */
+export function detectGPUMemory() {
+    if (rendererInfo !== undefined) {
+        return rendererInfo?.estimatedMemory;
+    }
+    const canvas = document.createElement('canvas');
+    const powerPreference = "high-performance";
+    const gl = canvas.getContext('webgl', { powerPreference }) || canvas.getContext('experimental-webgl', { powerPreference });
+    if (!gl) {
+        return undefined;
+    }
+    if ("getExtension" in gl) {
+        const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+        if (debugInfo) {
+            const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+            const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+            // Estimate memory based on renderer information (this is a very rough estimate)
+            let estimatedMemory = 512;
+            if (/NVIDIA/i.test(renderer)) {
+                estimatedMemory = 2048;
+            }
+            else if (/AMD/i.test(renderer)) {
+                estimatedMemory = 1024;
+            }
+            else if (/Intel/i.test(renderer)) {
+                estimatedMemory = 512;
+            }
+            rendererInfo = { vendor, renderer, estimatedMemory };
+            return estimatedMemory;
+        }
+    }
+    else {
+        rendererInfo = null;
+    }
+    return undefined;
+}

package/lib/version.js

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

package/lib/worker/loader.mainthread.js

@@ -21,7 +21,7 @@ export function getWorker(opts) {
 class GLTFLoaderWorker {
     worker;
     static async createWorker(opts) {
-        const worker = new Worker(new URL(`./loader.worker.js`, import.meta.url), {
+        const worker = new Worker(new URL(`./gltf-progressive.worker.js`, import.meta.url), {
             type: 'module',
         });
         const instance = new GLTFLoaderWorker(worker, opts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/gltf-progressive",
-  "version": "3.4.0-next.dbcee85",
+  "version": "3.5.0-canary.4d42385",
   "description": "three.js support for loading glTF or GLB files that contain progressive loading data",
   "homepage": "https://needle.tools",
   "author": {
@@ -12,6 +12,7 @@
     "type": "git",
     "url": "git+https://github.com/needle-tools/gltf-progressive"
   },
+  "license": "MIT",
   "readme": "README.md",
   "keywords": [
     "three.js",
@@ -41,7 +42,8 @@
     "gltf-progressive.js",
     "gltf-progressive.min.js",
     "gltf-progressive.umd.cjs",
-    "NEEDLE_progressive"
+    "NEEDLE_progressive",
+    "LICENSE"
   ],
   "watch": {
     "build:lib": {