@zephyr3d/scene 0.9.25 → 0.9.27

package/dist/asset/model.js

@@ -18,7 +18,7 @@ import '../animation/joint_dynamics/collision.js';
 import '../animation/joint_dynamics/solver.js';
 import { createTransformAccess, JointDynamicsSystem } from '../animation/joint_dynamics/joint_dynamics_system.js';
 import { JointDynamicsModifier } from '../animation/joint_dynamics_modifier.js';
-import { MAX_MORPH_TARGETS, MAX_MORPH_ATTRIBUTES } from '../values.js';
+import { MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, getMorphTargetLimit, MAX_SKIN_INFLUENCES } from '../values.js';
 import { Primitive } from '../render/primitive.js';
 import { UnlitMaterial } from '../material/unlit.js';
 import { PBRSpecularGlossinessMaterial } from '../material/pbrsg.js';
@@ -37,6 +37,30 @@ import { MToonMaterial } from '../material/mtoon.js';
         this.name = name;
     }
 }
+function normalizeAssetNodePath(path) {
+    return path.replace(/\\/g, '/').split('/').filter(Boolean).join('/');
+}
+function getSkinBindingKey(rig, joints, inverseBindMatrices) {
+    const matrixKey = inverseBindMatrices.map((matrix)=>{
+        const elements = [];
+        for(let i = 0; i < 16; i++){
+            elements.push(matrix[i]);
+        }
+        return elements.join(',');
+    }).join('|');
+    return `${rig.persistentId}|${joints.map((joint)=>joint.persistentId).join('|')}|${matrixKey}`;
+}
+function getAssetNodePath(node) {
+    const segments = [];
+    let current = node;
+    while(current){
+        if (current.name) {
+            segments.push(current.name);
+        }
+        current = current.parent;
+    }
+    return normalizeAssetNodePath(segments.reverse().join('/'));
+}
 /**
  * Heirarchical node interface for model loading
  * @public
@@ -184,6 +208,7 @@ import { MToonMaterial } from '../material/mtoon.js';
     /** Joints of the skeleton */ joints;
     /** Inverse of the binding matrices of the joints */ inverseBindMatrices;
     /** Binding pose matrices of the joints */ bindPose;
