@stowkit/three-loader 0.1.2 → 0.1.4

package/dist/stowkit-three-loader.js

@@ -2,6 +2,7 @@
 
 var THREE = require('three');
 var KTX2Loader_js = require('three/examples/jsm/loaders/KTX2Loader.js');
+var DRACOLoader_js = require('three/examples/jsm/loaders/DRACOLoader.js');
 var reader = require('@stowkit/reader');
 
 function _interopNamespaceDefault(e) {
@@ -51,8 +52,8 @@ class MeshParser {
         console.log(`Mesh counts: ${metadata.meshGeometryCount} geometries, ${metadata.materialCount} materials, ${metadata.nodeCount} nodes`);
         // Check if the metadata blob contains just the header or all the mesh info
         const expectedMetadataSize = 140 +
-            (metadata.meshGeometryCount * 76) +
-            (metadata.materialCount * 64) +
+            (metadata.meshGeometryCount * 40) + // Draco compressed (40 bytes each)
+            (metadata.materialCount * 196) + // MaterialData header
             (metadata.nodeCount * 116);
         let hasExtendedMetadata = metadataBlob.length >= expectedMetadataSize;
         console.log(`Expected metadata size: ${expectedMetadataSize}, actual: ${metadataBlob.length}, has extended: ${hasExtendedMetadata}`);
@@ -60,28 +61,25 @@ class MeshParser {
         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
-        // Parse geometry infos
+        // Parse geometry infos (now Draco compressed!)
         const geometries = [];
         for (let i = 0; i < metadata.meshGeometryCount; i++) {
-            if (offset + 76 > sourceBlob.length) {
+            if (offset + 40 > sourceBlob.length) {
                 console.warn(`Data truncated at geometry ${i}/${metadata.meshGeometryCount}`);
                 break;
             }
             const geo = {
                 vertexCount: metaView.getUint32(offset, true),
                 indexCount: metaView.getUint32(offset + 4, true),
-                vertexBufferOffset: Number(metaView.getBigUint64(offset + 8, true)),
-                indexBufferOffset: Number(metaView.getBigUint64(offset + 16, true)),
-                normalBufferOffset: Number(metaView.getBigUint64(offset + 24, true)),
-                uvBufferOffset: Number(metaView.getBigUint64(offset + 32, true)),
-                vertexBufferSize: Number(metaView.getBigUint64(offset + 40, true)),
-                indexBufferSize: Number(metaView.getBigUint64(offset + 48, true)),
-                normalBufferSize: Number(metaView.getBigUint64(offset + 56, true)),
-                uvBufferSize: Number(metaView.getBigUint64(offset + 64, true)),
-                materialIndex: metaView.getUint32(offset + 72, true)
+                hasNormals: metaView.getUint32(offset + 8, true),
+                hasUVs: metaView.getUint32(offset + 12, true),
+                compressedBufferOffset: Number(metaView.getBigUint64(offset + 16, true)),
+                compressedBufferSize: Number(metaView.getBigUint64(offset + 24, true)),
+                materialIndex: metaView.getUint32(offset + 32, true),
+                padding: metaView.getUint32(offset + 36, true)
             };
             geometries.push(geo);
-            offset += 76; // Size of MeshGeometryInfo
+            offset += 40; // Size of MeshGeometryInfo (Draco compressed)
         }
         // Parse materials - MaterialData structure: name[64] + schema_id[128] + property_count(4) = 196 bytes
         const materialData = [];
@@ -208,76 +206,40 @@ class MeshParser {
         return { metadata, geometries, materials, materialData, nodes, meshIndices };
     }
     /**
-     * Create Three.js BufferGeometry from mesh data
+     * Create Three.js BufferGeometry from Draco compressed mesh data
      */
-    static createGeometry(geoInfo, dataBlob) {
-        console.log('Creating geometry:', {
+    static async createGeometry(geoInfo, dataBlob, dracoLoader) {
+        console.log('Decoding Draco geometry:', {
             vertexCount: geoInfo.vertexCount,
             indexCount: geoInfo.indexCount,
-            vertexOffset: geoInfo.vertexBufferOffset,
-            vertexSize: geoInfo.vertexBufferSize,
-            dataBlobSize: dataBlob.length
+            hasNormals: geoInfo.hasNormals,
+            hasUVs: geoInfo.hasUVs,
+            compressedOffset: geoInfo.compressedBufferOffset,
+            compressedSize: geoInfo.compressedBufferSize
         });
-        const geometry = new THREE__namespace.BufferGeometry();
-        const dataView = new DataView(dataBlob.buffer, dataBlob.byteOffset, dataBlob.byteLength);
-        // Extract vertex positions (3 floats per vertex)
-        if (geoInfo.vertexBufferSize > 0 && geoInfo.vertexBufferOffset + geoInfo.vertexBufferSize <= dataBlob.length) {
-            const positions = new Float32Array(geoInfo.vertexCount * 3);
-            for (let i = 0; i < geoInfo.vertexCount * 3; i++) {
-                positions[i] = dataView.getFloat32(geoInfo.vertexBufferOffset + i * 4, true);
-            }
-            geometry.setAttribute('position', new THREE__namespace.BufferAttribute(positions, 3));
-            console.log('Added positions:', positions.slice(0, 9)); // First 3 vertices
-        }
-        else {
-            console.warn('No vertex data or out of bounds');
-        }
-        // Extract normals
-        if (geoInfo.normalBufferSize > 0 && geoInfo.normalBufferOffset + geoInfo.normalBufferSize <= dataBlob.length) {
-            const normals = new Float32Array(geoInfo.vertexCount * 3);
-            for (let i = 0; i < geoInfo.vertexCount * 3; i++) {
-                normals[i] = dataView.getFloat32(geoInfo.normalBufferOffset + i * 4, true);
-            }
-            geometry.setAttribute('normal', new THREE__namespace.BufferAttribute(normals, 3));
-        }
-        else {
-            // Compute normals if not provided
-            geometry.computeVertexNormals();
-        }
-        // Extract UVs
-        if (geoInfo.uvBufferSize > 0 && geoInfo.uvBufferOffset + geoInfo.uvBufferSize <= dataBlob.length) {
-            const uvs = new Float32Array(geoInfo.vertexCount * 2);
-            for (let i = 0; i < geoInfo.vertexCount * 2; i += 2) {
-                uvs[i] = dataView.getFloat32(geoInfo.uvBufferOffset + i * 4, true); // U
-                uvs[i + 1] = 1.0 - dataView.getFloat32(geoInfo.uvBufferOffset + (i + 1) * 4, true); // V (flipped)
-            }
-            geometry.setAttribute('uv', new THREE__namespace.BufferAttribute(uvs, 2));
-        }
-        // Extract indices
-        if (geoInfo.indexCount > 0 && geoInfo.indexBufferOffset + geoInfo.indexBufferSize <= dataBlob.length) {
-            const indices = new Uint32Array(geoInfo.indexCount);
-            // Read the first index to determine the base offset
-            let minIndex = Number.MAX_SAFE_INTEGER;
-            for (let i = 0; i < geoInfo.indexCount; i++) {
-                const index = dataView.getUint32(geoInfo.indexBufferOffset + i * 4, true);
-                if (index < minIndex)
-                    minIndex = index;
-            }
-            // Read indices again and offset them to start from 0
-            for (let i = 0; i < geoInfo.indexCount; i++) {
-                const absoluteIndex = dataView.getUint32(geoInfo.indexBufferOffset + i * 4, true);
-                indices[i] = absoluteIndex - minIndex;
-            }
-            geometry.setIndex(new THREE__namespace.BufferAttribute(indices, 1));
-            console.log(`Added indices (offset by ${minIndex}):`, indices.slice(0, 12)); // First 4 triangles
-        }
-        else if (geoInfo.indexCount > 0) {
-            console.warn('Index data out of bounds');
-        }
-        // Ensure we have normals (compute if missing)
-        if (!geometry.attributes.normal) {
-            geometry.computeVertexNormals();
+        // 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);
+        // 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 geometry = await new Promise((resolve, reject) => {
+            dracoLoader.load(url, (decoded) => {
+                URL.revokeObjectURL(url);
+                console.log('Draco decoded successfully:', decoded);
+                // UVs are pre-flipped in the packer now, no need to flip here
+                resolve(decoded);
+            }, undefined, (error) => {
+                URL.revokeObjectURL(url);
+                console.error('Draco decode failed:', error);
+                reject(new Error(`Failed to decode Draco geometry: ${error}`));
+            });
+        });
+        // Compute bounding volumes
         geometry.computeBoundingSphere();
         geometry.computeBoundingBox();
         console.log('Final geometry:', {
@@ -292,7 +254,7 @@ class MeshParser {
     /**
      * Build Three.js scene from parsed mesh data
      */
-    static buildScene(parsedData, dataBlob) {
+    static async buildScene(parsedData, dataBlob, dracoLoader) {
         const root = new THREE__namespace.Group();
         root.name = 'StowKitMesh';
         const { geometries, materials, nodes, meshIndices } = parsedData;
@@ -320,7 +282,7 @@ class MeshParser {
                 if (meshIndex < geometries.length) {
                     const geoInfo = geometries[meshIndex];
                     console.log(`  Creating geometry from geoInfo: vertices=${geoInfo.vertexCount}, indices=${geoInfo.indexCount}, material=${geoInfo.materialIndex}`);
-                    const geometry = this.createGeometry(geoInfo, dataBlob);
+                    const geometry = await this.createGeometry(geoInfo, dataBlob, dracoLoader);
                     // Use assigned material if valid, otherwise create default
                     let material;
                     if (geoInfo.materialIndex < materials.length) {
@@ -363,9 +325,10 @@ class MeshParser {
         // If no nodes, create a single mesh from all geometries
         if (nodes.length === 0 && geometries.length > 0) {
             console.log('No nodes found, creating meshes directly from geometries');
-            geometries.forEach((geoInfo, index) => {
+            for (let index = 0; index < geometries.length; index++) {
+                const geoInfo = geometries[index];
                 console.log(`Creating direct mesh ${index}: materialIndex=${geoInfo.materialIndex}, vertices=${geoInfo.vertexCount}`);
-                const geometry = this.createGeometry(geoInfo, dataBlob);
+                const geometry = await this.createGeometry(geoInfo, dataBlob, dracoLoader);
                 // Use assigned material if valid, otherwise create default
                 let material;
                 if (geoInfo.materialIndex < materials.length) {
@@ -384,7 +347,7 @@ class MeshParser {
                 mesh.name = `Mesh_${index}`;
                 root.add(mesh);
                 console.log(`Added mesh ${index} to root`);
-            });
+            }
         }
         console.log(`Final scene has ${root.children.length} direct children`);
         // Debug: traverse and count all meshes, showing full hierarchy
@@ -451,16 +414,26 @@ class StowKitLoader extends THREE__namespace.Loader {
             this.reader = new reader.StowKitReader(wasmPath);
             this.ownedReader = true;
         }
-        // Setup KTX2 loader for textures with default path
-        const transcoderPath = parameters?.transcoderPath || '/basis/';
+        // Setup KTX2 loader for textures with default path (user must provide basis files)
+        const transcoderPath = parameters?.transcoderPath || '/basis/'; // Users still need to provide this
         this.ktx2Loader = new KTX2Loader_js.KTX2Loader(manager);
         this.ktx2Loader.setTranscoderPath(transcoderPath);
+        // Setup Draco loader for mesh decompression
+        this.dracoLoader = new DRACOLoader_js.DRACOLoader(manager);
+        this.dracoLoader.setDecoderPath('/stowkit/draco/'); // Draco files copied by postinstall
         // Detect support with a temporary renderer
         // This is required for KTX2Loader to work
         const tempRenderer = new THREE__namespace.WebGLRenderer();
         this.ktx2Loader.detectSupport(tempRenderer);
         tempRenderer.dispose();
     }
+    /**
+     * Set the path to the Draco decoder
+     */
+    setDracoDecoderPath(path) {
+        this.dracoLoader.setDecoderPath(path);
+        return this;
+    }
     /**
      * Set the path to the Basis Universal transcoder
      */
@@ -490,6 +463,42 @@ class StowKitLoader extends THREE__namespace.Loader {
         const arrayBuffer = await response.arrayBuffer();
         await this.reader.open(arrayBuffer);
     }
+    /**
+     * Load and parse a mesh asset by its index
+     * @param index - Asset index
+     * @param onLoad - Callback when loading completes
+     * @param onProgress - Progress callback
+     * @param onError - Error callback
+     */
+    async loadMeshByIndex(index, onLoad, onProgress, onError) {
+        try {
+            // Read mesh data and metadata
+            const data = this.reader.readAssetData(index);
+            const metadata = this.reader.readAssetMetadata(index);
+            if (!data) {
+                throw new Error(`Failed to read mesh data for index ${index}`);
+            }
+            if (!metadata) {
+                throw new Error(`No metadata available for index ${index}`);
+            }
+            // Parse mesh data
+            const parsedData = MeshParser.parseMeshData(metadata, data);
+            // Load textures for materials
+            await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
+            // Build Three.js scene with Draco decoder
+            const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader);
+            if (onLoad) {
+                onLoad(scene);
+            }
+            return scene;
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+            throw error;
+        }
+    }
     /**
      * Load and parse a mesh asset from a StowKit pack
      * @param url - URL to the .stow file (or omit if already opened with openPack)
@@ -522,8 +531,8 @@ class StowKitLoader extends THREE__namespace.Loader {
             const parsedData = MeshParser.parseMeshData(metadata, data);
             // Load textures for materials
             await this.loadMaterialTextures(parsedData.materialData, parsedData.materials);
-            // Build Three.js scene
-            const scene = MeshParser.buildScene(parsedData, data);
+            // Build Three.js scene with Draco decoder
+            const scene = await MeshParser.buildScene(parsedData, data, this.dracoLoader);
             if (onLoad) {
                 onLoad(scene);
             }
@@ -759,20 +768,20 @@ class StowKitLoader extends THREE__namespace.Loader {
             if (assetIndex < 0)
                 return null;
             const metadata = this.reader.readAssetMetadata(assetIndex);
-            if (!metadata || metadata.length < 148)
-                return null;
+            if (!metadata || metadata.length < 144)
+                return null; // TextureMetadata is now 144 bytes
             const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
             const decoder = new TextDecoder();
-            // Parse TextureMetadata structure
-            const stringIdBytes = metadata.slice(20, 148);
+            // Parse TextureMetadata structure (width, height, channels, channel_format, string_id[128])
+            const stringIdBytes = metadata.slice(16, 144); // After 4 uint32s (16 bytes)
             const nullIdx = stringIdBytes.indexOf(0);
             const stringId = decoder.decode(stringIdBytes.slice(0, nullIdx >= 0 ? nullIdx : 128));
             return {
                 width: view.getUint32(0, true),
                 height: view.getUint32(4, true),
                 channels: view.getUint32(8, true),
-                isKtx2: view.getUint32(12, true) === 1,
-                channelFormat: view.getUint32(16, true),
+                isKtx2: true, // All textures are KTX2 now
+                channelFormat: view.getUint32(12, true),
                 stringId
             };
         }
@@ -901,8 +910,8 @@ class StowKitLoader extends THREE__namespace.Loader {
             const materialCount = view.getUint32(4, true);
             const nodeCount = view.getUint32(8, true);
             let offset = 140;
-            // Skip geometries (76 bytes each)
-            offset += meshGeometryCount * 76;
+            // Skip geometries (40 bytes each - Draco compressed)
+            offset += meshGeometryCount * 40;
             // Parse materials
             const materials = [];
             for (let i = 0; i < materialCount; i++) {
@@ -1023,6 +1032,7 @@ class StowKitLoader extends THREE__namespace.Loader {
      */
     dispose() {
         this.ktx2Loader.dispose();
+        this.dracoLoader.dispose();
         if (this.ownedReader) {
             this.reader.close();
         }