Merge branch 'master' into UNI-35294-export-legacy-skinned-mesh-anim

Author: inwoods

Assets/FbxExporters/Editor/FbxExporter.cs

@@ -1025,8 +1025,17 @@ private bool ExportSkin (SkinnedMeshRenderer skinnedMesh,
             /// </summary>
             private void SetVertexWeights (MeshInfo meshInfo, Dictionary<int, FbxCluster> boneCluster)
             {
+                HashSet<int> visitedVertices = new HashSet<int> ();
+
                 // set the vertex weights for each bone
                 for (int i = 0; i < meshInfo.BoneWeights.Length; i++) {
+                    var actualIndex = ControlPointToIndex [meshInfo.Vertices [i]];
+
+                    if (visitedVertices.Contains (actualIndex)) {
+                        continue;
+                    }
+                    visitedVertices.Add (actualIndex);
+
                     var boneWeights = meshInfo.BoneWeights;
                     int[] indices = {
                         boneWeights [i].boneIndex0,
@@ -1048,7 +1057,8 @@ boneWeights [i].weight3
                         if (!boneCluster.ContainsKey (indices [j])) {
                             continue;
                         }
-                        boneCluster [indices [j]].AddControlPointIndex (ControlPointToIndex[meshInfo.Vertices[i]], weights [j]);
+                        // add vertex and weighting on vertex to this bone's cluster
+                        boneCluster [indices [j]].AddControlPointIndex (actualIndex, weights [j]);
                     }
                 }
             }
@@ -1551,6 +1561,12 @@ public static bool TryGetValue(string uniPropertyName, out FbxPropertyChannelPai
                         return true;
                     }
 
+                    if (uniPropertyName.StartsWith("field of view", ct))
+                    {
+                        prop = new FbxPropertyChannelPair("FieldOfView", null);
+                        return true;
+                    }
+
                     prop = new FbxPropertyChannelPair ();
                     return false;
                 }

Assets/FbxExporters/Editor/FbxPrefabAutoUpdater.cs

@@ -233,6 +233,13 @@ protected virtual GameObject ExportSelection(params Object[] selected)
             return fbxRoot;
         }
 
+        protected virtual string ExportSelectedObjects(string filename, params Object[] selected)
+        {
+            string fbxFileName = FbxExporters.Editor.ModelExporter.ExportObjects(filename, selected);
+
+            return fbxFileName;
+        }
+
         /// <summary>
         /// Compares two hierarchies, asserts that they match precisely.
         /// The root can be allowed to mismatch. That's normal with

Assets/FbxExporters/Editor/UnitTests/ExporterTestBase.cs