+    /** Optional humanoid retarget reference pose, ordered like `joints`. */ retargetPose;
     /** Explicit humanoid joint mapping, when supplied by the source asset. */ humanoidJointMapping;
     /**
    * Creates an instance of AssetSkeleton
@@ -195,6 +220,7 @@ import { MToonMaterial } from '../material/mtoon.js';
         this.joints = [];
         this.inverseBindMatrices = [];
         this.bindPose = [];
+        this.retargetPose = null;
         this.humanoidJointMapping = null;
     }
     /**
@@ -665,18 +691,25 @@ import { MToonMaterial } from '../material/mtoon.js';
                 ASSERT(!!ext, `Unknown image mime type: ${mimeType}`);
                 const baseName = this.sanitizeResourceName(this.getImageBaseName(img, i, destName), `${destName}_texture_${i}`);
                 const path = await this.tryReuseExactResourcePath(dstVFS, destPath, baseName, ext, usedPaths, `${destName}_texture_${i}`) ?? this.consumeReusableResourcePath(reusableResourcePools, baseName, ext, usedPaths) ?? await this.createUniqueResourcePath(dstVFS, destPath, baseName, ext, usedPaths, `${destName}_texture_${i}`);
-                if (img.uri) {
-                    img.data = new Uint8Array(await srcVFS.readFile(img.uri, {
-                        encoding: 'binary'
-                    }));
+                try {
+                    if (img.uri) {
+                        img.data = new Uint8Array(await srcVFS.readFile(img.uri, {
+                            encoding: 'binary'
+                        }));
+                    }
+                    await dstVFS.writeFile(path, img.data.buffer.slice(img.data.byteOffset, img.data.byteOffset + img.data.byteLength), {
+                        encoding: 'binary',
+                        create: true
+                    });
+                    img.uri = path;
+                    img.data = undefined;
+                    img.mimeType = '';
+                } catch (err) {
+                    console.warn(`Skip missing or unreadable texture during import: ${img.uri || img.name || `${destName}_texture_${i}`}: ${String(err)}`);
+                    img.uri = undefined;
+                    img.data = undefined;
+                    img.mimeType = '';
                 }
-                await dstVFS.writeFile(path, img.data.buffer.slice(img.data.byteOffset, img.data.byteOffset + img.data.byteLength), {
-                    encoding: 'binary',
-                    create: true
-                });
-                img.uri = path;
-                img.data = undefined;
-                img.mimeType = '';
             }
         }
         const materialKeys = Object.keys(this._materialList);
@@ -900,6 +933,7 @@ import { MToonMaterial } from '../material/mtoon.js';
                     }
                 }
                 const rigMap = new Map();
+                const bindingMap = new Map();
                 for (const v of skeletonMeshMap){
                     const sk = v[0];
                     const joints = sk.joints.map((val)=>{
@@ -916,14 +950,22 @@ import { MToonMaterial } from '../material/mtoon.js';
                         const humanoidJointMapping = this.remapHumanoidJointMapping(sk.humanoidJointMapping, nodeMap);
                         rig = new SkeletonRig(joints, sk.bindPose, humanoidJointMapping ? {
                             rootJoint,
-                            humanoidJointMapping
+                            humanoidJointMapping,
+                            retargetPose: sk.retargetPose
                         } : {
-                            rootJoint
+                            rootJoint,
+                            retargetPose: sk.retargetPose
                         });
                         rigMap.set(rigKey, rig);
                         group.animationSet.rigs.push(new DRef(rig));
                     }
-                    const binding = new SkinBinding(rig, sk.inverseBindMatrices, joints);
+                    const bindingKey = getSkinBindingKey(rig, joints, sk.inverseBindMatrices);
+                    let binding = bindingMap.get(bindingKey);
+                    if (!binding) {
+                        binding = new SkinBinding(rig, sk.inverseBindMatrices, joints);
+                        bindingMap.set(bindingKey, binding);
+                        group.animationSet.skeletons.push(new DRef(binding));
+                    }
                     const nodes = skeletonMeshMap.get(sk);
                     if (nodes) {
                         if (!nodes.binding) {
@@ -933,14 +975,14 @@ import { MToonMaterial } from '../material/mtoon.js';
                                 const v = {
                                     positions: nodes.bounding[i].rawPositions,
                                     blendIndices: nodes.bounding[i].rawBlendIndices,
-                                    weights: nodes.bounding[i].rawJointWeights
+                                    weights: nodes.bounding[i].rawJointWeights,
+                                    influenceCount: nodes.bounding[i].rawSkinInfluenceCount ?? 4
                                 };
                                 mesh.setSkinnedBoundingInfo(nodes.binding.getBoundingInfo(v));
                                 mesh.skeletonName = nodes.binding.persistentId;
                             }
                         }
                     }
-                    group.animationSet.skeletons.push(new DRef(nodes.binding));
                 }
             }
             if (saveAnimations) {
@@ -979,8 +1021,9 @@ import { MToonMaterial } from '../material/mtoon.js';
                         } else if (track.type === 'weights') {
                             for (const m of track.node.mesh.subMeshes){
                                 const mesh = meshMap.get(m);
-                                if (track.interpolator.stride > MAX_MORPH_TARGETS) {
-                                    console.error(`Morph target too large: ${track.interpolator.stride}, the maximum is ${MAX_MORPH_TARGETS}`);
+                                const morphTargetLimit = getMorphTargetLimit();
+                                if (track.interpolator.stride > morphTargetLimit) {
+                                    console.error(`Morph target too large: ${track.interpolator.stride}, the project limit is ${morphTargetLimit}`);
                                 } else {
                                     const morphTrack = new MorphTargetTrack(track.interpolator, track.defaultMorphWeights, m.targetBox, mesh.getBoundingVolume().toAABB(), true);
                                     animation.addTrack(mesh, morphTrack);
@@ -1214,6 +1257,7 @@ import { MToonMaterial } from '../material/mtoon.js';
         node.rotation.set(assetNode.rotation);
         node.scale.set(assetNode.scaling);
         if (saveMeshes && assetNode.mesh) {
+            const sourceMorphReferenceAssetPath = this._preprocessOptions?.sourceMorphReferenceAssetPath ?? null;
             const meshData = assetNode.mesh;
             const skeleton = saveSkeletons ? assetNode.skeleton : null;
             for (const subMesh of meshData.subMeshes){
@@ -1229,7 +1273,7 @@ import { MToonMaterial } from '../material/mtoon.js';
                     meshNode.position = instance.t;
                     meshNode.scale = instance.s;
                     meshNode.rotation = instance.r;
-                    meshNode.name = subMesh.name;
+                    meshNode.name = subMesh.primitive?.name?.trim() || subMesh.name;
                     meshNode.clipTestEnabled = true;
                     meshNode.showState = 'inherit';
                     if (!this._primitiveMap.get(subMesh.primitive)) {
@@ -1250,7 +1294,20 @@ import { MToonMaterial } from '../material/mtoon.js';
                         mesh: meshData,
                         subMesh
                     });
-                    processMorphData(subMesh, meshNode, assetNode.weights ?? meshData.morphWeights, meshData.morphNames);
+                    const morphSource = sourceMorphReferenceAssetPath && subMesh.numTargets > 0 ? (()=>{
+                        const nodePath = getAssetNodePath(assetNode);
+                        const subMeshName = subMesh.name;
+                        if (!nodePath || !subMeshName) {
+                            return null;
+                        }
+                        return {
+                            sourcePath: sourceMorphReferenceAssetPath,
+                            nodePath,
+                            subMeshName
+                        };
+                    })() : null;
+                    processMorphData(subMesh, meshNode, assetNode.weights ?? meshData.morphWeights, meshData.morphNames, morphSource);
+                    applyMeshSkinInfluenceData(subMesh, meshNode);
                     if (skeleton) {
                         if (!skeletonMeshMap.has(skeleton)) {
                             skeletonMeshMap.set(skeleton, {
@@ -1762,30 +1819,28 @@ import { MToonMaterial } from '../material/mtoon.js';
         return null;
     }
 }
-/** @internal */ function processMorphData(subMesh, mesh, morphWeights, morphNames) {
-    const device = getDevice();
+function applyMeshMorphMetadata(subMesh, mesh, morphWeights, morphNames) {
     const numTargets = subMesh.numTargets;
-    if (numTargets === 0) {
+    if (numTargets === 0 || !subMesh.targets || !subMesh.targetBox) {
         return;
     }
+    const supportedNumTargets = Math.min(numTargets, getMorphTargetLimit());
+    if (supportedNumTargets !== numTargets) {
+        console.warn(`Morph target count truncated from ${numTargets} to ${supportedNumTargets} for mesh "${subMesh.name ?? mesh.name ?? ''}"`);
+    }
     const attributes = Object.getOwnPropertyNames(subMesh.targets);
     const positionInfo = subMesh.primitive.vertices['position'];
     const numVertices = positionInfo ? positionInfo.data.length / getVertexFormatComponentCount(positionInfo.format) >> 0 : 0;
     const weightsAndOffsets = new Float32Array(4 + MAX_MORPH_TARGETS + MAX_MORPH_ATTRIBUTES);
-    for(let i = 0; i < numTargets; i++){
+    for(let i = 0; i < supportedNumTargets; i++){
         weightsAndOffsets[4 + i] = morphWeights?.[i] ?? 0;
     }
     const textureSize = Math.ceil(Math.sqrt(numVertices * attributes.length * numTargets));
-    if (textureSize > device.getDeviceCaps().textureCaps.maxTextureSize) {
-        // TODO: reduce morph attributes
-        throw new Error(`Morph target data too large`);
-    }
     weightsAndOffsets[0] = textureSize;
     weightsAndOffsets[1] = textureSize;
     weightsAndOffsets[2] = numVertices;
-    weightsAndOffsets[3] = numTargets;
+    weightsAndOffsets[3] = supportedNumTargets;
     let offset = 0;
-    const textureData = new Float32Array(textureSize * textureSize * 4);
     for(let attrib = 0; attrib < MAX_MORPH_ATTRIBUTES; attrib++){
         const index = attributes.indexOf(String(attrib));
         if (index < 0) {
@@ -1798,64 +1853,124 @@ import { MToonMaterial } from '../material/mtoon.js';
             console.error(`Invalid morph target data`);
             return;
         }
-        for(let t = 0; t < numTargets; t++){
-            const data = info.data[t];
-            for(let i = 0; i < numVertices; i++){
-                for(let j = 0; j < 4; j++){
-                    textureData[offset++] = j < info.numComponents ? data[i * info.numComponents + j] : 1;
-                }
-            }
-        }
+        offset += numVertices * 4 * numTargets;
     }
-    const morphBoundingBox = new BoundingBox();
-    calculateMorphBoundingBox(morphBoundingBox, subMesh.targetBox, weightsAndOffsets.subarray(4, 4 + MAX_MORPH_TARGETS), numTargets);
-    const meshAABB = mesh.getBoundingVolume().toAABB();
-    morphBoundingBox.minPoint.addBy(meshAABB.minPoint);
-    morphBoundingBox.maxPoint.addBy(meshAABB.maxPoint);
     const names = {};
-    for(let i = 0; i < numTargets; i++){
+    for(let i = 0; i < supportedNumTargets; i++){
         const name = morphNames?.[i] ?? `Target${i}`;
         names[name] = i;
     }
-    mesh.setMorphData({
-        width: textureSize,
-        height: textureSize,
-        data: textureData
-    });
     mesh.setMorphInfo({
         data: weightsAndOffsets,
         names
     });
     mesh.setMorphBoundingInfo({
-        targetBoxes: subMesh.targetBox,
-        originBox: new BoundingBox(meshAABB)
+        targetBoxes: subMesh.targetBox.slice(0, supportedNumTargets),
+        originBox: new BoundingBox(mesh.getBoundingVolume().toAABB())
     });
-    mesh.setAnimatedBoundingBox(morphBoundingBox);
+}
+function createMorphSourceDataFromSubMesh(subMesh) {
+    const numTargets = Math.min(subMesh.numTargets, getMorphTargetLimit());
+    if (numTargets === 0 || !subMesh.targets) {
+        return null;
+    }
+    const positionInfo = subMesh.primitive.vertices['position'];
+    const numVertices = positionInfo ? positionInfo.data.length / getVertexFormatComponentCount(positionInfo.format) >> 0 : 0;
+    const targets = {};
+    for (const [attribKey, info] of Object.entries(subMesh.targets)){
+        const attrib = Number(attribKey);
+        if (!info || !Number.isInteger(attrib) || attrib < 0) {
+            continue;
+        }
+        if (info.data.length < numTargets) {
+            console.error(`Invalid morph target data`);
+            return null;
+        }
+        targets[attrib] = {
+            numComponents: info.numComponents,
+            data: info.data.slice(0, numTargets),
+            indices: info.indices?.slice(0, numTargets)
+        };
+    }
+    return {
+        numTargets,
+        numVertices,
+        targets
+    };
+}
+function applyMeshMorphData(subMesh, mesh) {
+    const sourceData = createMorphSourceDataFromSubMesh(subMesh);
+    if (!sourceData) {
+        mesh.setMorphData(null);
+        mesh.setMorphSourceData(null);
+        return;
+    }
+    mesh.setMorphSourceData(sourceData);
+}
+function createSkinInfluenceDataFromSubMesh(subMesh) {
+    // Preserve the influence count captured at import time so runtime settings do not silently
+    // degrade already-imported assets when a project lowers the import limit later on.
+    const influenceCount = Math.max(0, Math.min(subMesh.rawSkinInfluenceCount ?? 4, MAX_SKIN_INFLUENCES, Math.floor((subMesh.rawJointWeights?.length ?? 0) / Math.max(1, (subMesh.rawPositions?.length ?? 0) / 3))));
+    if (influenceCount <= 4 || !subMesh.rawPositions || !subMesh.rawBlendIndices || !subMesh.rawJointWeights || subMesh.rawPositions.length < 3) {
+        return null;
+    }
+    const numVertices = Math.floor(subMesh.rawPositions.length / 3);
+    if (numVertices <= 0) {
+        return null;
+    }
+    const extraInfluenceCount = influenceCount - 4;
+    const pairCount = Math.ceil(extraInfluenceCount / 2);
+    const textureSize = Math.ceil(Math.sqrt(numVertices * pairCount));
+    const textureData = new Float32Array(textureSize * textureSize * 4);
+    for(let vertexIndex = 0; vertexIndex < numVertices; vertexIndex++){
+        const baseOffset = vertexIndex * influenceCount + 4;
+        for(let pairIndex = 0; pairIndex < pairCount; pairIndex++){
+            const influenceIndex = 4 + pairIndex * 2;
+            const sourceIndex = baseOffset + pairIndex * 2;
+            const texelOffset = (vertexIndex * pairCount + pairIndex) * 4;
+            textureData[texelOffset] = Number(subMesh.rawBlendIndices[sourceIndex] ?? 0);
+            textureData[texelOffset + 1] = Number(subMesh.rawJointWeights[sourceIndex] ?? 0);
+            // Odd influence counts leave the second half of the final texel empty.
+            // Do not read it from the next vertex's first influence.
+            if (influenceIndex + 1 < influenceCount) {
+                textureData[texelOffset + 2] = Number(subMesh.rawBlendIndices[sourceIndex + 1] ?? 0);
+                textureData[texelOffset + 3] = Number(subMesh.rawJointWeights[sourceIndex + 1] ?? 0);
+            }
+        }
+    }
+    return {
+        width: textureSize,
+        height: textureSize,
+        influenceCount,
+        data: textureData
+    };
+}
+function applyMeshSkinInfluenceData(subMesh, mesh) {
+    mesh.setSkinInfluenceData(createSkinInfluenceDataFromSubMesh(subMesh));
+}
+/** @internal */ function processMorphData(subMesh, mesh, morphWeights, morphNames, morphSource) {
+    if (subMesh.numTargets === 0) {
+        return;
+    }
+    applyMeshMorphMetadata(subMesh, mesh, morphWeights, morphNames);
+    mesh.setMorphSource(morphSource ?? null);
+    if (morphSource) {
+        mesh.setMorphSourceData(null);
+        mesh.setMorphData(null);
+    } else {
+        applyMeshMorphData(subMesh, mesh);
+    }
 }
 /** @internal */ function getAssetMeshMorphTargetCount(mesh) {
     let count = 0;
     for (const subMesh of mesh.subMeshes){
         count = Math.max(count, subMesh.numTargets);
     }
-    return count;
+    return Math.min(count, getMorphTargetLimit());
 }
 /** @internal */ function getAssetMeshMorphTargetName(mesh, index) {
     return mesh.morphNames?.[index] ?? `Target${index}`;
 }
-/** @internal */ function calculateMorphBoundingBox(morphBoundingBox, keyframeBoundingBox, weights, numTargets) {
-    morphBoundingBox.minPoint.setXYZ(0, 0, 0);
-    morphBoundingBox.maxPoint.setXYZ(0, 0, 0);
-    for(let i = 0; i < numTargets; i++){
-        const weight = weights[i];
-        const keyframeBox = keyframeBoundingBox[i];
-        morphBoundingBox.minPoint.x += keyframeBox.minPoint.x * weight;
-        morphBoundingBox.minPoint.y += keyframeBox.minPoint.y * weight;
-        morphBoundingBox.minPoint.z += keyframeBox.minPoint.z * weight;
-        morphBoundingBox.maxPoint.x += keyframeBox.maxPoint.x * weight;
-        morphBoundingBox.maxPoint.y += keyframeBox.maxPoint.y * weight;
-        morphBoundingBox.maxPoint.z += keyframeBox.maxPoint.z * weight;
-    }
-}
 
-export { AssetHierarchyNode, AssetScene, AssetSkeleton, NamedObject, SharedModel };
+export { AssetHierarchyNode, AssetScene, AssetSkeleton, NamedObject, SharedModel, applyMeshMorphData, applyMeshMorphMetadata, applyMeshSkinInfluenceData, createMorphSourceDataFromSubMesh };
 //# sourceMappingURL=model.js.map