add anim only export test

Author: vkovec

Assets/FbxExporters/Editor/FbxExporter.cs

@@ -941,11 +941,8 @@ private bool ExportSkeleton (SkinnedMeshRenderer skinnedMesh, FbxScene fbxScene,
 
                 // Three steps:
                 // 0. Set up the map from bone to index.
-                // 1. Create the bones, in arbitrary order.
-                // 2. Connect up the hierarchy.
-                // 3. Set the transforms.
-                // Step 0 supports step 1 (finding which is the root bone) and step 3
-                // (setting up transforms; the complication is the use of pivots).
+                // 1. Gather complete list of bones
+                // 2. Set the transforms.
 
                 // Step 0: map transform to index so we can look up index by bone.
                 Dictionary<Transform, int> index = new Dictionary<Transform, int>();
@@ -971,6 +968,7 @@ private bool ExportSkeleton (SkinnedMeshRenderer skinnedMesh, FbxScene fbxScene,
                 var boneList = boneSet.ToArray();
                 skinnedMeshToBonesMap.Add (skinnedMesh, boneList);
 
+                // Step 2: Set transforms
                 var boneInfo = new SkinnedMeshBoneInfo (skinnedMesh, index);
                 foreach (var bone in boneList) {
                     var fbxBone = MapUnityObjectToFbxNode [bone.gameObject];
@@ -2103,6 +2101,7 @@ public struct AnimationOnlyExportData {
                 public Dictionary<AnimationClip, GameObject> animationClips;
                 public HashSet<GameObject> goExportSet;
                 public Dictionary<GameObject, System.Type> exportComponent;
+                public AnimationClip defaultClip; // first clip to export
 
                 public AnimationOnlyExportData(
                     Dictionary<AnimationClip, GameObject> animClips,
@@ -2112,6 +2111,7 @@ public AnimationOnlyExportData(
                     this.animationClips = animClips;
                     this.goExportSet = exportSet;
                     this.exportComponent = exportComponent;
+                    this.defaultClip = null;
                 }
             }
 
@@ -3176,7 +3176,7 @@ public bool HasValidVertexColors(){
             /// <summary>
             /// Get the GameObject
             /// </summary>
-            private static GameObject GetGameObject (Object obj)
+            public static GameObject GetGameObject (Object obj)
             {
                 if (obj is UnityEngine.Transform) {
                     var xform = obj as UnityEngine.Transform;
@@ -3484,9 +3484,9 @@ public static string ExportObjects (string filePath, UnityEngine.Object[] object
                 return null;
             }
 
-            public static string ExportObject (string filePath, UnityEngine.Object root)
+            public static string ExportObject (string filePath, UnityEngine.Object root, bool animOnly = false)
             {
-                return ExportObjects(filePath, new Object[] { root } );
+                return ExportObjects(filePath, new Object[] { root }, animOnly);
             }
 
             private static void EnsureDirectory (string path)

Assets/FbxExporters/Editor/UnitTests/FbxAnimationTest.cs

@@ -93,6 +93,12 @@ public static IEnumerable BlendShapeTestCases {
                 yield return "Models/blendshape_with_skinning.fbx";
             }
         }
+
+        public static IEnumerable AnimOnlyTestCaases {
+            get {
+                yield return new TestCaseData ("Models/DefaultMale/DefaultMale.prefab");
+            }
+        }
     }
 
     [TestFixture]
@@ -477,8 +483,7 @@ public int Main (KeyData keyData, string testName, string path)
 
             public static void ClipPropertyTest (AnimationClip animClipExpected, AnimationClip animClipActual)
             {
-                // TODO: figure out why we get __preview__ on Windows
-                Assert.That (animClipActual.name, Is.EqualTo (animClipExpected.name).Or.EqualTo("__preview__" + animClipExpected.name));
+                Assert.That (animClipActual.name, Is.EqualTo (animClipExpected.name).Or.EqualTo(animClipExpected.name));
                 Assert.That (animClipActual.legacy, Is.EqualTo (animClipExpected.legacy));
                 Assert.That (animClipActual.isLooping, Is.EqualTo (animClipExpected.isLooping));
                 Assert.That (animClipActual.wrapMode, Is.EqualTo (animClipExpected.wrapMode));
@@ -568,6 +573,28 @@ public static void CurveTest(AnimationCurve animCurveImported, AnimationCurve an
                 Assert.That(actualValueKeys, Is.EqualTo(importedValueKeys), string.Format("{0} key value doesn't match", message));
             }
 
+
+            public static Dictionary<string, AnimationClip> GetClipsFromFbx(string path, bool setLegacy = false){
+                //acquire imported object from exported file
+                Object [] goAssetImported = AssetDatabase.LoadAllAssetsAtPath (path);
+                Assert.That (goAssetImported, Is.Not.Null);
+
+                // TODO : configure object so that it imports w Legacy Animation
+
+                var animClips = new Dictionary<string, AnimationClip> ();
+                foreach (Object o in goAssetImported) {
+                    var animClipImported = o as AnimationClip;
+                    if (animClipImported && !animClipImported.name.StartsWith("__preview__")) {
+                        // TODO : configure import settings so we don't need to force legacy
+                        animClipImported.legacy = setLegacy;
+                        animClips.Add (animClipImported.name, animClipImported);
+                    }
+                }
+                Assert.That (animClips, Is.Not.Empty, "expected imported clips");
+
+                return animClips;
+            }
+
             public static AnimationClip GetClipFromFbx(string path){
                 //acquire imported object from exported file
                 Object [] goAssetImported = AssetDatabase.LoadAllAssetsAtPath (path);
@@ -578,7 +605,7 @@ public static AnimationClip GetClipFromFbx(string path){
                 AnimationClip animClipImported = null;
                 foreach (Object o in goAssetImported) {
                     animClipImported = o as AnimationClip;
-                    if (animClipImported) break;
+                    if (animClipImported && !animClipImported.name.StartsWith("__preview__")) break;
                 }
                 Assert.That (animClipImported, Is.Not.Null, "expected imported clip");
 
@@ -638,8 +665,6 @@ public void LegacySkinnedMeshAnimTest (string fbxPath)
                     AnimTester.CurveTest(animCurveImported, animCurveOrig, curveBinding.propertyName);
                 }
             }
-
-
         }
 
         [Test, TestCaseSource (typeof (AnimationTestDataClass), "TransformIndependantComponentTestCases")]
@@ -764,5 +789,114 @@ public int ComponentAnimTest (System.Type componentType)
             var tester = new AnimTester {keyData=keyData, testName=testName, path=GetRandomFbxFilePath ()};
             return tester.DoIt() <= propertyNames.Length ? 1 : 0;
         }
+
+        [Test, TestCaseSource (typeof (AnimationTestDataClass), "AnimOnlyTestCaases")]
+        public void AnimOnlyExportTest(string prefabPath)
+        {
+            prefabPath = FindPathInUnitTests (prefabPath);
+            Assert.That (prefabPath, Is.Not.Null);
+
+            // add prefab to scene
+            GameObject originalObj = AssetDatabase.LoadMainAssetAtPath ("Assets/" + prefabPath) as GameObject;
+            Assert.IsNotNull (originalObj);
+            GameObject originalGO = GameObject.Instantiate (originalObj);
+            Assert.IsTrue (originalGO);
+
+            // get clips
+            var animator = originalGO.GetComponentInChildren<Animator> ();
+            Assert.That (animator, Is.Not.Null);
+
+            var controller = animator.runtimeAnimatorController;
+            Assert.That (controller, Is.Not.Null);
+
+            var animClips = controller.animationClips;
+            Assert.That (animClips, Is.Not.Null);
+
+            // get the set of GameObject transforms to be exported with the clip
+            var animatedObjects = GetAnimatedGameObjects (animClips, animator.gameObject);
+
+            // export fbx
+            // get GameObject
+            string filename = GetRandomFbxFilePath ();
+            var exportedFilePath = ModelExporter.ExportObject (filename, originalGO, animOnly: true);
+            Assert.That (exportedFilePath, Is.EqualTo (filename));
+
+            GameObject fbxObj = AssetDatabase.LoadMainAssetAtPath (filename) as GameObject;
+            Assert.IsTrue (fbxObj);
+
+            // compare hierarchy matches animated objects
+            var s = new Stack<Transform> ();
+
+            // don't check the root since it probably won't have the same name anyway
+            foreach (Transform child in fbxObj.transform) {
+                s.Push (child);
+            }
+            while (s.Count > 0) {
+                var transform = s.Pop ();
+
+                Assert.That (animatedObjects.Contains(transform.name));
+                animatedObjects.Remove (transform.name);
+
+                foreach (Transform child in transform) {
+                    s.Push (child);
+                }
+            }
+
+            // compare clips
+            var fbxAnimClips = AnimTester.GetClipsFromFbx (filename);
+            Assert.That (fbxAnimClips.Count, Is.EqualTo (animClips.Count()));
+
+            foreach (var clip in animClips) {
+                Assert.That (fbxAnimClips.ContainsKey (clip.name));
+
+                var fbxClip = fbxAnimClips [clip.name];
+
+                AnimTester.ClipPropertyTest (clip, fbxClip);
+
+                foreach (EditorCurveBinding curveBinding in AnimationUtility.GetCurveBindings (clip)) {
+                    foreach(EditorCurveBinding impCurveBinding in AnimationUtility.GetCurveBindings (fbxClip)) {
+
+                        // only compare if the path and property names match
+                        if (curveBinding.path != impCurveBinding.path || curveBinding.propertyName != impCurveBinding.propertyName) {
+                            continue;
+                        }
+
+                        AnimationCurve animCurveOrig = AnimationUtility.GetEditorCurve (clip, curveBinding);
+                        Assert.That (animCurveOrig, Is.Not.Null);
+
+                        AnimationCurve animCurveImported = AnimationUtility.GetEditorCurve (fbxClip, impCurveBinding);
+                        Assert.That (animCurveImported, Is.Not.Null);
+
+                        AnimTester.CurveTest(animCurveImported, animCurveOrig, curveBinding.propertyName);
+                    }
+                }
+            }
+        }
+
+        private HashSet<string> GetAnimatedGameObjects(AnimationClip[] animClips, GameObject animatorObject){
+            var animatedObjects = new HashSet<string>();
+            foreach (var clip in animClips) {
+                foreach (EditorCurveBinding uniCurveBinding in AnimationUtility.GetCurveBindings (clip)) {
+                    Object uniObj = AnimationUtility.GetAnimatedObject (animatorObject, uniCurveBinding);
+                    if (!uniObj) {
+                        continue;
+                    }
+
+                    GameObject unityGo = ModelExporter.GetGameObject (uniObj);
+                    if (!unityGo) {
+                        continue;
+                    }
+
+                    // also it's parents up until but excluding the root (the root will have a different name)
+                    var parent = unityGo.transform;
+                    while (parent != null && parent.parent != null) {
+                        animatedObjects.Add (parent.name);
+                        parent = parent.parent;
+                    }
+
+                }
+            }
+            return animatedObjects;
+        }
     }
 }