@series-inc/stowkit-cli 0.1.11 → 0.1.13

package/dist/encoders/glb-loader.d.ts

@@ -0,0 +1,42 @@
+import type { ImportedMesh, ImportedAnimation } from './interfaces.js';
+import type { MaterialConfig } from '../app/state.js';
+export interface PbrMaterialConfig {
+    baseColorFactor: [number, number, number, number];
+    metallicFactor: number;
+    roughnessFactor: number;
+    baseColorTextureName: string | null;
+    normalTextureName: string | null;
+    metallicRoughnessTextureName: string | null;
+    emissiveTextureName: string | null;
+    emissiveFactor: [number, number, number];
+    alphaMode: string;
+    alphaCutoff: number;
+    doubleSided: boolean;
+}
+export interface GlbExtractedTexture {
+    name: string;
+    data: Uint8Array;
+    mimeType: string;
+}
+export interface GlbExtractedMesh {
+    name: string;
+    imported: ImportedMesh;
+    hasSkeleton: boolean;
+}
+export interface GlbExtractedMaterial {
+    name: string;
+    pbrConfig: PbrMaterialConfig;
+}
+export interface GlbExtractResult {
+    meshes: GlbExtractedMesh[];
+    textures: GlbExtractedTexture[];
+    materials: GlbExtractedMaterial[];
+    animations: {
+        name: string;
+        clips: ImportedAnimation[];
+    }[];
+}
+export declare function parseGlb(data: Uint8Array, opts?: {
+    preserveHierarchy?: boolean;
+}): Promise<GlbExtractResult>;
+export declare function pbrToMaterialConfig(pbr: PbrMaterialConfig, containerPath: string): MaterialConfig;

package/dist/encoders/glb-loader.js

