@stowkit/three-loader 0.1.32 → 0.1.33

package/dist/stowkit-three-loader.js

@@ -521,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}`);
@@ -531,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);
@@ -582,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)
@@ -737,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);
@@ -836,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;
     }
     /**