@stowkit/three-loader 0.1.29 → 0.1.30

package/dist/stowkit-three-loader.js

@@ -212,34 +212,24 @@ 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);
-                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);
                 reject(new Error(`Failed to decode Draco geometry: ${error}`));
             });
         });
-        // Bounds will be computed automatically by Three.js when needed
-        const totalTime = performance.now();
-        reader.PerfLogger.log(`[Perf] Total geometry creation: ${(totalTime - startTime).toFixed(2)}ms`);
         return geometry;
     }
     /**
@@ -250,10 +240,12 @@ class MeshParser {
         root.name = 'StowKitMesh';
         const { geometries, materials, nodes, meshIndices } = parsedData;
         // Pre-load ALL geometries in parallel for maximum speed
-        reader.PerfLogger.log(`[Perf] Starting parallel Draco decode of ${geometries.length} geometries...`);
+        const dracoStart = performance.now();
         const geometryPromises = geometries.map(geoInfo => this.createGeometry(geoInfo, dataBlob, dracoLoader));
         const loadedGeometries = await Promise.all(geometryPromises);
-        reader.PerfLogger.log(`[Perf] All Draco decodes complete`);
+        const dracoTime = performance.now() - dracoStart;
+        const totalVerts = geometries.reduce((sum, g) => sum + g.vertexCount, 0);
+        reader.PerfLogger.log(`[Perf] Draco decode: ${dracoTime.toFixed(2)}ms (${geometries.length} meshes, ${totalVerts} total vertices)`);
         // Create all Three.js objects for nodes
         const nodeObjects = [];
         for (const node of nodes) {
@@ -673,17 +665,13 @@ class StowKitPack {
     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}`);
         }
@@ -691,18 +679,18 @@ 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();
         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'})`);
+        const textureTime = performance.now() - textureStart;
+        if (textureNames.length > 0) {
+            reader.PerfLogger.log(`[Perf] Textures: ${textureTime.toFixed(2)}ms (${textureNames.join(', ')})`);
+        }
         // 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 =====`);
+        const totalTime = performance.now() - totalStart;
+        reader.PerfLogger.log(`[Perf] === Mesh "${assetPath}": ${totalTime.toFixed(2)}ms total ===`);
         return scene;
     }
     /**
@@ -711,7 +699,6 @@ class StowKitPack {
     async loadTexture(assetPath) {
         // Check cache first
         if (this.textureCache.has(assetPath)) {
-            reader.PerfLogger.log(`[Perf] Texture cache hit: ${assetPath}`);
             return this.textureCache.get(assetPath);
         }
         // Cache the promise to avoid duplicate loads
@@ -1049,18 +1036,14 @@ class StowKitPack {
         return Array.from(uniqueTextures);
     }
     async loadKTX2Texture(data, textureName) {
-        reader.PerfLogger.log(`[Perf] KTX2/Basis texture size: ${data.byteLength} bytes${textureName ? ` (${textureName})` : ''}`);
         // Create blob URL - KTX2Loader requires a URL, can't use ArrayBuffer directly
         const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
         const blob = new Blob([arrayBuffer]);
         const url = URL.createObjectURL(blob);
         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 (${textureName || 'unknown'}, resolution: ${texture.image?.width || '?'}x${texture.image?.height || '?'})`);
                     texture.needsUpdate = true;
                     resolve(texture);
                 }, undefined, (error) => {