@series-inc/stowkit-cli 0.1.27 → 0.1.29

package/dist/encoders/fbx-loader.js

@@ -2,6 +2,7 @@ import * as THREE from 'three';
 import { FBXLoader } from 'three/addons/loaders/FBXLoader.js';
 import { PropertyBinding } from 'three';
 import { parseBinary as fbxParseBinary, parseText as fbxParseText, FBXReader } from 'fbx-parser';
+import { mergeByMaterial, } from './interfaces.js';
 // ─── Minimal DOM shim for Three.js FBXLoader in Node ────────────────────────
 function ensureDomShim() {
     const g = globalThis;
@@ -291,14 +292,14 @@ function extractMeshFromGroup(group) {
     }
     if (materials.length === 0)
         materials.push({ name: 'default' });
-    return {
+    return mergeByMaterial({
         subMeshes,
         materials,
         nodes,
         hasSkeleton,
         bones: allBones,
         animations: [],
-    };
+    });
 }
 // ─── Hierarchical Group → ImportedMesh extraction ────────────────────────────
 function extractMeshFromGroupHierarchical(group) {

package/dist/encoders/glb-loader.js

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { mergeByMaterial } from './interfaces.js';
 import { PropertyBinding } from 'three';
 import { MaterialFieldType, PreviewPropertyFlag } from '../core/types.js';
 // ─── DOM shim (shared pattern from fbx-loader) ─────────────────────────────
@@ -333,14 +334,14 @@ function extractMeshes(gltf) {
     }
     if (materials.length === 0)
         materials.push({ name: 'default' });
-    const imported = {
+    const imported = mergeByMaterial({
         subMeshes,
         materials,
         nodes,
         hasSkeleton,
         bones: allBones,
         animations: [],
-    };
+    });
     const meshName = meshObjects[0]?.name || 'mesh';
     return [{ name: meshName, imported, hasSkeleton }];
 }

package/dist/encoders/interfaces.d.ts

@@ -83,6 +83,13 @@ export interface ImportedSkinData {
     boneIndices: Uint32Array;
     boneWeights: Float32Array;
 }