@@ -0,0 +1,592 @@
+import * as THREE from 'three';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { PropertyBinding } from 'three';
+import { MaterialFieldType, PreviewPropertyFlag } from '../core/types.js';
+// ─── DOM shim (shared pattern from fbx-loader) ─────────────────────────────
+function ensureDomShim() {
+    const g = globalThis;
+    if (typeof g.document !== 'undefined')
+        return;
+    g.document = {
+        createElementNS(_ns, tag) {
+            if (tag === 'img') {
+                const listeners = {};
+                const img = {
+                    width: 1,
+                    height: 1,
+                    data: new Uint8Array(4),
+                    set src(_) {
+                        // Fire load event async so GLTFLoader doesn't hang
+                        queueMicrotask(() => {
+                            for (const fn of (listeners['load'] ?? []))
+                                fn({ target: img });
+                        });
+                    },
+                    set onload(fn) { listeners['load'] = [fn]; },
+                    set onerror(fn) { listeners['error'] = [fn]; },
+                    addEventListener(event, fn) {
+                        (listeners[event] ??= []).push(fn);
+                    },
+                    removeEventListener(event, fn) {
+                        const arr = listeners[event];
+                        if (arr)
+                            listeners[event] = arr.filter(f => f !== fn);
+                    },
+                };
+                return img;
+            }
+            return {};
+        },
+    };
+    if (typeof g.self === 'undefined')
+        g.self = g;
+    if (typeof g.window === 'undefined')
+        g.window = g;
+    if (typeof g.Blob === 'undefined') {
+        g.Blob = class Blob {
+            parts;
+            constructor(parts) { this.parts = parts; }
+        };
+    }
+    if (typeof g.URL === 'undefined' || !g.URL.createObjectURL) {
+        const UrlClass = g.URL ?? {};
+        UrlClass.createObjectURL = () => '';
+        UrlClass.revokeObjectURL = () => { };
+    }
+}
+// ─── Main entry point ───────────────────────────────────────────────────────
+export async function parseGlb(data, opts) {
+    ensureDomShim();
+    const loader = new GLTFLoader();
+    const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    const gltf = await new Promise((resolve, reject) => {
+        loader.parse(buffer, '', resolve, reject);
+    });
+    const textures = extractTexturesFromGlb(data);
+    const materials = extractMaterials(gltf, textures);
+    const meshes = opts?.preserveHierarchy
+        ? extractMeshesHierarchical(gltf)
+        : extractMeshes(gltf);
+    const animations = extractAnimations(gltf);
+    return { meshes, textures, materials, animations };
+}
+// ─── Extract Textures from raw GLB binary ───────────────────────────────────
+function extractTexturesFromGlb(glbData) {
+    const results = [];
+    if (glbData.length < 20)
+        return results;
+    const headerView = new DataView(glbData.buffer, glbData.byteOffset, glbData.byteLength);
+    const magic = headerView.getUint32(0, true);
+    if (magic !== 0x46546C67)
+        return results; // 'glTF'
+    const jsonChunkLength = headerView.getUint32(12, true);
+    const jsonStart = 20;
+    const jsonText = new TextDecoder().decode(glbData.subarray(jsonStart, jsonStart + jsonChunkLength));
+    const json = JSON.parse(jsonText);
+    if (!json.images || !json.bufferViews)
+        return results;
+    const binChunkStart = 12 + 8 + jsonChunkLength;
+    if (binChunkStart + 8 > glbData.length)
+        return results;
+    const binDataStart = binChunkStart + 8;
+    for (let i = 0; i < json.images.length; i++) {
+        const imageDef = json.images[i];
+        if (imageDef.bufferView === undefined)
+            continue;
+        const bufferView = json.bufferViews[imageDef.bufferView];
+        if (!bufferView)
+            continue;
+        const offset = bufferView.byteOffset ?? 0;
+        const length = bufferView.byteLength;
+        const mimeType = imageDef.mimeType || 'image/png';
+        const ext = mimeType === 'image/jpeg' ? 'jpg' : 'png';
+        const baseName = imageDef.name || `texture_${i}`;
+        const textureName = baseName.endsWith(`.${ext}`) ? baseName : `${baseName}.${ext}`;
+        const start = binDataStart + offset;
+        const imageData = glbData.slice(start, start + length);
+        results.push({ name: textureName, data: imageData, mimeType });
+    }
+    return results;
+}
+// ─── Extract Materials ──────────────────────────────────────────────────────
+function extractMaterials(gltf, textures) {
+    const results = [];
+    const json = gltf.parser.json;
+    if (!json.materials)
+        return results;
+    function getTextureName(textureIndex) {
+        const texDef = json.textures?.[textureIndex];
+        if (!texDef || texDef.source === undefined)
+            return null;
+        return textures[texDef.source]?.name ?? null;
+    }
+    for (let i = 0; i < json.materials.length; i++) {
+        const mat = json.materials[i];
+        const pbr = mat.pbrMetallicRoughness;
+        const config = {
+            baseColorFactor: pbr?.baseColorFactor
+                ? [pbr.baseColorFactor[0], pbr.baseColorFactor[1], pbr.baseColorFactor[2], pbr.baseColorFactor[3] ?? 1]
+                : [1, 1, 1, 1],
+            metallicFactor: pbr?.metallicFactor ?? 1,
+            roughnessFactor: pbr?.roughnessFactor ?? 1,
+            baseColorTextureName: pbr?.baseColorTexture !== undefined ? getTextureName(pbr.baseColorTexture.index) : null,
+            normalTextureName: mat.normalTexture !== undefined ? getTextureName(mat.normalTexture.index) : null,
+            metallicRoughnessTextureName: pbr?.metallicRoughnessTexture !== undefined ? getTextureName(pbr.metallicRoughnessTexture.index) : null,
+            emissiveTextureName: mat.emissiveTexture !== undefined ? getTextureName(mat.emissiveTexture.index) : null,
+            emissiveFactor: mat.emissiveFactor
+                ? [mat.emissiveFactor[0], mat.emissiveFactor[1], mat.emissiveFactor[2]]
+                : [0, 0, 0],
+            alphaMode: mat.alphaMode ?? 'OPAQUE',
+            alphaCutoff: mat.alphaCutoff ?? 0.5,
+            doubleSided: mat.doubleSided ?? false,
+        };
+        results.push({ name: mat.name || `material_${i}`, pbrConfig: config });
+    }
+    return results;
+}
+// ─── Extract Meshes ─────────────────────────────────────────────────────────
+function extractMeshes(gltf) {
+    const scene = gltf.scene;
+    if (!scene)
+        return [];
+    scene.updateMatrixWorld(true);
+    const meshObjects = [];
+    scene.traverse((child) => {
+        if (child.isMesh) {
+            meshObjects.push(child);
+        }
+    });
+    if (meshObjects.length === 0)
+        return [];
+    const sceneBones = [];
+    const seenBoneNames = new Set();
+    scene.traverse((child) => {
+        if (child.isBone) {
+            const name = child.name;
+            if (!seenBoneNames.has(name)) {
+                seenBoneNames.add(name);
+                sceneBones.push(child);
+            }
+        }
+    });
+    let hasSkeleton = false;
+    const perMeshSkeletons = new Map();
+    for (const mesh of meshObjects) {
+        if (mesh.isSkinnedMesh) {
+            const sm = mesh;
+            if (sm.skeleton && sm.skeleton.bones.length > 0) {
+                hasSkeleton = true;
+                perMeshSkeletons.set(sm, sm.skeleton);
+            }
+        }
+    }
+    const allBones = [];
+    if (sceneBones.length > 0 && hasSkeleton) {
+        const rootInverse = new THREE.Matrix4().copy(scene.matrixWorld).invert();
+        const boneInverses = new Map();
+        for (const skel of perMeshSkeletons.values()) {
+            for (let i = 0; i < skel.bones.length; i++) {
+                if (!boneInverses.has(skel.bones[i].name)) {
+                    boneInverses.set(skel.bones[i].name, skel.boneInverses[i]);
+                }
+            }
+        }
+        const boneIndexMap = new Map();
+        for (let i = 0; i < sceneBones.length; i++) {
+            boneIndexMap.set(sceneBones[i], i);
+        }
+        function computeOffset(obj) {
+            const localWorld = new THREE.Matrix4().multiplyMatrices(rootInverse, obj.matrixWorld);
+            localWorld.invert();
+            return Array.from(localWorld.elements);
+        }
+        for (let i = 0; i < sceneBones.length; i++) {
+            const bone = sceneBones[i];
+            let parentIndex = -1;
+            let ancestor = bone.parent;
+            while (ancestor && ancestor !== scene) {
+                const boneIdx = boneIndexMap.get(ancestor);
+                if (boneIdx !== undefined) {
+                    parentIndex = boneIdx;
+                    break;
+                }
+                ancestor = ancestor.parent;
+            }
+            const inv = boneInverses.get(bone.name);
+            const offsetMatrix = inv ? Array.from(inv.elements) : computeOffset(bone);
+            allBones.push({ name: bone.name, parentIndex, offsetMatrix });
+        }
+    }
+    const subMeshes = [];
+    const materials = [];
+    const materialSet = new Map();
+    const nodes = [];
+    for (let mi = 0; mi < meshObjects.length; mi++) {
+        const mesh = meshObjects[mi];
+        const geometry = mesh.geometry;
+        const posAttr = geometry.getAttribute('position');
+        if (!posAttr)
+            continue;
+        const vertCount = posAttr.count;
+        const positions = new Float32Array(vertCount * 3);
+        {
+            const worldMatrix = mesh.matrixWorld;
+            const v = new THREE.Vector3();
+            for (let vi = 0; vi < vertCount; vi++) {
+                v.fromBufferAttribute(posAttr, vi);
+                v.applyMatrix4(worldMatrix);
+                positions[vi * 3] = v.x;
+                positions[vi * 3 + 1] = v.y;
+                positions[vi * 3 + 2] = v.z;
+            }
+        }
+        let normals = null;
+        const normAttr = geometry.getAttribute('normal');
+        if (normAttr && normAttr.count === vertCount) {
+            normals = new Float32Array(vertCount * 3);
+            const normalMatrix = new THREE.Matrix3().getNormalMatrix(mesh.matrixWorld);
+            const n = new THREE.Vector3();
+            for (let vi = 0; vi < vertCount; vi++) {
+                n.fromBufferAttribute(normAttr, vi);
+                n.applyMatrix3(normalMatrix).normalize();
+                normals[vi * 3] = n.x;
+                normals[vi * 3 + 1] = n.y;
+                normals[vi * 3 + 2] = n.z;
+            }
+        }
+        let uvs = null;
+        const uvAttr = geometry.getAttribute('uv');
+        if (uvAttr && uvAttr.count === vertCount) {
+            uvs = new Float32Array(vertCount * 2);
+            for (let vi = 0; vi < vertCount; vi++) {
+                uvs[vi * 2] = uvAttr.getX(vi);
+                // Flip V: glTF uses top-left origin (V=0 at top), but our KTX2 pipeline
+                // flips textures to bottom-left origin for Basis Universal encoding.
+                uvs[vi * 2 + 1] = 1 - uvAttr.getY(vi);
+            }
+        }
+        const indexAttr = geometry.getIndex();
+        let indices;
+        if (indexAttr) {
+            indices = new Uint32Array(indexAttr.count);
+            for (let ii = 0; ii < indexAttr.count; ii++)
+                indices[ii] = indexAttr.getX(ii);
+        }
+        else {
+            indices = new Uint32Array(vertCount);
+            for (let ii = 0; ii < vertCount; ii++)
+                indices[ii] = ii;
+        }
+        let skinData;
+        if (mesh.isSkinnedMesh) {
+            const skinIndexAttr = geometry.getAttribute('skinIndex');
+            const skinWeightAttr = geometry.getAttribute('skinWeight');
+            if (skinIndexAttr && skinWeightAttr) {
+                const meshSkeleton = perMeshSkeletons.get(mesh);
+                let remap = null;
+                if (meshSkeleton) {
+                    remap = new Uint32Array(meshSkeleton.bones.length);
+                    for (let si = 0; si < meshSkeleton.bones.length; si++) {
+                        const idx = sceneBones.findIndex(b => b.name === meshSkeleton.bones[si].name);
+                        remap[si] = idx >= 0 ? idx : 0;
+                    }
+                }
+                const boneIndices = new Uint32Array(vertCount * 4);
+                const boneWeights = new Float32Array(vertCount * 4);
+                for (let vi = 0; vi < vertCount; vi++) {
+                    const si0 = skinIndexAttr.getX(vi);
+                    const si1 = skinIndexAttr.getY(vi);
+                    const si2 = skinIndexAttr.getZ(vi);
+                    const si3 = skinIndexAttr.getW(vi);
+                    boneIndices[vi * 4] = remap && si0 < remap.length ? remap[si0] : si0;
+                    boneIndices[vi * 4 + 1] = remap && si1 < remap.length ? remap[si1] : si1;
+                    boneIndices[vi * 4 + 2] = remap && si2 < remap.length ? remap[si2] : si2;
+                    boneIndices[vi * 4 + 3] = remap && si3 < remap.length ? remap[si3] : si3;
+                    boneWeights[vi * 4] = skinWeightAttr.getX(vi);
+                    boneWeights[vi * 4 + 1] = skinWeightAttr.getY(vi);
+                    boneWeights[vi * 4 + 2] = skinWeightAttr.getZ(vi);
+                    boneWeights[vi * 4 + 3] = skinWeightAttr.getW(vi);
+                }
+                skinData = { boneIndices, boneWeights };
+            }
+        }
+        const meshMaterial = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+        const matName = meshMaterial?.name || 'default';
+        let matIndex;
+        if (materialSet.has(matName)) {
+            matIndex = materialSet.get(matName);
+        }
+        else {
+            matIndex = materials.length;
+            materialSet.set(matName, matIndex);
+            materials.push({ name: matName });
+        }
+        subMeshes.push({ skinData, positions, normals, uvs, indices, materialIndex: matIndex });
+        nodes.push({
+            name: mesh.name || `mesh_${mi}`,
+            parentIndex: -1,
+            position: [0, 0, 0],
+            rotation: [0, 0, 0, 1],
+            scale: [1, 1, 1],
+            meshIndices: [mi],
+        });
+    }
+    if (materials.length === 0)
+        materials.push({ name: 'default' });
+    const imported = {
+        subMeshes,
+        materials,
+        nodes,
+        hasSkeleton,
+        bones: allBones,
+        animations: [],
+    };
+    const meshName = meshObjects[0]?.name || 'mesh';
+    return [{ name: meshName, imported, hasSkeleton }];
+}
+// ─── Extract Meshes (Hierarchical) ──────────────────────────────────────────
+function extractMeshesHierarchical(gltf) {
+    const scene = gltf.scene;
+    if (!scene)
+        return [];
+    scene.updateMatrixWorld(true);
+    // Collect all relevant nodes (meshes and groups that form the hierarchy).
+    // Skip Bone, Light, Camera, and SkinnedMesh nodes.
+    const nodeList = [];
+    const nodeIndexMap = new Map();
+    function collectNodes(obj) {
+        // Skip skeleton bones, lights, cameras
+        if (obj.isBone)
+            return;
+        if (obj.isLight)
+            return;
+        if (obj.isCamera)
+            return;
+        // Skip skinned meshes — hierarchy preservation is static-mesh only
+        if (obj.isSkinnedMesh)
+            return;
+        nodeIndexMap.set(obj, nodeList.length);
+        nodeList.push(obj);
+        for (const child of obj.children) {
+            collectNodes(child);
+        }
+    }
+    // Start from scene children (skip the scene root itself)
+    for (const child of scene.children) {
+        collectNodes(child);
+    }
+    if (nodeList.length === 0)
+        return [];
+    const subMeshes = [];
+    const materials = [];
+    const materialSet = new Map();
+    const nodes = [];
+    for (let ni = 0; ni < nodeList.length; ni++) {
+        const obj = nodeList[ni];
+        const isMesh = obj.isMesh;
+        // Determine parent index
+        let parentIndex = -1;
+        let ancestor = obj.parent;
+        while (ancestor && ancestor !== scene) {
+            const idx = nodeIndexMap.get(ancestor);
+            if (idx !== undefined) {
+                parentIndex = idx;
+                break;
+            }
+            ancestor = ancestor.parent;
+        }
+        // Decompose local transform
+        const pos = [obj.position.x, obj.position.y, obj.position.z];
+        const rot = [obj.quaternion.x, obj.quaternion.y, obj.quaternion.z, obj.quaternion.w];
+        const scl = [obj.scale.x, obj.scale.y, obj.scale.z];
+        const meshIndices = [];
+        if (isMesh) {
+            const mesh = obj;
+            const geometry = mesh.geometry;
+            const posAttr = geometry.getAttribute('position');
+            if (!posAttr) {
+                nodes.push({ name: obj.name || `node_${ni}`, parentIndex, position: pos, rotation: rot, scale: scl, meshIndices: [] });
+                continue;
+            }
+            const vertCount = posAttr.count;
+            // Store positions in LOCAL space (no matrixWorld bake)
+            const positions = new Float32Array(vertCount * 3);
+            for (let vi = 0; vi < vertCount; vi++) {
+                positions[vi * 3] = posAttr.getX(vi);
+                positions[vi * 3 + 1] = posAttr.getY(vi);
+                positions[vi * 3 + 2] = posAttr.getZ(vi);
+            }
+            // Normals in local space (use local normal matrix = identity for unscaled,
+            // but compute from local matrix for correctness with non-uniform scale)
+            let normals = null;
+            const normAttr = geometry.getAttribute('normal');
+            if (normAttr && normAttr.count === vertCount) {
+                normals = new Float32Array(vertCount * 3);
+                const localNormalMatrix = new THREE.Matrix3().getNormalMatrix(mesh.matrix);
+                const n = new THREE.Vector3();
+                for (let vi = 0; vi < vertCount; vi++) {
+                    n.fromBufferAttribute(normAttr, vi);
+                    n.applyMatrix3(localNormalMatrix).normalize();
+                    normals[vi * 3] = n.x;
+                    normals[vi * 3 + 1] = n.y;
+                    normals[vi * 3 + 2] = n.z;
+                }
+            }
+            let uvs = null;
+            const uvAttr = geometry.getAttribute('uv');
+            if (uvAttr && uvAttr.count === vertCount) {
+                uvs = new Float32Array(vertCount * 2);
+                for (let vi = 0; vi < vertCount; vi++) {
+                    uvs[vi * 2] = uvAttr.getX(vi);
+                    uvs[vi * 2 + 1] = 1 - uvAttr.getY(vi);
+                }
+            }
+            const indexAttr = geometry.getIndex();
+            let indices;
+            if (indexAttr) {
+                indices = new Uint32Array(indexAttr.count);
+                for (let ii = 0; ii < indexAttr.count; ii++)
+                    indices[ii] = indexAttr.getX(ii);
+            }
+            else {
+                indices = new Uint32Array(vertCount);
+                for (let ii = 0; ii < vertCount; ii++)
+                    indices[ii] = ii;
+            }
+            const meshMaterial = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+            const matName = meshMaterial?.name || 'default';
+            let matIndex;
+            if (materialSet.has(matName)) {
+                matIndex = materialSet.get(matName);
+            }
+            else {
+                matIndex = materials.length;
+                materialSet.set(matName, matIndex);
+                materials.push({ name: matName });
+            }
+            meshIndices.push(subMeshes.length);
+            subMeshes.push({ positions, normals, uvs, indices, materialIndex: matIndex });
+        }
+        nodes.push({
+            name: obj.name || `node_${ni}`,
+            parentIndex,
+            position: pos,
+            rotation: rot,
+            scale: scl,
+            meshIndices,
+        });
+    }
+    if (materials.length === 0)
+        materials.push({ name: 'default' });
+    const imported = {
+        subMeshes,
+        materials,
+        nodes,
+        hasSkeleton: false,
+        bones: [],
+        animations: [],
+    };
+    const meshName = nodeList[0]?.name || 'mesh';
+    return [{ name: meshName, imported, hasSkeleton: false }];
+}
+// ─── Extract Animations ─────────────────────────────────────────────────────
+function extractAnimations(gltf) {
+    if (!gltf.animations || gltf.animations.length === 0)
+        return [];
+    const results = [];
+    for (const clip of gltf.animations) {
+        const tracks = [];
+        for (const track of clip.tracks) {
+            const sanitizedName = PropertyBinding.sanitizeNodeName(track.name);
+            const valuesPerKey = track.getValueSize();
+            tracks.push({
+                name: sanitizedName,
+                times: new Float32Array(track.times),
+                values: new Float32Array(track.values),
+                valuesPerKey,
+            });
+        }
+        if (tracks.length > 0) {
+            results.push({
+                name: clip.name || 'default',
+                clips: [{
+                        name: clip.name || 'default',
+                        duration: clip.duration,
+                        tracks,
+                    }],
+            });
+        }
+    }
+    return results;
+}
+// ─── PBR → MaterialConfig helper ────────────────────────────────────────────
+export function pbrToMaterialConfig(pbr, containerPath) {
+    const properties = [];
+    if (pbr.baseColorTextureName) {
+        properties.push({
+            fieldName: 'BaseColor',
+            fieldType: MaterialFieldType.Texture,
+            previewFlag: PreviewPropertyFlag.MainTex,
+            value: [1, 1, 1, 1],
+            textureAssetId: `${containerPath}/${pbr.baseColorTextureName}`,
+        });
+    }
+    properties.push({
+        fieldName: 'Tint',
+        fieldType: MaterialFieldType.Color,
+        previewFlag: PreviewPropertyFlag.Tint,
+        value: pbr.baseColorFactor,
+        textureAssetId: null,
+    });
+    properties.push({
+        fieldName: 'Metallic',
+        fieldType: MaterialFieldType.Float,
+        previewFlag: PreviewPropertyFlag.None,
+        value: [pbr.metallicFactor, 0, 0, 0],
+        textureAssetId: null,
+    });
+    properties.push({
+        fieldName: 'Roughness',
+        fieldType: MaterialFieldType.Float,
+        previewFlag: PreviewPropertyFlag.None,
+        value: [pbr.roughnessFactor, 0, 0, 0],
+        textureAssetId: null,
+    });
+    if (pbr.normalTextureName) {
+        properties.push({
+            fieldName: 'NormalMap',
+            fieldType: MaterialFieldType.Texture,
+            previewFlag: PreviewPropertyFlag.None,
+            value: [1, 1, 1, 1],
+            textureAssetId: `${containerPath}/${pbr.normalTextureName}`,
+        });
+    }
+    if (pbr.emissiveTextureName) {
+        properties.push({
+            fieldName: 'Emissive',
+            fieldType: MaterialFieldType.Texture,
+            previewFlag: PreviewPropertyFlag.None,
+            value: [1, 1, 1, 1],
+            textureAssetId: `${containerPath}/${pbr.emissiveTextureName}`,
+        });
+    }
+    if (pbr.emissiveFactor[0] > 0 || pbr.emissiveFactor[1] > 0 || pbr.emissiveFactor[2] > 0) {
+        properties.push({
+            fieldName: 'EmissiveColor',
+            fieldType: MaterialFieldType.Color,
+            previewFlag: PreviewPropertyFlag.None,
+            value: [pbr.emissiveFactor[0], pbr.emissiveFactor[1], pbr.emissiveFactor[2], 1],
+            textureAssetId: null,
+        });
+    }
+    if (pbr.metallicRoughnessTextureName) {
+        properties.push({
+            fieldName: 'MetallicRoughness',
+            fieldType: MaterialFieldType.Texture,
+            previewFlag: PreviewPropertyFlag.None,
+            value: [1, 1, 1, 1],
+            textureAssetId: `${containerPath}/${pbr.metallicRoughnessTextureName}`,
+        });
+    }
+    return { schemaId: '', properties };
+}

package/dist/encoders/interfaces.d.ts

@@ -35,8 +35,11 @@ export interface ImportedMesh {
     bones: ImportedBone[];
     animations: ImportedAnimation[];
 }
+export interface MeshImportOpts {
+    preserveHierarchy?: boolean;
+}
 export interface IMeshImporter {
-    import(data: Uint8Array, fileName: string): Promise<ImportedMesh>;
+    import(data: Uint8Array, fileName: string, opts?: MeshImportOpts): Promise<ImportedMesh>;
 }
 export interface MeshEncodeSettings {
     compressionLevel: number;

package/dist/node-fs.js

@@ -106,6 +106,8 @@ async function walkDirectory(basePath, prefix, sourceFiles, metaFiles, matFiles,
         if (entry.isDirectory()) {
             if (entry.name.startsWith('.'))
                 continue;
+            if (entry.name.endsWith('.children'))
+                continue;
             folders.push(relativePath);
             await walkDirectory(basePath, relativePath, sourceFiles, metaFiles, matFiles, folders);
         }