Skin hierarchy (#1026)

* Skin_hierarchy_check

Check the skeleton hierarchy to see if any ancestor has the skin as children. The goal is to choose which transformation matrix to apply at the root of the skeleton (World or Local).

* Add comment

* Change Default Tuple syntax to Tuple to retro-compatibilty

Author: pandaGaume

3ds Max/Max2Babylon/Exporter/BabylonExporter.Mesh.cs

@@ -236,7 +236,7 @@ private BabylonNode ExportMasterMesh(IIGameScene scene, IIGameNode meshNode, Bab
             IGMatrix skinInitPoseMatrix = Loader.Global.GMatrix.Create(Loader.Global.Matrix3.Create(true));
             List<int> boneIds = null;
             int maxNbBones = 0;
-            List<IIGameNode> skinnedBones = GetSkinnedBones(skin);
+            List<IIGameNode> skinnedBones = GetSkinnedBones(skin).Item1;
             if (isSkinned && skinnedBones.Count > 0)  // if the mesh has a skin with at least one bone
             {
                 var skinAlreadyStored = skins.Find(_skin => IsSkinEqualTo(_skin, skin));

3ds Max/Max2Babylon/Exporter/BabylonExporter.Skeleton.cs

@@ -50,13 +50,13 @@ private List<IIGameNode> GetBones(IIGameSkin skin)
         /// <returns>
         /// All nodes needed for the skeleton hierarchy
         /// </returns>
-        private Dictionary<IIGameSkin, List<IIGameNode>> relevantNodesBySkin = new Dictionary<IIGameSkin, List<IIGameNode>>();
-        private List<IIGameNode> GetSkinnedBones(IIGameSkin skin)
+        private Dictionary<IIGameSkin, Tuple<List<IIGameNode>, float[]>> relevantNodesBySkin = new Dictionary<IIGameSkin, Tuple<List<IIGameNode>, float[]>>();
+        private Tuple<List<IIGameNode>, float[]> GetSkinnedBones(IIGameSkin skin)
         {
 
             if (skin == null)
             {
-                return new List<IIGameNode>();
+                return new Tuple<List<IIGameNode>, float[]>(new List<IIGameNode>(),null);
             }
 
             int logRank = 2;
@@ -72,14 +72,14 @@ private List<IIGameNode> GetSkinnedBones(IIGameSkin skin)
             if (bones.Count == 0)
             {
                 RaiseWarning("Skin has no bones.", logRank);
-                return new List<IIGameNode>();
+                return new Tuple<List<IIGameNode>, float[]>(new List<IIGameNode>(), null);
             }
 
             if (bones.Contains(null))
             {
                 RaiseError("Skin has bones that are outside of the exported hierarchy.", logRank);
                 RaiseError("The skin cannot be exported", logRank);
-                return new List<IIGameNode>();
+                return new Tuple<List<IIGameNode>, float[]>(new List<IIGameNode>(), null);
             }
 
             List<IIGameNode> allHierarchyNodes = null;
@@ -90,18 +90,31 @@ private List<IIGameNode> GetSkinnedBones(IIGameSkin skin)
                 RaiseError($"More than one root node for the skin. The skeleton bones need to be part of the same hierarchy.", logRank);
                 RaiseError($"The skin cannot be exported", logRank);
 
-                return new List<IIGameNode>();
+                return new Tuple<List<IIGameNode>, float[]>(new List<IIGameNode>(), null);
             }
 
-            // Babylon format assumes skeleton root is at origin, add any additional node parents from the lowest common ancestor to the scene root to the skeleton hierarchy.
             allHierarchyNodes.Add(lowestCommonAncestor);
+
+            float[] rootTransformation = null;
+
+            // Babylon format assumes skeleton root is at origin, add any additional node parents from the lowest common ancestor to the scene root to the skeleton hierarchy.
             if (lowestCommonAncestor.NodeParent != null)
             {
-                do {
+                do
+                {
+                    // we need to check if the ancestor has the current skin as child (anywhere down the hierarchy)
+                    // in this case, we stop to stack commonAncestor and we set the root transformation Matrix as Local.
+                    if(HasSkinAsChild(lowestCommonAncestor.NodeParent, skin))
+                    {
+                        rootTransformation = lowestCommonAncestor.GetLocalTM(0).ToArray();
+                        break;
+                    }
                     lowestCommonAncestor = lowestCommonAncestor.NodeParent;
                     allHierarchyNodes.Add(lowestCommonAncestor);
-                } while (lowestCommonAncestor.NodeParent != null) ;
-            } 
+                } while (lowestCommonAncestor.NodeParent != null);
+            }
+
+            rootTransformation = rootTransformation ?? lowestCommonAncestor.GetWorldTM(0).ToArray();
 
             // starting from the root, sort the nodes by depth first (add the children before the siblings)
             List<IIGameNode> sorted = new List<IIGameNode>();
@@ -133,10 +146,11 @@ private List<IIGameNode> GetSkinnedBones(IIGameSkin skin)
                     }
                 }
             }
