@stowkit/three-loader 0.1.17 → 0.1.19

package/dist/stowkit-three-loader.js

@@ -29,13 +29,22 @@ class MeshParser {
      * Parse mesh metadata from binary data
      */
     static parseMeshMetadata(data) {
+        // NEW FORMAT: Skip past tag header
+        // Format: [4-byte tag_csv_length][CSV string][MeshMetadata struct]
         const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const tagCsvLength = view.getUint32(0, true);
+        const metadataOffset = 4 + tagCsvLength;
+        if (metadataOffset >= data.length) {
+            throw new Error('Invalid metadata: tag header exceeds bounds');
+        }
+        const actualMetadata = data.slice(metadataOffset);
+        const metaView = new DataView(actualMetadata.buffer, actualMetadata.byteOffset, actualMetadata.byteLength);
         // MeshMetadata structure (140 bytes total when packed)
         const metadata = {
-            meshGeometryCount: view.getUint32(0, true),
-            materialCount: view.getUint32(4, true),
-            nodeCount: view.getUint32(8, true),
-            stringId: this.readString(data.slice(12, 140)) // 128 bytes for string
+            meshGeometryCount: metaView.getUint32(0, true),
+            materialCount: metaView.getUint32(4, true),
+            nodeCount: metaView.getUint32(8, true),
+            stringId: this.readString(actualMetadata.slice(12, 140)) // 128 bytes for string
         };
         return metadata;
     }
@@ -43,21 +52,24 @@ class MeshParser {
      * Parse complete mesh data including geometry, materials, and nodes
      */
     static parseMeshData(metadataBlob, dataBlob) {
-        // Ensure we have at least the minimum metadata size
-        if (metadataBlob.length < 140) {
-            throw new Error(`Metadata blob too small: ${metadataBlob.length} bytes (expected at least 140)`);
-        }
-        const metadata = this.parseMeshMetadata(metadataBlob);
-        // Check if the metadata blob contains just the header or all the mesh info
-        const expectedMetadataSize = 140 +
+        // NEW FORMAT: Account for tag header at front
+        const view = new DataView(metadataBlob.buffer, metadataBlob.byteOffset, metadataBlob.byteLength);
+        const tagCsvLength = view.getUint32(0, true);
+        const tagHeaderSize = 4 + tagCsvLength;
+        const metadata = this.parseMeshMetadata(metadataBlob); // This already handles tag header
+        // Check if the metadata blob contains all the mesh info (shifted by tag header)
+        // Total expected size = tagHeaderSize + 140 (MeshMetadata) + geometries + materials + nodes
+        const expectedMetadataSize = tagHeaderSize + 140 +
             (metadata.meshGeometryCount * 40) + // Draco compressed (40 bytes each)
             (metadata.materialCount * 196) + // MaterialData header
             (metadata.nodeCount * 116);
         let hasExtendedMetadata = metadataBlob.length >= expectedMetadataSize;
-        // If metadata only has the header, the mesh info might be at the start of the data blob
+        // If metadata has everything, read from metadataBlob (accounting for tag header)
+        // Otherwise, read from dataBlob (no tag header there)
         const sourceBlob = hasExtendedMetadata ? metadataBlob : dataBlob;
         const metaView = new DataView(sourceBlob.buffer, sourceBlob.byteOffset, sourceBlob.byteLength);
-        let offset = hasExtendedMetadata ? 140 : 0; // Start after MeshMetadata if in metadata blob, or at beginning of data blob
+        // Offset: skip tag header + MeshMetadata struct if reading from metadata blob
+        let offset = hasExtendedMetadata ? (tagHeaderSize + 140) : 0;
         // Parse geometry infos (now Draco compressed!)
         const geometries = [];
         for (let i = 0; i < metadata.meshGeometryCount; i++) {
@@ -176,10 +188,16 @@ class MeshParser {
             });
             // Apply properties
             for (const prop of matData.properties) {
-                if (prop.fieldName.toLowerCase() === 'tint' || prop.fieldName.toLowerCase().includes('color')) {
-                    // Apply color/tint
+                const fieldName = prop.fieldName.toLowerCase();
+                if (fieldName === 'tint' || fieldName.includes('color')) {
                     mat.color = new THREE__namespace.Color(prop.value[0], prop.value[1], prop.value[2]);
                 }
+                else if (fieldName === 'alphatest') {
+                    if (prop.value[0] > 0) {
+                        mat.alphaTest = 0.5;
+                        mat.transparent = true;
+                    }
+                }
             }
             materials.push(mat);
         }
@@ -347,15 +365,20 @@ class StowKitPack {
      * Parse skinned mesh from binary data
      */
     async parseSkinnedMesh(metadata, data) {
-        // Parse skinned mesh metadata
+        // NEW FORMAT: Skip past tag header
         const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+        const tagCsvLength = view.getUint32(0, true);
+        const tagHeaderSize = 4 + tagCsvLength;
+        // Skip to actual metadata
+        const actualMetadata = metadata.slice(tagHeaderSize);
+        const metaView = new DataView(actualMetadata.buffer, actualMetadata.byteOffset, actualMetadata.byteLength);
         const decoder = new TextDecoder();
         // SkinnedMeshMetadata: 4 uint32s (16 bytes) THEN string_id[128] = 144 bytes total
-        const meshGeometryCount = view.getUint32(0, true);
-        const materialCount = view.getUint32(4, true);
-        const nodeCount = view.getUint32(8, true);
-        const boneCount = view.getUint32(12, true);
-        const stringIdBytes = metadata.slice(16, 144);
+        const meshGeometryCount = metaView.getUint32(0, true);
+        const materialCount = metaView.getUint32(4, true);
+        const nodeCount = metaView.getUint32(8, true);
+        const boneCount = metaView.getUint32(12, true);
+        const stringIdBytes = actualMetadata.slice(16, 144);
         const stringIdNullIndex = stringIdBytes.indexOf(0);
         const stringId = decoder
             .decode(stringIdBytes.slice(0, stringIdNullIndex >= 0 ? stringIdNullIndex : 128))
@@ -368,21 +391,21 @@ class StowKitPack {
         //         vertex_buffer_offset, vertex_buffer_size, index_buffer_offset, index_buffer_size, weights_offset, weights_size (48 bytes)
         //         material_index, _padding (8 bytes)
         for (let g = 0; g < meshGeometryCount; g++) {
-            if (offset + 72 > metadata.length) {
+            if (offset + 72 > actualMetadata.length) {
                 throw new Error(`Metadata too small for geometry ${g}`);
             }
             geometryInfos.push({
-                vertexCount: view.getUint32(offset, true),
-                indexCount: view.getUint32(offset + 4, true),
-                hasNormals: view.getUint32(offset + 8, true),
-                hasUVs: view.getUint32(offset + 12, true),
-                vertexBufferOffset: Number(view.getBigUint64(offset + 16, true)),
-                vertexBufferSize: Number(view.getBigUint64(offset + 24, true)),
-                indexBufferOffset: Number(view.getBigUint64(offset + 32, true)),
-                indexBufferSize: Number(view.getBigUint64(offset + 40, true)),
-                weightsOffset: Number(view.getBigUint64(offset + 48, true)),
-                weightsSize: Number(view.getBigUint64(offset + 56, true)),
-                materialIndex: view.getUint32(offset + 64, true)
+                vertexCount: metaView.getUint32(offset, true),
+                indexCount: metaView.getUint32(offset + 4, true),
+                hasNormals: metaView.getUint32(offset + 8, true),
+                hasUVs: metaView.getUint32(offset + 12, true),
+                vertexBufferOffset: Number(metaView.getBigUint64(offset + 16, true)),
+                vertexBufferSize: Number(metaView.getBigUint64(offset + 24, true)),
+                indexBufferOffset: Number(metaView.getBigUint64(offset + 32, true)),
+                indexBufferSize: Number(metaView.getBigUint64(offset + 40, true)),
+                weightsOffset: Number(metaView.getBigUint64(offset + 48, true)),
+                weightsSize: Number(metaView.getBigUint64(offset + 56, true)),
+                materialIndex: metaView.getUint32(offset + 64, true)
                 // _padding at offset + 68 (ignored)
             });
             offset += 72;
@@ -395,15 +418,15 @@ class StowKitPack {
         const materialData = [];
         // Parse MaterialData headers
         for (let i = 0; i < materialCount; i++) {
-            if (metadataOffset + 196 > metadata.length) {
+            if (metadataOffset + 196 > actualMetadata.length) {
                 console.warn('Skinned mesh metadata truncated while reading material headers');
                 break;
             }
-            const nameBytes = metadata.slice(metadataOffset, metadataOffset + 64);
-            const schemaIdBytes = metadata.slice(metadataOffset + 64, metadataOffset + 192);
+            const nameBytes = actualMetadata.slice(metadataOffset, metadataOffset + 64);
+            const schemaIdBytes = actualMetadata.slice(metadataOffset + 64, metadataOffset + 192);
             const name = decoder.decode(nameBytes.slice(0, nameBytes.indexOf(0) || 64));
             const schemaId = decoder.decode(schemaIdBytes.slice(0, schemaIdBytes.indexOf(0) || 128));
-            const propertyCount = view.getUint32(metadataOffset + 192, true);
+            const propertyCount = metaView.getUint32(metadataOffset + 192, true);
             materialData.push({ name, schemaId, propertyCount, properties: [] });
             metadataOffset += 196;
         }
@@ -418,20 +441,20 @@ class StowKitPack {
             const mat = materialData[i];
             for (let p = 0; p < mat.propertyCount; p++) {
                 try {
-                    if (metadataOffset + PROPERTY_STRIDE > metadata.length) {
+                    if (metadataOffset + PROPERTY_STRIDE > actualMetadata.length) {
                         break;
                     }
-                    const fieldNameBytes = metadata.slice(metadataOffset, metadataOffset + 64);
+                    const fieldNameBytes = actualMetadata.slice(metadataOffset, metadataOffset + 64);
                     const fieldName = decoder
                         .decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64))
                         .trim();
                     const value = [
-                        view.getFloat32(metadataOffset + 64, true),
-                        view.getFloat32(metadataOffset + 68, true),
-                        view.getFloat32(metadataOffset + 72, true),
-                        view.getFloat32(metadataOffset + 76, true)
+                        metaView.getFloat32(metadataOffset + 64, true),
+                        metaView.getFloat32(metadataOffset + 68, true),
+                        metaView.getFloat32(metadataOffset + 72, true),
+                        metaView.getFloat32(metadataOffset + 76, true)
                     ];
-                    const textureIdBytes = metadata.slice(metadataOffset + 80, metadataOffset + 144);
+                    const textureIdBytes = actualMetadata.slice(metadataOffset + 80, metadataOffset + 144);
                     const textureIdNullIndex = textureIdBytes.indexOf(0);
                     const textureId = (textureIdNullIndex >= 0
                         ? decoder.decode(textureIdBytes.slice(0, textureIdNullIndex))
@@ -453,17 +476,17 @@ class StowKitPack {
         const boneOriginalNames = [];
         const bindPoses = [];
         for (let i = 0; i < boneCount; i++) {
-            if (metadataOffset + BONE_STRIDE > metadata.length) {
+            if (metadataOffset + BONE_STRIDE > actualMetadata.length) {
                 throw new Error(`Skinned mesh metadata truncated while reading bone ${i}`);
             }
-            const nameBytes = new Uint8Array(metadata.buffer, metadata.byteOffset + metadataOffset, 64);
+            const nameBytes = new Uint8Array(actualMetadata.buffer, actualMetadata.byteOffset + metadataOffset, 64);
             const nullIndex = nameBytes.indexOf(0);
             const rawName = decoder.decode(nameBytes.subarray(0, nullIndex >= 0 ? nullIndex : 64)).trim();
-            const parentIndex = view.getInt32(metadataOffset + 64, true);
+            const parentIndex = metaView.getInt32(metadataOffset + 64, true);
             const offsetMatrix = new THREE__namespace.Matrix4();
             const matrixElements = new Float32Array(16);
             for (let j = 0; j < 16; j++) {
-                matrixElements[j] = view.getFloat32(metadataOffset + 68 + j * 4, true);
+                matrixElements[j] = metaView.getFloat32(metadataOffset + 68 + j * 4, true);
             }
             offsetMatrix.fromArray(matrixElements);
             const sanitizedName = this.sanitizeTrackName(rawName);
@@ -524,7 +547,6 @@ class StowKitPack {
             // Apply non-texture properties
             for (const prop of mat.properties) {
                 const fieldName = prop.fieldName.toLowerCase();
-                // Handle color properties
                 if (fieldName.includes('color') || fieldName.includes('tint')) {
                     material.color.setRGB(prop.value[0], prop.value[1], prop.value[2]);
                 }
@@ -534,6 +556,12 @@ class StowKitPack {
                 else if (fieldName === 'roughness') {
                     material.roughness = prop.value[0];
                 }
+                else if (fieldName === 'alphatest') {
+                    if (prop.value[0] > 0) {
+                        material.alphaTest = 0.5;
+                        material.transparent = true;
+                    }
+                }
             }
             materials.push(material);
         }
@@ -853,32 +881,38 @@ class StowKitPack {
      * Parse animation clip from binary data
      */
     parseAnimationClip(metadata, data) {
+        // NEW FORMAT: Skip past tag header
         const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+        const tagCsvLength = view.getUint32(0, true);
+        const tagHeaderSize = 4 + tagCsvLength;
+        // Skip to actual metadata
+        const actualMetadata = metadata.slice(tagHeaderSize);
+        const metaView = new DataView(actualMetadata.buffer, actualMetadata.byteOffset, actualMetadata.byteLength);
         const decoder = new TextDecoder();
         // Parse AnimationClipMetadata (272 bytes total)
-        const stringIdBytes = metadata.slice(0, 128);
+        const stringIdBytes = actualMetadata.slice(0, 128);
         const stringIdNullIndex = stringIdBytes.indexOf(0);
         const stringId = decoder.decode(stringIdBytes.slice(0, stringIdNullIndex >= 0 ? stringIdNullIndex : 128));
-        const targetMeshIdBytes = metadata.slice(128, 256);
+        const targetMeshIdBytes = actualMetadata.slice(128, 256);
         const targetMeshIdNullIndex = targetMeshIdBytes.indexOf(0);
         decoder
             .decode(targetMeshIdBytes.slice(0, targetMeshIdNullIndex >= 0 ? targetMeshIdNullIndex : 128))
             .trim();
-        const durationSeconds = view.getFloat32(256, true); // Duration in seconds (per C header)
-        view.getFloat32(260, true); // For custom playback rate if needed
-        const channelCount = view.getUint32(264, true);
-        const boneCount = view.getUint32(268, true);
+        const durationSeconds = metaView.getFloat32(256, true); // Duration in seconds (per C header)
+        metaView.getFloat32(260, true); // For custom playback rate if needed
+        const channelCount = metaView.getUint32(264, true);
+        const boneCount = metaView.getUint32(268, true);
         // Parse AnimationChannel[] (starts at offset 272, each is 28 bytes)
         const channelsOffset = 272;
         const channels = [];
         for (let i = 0; i < channelCount; i++) {
             const chOffset = channelsOffset + i * 28;
             channels.push({
-                boneIndex: view.getUint32(chOffset, true),
-                keyframeType: view.getUint32(chOffset + 4, true),
-                keyframeCount: view.getUint32(chOffset + 8, true),
-                keyframeTimesOffset: Number(view.getBigUint64(chOffset + 12, true)),
-                keyframeValuesOffset: Number(view.getBigUint64(chOffset + 20, true))
+                boneIndex: metaView.getUint32(chOffset, true),
+                keyframeType: metaView.getUint32(chOffset + 4, true),
+                keyframeCount: metaView.getUint32(chOffset + 8, true),
+                keyframeTimesOffset: Number(metaView.getBigUint64(chOffset + 12, true)),
+                keyframeValuesOffset: Number(metaView.getBigUint64(chOffset + 20, true))
             });
         }
         // Parse AnimationBoneInfo[] (starts after all channels, each is 68 bytes)
@@ -886,13 +920,13 @@ class StowKitPack {
         const bones = [];
         for (let i = 0; i < boneCount; i++) {
             const boneOffset = bonesOffset + i * 68;
-            const nameBytes = metadata.slice(boneOffset, boneOffset + 64);
+            const nameBytes = actualMetadata.slice(boneOffset, boneOffset + 64);
             const nullIndex = nameBytes.indexOf(0);
             const rawName = decoder
                 .decode(nameBytes.slice(0, nullIndex >= 0 ? nullIndex : 64))
                 .trim();
             const sanitizedName = this.sanitizeTrackName(rawName);
-            const parentIndex = view.getInt32(boneOffset + 64, true);
+            const parentIndex = metaView.getInt32(boneOffset + 64, true);
             bones.push({ name: rawName, parentIndex, sanitizedName });
         }
         // Create DataView for keyframe data