@babylonjs/loaders 9.17.0 → 9.18.0

package/FBX/fbxFileLoader.pure.d.ts

@@ -87,6 +87,7 @@ export declare class FBXFileLoader implements ISceneLoaderPluginAsync, ISceneLoa
     private _setAssetContainer;
     private static _computeFBXAxisConversionMatrix;
     private _buildModel;
+    private _linkSkeletonsToTransformNodes;
     private static _modelSubtreeMatchesNameFilter;
     private static _applyModelMetadata;
     private _createMesh;

package/FBX/fbxFileLoader.pure.js

@@ -238,6 +238,7 @@ export class FBXFileLoader {
         for (const model of fbxScene.rootModels) {
             this._buildModel(model, scene, assetRoot, assetRoot, fbxWorldIdentity, materialCache, nameFilter, meshes, transformNodes, skeletonByGeometryId, skinByGeometryId, skinBindingByGeometryId, modelIdToNode, cullingConflictMaterialIds, cullingMaterialCloneCache);
         }
+        this._linkSkeletonsToTransformNodes(fbxScene.rigs, skeletonByRigId, modelIdToNode, transformNodes, scene);
         // Link non-skinned child meshes/nodes to their parent bones so they
         // follow skeletal animation. Preserve their current world matrix when
         // switching from the FBX model hierarchy to Babylon's bone parent.
@@ -246,9 +247,15 @@ export class FBXFileLoader {
             if (!skeleton) {
                 continue;
             }
-            const boneModelIds = new Set(rig.bones.map((b) => b.modelId));
             const skinnedMesh = meshes.find((m) => m.skeleton === skeleton) ?? null;
             const boneReferenceNode = skinnedMesh ?? rootNode;
+            const boneTransformNodes = new Set();
+            for (const skeletonBone of skeleton.bones) {
+                const transformNode = skeletonBone.getTransformNode();
+                if (transformNode) {
+                    boneTransformNodes.add(transformNode);
+                }
+            }
             for (const boneData of rig.bones) {
                 if (!boneData.isCluster) {
                     continue;
@@ -261,15 +268,7 @@ export class FBXFileLoader {
                 // Find direct children of this bone's TransformNode that aren't bones themselves
                 for (const child of [...boneNode.getChildren()]) {
                     const childTransform = child;
-                    // Check if this child is itself a bone — if so, skip it
-                    let childIsBone = false;
-                    for (const [modelId, node] of Array.from(modelIdToNode)) {
-                        if (node === childTransform && boneModelIds.has(modelId)) {
-                            childIsBone = true;
-                            break;
-                        }
-                    }
-                    if (!childIsBone) {
+                    if (!boneTransformNodes.has(childTransform)) {
                         const childWorld = childTransform.computeWorldMatrix(true).clone();
                         const boneReferenceWorld = FBXFileLoader._getBoneReferenceWorldMatrix(skeleton, bone, boneReferenceNode, skinnedMesh);
                         const boneReferenceWorldInv = new Matrix();
@@ -472,6 +471,35 @@ export class FBXFileLoader {
             }
         }
     }
+    _linkSkeletonsToTransformNodes(rigs, skeletonByRigId, modelIdToNode, transformNodes, scene) {
+        for (const rig of rigs) {
+            const skeleton = skeletonByRigId.get(rig.id);
+            if (!skeleton) {
+                continue;
+            }
+            for (const boneData of rig.bones) {
+                const bone = this._getSourceBone(skeleton, boneData.index);
+                const boneNode = modelIdToNode.get(boneData.modelId);
+                if (!bone || !boneNode) {
+                    continue;
+                }
+                const scaleCompensationHelper = this._getScaleCompensationHelper(skeleton, boneData.index);
+                if (scaleCompensationHelper) {
+                    const helperNode = new TransformNode(scaleCompensationHelper.name, scene);
+                    helperNode.parent = boneNode.parent;
+                    boneNode.parent = helperNode;
+                    FBXFileLoader._applyMatrixToTransform(helperNode, scaleCompensationHelper.getLocalMatrix());
+                    FBXFileLoader._applyMatrixToTransform(boneNode, bone.getLocalMatrix());
+                    scaleCompensationHelper.linkTransformNode(helperNode);
+                    transformNodes.push(helperNode);
+                }
+                else {
+                    FBXFileLoader._applyMatrixToTransform(boneNode, bone.getLocalMatrix());
+                }
+                bone.linkTransformNode(boneNode);
+            }
+        }
+    }
     static _modelSubtreeMatchesNameFilter(model, nameFilter) {
         for (const child of model.children) {
             if (child.geometry && child.subType === "Mesh" && nameFilter(child.name)) {
@@ -1543,6 +1571,20 @@ export class FBXFileLoader {
             return null;
         }
         const animGroup = new AnimationGroup(animStack.name, scene);
+        const animatedBoneTargetProperties = new Map();
+        const addBoneAnimation = (animation, bone) => {
+            const target = bone.getTransformNode() ?? bone;
+            let targetProperties = animatedBoneTargetProperties.get(target);
+            if (!targetProperties) {
+                targetProperties = new Set();
+                animatedBoneTargetProperties.set(target, targetProperties);
+            }
+            else if (targetProperties.has(animation.targetProperty)) {
+                return;
+            }
+            targetProperties.add(animation.targetProperty);
+            animGroup.addTargetedAnimation(animation, target);
+        };
         // Build a map from model ID to resolved rig bones. A single FBX model ID
         // should only appear once per resolved rig, but keeping an array preserves
         // the previous animation fan-out behavior for any future duplicate rigs.
@@ -1609,7 +1651,7 @@ export class FBXFileLoader {
             }
             for (const { bone, animations } of this._buildInheritedRigBoneAnimations(rig, skeleton, boneCurves, modelIdToData, inheritType2ModelIds, animStack.startTime, animStack.stopTime)) {
                 for (const animation of animations) {
-                    animGroup.addTargetedAnimation(animation, bone);
+                    addBoneAnimation(animation, bone);
                 }
             }
         }
@@ -1625,7 +1667,7 @@ export class FBXFileLoader {
             for (const bone of bones) {
                 const animations = this._buildBoneAnimations(curveNodes, bone.name, modelData, animStack.startTime, animStack.stopTime, this._bindRestBones.has(bone) ? bone.getBindMatrix() : undefined);
                 for (const animation of animations) {
-                    animGroup.addTargetedAnimation(animation, bone);
+                    addBoneAnimation(animation, bone);
                 }
             }
         }