@@ -0,0 +1,83 @@
+using UnityEngine;
+using UnityEditor;
+using NUnit.Framework;
+using System.Collections.Generic;
+
+namespace FbxExporters.UnitTests
+{
+    public class MyKeyComparer : IComparer<Keyframe>
+    {
+        public int Compare(Keyframe a, Keyframe b)
+        {
+            Debug.Log(string.Format("a.value: {0}, b.value: {1}, a.time: {2}, b.time: {3}", a.value, b.value, a.time, b.time));
+            return a.time == b.time && a.value == b.value ? 0 : 1;
+        }
+    }
+
+    public class FbxCameraTest : ExporterTestBase
+    {
+
+        [Test]
+        public void AnimationWithCameraFOVTest()
+        {
+            string filename = GetRandomFbxFilePath();
+            GameObject go = new GameObject();
+            go.name = "originalCamera";
+            Camera camera = go.AddComponent(typeof(Camera)) as Camera;
+            Animation anim = go.AddComponent(typeof(Animation)) as Animation;
+
+            Keyframe[] keys = new Keyframe[3];
+            keys[0] = new Keyframe(0.0f, 1f);
+            keys[1] = new Keyframe(1.0f, 2f);
+            keys[2] = new Keyframe(2.0f, 3f);
+            
+            AnimationCurve curve = new AnimationCurve(keys);
+
+            AnimationClip clip = new AnimationClip();
+
+            clip.legacy = true;
+
+            clip.SetCurve("", typeof(Camera), "field of view", curve);
+
+            anim.AddClip(clip, "test");
+
+            //export the object
+            var exported = FbxExporters.Editor.ModelExporter.ExportObject(filename, go);
+
+            Assert.That(exported, Is.EqualTo(filename));
+
+            // TODO: Uni-34492 change importer settings of (newly exported model) 
+            // so that it's not resampled and it is legacy animation
+            {
+                ModelImporter modelImporter = AssetImporter.GetAtPath(filename) as ModelImporter;
+                Assert.That(modelImporter, Is.Not.Null);
+                modelImporter.resampleCurves = false;
+                AssetDatabase.ImportAsset(filename);
+                modelImporter.animationType = ModelImporterAnimationType.Legacy;
+                AssetDatabase.ImportAsset(filename);
+            }
+
+            Object[] objects = AssetDatabase.LoadAllAssetsAtPath(filename);
+
+            AnimationClip exportedClip = null;
+            foreach (Object o in objects)
+            {
+                exportedClip = o as AnimationClip;
+                if (exportedClip != null) break;
+            }
+
+            Assert.IsNotNull(exportedClip);
+            exportedClip.legacy = true;
+
+            EditorCurveBinding exportedEditorCurveBinding = AnimationUtility.GetCurveBindings(exportedClip)[0];
+
+            AnimationCurve exportedCurve = AnimationUtility.GetEditorCurve(exportedClip, exportedEditorCurveBinding);
+
+            Assert.That(exportedCurve.keys.Length, Is.EqualTo(keys.Length));
+
+            //check imported animation against original
+            Assert.That(exportedCurve.keys, Is.EqualTo(keys).Using<Keyframe>(new MyKeyComparer()), string.Format("key doesn't match"));
+        }
+
+    }
+}

Assets/FbxExporters/Editor/UnitTests/FbxAnimationTest.cs

@@ -146,6 +146,55 @@ public void ReplaceTest ()
         }
 
     }
+
+    public class FbxPrefabAutoUpdaterRemappingTest : ExporterTestBase
+    {
+        [Test]
+        public void RemappingTest()
+        {
+            //Create a hierarchy of objects
+            GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
+            sphere.transform.SetParent(cube.transform);
+            GameObject cylinder = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
+            cylinder.transform.SetParent(sphere.transform);
+
+            string filePath = GetRandomFbxFilePath();
+
+            // Convert to linked prefab instance (auto-updating prefab)
+            GameObject cubePrefabInstance = ConvertToModel.Convert(cube, fbxFullPath: filePath);
+            Object cubePrefabParent = PrefabUtility.GetPrefabParent(cubePrefabInstance);
+
+            // In FbxPrefab Component of Cube, add SphereFBX/Sphere name mapping
+            FbxPrefab fbxPrefabScript = cubePrefabInstance.transform.GetComponent<FbxPrefab>();
+            FbxPrefab.StringPair stringpair = new FbxPrefab.StringPair();
+            stringpair.FBXObjectName = "SphereFBX";
+            stringpair.UnityObjectName = "Sphere";
+            fbxPrefabScript.NameMapping.Add(stringpair);
+            PrefabUtility.ReplacePrefab(cubePrefabInstance, cubePrefabParent);
+
+            //Create second FBX
+            GameObject cube2 = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            GameObject sphere2 = GameObject.CreatePrimitive(PrimitiveType.Sphere);
+            // Change name of Sphere to SphereFBX
+            sphere2.transform.name = "SphereFBX";
+            sphere2.transform.SetParent(cube2.transform);
+            GameObject cylinder2 = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
+            cylinder2.transform.SetParent(sphere2.transform);
+
+            //export our updated hierarchy to the same file path as the original
+            SleepForFileTimestamp();
+            // "Import" model to Unity (Exporting modified FBX to Unity to see if the remapping works)
+            ExportSelectedObjects(filePath, cube2);
+            AssetDatabase.Refresh();
+
+            // Assert Check Sphere = SphereFBX
+            Assert.IsTrue(cubePrefabInstance != null);
+            Assert.IsTrue(cubePrefabInstance.GetComponent<MeshFilter>().sharedMesh != null);
+            Assert.IsTrue(cubePrefabInstance.transform.GetChild(0).name == "SphereFBX");
+            Assert.IsTrue(cubePrefabInstance.transform.GetChild(0).GetComponent<MeshFilter>().sharedMesh != null);
+        }
+    }
 }
 
 namespace FbxExporters.PerformanceTests {

Assets/FbxExporters/Editor/UnitTests/FbxCameraTests.cs

@@ -507,14 +507,9 @@ private void CompareMeshComponentAttributes(Mesh mesh, Mesh fbxMesh)
             Assert.AreEqual (mesh.tangents, fbxMesh.tangents);
         }
 
