Merge remote-tracking branch 'refs/remotes/origin/master' into UNI-21390-sprint-18-release

Author: vkovec

Assets/FbxExporters/Editor/FbxExporter.cs

@@ -823,7 +823,7 @@ public static HashSet<GameObject> RemoveRedundantObjects(IEnumerable<UnityEngine
             /// </summary>
             /// <param name="t">Transform.</param>
             /// <param name="boundsUnion">The Bounds that is the Union of all the bounds on this transform's hierarchy.</param>
-            private void EncapsulateBounds(Transform t, ref Bounds boundsUnion)
+            private static void EncapsulateBounds(Transform t, ref Bounds boundsUnion)
             {
                 var bounds = GetBounds (t);
                 boundsUnion.Encapsulate (bounds);
@@ -840,7 +840,7 @@ private void EncapsulateBounds(Transform t, ref Bounds boundsUnion)
             /// </summary>
             /// <returns>The bounds.</returns>
             /// <param name="t">Transform.</param>
-            private Bounds GetBounds(Transform t)
+            private static Bounds GetBounds(Transform t)
             {
                 var renderer = t.GetComponent<Renderer> ();
                 if (renderer) {
@@ -862,7 +862,7 @@ private Bounds GetBounds(Transform t)
             /// </summary>
             /// <returns>Center of gameObjects.</returns>
             /// <param name="gameObjects">Game objects.</param>
-            private Vector3 FindCenter(IEnumerable<GameObject> gameObjects)
+            public static Vector3 FindCenter(IEnumerable<GameObject> gameObjects)
             {
                 Bounds bounds = new Bounds();
                 // Assign the initial bounds to first GameObject's bounds
@@ -884,7 +884,7 @@ private Vector3 FindCenter(IEnumerable<GameObject> gameObjects)
             /// <returns>The recentered translation.</returns>
             /// <param name="t">Transform.</param>
             /// <param name="center">Center point.</param>
-            private Vector3 GetRecenteredTranslation(Transform t, Vector3 center)
+            public static Vector3 GetRecenteredTranslation(Transform t, Vector3 center)
             {
                 return t.position - center;
             }

Assets/FbxExporters/Editor/UnitTests/DefaultSelectionTest.cs

@@ -16,6 +16,13 @@ namespace FbxExporters.UnitTests
     public class DefaultSelectionTest : ExporterTestBase
     {
         protected GameObject m_root;
+        protected bool m_centerObjectsSetting;
+
+        [SetUp]
+        public void Init ()
+        {
+            m_centerObjectsSetting = FbxExporters.EditorTools.ExportSettings.instance.centerObjects;
+        }
 
         [TearDown]
         public override void Term ()
@@ -24,6 +31,8 @@ public override void Term ()
             if (m_root) {
                 UnityEngine.Object.DestroyImmediate (m_root);
             }
+            // restore original setting
+            FbxExporters.EditorTools.ExportSettings.instance.centerObjects = m_centerObjectsSetting;
         }
 
         [Test]
@@ -41,48 +50,68 @@ public void TestDefaultSelection ()
             //  - if there is only one root GameObject being exported
             //    then zero out the root transform, leave all descendants
             //    with local transform
-            //  - if there are multiple root GameObjects, then export
-            //    the global transform of each, and local transform
-            //    of descendants
+            //  - if there are multiple root GameObjects, export
+            //    the global transform of root GameObjects, and local transform
+            //    of descendants.
+            //    if Center Objects is checked in the preferences,
+            //    then export the translations so they are centered
+            //    around the center of the union of the bounding boxes.
 
             m_root = CreateHierarchy ();
             Assert.IsNotNull (m_root);
 
             // test Export Root
             // Expected result: everything gets exported
             // Expected transform: root is zeroed out, all other transforms unchanged
-            var exportedRoot = ExportSelection (new Object[]{m_root});
-            CompareHierarchies(m_root, exportedRoot, true, false);
+            var exportedRoot = ExportSelection (new Object[]{ m_root });
+            CompareHierarchies (m_root, exportedRoot, true, false);
             CompareGlobalTransform (exportedRoot.transform);
 
             // test Export Parent1, Child1
             // Expected result: Parent1, Child1, Child2
             // Expected transform: Parent1 zeroed out, all other transforms unchanged
-            var parent1 = m_root.transform.Find("Parent1");
+            var parent1 = m_root.transform.Find ("Parent1");
             var child1 = parent1.Find ("Child1");
-            exportedRoot = ExportSelection (new Object[]{parent1.gameObject, child1.gameObject});
-            CompareHierarchies(parent1.gameObject, exportedRoot, true, false);
+            exportedRoot = ExportSelection (new Object[]{ parent1.gameObject, child1.gameObject });
+            CompareHierarchies (parent1.gameObject, exportedRoot, true, false);
             CompareGlobalTransform (exportedRoot.transform);
 
             // test Export Child2
             // Expected result: Child2
             // Expected transform: Child2 zeroed out
-            var child2 = parent1.Find("Child2").gameObject;
-            exportedRoot = ExportSelection (new Object[]{child2});
-            CompareHierarchies(child2, exportedRoot, true, false);
+            var child2 = parent1.Find ("Child2").gameObject;
+            exportedRoot = ExportSelection (new Object[]{ child2 });
+            CompareHierarchies (child2, exportedRoot, true, false);
             CompareGlobalTransform (exportedRoot.transform);
 
             // test Export Child2, Parent2
             // Expected result: Parent2, Child3, Child2
             // Expected transform: Child2 and Parent2 maintain global transform
-            var parent2 = m_root.transform.Find("Parent2");
-            exportedRoot = ExportSelection (new Object[]{child2, parent2});
+            var parent2 = m_root.transform.Find ("Parent2");
+            var exportSet = new Object[]{ child2, parent2 };
+            // for passing to FindCenter()
+            var goExportSet = new GameObject[]{ child2.gameObject, parent2.gameObject };
 
+            // test without centering objects
+            FbxExporters.EditorTools.ExportSettings.instance.centerObjects = false;
+
+            exportedRoot = ExportSelection (exportSet);
             List<GameObject> children = new List<GameObject> ();
             foreach (Transform child in exportedRoot.transform) {
                 children.Add (child.gameObject);
             }
-            CompareHierarchies(new GameObject[]{child2, parent2.gameObject}, children.ToArray());
+            CompareHierarchies (new GameObject[]{ child2, parent2.gameObject }, children.ToArray ());
+
+            // test with centered objects
+            FbxExporters.EditorTools.ExportSettings.instance.centerObjects = true;
+            var newCenter = FbxExporters.Editor.ModelExporter.FindCenter (goExportSet);
+
+            exportedRoot = ExportSelection (exportSet);
+            children = new List<GameObject> ();
+            foreach (Transform child in exportedRoot.transform) {
+                children.Add (child.gameObject);
+            }
+            CompareHierarchies (new GameObject[]{ child2, parent2.gameObject }, children.ToArray (), newCenter);
         }
 
         /// <summary>
@@ -92,9 +121,11 @@ public void TestDefaultSelection ()
         /// </summary>
         /// <param name="actual">Actual.</param>
         /// <param name="expected">Expected.</param>
-        private void CompareGlobalTransform(Transform actual, Transform expected=null){
+        /// <param name="center">New center for expected transform, if present.</param>
+        private void CompareGlobalTransform (Transform actual, Transform expected = null, Vector3 center = default(Vector3))
+        {
             var actualMatrix = ConstructTRSMatrix (actual);
-            var expectedMatrix = expected == null? new FbxAMatrix() : ConstructTRSMatrix (expected, false);
+            var expectedMatrix = expected == null ? new FbxAMatrix () : ConstructTRSMatrix (expected, false, center);
             Assert.AreEqual (expectedMatrix, actualMatrix);
         }
 
@@ -104,18 +135,23 @@ private void CompareGlobalTransform(Transform actual, Transform expected=null){
         /// <returns>The TRS matrix.</returns>
         /// <param name="t">Transform.</param>
         /// <param name="local">If set to <c>true</c> use local transform.</param>
-        private FbxAMatrix ConstructTRSMatrix(Transform t, bool local=true)
+        /// <param name="center">New center for global transform.</param>
+        private FbxAMatrix ConstructTRSMatrix (Transform t, bool local = true, Vector3 center = default(Vector3))
         {
-            var translation = local? t.localPosition : t.position;
-            var rotation = local? t.localEulerAngles : t.eulerAngles;
-            var scale = local? t.localScale : t.lossyScale;
+            var translation = local ? t.localPosition : FbxExporters.Editor.ModelExporter.GetRecenteredTranslation (t, center);
+            var rotation = local ? t.localEulerAngles : t.eulerAngles;
+            var scale = local ? t.localScale : t.lossyScale;
             return new FbxAMatrix (
                 new FbxVector4 (translation.x, translation.y, translation.z),
                 new FbxVector4 (rotation.x, rotation.y, rotation.z),
                 new FbxVector4 (scale.x, scale.y, scale.z)
             );
         }
 
+        /// <summary>
+        /// Creates test hierarchy.
+        /// </summary>
+        /// <returns>The hierarchy root.</returns>
         private GameObject CreateHierarchy ()
         {
             // Create the following hierarchy:
@@ -153,20 +189,41 @@ private GameObject CreateHierarchy ()
             return root;
         }
 
-        private void SetTransform(Transform t, Vector3 pos, Vector3 rot, Vector3 scale){
+        /// <summary>
+        /// Sets the transform.
+        /// </summary>
+        /// <param name="t">Transform.</param>
+        /// <param name="pos">Position.</param>
+        /// <param name="rot">Rotation.</param>
+        /// <param name="scale">Scale.</param>
+        private void SetTransform (Transform t, Vector3 pos, Vector3 rot, Vector3 scale)
+        {
             t.localPosition = pos;
             t.localEulerAngles = rot;
             t.localScale = scale;
         }
 
-        private GameObject CreateGameObject(string name, Transform parent = null)
+        /// <summary>
+        /// Creates a GameObject.
+        /// </summary>
+        /// <returns>The created GameObject.</returns>
+        /// <param name="name">Name.</param>
+        /// <param name="parent">Parent.</param>
+        private GameObject CreateGameObject (string name, Transform parent = null)
         {
             var go = new GameObject (name);
             go.transform.SetParent (parent);
             return go;
-        }    
+        }
 
-        private void CompareHierarchies(
+        /// <summary>
+        /// Compares the hierarchies.
+        /// </summary>
+        /// <param name="expectedHierarchy">Expected hierarchy.</param>
+        /// <param name="actualHierarchy">Actual hierarchy.</param>
+        /// <param name="ignoreName">If set to <c>true</c> ignore name.</param>
+        /// <param name="compareTransform">If set to <c>true</c> compare transform.</param>
+        private void CompareHierarchies (
             GameObject expectedHierarchy, GameObject actualHierarchy,
             bool ignoreName = false, bool compareTransform = true)
         {
@@ -190,22 +247,28 @@ private void CompareHierarchies(
             }
         }
 
-        private void CompareHierarchies(GameObject[] expectedHierarchy, GameObject[] actualHierarchy)
+        /// <summary>
+        /// Compares the hierarchies.
+        /// </summary>
+        /// <param name="expectedHierarchy">Expected hierarchy.</param>
+        /// <param name="actualHierarchy">Actual hierarchy.</param>
+        /// <param name="center">New center for global transforms.</param>
+        private void CompareHierarchies (GameObject[] expectedHierarchy, GameObject[] actualHierarchy, Vector3 center = default(Vector3))
         {
             Assert.AreEqual (expectedHierarchy.Length, actualHierarchy.Length);
 
             System.Array.Sort (expectedHierarchy, delegate (GameObject x, GameObject y) {
-                return x.name.CompareTo(y.name);
+                return x.name.CompareTo (y.name);
             });
             System.Array.Sort (actualHierarchy, delegate (GameObject x, GameObject y) {
-                return x.name.CompareTo(y.name);
+                return x.name.CompareTo (y.name);
             });
 
             for (int i = 0; i < expectedHierarchy.Length; i++) {
                 CompareHierarchies (expectedHierarchy [i], actualHierarchy [i], false, false);
                 // if we are Comparing lists of hierarchies, that means that the transforms
                 // should be the global transform of expected, as there is no zeroed out root
-                CompareGlobalTransform (actualHierarchy [i].transform, expectedHierarchy [i].transform);
+                CompareGlobalTransform (actualHierarchy [i].transform, expectedHierarchy [i].transform, center);
             }
         }
     }