@stowkit/three-loader 0.1.26 → 0.1.28

package/dist/stowkit-three-loader.js

@@ -341,6 +341,7 @@ class MeshParser {
  */
 class StowKitPack {
     constructor(reader, ktx2Loader, dracoLoader) {
+        this.textureCache = new Map();
         this.reader = reader;
         this.ktx2Loader = ktx2Loader;
         this.dracoLoader = dracoLoader;
@@ -695,8 +696,8 @@ class StowKitPack {
         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`);
+        const textureNames = await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
+        reader.PerfLogger.log(`[Perf] Load textures: ${(performance.now() - textureStart).toFixed(2)}ms (${textureNames.length > 0 ? textureNames.join(', ') : 'none'})`);
         // Build Three.js scene with Draco decoder
         const buildStart = performance.now();
         const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader);
@@ -708,18 +709,28 @@ class StowKitPack {
      * 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}`);
+        // Check cache first
+        if (this.textureCache.has(assetPath)) {
+            reader.PerfLogger.log(`[Perf] Texture cache hit: ${assetPath}`);
+            return this.textureCache.get(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);
+        // 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
@@ -998,27 +1009,44 @@ 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 = [];
+        const uniqueTextures = new Set();
         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);
-                    }
+                    uniqueTextures.add(textureId);
+                    textureLoads.push({
+                        materialIndex: i,
+                        propertyName: prop.fieldName,
+                        textureId: textureId,
+                        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);
+            }
+        }
+        return Array.from(uniqueTextures);
     }
     async loadKTX2Texture(data) {
         performance.now();