+            var result = new Tuple<List<IIGameNode>, float[]>(sorted, rootTransformation);
+            
+            relevantNodesBySkin.Add(skin, result);   // Stock the result for optimization
 
-            relevantNodesBySkin.Add(skin, sorted);   // Stock the result for optimization
-
-            return sorted;
+            return result;
         }
 
         private IIGameNode GetLowestCommonAncestor(List<IIGameNode> nodes, ref List<IIGameNode> allHierarchyNodes)
@@ -169,6 +183,32 @@ private IIGameNode GetLowestCommonAncestor(List<IIGameNode> nodes, ref List<IIGa
             return commonAncestor;
         }
 
+        // fetch recursively the childrens to see if any of it, reference the skin.
+        // the fetch stop at the first node passing the test.
+        // down search is deep first.
+        private bool HasSkinAsChild(IIGameNode node, IIGameSkin skin)
+        {
+            if( skin == null)
+            {
+                return false;
+            }
+
+            if(node.IGameObject.IGameSkin != null && skin.Equals(node.IGameObject.IGameSkin))
+            {
+                return true;
+            }
+
+            for( var i=0; i != node.ChildCount; i++)
+            {
+                var n = node.GetNodeChild(i);
+                if (HasSkinAsChild(n, skin)){
+                    return true;
+                }
+            }
+            return false;
+        }
+
+
         private IIGameNode GetLowestCommonAncestor(IIGameNode nodeA, IIGameNode nodeB, List<IIGameNode> nodeHierarchyA = null, List<IIGameNode> nodeHierarchyB = null)
         {
             if (nodeA == nodeB || nodeB == null) return nodeA;
@@ -272,7 +312,7 @@ private List<int> GetNodeIndices(IIGameSkin skin)
             }
 
             List<int> nodeIndex = new List<int>();
-            List<IIGameNode> revelantNodes = GetSkinnedBones(skin);
+            List<IIGameNode> revelantNodes = GetSkinnedBones(skin).Item1;
 
             for (int index = 0; index < revelantNodes.Count; index++)
             {
@@ -316,9 +356,11 @@ private BabylonBone[] ExportBones(IIGameSkin skin)
         {
             List<BabylonBone> bones = new List<BabylonBone>();
             List<int> nodeIndices = GetNodeIndices(skin);
-            List<IIGameNode> revelantNodes = GetSkinnedBones(skin);
+            Tuple<List<IIGameNode>,float[]> revelantNodes = GetSkinnedBones(skin);
+            
+            var rootMatrix = revelantNodes.Item2;
 
-            foreach (IIGameNode node in revelantNodes)
+            foreach (IIGameNode node in revelantNodes.Item1)
             {
                 int parentIndex = (node.NodeParent == null) ? -1 : nodeIndices.IndexOf(node.NodeParent.NodeID);
 
@@ -331,7 +373,7 @@ private BabylonBone[] ExportBones(IIGameSkin skin)
                     name = node.Name,
                     index = nodeIndices.IndexOf(node.NodeID),
                     parentBoneIndex = parentIndex,
-                    matrix = (parentIndex==-1)?node.GetWorldTM(0).ToArray():node.GetLocalTM(0).ToArray()
+                    matrix = (parentIndex == -1) ? rootMatrix : node.GetLocalTM(0).ToArray()
                 };
 
                 // Apply unit conversion factor to meter