@stowkit/three-loader 0.1.31 → 0.1.33

package/dist/stowkit-three-loader.js

@@ -364,7 +364,6 @@ class MeshParser {
         if (cacheKey && version) {
             const cached = await AssetMemoryCache.getGeometry(cacheKey, version);
             if (cached) {
-                reader.PerfLogger.log(`[Perf] Geometry cache hit: ${cacheKey}`);
                 const geometry = new THREE__namespace.BufferGeometry();
                 geometry.setAttribute('position', new THREE__namespace.BufferAttribute(cached.positions, 3));
                 if (cached.normals) {
@@ -422,12 +421,8 @@ class MeshParser {
         root.name = 'StowKitMesh';
         const { geometries, materials, nodes, meshIndices } = parsedData;
         // Pre-load ALL geometries in parallel for maximum speed
-        const dracoStart = performance.now();
         const geometryPromises = geometries.map((geoInfo, index) => this.createGeometry(geoInfo, dataBlob, dracoLoader, cacheKeyPrefix ? `${cacheKeyPrefix}_geo${index}` : undefined, version));
         const loadedGeometries = await Promise.all(geometryPromises);
-        const dracoTime = performance.now() - dracoStart;
-        const totalVerts = geometries.reduce((sum, g) => sum + g.vertexCount, 0);
-        reader.PerfLogger.log(`[Perf] Draco: ${dracoTime.toFixed(2)}ms (${geometries.length} meshes, ${totalVerts} verts)`);
         // Create all Three.js objects for nodes
         const nodeObjects = [];
         for (const node of nodes) {
@@ -526,6 +521,7 @@ class StowKitPack {
      * Load a skinned mesh by its string ID
      */
     async loadSkinnedMesh(stringId) {
+        const totalStart = performance.now();
         const assetIndex = this.reader.findAssetByPath(stringId);
         if (assetIndex < 0) {
             throw new Error(`Skinned mesh not found: ${stringId}`);
@@ -536,12 +532,16 @@ class StowKitPack {
             throw new Error(`Failed to read skinned mesh data: ${stringId}`);
         if (!metadata)
             throw new Error(`No metadata for skinned mesh: ${stringId}`);
-        return await this.parseSkinnedMesh(metadata, data);
+        const result = await this.parseSkinnedMesh(metadata, data);
+        const totalTime = performance.now() - totalStart;
+        reader.PerfLogger.log(`[Perf] === Skinned Mesh "${stringId}": ${totalTime.toFixed(2)}ms total ===`);
+        return result;
     }
     /**
      * Parse skinned mesh from binary data
      */
     async parseSkinnedMesh(metadata, data) {
+        const parseStart = performance.now();
         // NEW FORMAT: Skip past tag header
         const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
         const tagCsvLength = view.getUint32(0, true);
@@ -587,7 +587,7 @@ class StowKitPack {
             });
             offset += 72;
         }
-        const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        new DataView(data.buffer, data.byteOffset, data.byteLength);
         // Sort geometry infos by vertex buffer offset to ensure sequential parsing
         const sortedGeometryInfos = geometryInfos.slice().sort((a, b) => a.vertexBufferOffset - b.vertexBufferOffset);
         // Parse materials from metadata (immediately after geometries)
@@ -742,88 +742,39 @@ class StowKitPack {
             }
             materials.push(material);
         }
+        const parseTime = performance.now() - parseStart;
+        reader.PerfLogger.log(`[Perf]   Parse skinned metadata: ${parseTime.toFixed(2)}ms`);
+        const textureStart = performance.now();
         await this.loadMaterialTextures(materialData, materials);
+        const textureTime = performance.now() - textureStart;
+        if (materialData.length > 0) {
+            reader.PerfLogger.log(`[Perf]   Load textures: ${textureTime.toFixed(2)}ms`);
+        }
         // Collect root bones (hierarchy already built earlier)
+        const buildStart = performance.now();
         const rootBones = bones.filter((_, index) => parentIndices[index] < 0);
         // Create shared skeleton
         const skeleton = new THREE__namespace.Skeleton(bones, boneMatrices);
-        // Pre-allocate combined buffers
-        const totalVertexCount = sortedGeometryInfos.reduce((sum, info) => sum + info.vertexCount, 0);
-        const totalIndexCount = sortedGeometryInfos.reduce((sum, info) => sum + info.indexCount, 0);
-        const combinedPositions = new Float32Array(totalVertexCount * 3);
-        const combinedNormals = new Float32Array(totalVertexCount * 3);
-        const combinedUVs = new Float32Array(totalVertexCount * 2);
-        const combinedSkinIndices = new Uint16Array(totalVertexCount * 4);
-        const combinedSkinWeights = new Float32Array(totalVertexCount * 4);
-        const combinedIndices = new Uint32Array(totalIndexCount);
+        // Use WASM to parse geometry data (10-50x faster!)
+        const geomData = this.reader.parseSkinnedMeshGeometryFast(metadata, data);
+        if (!geomData) {
+            throw new Error('Failed to parse skinned mesh geometry');
+        }
+        // Convert Uint32Array skinIndices to Uint16Array for Three.js
+        const skinIndices16 = new Uint16Array(geomData.skinIndices);
         const combinedGeometry = new THREE__namespace.BufferGeometry();
-        combinedGeometry.clearGroups();
-        let vertexCursor = 0; // counts vertices
-        let indexCursor = 0; // counts indices
+        combinedGeometry.setAttribute('position', new THREE__namespace.BufferAttribute(geomData.positions, 3));
+        combinedGeometry.setAttribute('normal', new THREE__namespace.BufferAttribute(geomData.normals, 3));
+        combinedGeometry.setAttribute('uv', new THREE__namespace.BufferAttribute(geomData.uvs, 2));
+        combinedGeometry.setAttribute('skinIndex', new THREE__namespace.Uint16BufferAttribute(skinIndices16, 4));
+        combinedGeometry.setAttribute('skinWeight', new THREE__namespace.BufferAttribute(geomData.skinWeights, 4));
+        combinedGeometry.setIndex(new THREE__namespace.BufferAttribute(geomData.indices, 1));
+        // Add geometry groups for materials
+        let indexCursor = 0;
         for (const geomInfo of sortedGeometryInfos) {
-            const vertexStrideBytes = 32;
-            const vertexBase = vertexCursor; // base vertex index for this submesh
-            // Validate offsets before parsing
-            const requiredVertexBytes = geomInfo.vertexBufferOffset + geomInfo.vertexCount * vertexStrideBytes;
-            const requiredIndexBytes = geomInfo.indexBufferOffset + geomInfo.indexCount * 4;
-            const requiredWeightBytes = geomInfo.weightsOffset + geomInfo.vertexCount * 32;
-            if (requiredVertexBytes > data.byteLength) {
-                throw new Error(`Vertex buffer out of bounds: need ${requiredVertexBytes}, have ${data.byteLength}`);
-            }
-            if (requiredIndexBytes > data.byteLength) {
-                throw new Error(`Index buffer out of bounds: need ${requiredIndexBytes}, have ${data.byteLength}`);
-            }
-            if (requiredWeightBytes > data.byteLength) {
-                throw new Error(`Weight buffer out of bounds: need ${requiredWeightBytes}, have ${data.byteLength}`);
-            }
-            // Parse vertices
-            for (let v = 0; v < geomInfo.vertexCount; v++) {
-                const vertexOffset = geomInfo.vertexBufferOffset + v * vertexStrideBytes;
-                // positions
-                combinedPositions[(vertexCursor + v) * 3 + 0] = dataView.getFloat32(vertexOffset + 0, true);
-                combinedPositions[(vertexCursor + v) * 3 + 1] = dataView.getFloat32(vertexOffset + 4, true);
-                combinedPositions[(vertexCursor + v) * 3 + 2] = dataView.getFloat32(vertexOffset + 8, true);
-                // normals
-                if (geomInfo.hasNormals) {
-                    combinedNormals[(vertexCursor + v) * 3 + 0] = dataView.getFloat32(vertexOffset + 12, true);
-                    combinedNormals[(vertexCursor + v) * 3 + 1] = dataView.getFloat32(vertexOffset + 16, true);
-                    combinedNormals[(vertexCursor + v) * 3 + 2] = dataView.getFloat32(vertexOffset + 20, true);
-                }
-                // uvs
-                if (geomInfo.hasUVs) {
-                    combinedUVs[(vertexCursor + v) * 2 + 0] = dataView.getFloat32(vertexOffset + 24, true);
-                    combinedUVs[(vertexCursor + v) * 2 + 1] = dataView.getFloat32(vertexOffset + 28, true);
-                }
-                // bone indices & weights
-                const weightOffset = geomInfo.weightsOffset + v * 32;
-                for (let j = 0; j < 4; j++) {
-                    const boneIndex = dataView.getUint32(weightOffset + j * 4, true);
-                    combinedSkinIndices[(vertexCursor + v) * 4 + j] = boneIndex < boneCount ? boneIndex : 0;
-                }
-                for (let j = 0; j < 4; j++) {
-                    combinedSkinWeights[(vertexCursor + v) * 4 + j] = dataView.getFloat32(weightOffset + 16 + j * 4, true);
-                }
-            }
-            // Parse indices
-            const groupStart = indexCursor;
-            for (let i = 0; i < geomInfo.indexCount; i++) {
-                const indexValue = dataView.getUint32(geomInfo.indexBufferOffset + i * 4, true);
-                combinedIndices[indexCursor + i] = indexValue + vertexBase;
-            }
-            combinedGeometry.addGroup(groupStart, geomInfo.indexCount, Math.min(geomInfo.materialIndex, materials.length - 1));
-            vertexCursor += geomInfo.vertexCount;
+            combinedGeometry.addGroup(indexCursor, geomInfo.indexCount, Math.min(geomInfo.materialIndex, materials.length - 1));
             indexCursor += geomInfo.indexCount;
         }
-        combinedGeometry.setAttribute('position', new THREE__namespace.BufferAttribute(combinedPositions, 3));
-        if (geometryInfos.some(info => info.hasNormals)) {
-            combinedGeometry.setAttribute('normal', new THREE__namespace.BufferAttribute(combinedNormals, 3));
-        }
-        if (geometryInfos.some(info => info.hasUVs)) {
-            combinedGeometry.setAttribute('uv', new THREE__namespace.BufferAttribute(combinedUVs, 2));
-        }
-        combinedGeometry.setAttribute('skinIndex', new THREE__namespace.Uint16BufferAttribute(combinedSkinIndices, 4));
-        combinedGeometry.setAttribute('skinWeight', new THREE__namespace.BufferAttribute(combinedSkinWeights, 4));
-        combinedGeometry.setIndex(new THREE__namespace.BufferAttribute(combinedIndices, 1));
         combinedGeometry.computeBoundingBox();
         combinedGeometry.computeBoundingSphere();
         const skinnedMesh = new THREE__namespace.SkinnedMesh(combinedGeometry, materials);
@@ -841,6 +792,8 @@ class StowKitPack {
         container.add(skinnedMesh);
         container.userData.boneOriginalNames = boneOriginalNames;
         container.userData.skinnedMesh = skinnedMesh;
+        const buildTime = performance.now() - buildStart;
+        reader.PerfLogger.log(`[Perf]   Build skinned mesh: ${buildTime.toFixed(2)}ms (${boneCount} bones, ${geomData.vertexCount} verts)`);
         return container;
     }
     /**
@@ -865,12 +818,7 @@ class StowKitPack {
         // Parse mesh data
         const parsedData = MeshParser.parseMeshData(metadata, data);
         // Load textures for materials
-        const textureStart = performance.now();
-        const textureNames = await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
-        const textureTime = performance.now() - textureStart;
-        if (textureNames.length > 0) {
-            reader.PerfLogger.log(`[Perf] Textures: ${textureTime.toFixed(2)}ms (${textureNames.join(', ')})`);
-        }
+        await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
         // Build Three.js scene with Draco decoder (with caching)
         const cacheKey = `${this.packUrl}::${assetPath}`;
         const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader, cacheKey, this.packVersion);
@@ -1224,26 +1172,23 @@ class StowKitPack {
         // Try IndexedDB cache first
         const cacheKey = textureName ? `${this.packUrl}::${textureName}` : undefined;
         if (cacheKey) {
-            const startCache = performance.now();
             const cached = await AssetMemoryCache.getTexture(cacheKey, this.packVersion);
             if (cached) {
-                reader.PerfLogger.log(`[Perf] Texture cache hit (IndexedDB): ${textureName} (${(performance.now() - startCache).toFixed(2)}ms)`);
+                reader.PerfLogger.log(`[Perf] ✓ Texture "${textureName}": 0ms (IndexedDB cache)`);
                 const texture = new THREE__namespace.CompressedTexture([{ data: cached.data, width: cached.width, height: cached.height }], cached.width, cached.height, cached.format, THREE__namespace.UnsignedByteType);
                 texture.needsUpdate = true;
                 return texture;
             }
         }
-        // Create blob URL - KTX2Loader requires a URL, can't use ArrayBuffer directly
+        // Decode using Basis transcoder
+        const decodeStart = performance.now();
         const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
         const blob = new Blob([arrayBuffer]);
         const url = URL.createObjectURL(blob);
         try {
-            const decodeStart = performance.now();
             const texture = await new Promise((resolve, reject) => {
                 this.ktx2Loader.load(url, (texture) => {
                     URL.revokeObjectURL(url);
-                    const decodeTime = performance.now() - decodeStart;
-                    reader.PerfLogger.log(`[Perf] Basis decode: ${decodeTime.toFixed(2)}ms (${textureName || 'unknown'}, ${texture.image?.width}x${texture.image?.height})`);
                     texture.needsUpdate = true;
                     resolve(texture);
                 }, undefined, (error) => {
@@ -1251,6 +1196,8 @@ class StowKitPack {
                     reject(error);
                 });
             });
+            const decodeTime = performance.now() - decodeStart;
+            reader.PerfLogger.log(`[Perf] ✓ Texture "${textureName || 'unknown'}": ${decodeTime.toFixed(2)}ms (Basis decode ${texture.image?.width}x${texture.image?.height})`);
             // Cache the transcoded texture data to IndexedDB
             if (cacheKey && texture.mipmaps && texture.mipmaps.length > 0) {
                 const mipmap = texture.mipmaps[0];