@stowkit/three-loader 0.1.2

package/dist/stowkit-three-loader.js

@@ -0,0 +1,1034 @@
+'use strict';
+
+var THREE = require('three');
+var KTX2Loader_js = require('three/examples/jsm/loaders/KTX2Loader.js');
+var reader = require('@stowkit/reader');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespaceDefault(THREE);
+
+class MeshParser {
+    /**
+     * Parse mesh metadata from binary data
+     */
+    static parseMeshMetadata(data) {
+        const view = new DataView(data.buffer, data.byteOffset, data.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
+        };
+        return metadata;
+    }
+    /**
+     * 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)`);
+        }
+        console.log(`Parsing mesh metadata: ${metadataBlob.length} bytes metadata, ${dataBlob.length} bytes data`);
+        const metadata = this.parseMeshMetadata(metadataBlob);
+        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.nodeCount * 116);
+        let hasExtendedMetadata = metadataBlob.length >= expectedMetadataSize;
+        console.log(`Expected metadata size: ${expectedMetadataSize}, actual: ${metadataBlob.length}, has extended: ${hasExtendedMetadata}`);
+        // If metadata only has the header, the mesh info might be at the start of the data blob
+        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
+        const geometries = [];
+        for (let i = 0; i < metadata.meshGeometryCount; i++) {
+            if (offset + 76 > 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)
+            };
+            geometries.push(geo);
+            offset += 76; // Size of MeshGeometryInfo
+        }
+        // Parse materials - MaterialData structure: name[64] + schema_id[128] + property_count(4) = 196 bytes
+        const materialData = [];
+        const materials = [];
+        for (let i = 0; i < metadata.materialCount; i++) {
+            if (offset + 196 > sourceBlob.length) {
+                console.warn(`Data truncated at material ${i}/${metadata.materialCount}`);
+                break;
+            }
+            const name = this.readString(sourceBlob.slice(offset, offset + 64));
+            const schemaId = this.readString(sourceBlob.slice(offset + 64, offset + 192));
+            const propertyCount = metaView.getUint32(offset + 192, true);
+            materialData.push({
+                name,
+                schemaId,
+                propertyCount,
+                properties: []
+            });
+            offset += 196; // Size of MaterialData header
+        }
+        // Parse nodes first (they come before material properties in the blob)
+        const nodes = [];
+        console.log(`\n=== Nodes from StowKit file (${metadata.nodeCount} total) ===`);
+        for (let i = 0; i < metadata.nodeCount; i++) {
+            if (offset + 116 > sourceBlob.length) {
+                console.warn(`Data truncated at node ${i}/${metadata.nodeCount}`);
+                break;
+            }
+            const node = {
+                name: this.readString(sourceBlob.slice(offset, offset + 64)),
+                parentIndex: metaView.getInt32(offset + 64, true),
+                position: [
+                    metaView.getFloat32(offset + 68, true),
+                    metaView.getFloat32(offset + 72, true),
+                    metaView.getFloat32(offset + 76, true)
+                ],
+                rotation: [
+                    metaView.getFloat32(offset + 80, true),
+                    metaView.getFloat32(offset + 84, true),
+                    metaView.getFloat32(offset + 88, true),
+                    metaView.getFloat32(offset + 92, true)
+                ],
+                scale: [
+                    metaView.getFloat32(offset + 96, true),
+                    metaView.getFloat32(offset + 100, true),
+                    metaView.getFloat32(offset + 104, true)
+                ],
+                meshCount: metaView.getUint32(offset + 108, true),
+                firstMeshIndex: metaView.getUint32(offset + 112, true)
+            };
+            console.log(`Node ${i}: "${node.name}" (parent=${node.parentIndex}, meshCount=${node.meshCount}, firstMeshIndex=${node.firstMeshIndex})`);
+            nodes.push(node);
+            offset += 116; // Size of Node struct
+        }
+        console.log(`=== End of nodes from file ===\n`);
+        // Parse mesh indices
+        const totalMeshRefs = nodes.reduce((sum, node) => sum + node.meshCount, 0);
+        console.log(`Parsing ${totalMeshRefs} mesh indices at offset ${offset}`);
+        const meshIndices = new Uint32Array(totalMeshRefs);
+        for (let i = 0; i < totalMeshRefs; i++) {
+            if (offset + (i + 1) * 4 > sourceBlob.length) {
+                console.warn(`Data truncated at mesh index ${i}/${totalMeshRefs}`);
+                break;
+            }
+            meshIndices[i] = metaView.getUint32(offset + i * 4, true);
+            console.log(`  meshIndices[${i}] = ${meshIndices[i]}`);
+        }
+        offset += totalMeshRefs * 4;
+        console.log(`After mesh indices, offset = ${offset}`);
+        // Second pass: read material properties
+        // MaterialPropertyValue: field_name[64] + value[4*4=16] + texture_id[64] = 144 bytes
+        for (let i = 0; i < materialData.length; i++) {
+            const matData = materialData[i];
+            console.log(`Material "${matData.name}": schema="${matData.schemaId}", ${matData.propertyCount} properties`);
+            for (let j = 0; j < matData.propertyCount; j++) {
+                if (offset + 144 > sourceBlob.length) {
+                    console.warn(`Data truncated at property ${j}/${matData.propertyCount} of material ${i}`);
+                    break;
+                }
+                const fieldName = this.readString(sourceBlob.slice(offset, offset + 64));
+                const value = [
+                    metaView.getFloat32(offset + 64, true),
+                    metaView.getFloat32(offset + 68, true),
+                    metaView.getFloat32(offset + 72, true),
+                    metaView.getFloat32(offset + 76, true)
+                ];
+                const textureId = this.readString(sourceBlob.slice(offset + 80, offset + 144));
+                matData.properties.push({
+                    fieldName,
+                    value,
+                    textureId
+                });
+                console.log(`  Property "${fieldName}": value=[${value.join(', ')}], textureId="${textureId}"`);
+                offset += 144; // Size of MaterialPropertyValue
+            }
+            // Create Three.js material based on properties
+            const mat = new THREE__namespace.MeshStandardMaterial({
+                name: matData.name,
+                side: THREE__namespace.DoubleSide,
+                // Start with default gray color
+                color: new THREE__namespace.Color(0.8, 0.8, 0.8)
+            });
+            console.log(`Creating material ${i}: "${matData.name}", ${matData.propertyCount} properties`);
+            // Apply properties
+            for (const prop of matData.properties) {
+                if (prop.fieldName.toLowerCase() === 'tint' || prop.fieldName.toLowerCase().includes('color')) {
+                    // Apply color/tint
+                    mat.color = new THREE__namespace.Color(prop.value[0], prop.value[1], prop.value[2]);
+                    console.log(`  Applied tint color: rgb(${prop.value[0]}, ${prop.value[1]}, ${prop.value[2]})`);
+                }
+            }
+            console.log(`  Material ${i} final color: rgb(${mat.color.r}, ${mat.color.g}, ${mat.color.b})`);
+            materials.push(mat);
+        }
+        // Default material if none exist
+        if (materials.length === 0) {
+            materials.push(new THREE__namespace.MeshStandardMaterial({
+                color: new THREE__namespace.Color(0.8, 0.8, 0.8), // Light gray
+                roughness: 0.5,
+                metalness: 0.0,
+                side: THREE__namespace.DoubleSide
+            }));
+        }
+        return { metadata, geometries, materials, materialData, nodes, meshIndices };
+    }
+    /**
+     * Create Three.js BufferGeometry from mesh data
+     */
+    static createGeometry(geoInfo, dataBlob) {
+        console.log('Creating geometry:', {
+            vertexCount: geoInfo.vertexCount,
+            indexCount: geoInfo.indexCount,
+            vertexOffset: geoInfo.vertexBufferOffset,
+            vertexSize: geoInfo.vertexBufferSize,
+            dataBlobSize: dataBlob.length
+        });
+        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();
+        }
+        geometry.computeBoundingSphere();
+        geometry.computeBoundingBox();
+        console.log('Final geometry:', {
+            hasPositions: !!geometry.attributes.position,
+            hasNormals: !!geometry.attributes.normal,
+            hasUVs: !!geometry.attributes.uv,
+            hasIndices: !!geometry.index,
+            vertexCount: geometry.attributes.position?.count || 0
+        });
+        return geometry;
+    }
+    /**
+     * Build Three.js scene from parsed mesh data
+     */
+    static buildScene(parsedData, dataBlob) {
+        const root = new THREE__namespace.Group();
+        root.name = 'StowKitMesh';
+        const { geometries, materials, nodes, meshIndices } = parsedData;
+        console.log('Building scene with:', {
+            geometries: geometries.length,
+            materials: materials.length,
+            nodes: nodes.length,
+            meshIndices: meshIndices.length
+        });
+        // Create all Three.js objects for nodes
+        const nodeObjects = [];
+        for (const node of nodes) {
+            const obj = new THREE__namespace.Group();
+            obj.name = node.name;
+            console.log(`Node ${node.name}: position=${node.position}, rotation=${node.rotation}, scale=${node.scale}, meshCount=${node.meshCount}, firstMeshIndex=${node.firstMeshIndex}`);
+            // Apply transform
+            obj.position.set(...node.position);
+            obj.quaternion.set(...node.rotation);
+            obj.scale.set(...node.scale);
+            // Add meshes to this node
+            for (let i = 0; i < node.meshCount; i++) {
+                const meshIndexArrayPos = node.firstMeshIndex + i;
+                const meshIndex = meshIndices[meshIndexArrayPos];
+                console.log(`  meshIndices[${meshIndexArrayPos}] = ${meshIndex} (adding to node ${node.name})`);
+                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);
+                    // Use assigned material if valid, otherwise create default
+                    let material;
+                    if (geoInfo.materialIndex < materials.length) {
+                        material = materials[geoInfo.materialIndex];
+                    }
+                    else {
+                        console.warn(`  Material index ${geoInfo.materialIndex} out of bounds, using default`);
+                        material = new THREE__namespace.MeshStandardMaterial({
+                            color: new THREE__namespace.Color(0.8, 0.8, 0.8),
+                            roughness: 0.5,
+                            metalness: 0.0,
+                            side: THREE__namespace.DoubleSide
+                        });
+                    }
+                    const mesh = new THREE__namespace.Mesh(geometry, material);
+                    obj.add(mesh);
+                    console.log(`  ✓ Added mesh to node ${node.name} (${geometry.attributes.position?.count || 0} vertices, material: ${material.name || 'default'})`);
+                }
+                else {
+                    console.error(`  ✗ Mesh index ${meshIndex} out of bounds (have ${geometries.length} geometries)`);
+                }
+            }
+            console.log(`  Node ${node.name} now has ${obj.children.length} children`);
+            nodeObjects.push(obj);
+        }
+        // Build hierarchy
+        console.log('Building node hierarchy...');
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            const obj = nodeObjects[i];
+            if (node.parentIndex >= 0 && node.parentIndex < nodeObjects.length) {
+                console.log(`  Adding node "${node.name}" (index ${i}) as child of node "${nodes[node.parentIndex].name}" (index ${node.parentIndex})`);
+                nodeObjects[node.parentIndex].add(obj);
+            }
+            else {
+                console.log(`  Adding node "${node.name}" (index ${i}) as direct child of root (parentIndex=${node.parentIndex})`);
+                root.add(obj);
+            }
+        }
+        // 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) => {
+                console.log(`Creating direct mesh ${index}: materialIndex=${geoInfo.materialIndex}, vertices=${geoInfo.vertexCount}`);
+                const geometry = this.createGeometry(geoInfo, dataBlob);
+                // Use assigned material if valid, otherwise create default
+                let material;
+                if (geoInfo.materialIndex < materials.length) {
+                    material = materials[geoInfo.materialIndex];
+                }
+                else {
+                    console.warn(`  Material index ${geoInfo.materialIndex} out of bounds, using default`);
+                    material = new THREE__namespace.MeshStandardMaterial({
+                        color: new THREE__namespace.Color(0.8, 0.8, 0.8),
+                        roughness: 0.5,
+                        metalness: 0.0,
+                        side: THREE__namespace.DoubleSide
+                    });
+                }
+                const mesh = new THREE__namespace.Mesh(geometry, material);
+                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
+        let totalMeshCount = 0;
+        let hierarchyLog = 'Scene hierarchy:\n';
+        root.traverse((obj) => {
+            // Calculate depth by counting parents
+            let depth = 0;
+            let parent = obj.parent;
+            while (parent && parent !== root) {
+                depth++;
+                parent = parent.parent;
+            }
+            const indent = '  '.repeat(depth);
+            if (obj instanceof THREE__namespace.Mesh) {
+                totalMeshCount++;
+                const mat = obj.material;
+                hierarchyLog += `${indent}[Mesh] vertices=${obj.geometry.attributes.position?.count || 0}, material=${mat.name}, hasTexture=${!!mat.map}\n`;
+            }
+            else if (obj instanceof THREE__namespace.Group && obj !== root) {
+                hierarchyLog += `${indent}[Group] ${obj.name} (${obj.children.length} children)\n`;
+            }
+        });
+        console.log(hierarchyLog);
+        console.log(`Total meshes in scene: ${totalMeshCount}`);
+        return root;
+    }
+    /**
+     * Read null-terminated string from buffer
+     */
+    static readString(buffer) {
+        let end = buffer.indexOf(0);
+        if (end === -1)
+            end = buffer.length;
+        return new TextDecoder().decode(buffer.slice(0, end));
+    }
+}
+
+/**
+ * Three.js loader for StowKit asset packs (.stow files)
+ *
+ * Usage:
+ * ```typescript
+ * const loader = new StowKitLoader();
+ * loader.setTranscoderPath('/basis/');
+ *
+ * // Load a mesh asset
+ * loader.loadMesh('assets.stow', 'path/to/mesh', (scene) => {
+ *   threeScene.add(scene);
+ * });
+ * ```
+ */
+class StowKitLoader extends THREE__namespace.Loader {
+    constructor(manager, parameters) {
+        super(manager);
+        this.ownedReader = false;
+        // Use provided reader or create new one
+        if (parameters?.reader) {
+            this.reader = parameters.reader;
+            this.ownedReader = false;
+        }
+        else {
+            const wasmPath = parameters?.wasmPath || '/stowkit_reader.wasm';
+            this.reader = new reader.StowKitReader(wasmPath);
+            this.ownedReader = true;
+        }
+        // Setup KTX2 loader for textures with default path
+        const transcoderPath = parameters?.transcoderPath || '/basis/';
+        this.ktx2Loader = new KTX2Loader_js.KTX2Loader(manager);
+        this.ktx2Loader.setTranscoderPath(transcoderPath);
+        // 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 Basis Universal transcoder
+     */
+    setTranscoderPath(path) {
+        this.ktx2Loader.setTranscoderPath(path);
+        return this;
+    }
+    /**
+     * Detect WebGL support for compressed textures
+     */
+    detectSupport(renderer) {
+        this.ktx2Loader.detectSupport(renderer);
+        return this;
+    }
+    /**
+     * Open a .stow pack file (call this first if loading multiple assets)
+     * @param url - URL to the .stow file
+     */
+    async openPack(url) {
+        if (this.ownedReader) {
+            await this.reader.init();
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        await this.reader.open(arrayBuffer);
+    }
+    /**
+     * Load and parse a mesh asset from a StowKit pack
+     * @param url - URL to the .stow file (or omit if already opened with openPack)
+     * @param assetPath - Path to the mesh asset within the pack
+     * @param onLoad - Callback when loading completes
+     * @param onProgress - Progress callback
+     * @param onError - Error callback
+     */
+    async loadMesh(url, assetPath, onLoad, onProgress, onError) {
+        try {
+            // Open pack if URL provided
+            if (url) {
+                await this.openPack(url);
+            }
+            // Find the mesh asset
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0) {
+                throw new Error(`Asset not found: ${assetPath}`);
+            }
+            // Read mesh data and metadata
+            const data = this.reader.readAssetData(assetIndex);
+            const metadata = this.reader.readAssetMetadata(assetIndex);
+            if (!data) {
+                throw new Error(`Failed to read mesh data for ${assetPath}`);
+            }
+            if (!metadata) {
+                throw new Error(`No metadata available for ${assetPath}`);
+            }
+            // Parse mesh data
+            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);
+            if (onLoad) {
+                onLoad(scene);
+            }
+            return scene;
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Load textures for materials
+     */
+    async loadMaterialTextures(materialData, materials) {
+        for (let i = 0; i < materialData.length; i++) {
+            const matData = materialData[i];
+            const material = materials[i];
+            for (const prop of matData.properties) {
+                if (prop.textureId && prop.textureId.length > 0) {
+                    try {
+                        // Find texture asset
+                        const textureIndex = this.reader.findAssetByPath(prop.textureId);
+                        if (textureIndex < 0) {
+                            console.warn(`Texture not found: ${prop.textureId}`);
+                            continue;
+                        }
+                        // Read texture data
+                        const textureData = this.reader.readAssetData(textureIndex);
+                        if (!textureData) {
+                            console.warn(`Failed to read texture: ${prop.textureId}`);
+                            continue;
+                        }
+                        // Load as KTX2
+                        const texture = await this.loadKTX2Texture(textureData);
+                        // Apply to material based on property name
+                        this.applyTextureToMaterial(material, prop.fieldName, texture);
+                    }
+                    catch (error) {
+                        console.error(`Failed to load texture "${prop.textureId}":`, error);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Load a KTX2 texture from binary data
+     */
+    async loadKTX2Texture(data) {
+        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) => {
+                this.ktx2Loader.load(url, (texture) => {
+                    URL.revokeObjectURL(url);
+                    // Compressed textures don't support flipY, we flip UVs in MeshParser instead
+                    texture.needsUpdate = true;
+                    resolve(texture);
+                }, undefined, (error) => {
+                    URL.revokeObjectURL(url);
+                    reject(error);
+                });
+            });
+        }
+        catch (error) {
+            URL.revokeObjectURL(url);
+            throw error;
+        }
+    }
+    /**
+     * Apply texture to appropriate material property
+     */
+    applyTextureToMaterial(material, propertyName, texture) {
+        const propNameLower = propertyName.toLowerCase();
+        if (propNameLower === 'maintex' || propNameLower.includes('diffuse') ||
+            propNameLower.includes('albedo') || propNameLower.includes('base')) {
+            material.map = texture;
+        }
+        else if (propNameLower.includes('normal')) {
+            material.normalMap = texture;
+        }
+        else if (propNameLower.includes('metallic')) {
+            material.metalnessMap = texture;
+        }
+        else if (propNameLower.includes('roughness')) {
+            material.roughnessMap = texture;
+        }
+        else {
+            // Default to main texture
+            material.map = texture;
+        }
+        material.needsUpdate = true;
+    }
+    /**
+     * Load a texture asset from a StowKit pack
+     * @param url - URL to the .stow file (or omit if already opened with openPack)
+     * @param assetPath - Path to the texture asset within the pack
+     * @param onLoad - Callback when loading completes
+     * @param onProgress - Progress callback
+     * @param onError - Error callback
+     */
+    async loadTexture(url, assetPath, onLoad, onProgress, onError) {
+        try {
+            // Open pack if URL provided
+            if (url) {
+                await this.openPack(url);
+            }
+            // Find the texture asset
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0) {
+                throw new Error(`Asset not found: ${assetPath}`);
+            }
+            return await this.loadTextureByIndex(assetIndex, onLoad, onProgress, onError);
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Load a texture asset by its index in the pack
+     * @param index - Asset index
+     * @param onLoad - Callback when loading completes
+     * @param onProgress - Progress callback
+     * @param onError - Error callback
+     */
+    async loadTextureByIndex(index, onLoad, onProgress, onError) {
+        try {
+            // Read texture data
+            const data = this.reader.readAssetData(index);
+            if (!data) {
+                throw new Error(`Failed to read texture data for index ${index}`);
+            }
+            // Load as KTX2
+            const texture = await this.loadKTX2Texture(data);
+            if (onLoad) {
+                onLoad(texture);
+            }
+            return texture;
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Load an audio asset from a StowKit pack
+     * @param url - URL to the .stow file (or omit if already opened with openPack)
+     * @param assetPath - Path to the audio asset within the pack
+     * @param listener - THREE.AudioListener to attach to
+     * @param onLoad - Callback when loading completes
+     * @param onProgress - Progress callback
+     * @param onError - Error callback
+     */
+    async loadAudio(url, assetPath, listener, onLoad, onProgress, onError) {
+        try {
+            // Open pack if URL provided
+            if (url) {
+                await this.openPack(url);
+            }
+            // Find the audio asset
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0) {
+                throw new Error(`Asset not found: ${assetPath}`);
+            }
+            // Read audio data
+            const data = this.reader.readAssetData(assetIndex);
+            if (!data) {
+                throw new Error(`Failed to read audio data for ${assetPath}`);
+            }
+            // Create audio object
+            const audio = new THREE__namespace.Audio(listener);
+            // Decode audio data
+            const arrayBuffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            const audioContext = listener.context;
+            const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+            audio.setBuffer(audioBuffer);
+            if (onLoad) {
+                onLoad(audio);
+            }
+            return audio;
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get metadata for an audio asset
+     * @param assetPath - Path to the audio asset within the pack
+     */
+    getAudioMetadata(assetPath) {
+        try {
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0)
+                return null;
+            const metadata = this.reader.readAssetMetadata(assetIndex);
+            if (!metadata || metadata.length < 140)
+                return null;
+            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+            const decoder = new TextDecoder();
+            // Parse AudioMetadata structure
+            const stringIdBytes = metadata.slice(0, 128);
+            const nullIdx = stringIdBytes.indexOf(0);
+            const stringId = decoder.decode(stringIdBytes.slice(0, nullIdx >= 0 ? nullIdx : 128));
+            return {
+                stringId,
+                sampleRate: view.getUint32(128, true),
+                channels: view.getUint32(132, true),
+                durationMs: view.getUint32(136, true)
+            };
+        }
+        catch (error) {
+            console.error('Failed to read audio metadata:', error);
+            return null;
+        }
+    }
+    /**
+     * Get metadata for a texture asset
+     * @param assetPath - Path to the texture asset within the pack
+     */
+    getTextureMetadata(assetPath) {
+        try {
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0)
+                return null;
+            const metadata = this.reader.readAssetMetadata(assetIndex);
+            if (!metadata || metadata.length < 148)
+                return null;
+            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+            const decoder = new TextDecoder();
+            // Parse TextureMetadata structure
+            const stringIdBytes = metadata.slice(20, 148);
+            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),
+                stringId
+            };
+        }
+        catch (error) {
+            console.error('Failed to read texture metadata:', error);
+            return null;
+        }
+    }
+    /**
+     * Load material schema information by index
+     * @param index - Asset index
+     */
+    loadMaterialSchemaByIndex(index) {
+        try {
+            const metadata = this.reader.readAssetMetadata(index);
+            if (!metadata || metadata.length < 196)
+                return null;
+            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+            const decoder = new TextDecoder();
+            const stringIdBytes = metadata.slice(0, 128);
+            const schemaNameBytes = metadata.slice(128, 192);
+            const stringId = decoder.decode(stringIdBytes.slice(0, stringIdBytes.indexOf(0) || 128));
+            const schemaName = decoder.decode(schemaNameBytes.slice(0, schemaNameBytes.indexOf(0) || 64));
+            const fieldCount = view.getUint32(192, true);
+            const fields = [];
+            let offset = 196;
+            for (let i = 0; i < fieldCount; i++) {
+                if (offset + 88 > metadata.length)
+                    break;
+                const fieldNameBytes = metadata.slice(offset, offset + 64);
+                const fieldName = decoder.decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64));
+                const fieldType = view.getUint32(offset + 64, true);
+                const previewFlags = view.getUint32(offset + 68, true);
+                const defaultValue = [
+                    view.getFloat32(offset + 72, true),
+                    view.getFloat32(offset + 76, true),
+                    view.getFloat32(offset + 80, true),
+                    view.getFloat32(offset + 84, true)
+                ];
+                const typeNames = ['Texture', 'Color', 'Float', 'Vec2', 'Vec3', 'Vec4', 'Int'];
+                const previewFlagNames = ['None', 'MainTex', 'Tint'];
+                fields.push({
+                    name: fieldName,
+                    type: typeNames[fieldType] || 'Float',
+                    previewFlag: previewFlagNames[previewFlags] || 'None',
+                    defaultValue
+                });
+                offset += 88;
+            }
+            return { stringId, schemaName, fields };
+        }
+        catch (error) {
+            console.error('Failed to read material schema:', error);
+            return null;
+        }
+    }
+    /**
+     * Load material schema information by path
+     * @param assetPath - Path to the material schema asset
+     */
+    loadMaterialSchema(assetPath) {
+        try {
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0)
+                return null;
+            const metadata = this.reader.readAssetMetadata(assetIndex);
+            if (!metadata || metadata.length < 196)
+                return null;
+            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+            const decoder = new TextDecoder();
+            // Parse MaterialSchemaMetadata: string_id[128] + schema_name[64] + field_count(4) = 196 bytes
+            const stringIdBytes = metadata.slice(0, 128);
+            const schemaNameBytes = metadata.slice(128, 192);
+            const stringId = decoder.decode(stringIdBytes.slice(0, stringIdBytes.indexOf(0) || 128));
+            const schemaName = decoder.decode(schemaNameBytes.slice(0, schemaNameBytes.indexOf(0) || 64));
+            const fieldCount = view.getUint32(192, true);
+            const fields = [];
+            let offset = 196;
+            // Parse fields: name[64] + field_type(4) + preview_flags(4) + default_value[4*4=16] = 88 bytes
+            for (let i = 0; i < fieldCount; i++) {
+                if (offset + 88 > metadata.length)
+                    break;
+                const fieldNameBytes = metadata.slice(offset, offset + 64);
+                const fieldName = decoder.decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64));
+                const fieldType = view.getUint32(offset + 64, true);
+                const previewFlags = view.getUint32(offset + 68, true);
+                const defaultValue = [
+                    view.getFloat32(offset + 72, true),
+                    view.getFloat32(offset + 76, true),
+                    view.getFloat32(offset + 80, true),
+                    view.getFloat32(offset + 84, true)
+                ];
+                const typeNames = ['Texture', 'Color', 'Float', 'Vec2', 'Vec3', 'Vec4', 'Int'];
+                const previewFlagNames = ['None', 'MainTex', 'Tint'];
+                fields.push({
+                    name: fieldName,
+                    type: typeNames[fieldType] || 'Float',
+                    previewFlag: previewFlagNames[previewFlags] || 'None',
+                    defaultValue
+                });
+                offset += 88; // MaterialSchemaField is 88 bytes total
+            }
+            return { stringId, schemaName, fields };
+        }
+        catch (error) {
+            console.error('Failed to read material schema:', error);
+            return null;
+        }
+    }
+    /**
+     * Get material information from a loaded mesh
+     * Returns material data including properties and texture references
+     */
+    getMeshMaterials(assetPath) {
+        try {
+            const assetIndex = this.reader.findAssetByPath(assetPath);
+            if (assetIndex < 0)
+                return null;
+            const metadata = this.reader.readAssetMetadata(assetIndex);
+            if (!metadata || metadata.length < 140)
+                return null;
+            const view = new DataView(metadata.buffer, metadata.byteOffset, metadata.byteLength);
+            const decoder = new TextDecoder();
+            // Parse MeshMetadata
+            const meshGeometryCount = view.getUint32(0, true);
+            const materialCount = view.getUint32(4, true);
+            const nodeCount = view.getUint32(8, true);
+            let offset = 140;
+            // Skip geometries (76 bytes each)
+            offset += meshGeometryCount * 76;
+            // Parse materials
+            const materials = [];
+            for (let i = 0; i < materialCount; i++) {
+                if (offset + 196 > metadata.length)
+                    break;
+                const nameBytes = metadata.slice(offset, offset + 64);
+                const schemaIdBytes = metadata.slice(offset + 64, offset + 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(offset + 192, true);
+                materials.push({ name, schemaId, propertyCount, properties: [] });
+                offset += 196;
+            }
+            // Skip nodes (116 bytes each)
+            offset += nodeCount * 116;
+            // Skip mesh indices (4 bytes each)
+            const totalMeshRefs = materials.reduce((sum, mat) => {
+                // This is a simplification - we'd need to parse nodes to get exact count
+                return sum;
+            }, 0);
+            // For now, skip based on nodeCount assumption
+            offset += nodeCount * 4;
+            // Parse material properties
+            for (const mat of materials) {
+                for (let j = 0; j < mat.propertyCount; j++) {
+                    if (offset + 144 > metadata.length)
+                        break;
+                    const fieldNameBytes = metadata.slice(offset, offset + 64);
+                    const fieldName = decoder.decode(fieldNameBytes.slice(0, fieldNameBytes.indexOf(0) || 64));
+                    const value = [
+                        view.getFloat32(offset + 64, true),
+                        view.getFloat32(offset + 68, true),
+                        view.getFloat32(offset + 72, true),
+                        view.getFloat32(offset + 76, true)
+                    ];
+                    const textureIdBytes = metadata.slice(offset + 80, offset + 144);
+                    const textureId = decoder.decode(textureIdBytes.slice(0, textureIdBytes.indexOf(0) || 64));
+                    mat.properties.push({ fieldName, value, textureId });
+                    offset += 144;
+                }
+            }
+            return materials;
+        }
+        catch (error) {
+            console.error('Failed to read mesh materials:', error);
+            return null;
+        }
+    }
+    /**
+     * Open a .stow file from a File or ArrayBuffer
+     */
+    async open(fileOrBuffer) {
+        // Initialize reader if needed
+        if (this.ownedReader) {
+            await this.reader.init();
+        }
+        return await this.reader.open(fileOrBuffer);
+    }
+    /**
+     * Get the total number of assets
+     */
+    getAssetCount() {
+        return this.reader.getAssetCount();
+    }
+    /**
+     * Get info about a specific asset
+     */
+    getAssetInfo(index) {
+        return this.reader.getAssetInfo(index);
+    }
+    /**
+     * Read asset data by index
+     */
+    readAssetData(index) {
+        return this.reader.readAssetData(index);
+    }
+    /**
+     * Read asset metadata by index
+     */
+    readAssetMetadata(index) {
+        return this.reader.readAssetMetadata(index);
+    }
+    /**
+     * Parse texture metadata
+     */
+    parseTextureMetadata(metadataBytes) {
+        return this.reader.parseTextureMetadata(metadataBytes);
+    }
+    /**
+     * Create an HTML audio element for preview
+     * @param index - Asset index
+     */
+    async createAudioPreview(index) {
+        const data = this.reader.readAssetData(index);
+        if (!data) {
+            throw new Error(`Failed to read audio data for index ${index}`);
+        }
+        // Create blob URL for HTML5 audio
+        const blob = new Blob([data], { type: 'audio/ogg' });
+        const url = URL.createObjectURL(blob);
+        // Create and configure audio element
+        const audio = document.createElement('audio');
+        audio.controls = true;
+        audio.src = url;
+        // Clean up URL when audio ends or on error
+        audio.addEventListener('ended', () => URL.revokeObjectURL(url));
+        audio.addEventListener('error', () => URL.revokeObjectURL(url));
+        return audio;
+    }
+    /**
+     * List all assets in the opened pack
+     */
+    listAssets() {
+        return this.reader.listAssets();
+    }
+    /**
+     * Dispose of resources
+     */
+    dispose() {
+        this.ktx2Loader.dispose();
+        if (this.ownedReader) {
+            this.reader.close();
+        }
+    }
+}
+
+exports.MeshParser = MeshParser;
+exports.StowKitLoader = StowKitLoader;
+//# sourceMappingURL=stowkit-three-loader.js.map