-        [Test]
-        public void TestSkinnedMeshExport(){
-            // for now use this cowboy taken from the asset store as the test file
-            // TODO: find a better/simpler test file
-            var fbxPath = "FbxExporters/Editor/UnitTests/Models/Cowboy/cowboyMidPoly(riged).fbx";
-
+        private void ExportSkinnedMesh(string fileToExport, out SkinnedMeshRenderer originalSkinnedMesh, out SkinnedMeshRenderer exportedSkinnedMesh){
             // add fbx to scene
-            GameObject originalFbxObj = AssetDatabase.LoadMainAssetAtPath("Assets/" + fbxPath) as GameObject;
+            GameObject originalFbxObj = AssetDatabase.LoadMainAssetAtPath("Assets/" + fileToExport) as GameObject;
             Assert.IsNotNull (originalFbxObj);
             GameObject originalGO = GameObject.Instantiate (originalFbxObj);
             Assert.IsTrue (originalGO);
@@ -526,11 +521,36 @@ public void TestSkinnedMeshExport(){
             GameObject fbxObj = AssetDatabase.LoadMainAssetAtPath(filename) as GameObject;
             Assert.IsTrue (fbxObj);
 
-            var originalSkinnedMesh = originalGO.GetComponentInChildren<SkinnedMeshRenderer> ();
+            originalSkinnedMesh = originalGO.GetComponentInChildren<SkinnedMeshRenderer> ();
             Assert.IsNotNull (originalSkinnedMesh);
 
-            var exportedSkinnedMesh = fbxObj.GetComponentInChildren<SkinnedMeshRenderer> ();
+            exportedSkinnedMesh = fbxObj.GetComponentInChildren<SkinnedMeshRenderer> ();
             Assert.IsNotNull (exportedSkinnedMesh);
+        }
+
+        public class SkinnedMeshTestDataClass
+        {
+            public static System.Collections.IEnumerable TestCases1 {
+                get {
+                    // for now use this cowboy taken from the asset store as the test file
+                    // TODO: find a better/simpler test file
+                    yield return "Models/Cowboy/cowboyMidPoly(riged).fbx";
+                }
+            }
+            public static System.Collections.IEnumerable TestCases2 {
+                get {
+                    yield return "Models/SimpleMan/SimpleMan.fbx";
+                }
+            }
+        }
+
+        [Test, TestCaseSource(typeof(SkinnedMeshTestDataClass), "TestCases1")]
+        public void TestSkinnedMeshExport(string fbxPath){
+            fbxPath = FindPathInUnitTests (fbxPath);
+            Assert.That (fbxPath, Is.Not.Null);
+
+            SkinnedMeshRenderer originalSkinnedMesh, exportedSkinnedMesh;
+            ExportSkinnedMesh (fbxPath, out originalSkinnedMesh, out exportedSkinnedMesh);
 
             Assert.IsTrue (originalSkinnedMesh.name == exportedSkinnedMesh.name ||
                 (originalSkinnedMesh.transform.parent == null && exportedSkinnedMesh.transform.parent == null));
@@ -594,5 +614,68 @@ public void TestSkinnedMeshExport(){
             var expWeights = exportedMesh.boneWeights;
             Assert.IsNotNull (expWeights);
         }
+
+        [Test, TestCaseSource(typeof(SkinnedMeshTestDataClass), "TestCases2")]
+        public void TestBoneWeightExport(string fbxPath){
+            fbxPath = FindPathInUnitTests (fbxPath);
+            Assert.That (fbxPath, Is.Not.Null);
+
+            SkinnedMeshRenderer originalSkinnedMesh, exportedSkinnedMesh;
+            ExportSkinnedMesh (fbxPath, out originalSkinnedMesh, out exportedSkinnedMesh);
+
+            var origVerts = originalSkinnedMesh.sharedMesh.vertices;
+            Assert.That (origVerts, Is.Not.Null);
+
+            var expVerts = exportedSkinnedMesh.sharedMesh.vertices;
+            Assert.That (expVerts, Is.Not.Null);
+
+            var origBoneWeights = originalSkinnedMesh.sharedMesh.boneWeights;
+            Assert.That (origBoneWeights, Is.Not.Null);
+            Assert.That (origBoneWeights.Length, Is.GreaterThan (0));
+
+            var expBoneWeights = exportedSkinnedMesh.sharedMesh.boneWeights;
+            Assert.That (expBoneWeights, Is.Not.Null);
+            Assert.That (expBoneWeights.Length, Is.GreaterThan (0));
+
+            var origBones = originalSkinnedMesh.bones;
+            var expBones = exportedSkinnedMesh.bones;
+
+            int comparisonCount = 0;
+            int minVertCount = Mathf.Min (origVerts.Length, expVerts.Length);
+            for(int i = 0; i < minVertCount; i++){
+                for (int j = 0; j < minVertCount; j++) {
+                    if (origVerts [i] == expVerts [j]) {
+                        // compare bone weights
+                        var origBw = origBoneWeights[i];
+                        var expBw = expBoneWeights [j];
+
+                        var indexMsg = "Bone index {0} doesn't match";
+                        var nameMsg = "bone names don't match";
+
+                        Assert.That (expBw.boneIndex0, Is.EqualTo (origBw.boneIndex0), string.Format(indexMsg, 0));
+                        Assert.That (expBones[expBw.boneIndex0].name, Is.EqualTo (origBones[origBw.boneIndex0].name), nameMsg);
+
+                        Assert.That (expBw.boneIndex1, Is.EqualTo (origBw.boneIndex1), string.Format(indexMsg, 1));
+                        Assert.That (expBones[expBw.boneIndex1].name, Is.EqualTo (origBones[origBw.boneIndex1].name), nameMsg);
+
+                        Assert.That (expBw.boneIndex2, Is.EqualTo (origBw.boneIndex2), string.Format(indexMsg, 2));
+                        Assert.That (expBones[expBw.boneIndex2].name, Is.EqualTo (origBones[origBw.boneIndex2].name), nameMsg);
+
+                        Assert.That (expBw.boneIndex3, Is.EqualTo (origBw.boneIndex3), string.Format(indexMsg, 3));
+                        Assert.That (expBones[expBw.boneIndex3].name, Is.EqualTo (origBones[origBw.boneIndex3].name), nameMsg);
+
+                        var message = "Bone weight {0} doesn't match";
+                        Assert.That (expBw.weight0, Is.EqualTo (origBw.weight0).Within(0.001f), string.Format(message, 0));
+                        Assert.That (expBw.weight1, Is.EqualTo (origBw.weight1).Within(0.001f), string.Format(message, 1));
+                        Assert.That (expBw.weight2, Is.EqualTo (origBw.weight2).Within(0.001f), string.Format(message, 2));
+                        Assert.That (expBw.weight3, Is.EqualTo (origBw.weight3).Within(0.001f), string.Format(message, 3));
+
+                        comparisonCount++;
+                        break;
+                    }
+                }
+            }
+            Debug.LogWarningFormat ("Compared {0} out of a possible {1} bone weights", comparisonCount, minVertCount);
+        }
     }
 }