@stowkit/three-loader 0.1.25 → 0.1.27

package/dist/stowkit-three-loader.js

@@ -212,20 +212,25 @@ class MeshParser {
      * Create Three.js BufferGeometry from Draco compressed mesh data
      */
     static async createGeometry(geoInfo, dataBlob, dracoLoader) {
+        const startTime = performance.now();
         // Extract the Draco compressed buffer
         if (geoInfo.compressedBufferOffset + geoInfo.compressedBufferSize > dataBlob.length) {
             throw new Error(`Compressed buffer out of bounds: offset=${geoInfo.compressedBufferOffset}, size=${geoInfo.compressedBufferSize}, dataLength=${dataBlob.length}`);
         }
         const compressedData = dataBlob.slice(geoInfo.compressedBufferOffset, geoInfo.compressedBufferOffset + geoInfo.compressedBufferSize);
+        const extractTime = performance.now();
+        reader.PerfLogger.log(`[Perf] Draco extract: ${(extractTime - startTime).toFixed(2)}ms (${geoInfo.compressedBufferSize} bytes)`);
         // Decode using Draco
         // Create a blob URL for the Draco data (DRACOLoader expects a URL)
         const arrayBuffer = compressedData.buffer.slice(compressedData.byteOffset, compressedData.byteOffset + compressedData.byteLength);
         const blob = new Blob([arrayBuffer]);
         const url = URL.createObjectURL(blob);
+        const decodeStart = performance.now();
         const geometry = await new Promise((resolve, reject) => {
             dracoLoader.load(url, (decoded) => {
                 URL.revokeObjectURL(url);
-                // UVs are pre-flipped in the packer now
+                const decodeEnd = performance.now();
+                reader.PerfLogger.log(`[Perf] Draco decode: ${(decodeEnd - decodeStart).toFixed(2)}ms (vertices: ${geoInfo.vertexCount}, indices: ${geoInfo.indexCount})`);
                 resolve(decoded);
             }, undefined, (error) => {
                 URL.revokeObjectURL(url);
@@ -233,8 +238,13 @@ class MeshParser {
             });
         });
         // Compute bounding volumes
+        const boundsStart = performance.now();
         geometry.computeBoundingSphere();
         geometry.computeBoundingBox();
+        const boundsEnd = performance.now();
+        reader.PerfLogger.log(`[Perf] Bounds computation: ${(boundsEnd - boundsStart).toFixed(2)}ms`);
+        const totalTime = performance.now();
+        reader.PerfLogger.log(`[Perf] Total geometry creation: ${(totalTime - startTime).toFixed(2)}ms`);
         return geometry;
     }
     /**
@@ -331,6 +341,7 @@ class MeshParser {
  */
 class StowKitPack {
     constructor(reader, ktx2Loader, dracoLoader) {
+        this.textureCache = new Map();
         this.reader = reader;
         this.ktx2Loader = ktx2Loader;
         this.dracoLoader = dracoLoader;
@@ -660,14 +671,19 @@ class StowKitPack {
      * Load a mesh by its canonical path/name
      */
     async loadMesh(assetPath) {
+        const totalStart = performance.now();
         // Find asset by path
+        const findStart = performance.now();
         const assetIndex = this.reader.findAssetByPath(assetPath);
         if (assetIndex < 0) {
             throw new Error(`Mesh not found: ${assetPath}`);
         }
+        reader.PerfLogger.log(`[Perf] Find asset: ${(performance.now() - findStart).toFixed(2)}ms`);
         // Read mesh data and metadata
+        const readStart = performance.now();
         const data = this.reader.readAssetData(assetIndex);
         const metadata = this.reader.readAssetMetadata(assetIndex);
+        reader.PerfLogger.log(`[Perf] Read mesh data: ${(performance.now() - readStart).toFixed(2)}ms (data: ${data?.byteLength || 0} bytes, metadata: ${metadata?.byteLength || 0} bytes)`);
         if (!data) {
             throw new Error(`Failed to read mesh data: ${assetPath}`);
         }
@@ -675,29 +691,46 @@ class StowKitPack {
             throw new Error(`No metadata available: ${assetPath}`);
         }
         // Parse mesh data
+        const parseStart = performance.now();
         const parsedData = MeshParser.parseMeshData(metadata, data);
+        reader.PerfLogger.log(`[Perf] Parse mesh metadata: ${(performance.now() - parseStart).toFixed(2)}ms`);
         // Load textures for materials
+        const textureStart = performance.now();
         await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
+        reader.PerfLogger.log(`[Perf] Load textures: ${(performance.now() - textureStart).toFixed(2)}ms`);
         // Build Three.js scene with Draco decoder
+        const buildStart = performance.now();
         const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader);
+        reader.PerfLogger.log(`[Perf] Build scene: ${(performance.now() - buildStart).toFixed(2)}ms`);
+        reader.PerfLogger.log(`[Perf] ===== Total mesh load: ${(performance.now() - totalStart).toFixed(2)}ms =====`);
         return scene;
     }
     /**
      * Load a texture by its canonical path/name
      */
     async loadTexture(assetPath) {
-        // Find asset by path
-        const assetIndex = this.reader.findAssetByPath(assetPath);
-        if (assetIndex < 0) {
-            throw new Error(`Texture not found: ${assetPath}`);
-        }
-        // Read texture data
-        const data = this.reader.readAssetData(assetIndex);
-        if (!data) {
-            throw new Error(`Failed to read texture data: ${assetPath}`);
+        // Check cache first
+        if (this.textureCache.has(assetPath)) {
+            reader.PerfLogger.log(`[Perf] Texture cache hit: ${assetPath}`);
+            return this.textureCache.get(assetPath);
         }
-        // Load as KTX2
-        return await this.loadKTX2Texture(data);
+        // Cache the promise to avoid duplicate loads
+        const loadPromise = (async () => {
+            // Find asset by path
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0) {
+                throw new Error(`Texture not found: ${assetPath}`);
+            }
+            // Read texture data
+            const data = this.reader.readAssetData(assetIndex);
+            if (!data) {
+                throw new Error(`Failed to read texture data: ${assetPath}`);
+            }
+            // Load as KTX2
+            return await this.loadKTX2Texture(data);
+        })();
+        this.textureCache.set(assetPath, loadPromise);
+        return loadPromise;
     }
     /**
      * Load audio by its canonical path/name
@@ -976,36 +1009,54 @@ class StowKitPack {
      * Close the pack and free resources
      */
     dispose() {
+        this.textureCache.clear();
         this.reader.close();
     }
     // Private methods moved from StowKitLoader
     async loadMaterialTextures(materialData, materials) {
+        // Collect all texture load promises to load in parallel
+        const textureLoads = [];
         for (let i = 0; i < materialData.length; i++) {
             const matData = materialData[i];
-            const material = materials[i];
             for (const prop of matData.properties) {
-                // Trim and check for truly non-empty texture ID
                 const textureId = prop.textureId?.trim();
                 if (textureId && textureId.length > 0) {
-                    try {
-                        const texture = await this.loadTexture(textureId);
-                        this.applyTextureToMaterial(material, prop.fieldName, texture);
-                    }
-                    catch (error) {
-                        console.error(`Failed to load texture "${textureId}":`, error);
-                    }
+                    textureLoads.push({
+                        materialIndex: i,
+                        propertyName: prop.fieldName,
+                        texturePromise: this.loadTexture(textureId).catch(error => {
+                            console.error(`Failed to load texture "${textureId}":`, error);
+                            throw error;
+                        })
+                    });
                 }
             }
         }
+        // Load all textures in parallel
+        const results = await Promise.allSettled(textureLoads.map(load => load.texturePromise));
+        // Apply successfully loaded textures
+        for (let i = 0; i < textureLoads.length; i++) {
+            const result = results[i];
+            if (result.status === 'fulfilled') {
+                const load = textureLoads[i];
+                const material = materials[load.materialIndex];
+                this.applyTextureToMaterial(material, load.propertyName, result.value);
+            }
+        }
     }
     async loadKTX2Texture(data) {
+        performance.now();
         const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
         const blob = new Blob([arrayBuffer]);
         const url = URL.createObjectURL(blob);
+        reader.PerfLogger.log(`[Perf] KTX2/Basis texture size: ${data.byteLength} bytes`);
         try {
             return await new Promise((resolve, reject) => {
+                const loadStart = performance.now();
                 this.ktx2Loader.load(url, (texture) => {
                     URL.revokeObjectURL(url);
+                    const loadEnd = performance.now();
+                    reader.PerfLogger.log(`[Perf] Basis transcode: ${(loadEnd - loadStart).toFixed(2)}ms (resolution: ${texture.image?.width || '?'}x${texture.image?.height || '?'})`);
                     texture.needsUpdate = true;
                     resolve(texture);
                 }, undefined, (error) => {
@@ -1138,6 +1189,10 @@ Object.defineProperty(exports, 'AssetType', {
     enumerable: true,
     get: function () { return reader.AssetType; }
 });
+Object.defineProperty(exports, 'PerfLogger', {
+    enumerable: true,
+    get: function () { return reader.PerfLogger; }
+});
 exports.StowKitLoader = StowKitLoader;
 exports.StowKitPack = StowKitPack;
 //# sourceMappingURL=stowkit-three-loader.js.map