+/**
+ * Merge submeshes that share the same material into a single submesh.
+ * Only used when preserveHierarchy is OFF — vertices are already in world space.
+ * Skinned submeshes are left unmerged.
+ * Returns a new ImportedMesh with merged submeshes and a single root node.
+ */
+export declare function mergeByMaterial(mesh: ImportedMesh): ImportedMesh;
 export interface DecodedPcm {
     channels: Float32Array[];
     sampleRate: number;

package/dist/encoders/interfaces.js

@@ -1 +1,107 @@
-export {};
+// ─── Mesh Merging (flat mode) ────────────────────────────────────────────────
+/**
+ * Merge submeshes that share the same material into a single submesh.
+ * Only used when preserveHierarchy is OFF — vertices are already in world space.
+ * Skinned submeshes are left unmerged.
+ * Returns a new ImportedMesh with merged submeshes and a single root node.
+ */
+export function mergeByMaterial(mesh) {
+    // Group non-skinned submeshes by materialIndex
+    const groups = new Map(); // materialIndex → submesh indices
+    const skinnedIndices = [];
+    for (let i = 0; i < mesh.subMeshes.length; i++) {
+        const sm = mesh.subMeshes[i];
+        if (sm.skinData) {
+            skinnedIndices.push(i);
+            continue;
+        }
+        let list = groups.get(sm.materialIndex);
+        if (!list) {
+            list = [];
+            groups.set(sm.materialIndex, list);
+        }
+        list.push(i);
+    }
+    // Nothing to merge
+    if (groups.size === mesh.subMeshes.length - skinnedIndices.length && skinnedIndices.length === 0) {
+        // Already one submesh per material, just collapse to single node
+        return collapseToSingleNode(mesh);
+    }
+    const mergedSubMeshes = [];
+    // Merge each material group
+    for (const [matIdx, smIndices] of groups) {
+        if (smIndices.length === 1) {
+            mergedSubMeshes.push(mesh.subMeshes[smIndices[0]]);
+            continue;
+        }
+        // Calculate total sizes
+        let totalVerts = 0;
+        let totalIndices = 0;
+        let hasNormals = true;
+        let hasUvs = true;
+        for (const si of smIndices) {
+            const sm = mesh.subMeshes[si];
+            totalVerts += sm.positions.length / 3;
+            totalIndices += sm.indices.length;
+            if (!sm.normals)
+                hasNormals = false;
+            if (!sm.uvs)
+                hasUvs = false;
+        }
+        const positions = new Float32Array(totalVerts * 3);
+        const normals = hasNormals ? new Float32Array(totalVerts * 3) : null;
+        const uvs = hasUvs ? new Float32Array(totalVerts * 2) : null;
+        const indices = new Uint32Array(totalIndices);
+        let vertOffset = 0;
+        let idxOffset = 0;
+        for (const si of smIndices) {
+            const sm = mesh.subMeshes[si];
+            const vc = sm.positions.length / 3;
+            positions.set(sm.positions, vertOffset * 3);
+            if (normals && sm.normals)
+                normals.set(sm.normals, vertOffset * 3);
+            if (uvs && sm.uvs)
+                uvs.set(sm.uvs, vertOffset * 2);
+            // Offset indices to account for merged vertex buffer
+            for (let j = 0; j < sm.indices.length; j++) {
+                indices[idxOffset + j] = sm.indices[j] + vertOffset;
+            }
+            vertOffset += vc;
+            idxOffset += sm.indices.length;
+        }
+        mergedSubMeshes.push({ positions, normals, uvs, indices, materialIndex: matIdx });
+    }
+    // Append skinned submeshes unchanged
+    for (const si of skinnedIndices) {
+        mergedSubMeshes.push(mesh.subMeshes[si]);
+    }
+    // Single node referencing all submeshes — the user sees one mesh
+    const node = {
+        name: mesh.nodes[0]?.name || 'mesh',
+        parentIndex: -1,
+        position: [0, 0, 0],
+        rotation: [0, 0, 0, 1],
+        scale: [1, 1, 1],
+        meshIndices: mergedSubMeshes.map((_, i) => i),
+    };
+    return {
+        subMeshes: mergedSubMeshes,
+        materials: mesh.materials,
+        nodes: [node],
+        hasSkeleton: mesh.hasSkeleton,
+        bones: mesh.bones,
+        animations: mesh.animations,
+    };
+}
+/** Collapse N flat nodes into a single node referencing all submeshes */
+function collapseToSingleNode(mesh) {
+    const node = {
+        name: mesh.nodes[0]?.name || 'mesh',
+        parentIndex: -1,
+        position: [0, 0, 0],
+        rotation: [0, 0, 0, 1],
+        scale: [1, 1, 1],
+        meshIndices: mesh.subMeshes.map((_, i) => i),
+    };
+    return { ...mesh, nodes: [node] };
+}

package/dist/pipeline.js

@@ -367,8 +367,14 @@ function resolveAssignedMaterial(meshAsset, subMeshIndex, sourceMaterialName, as
 }
 function toMaterialPropertyValue(prop, assetsById) {
     const textureAsset = prop.textureAssetId ? assetsById.get(prop.textureAssetId) : undefined;
+    // Use previewFlag name as fallback when fieldName is empty (e.g. alphaTest)
+    const flagNames = {
+        1: 'mainTex', 2: 'tint', 3: 'alphaTest',
+        4: 'metalness', 5: 'roughness', 6: 'normalMap', 7: 'emissiveMap', 8: 'emissive',
+    };
+    const fieldName = prop.fieldName.trim() || flagNames[prop.previewFlag] || '';
     return {
-        fieldName: prop.fieldName,
+        fieldName,
         value: [prop.value[0], prop.value[1], prop.value[2], prop.value[3]],
         textureId: textureAsset?.stringId ?? '',
     };
@@ -390,7 +396,7 @@ function applyMaterialAssignments(meshAsset, metadata, assetsById, materialsBySt
             continue;
         const config = assigned.settings.materialConfig;
         const propertyValues = config.properties
-            .filter((prop) => prop.fieldName.trim().length > 0)
+            .filter((prop) => prop.fieldName.trim().length > 0 || prop.previewFlag > 0)
             .map((prop) => toMaterialPropertyValue(prop, assetsById));
         materials[i].schemaId = config.schemaId || assigned.stringId;
         materials[i].properties = propertyValues;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/stowkit-cli",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "type": "module",
   "bin": {
     "stowkit": "./dist/cli.js"
@@ -17,7 +17,7 @@
     "dev": "tsc --watch"
   },
   "dependencies": {
-    "@series-inc/stowkit-packer-gui": "^0.1.12",
+    "@series-inc/stowkit-packer-gui": "^0.1.16",
     "@series-inc/stowkit-editor": "^0.1.2",
     "draco3d": "^1.5.7",
     "fbx-parser": "^2.1.3",