Merge branch 'master' into temp-merge-master-3.0

Author: vkovec

appcollector.yaml

@@ -0,0 +1,19 @@
+application_name: FBX Exporter
+application_type: Package
+language: C#
+development_stage: Production
+findings_access:
+- [email protected]
+- [email protected]
+organization: 5d8b8596cadf01000a30db1f
+poc: [email protected]
+slack_channel: devs-fbx-exporter
+description: The Unity FBX Exporter package makes it easy to send geometry and animation from Unity 2018.3 or later to any application that supports FBX and back again with minimal effort.\n\nIn particular, this round-trip workflow enables you to export Unity scenes to FBX, import into Maya, Maya LT, or 3ds Max using an artist-friendly interface, export Unity-ready FBX geometry and animation, and safely merge your changes back into those Assets to continue your work.\n\nFor more information, see the FBX Exporter package documentation.
+risk_assessment:
+  internet_facing: false
+  personal_info: false
+  payment_info: false
+  authentication: No Authentication
+  hosting: N/A
+  revenue_impact: false
+  pci: false

com.unity.formats.fbx/Editor/FbxExportSettings.cs

@@ -462,7 +462,7 @@ public bool HideSendToUnityMenuProperty
         }
 
         [SerializeField]
-        private bool BakeAnimation = true;
+        private bool BakeAnimation = false;
         internal bool BakeAnimationProperty
         {
             get { return BakeAnimation; }
@@ -580,7 +580,7 @@ internal override void LoadDefaults()
             integrationSavePath = DefaultIntegrationSavePath;
             dccOptionPaths = null;
             dccOptionNames = null;
-            BakeAnimationProperty = true;
+            BakeAnimationProperty = false;
             ExportModelSettings = ScriptableObject.CreateInstance (typeof(ExportModelSettings)) as ExportModelSettings;
             exportModelSettingsSerialize = ExportModelSettings.info;
             ShowConvertToPrefabDialog = true;

com.unity.formats.fbx/Editor/FbxExporter.cs

@@ -61,7 +61,8 @@ public PropertyChannelMap(Dictionary<string,string> propertyMap, Dictionary<stri
                 { "Motion T", "Lcl Translation" },
                 { "m_TranslationOffset", "Translation" },
                 { "m_ScaleOffset", "Scaling" },
-                { "m_RotationOffset", "Rotation" }
+                { "m_RotationOffset", "Rotation" },
+                { "localEulerAnglesRaw", "Lcl Rotation" }
             };
 
         /// <summary>

com.unity.formats.fbx/Editor/FbxPropertyChannelPair.cs

@@ -54,14 +54,11 @@ private Key [] ComputeKeys(UnityEngine.Quaternion restRotation, FbxNode node) {
                 : new FbxVector4();
 
             // Get the inverse of the prerotation
-            var fbxPreRotationInverse = ModelExporter.EulerToQuaternion (fbxPreRotationEuler);
+            var fbxPreRotationInverse = ModelExporter.EulerToQuaternionXYZ (fbxPreRotationEuler);
             fbxPreRotationInverse.Inverse();
 
             // Find when we have keys set.
-            var keyTimes = 
-                (UnityEditor.Formats.Fbx.Exporter.ModelExporter.ExportSettings.BakeAnimationProperty) 
-                ? ModelExporter.GetSampleTimes(GetCurves(), SampleRate) 
-                : ModelExporter.GetKeyTimes(GetCurves());
+            var keyTimes = ModelExporter.GetSampleTimes(GetCurves(), SampleRate);
 
             // Convert to the Key type.
             var keys = new Key[keyTimes.Count];
@@ -76,10 +73,12 @@ private Key [] ComputeKeys(UnityEngine.Quaternion restRotation, FbxNode node) {
                 //      then animation.
                 var fbxFinalQuat = fbxPreRotationInverse * fbxFinalAnimation;
 
+                var finalUnityQuat = new Quaternion((float)fbxFinalQuat.X, (float)fbxFinalQuat.Y, (float)fbxFinalQuat.Z, (float)fbxFinalQuat.W);
+
                 // Store the key so we can sort them later.
                 Key key = new Key();
                 key.time = FbxTime.FromSecondDouble(seconds);
-                key.euler = ModelExporter.QuaternionToEuler (fbxFinalQuat);
+                key.euler = ModelExporter.ConvertToFbxVector4(finalUnityQuat.eulerAngles);
                 keys[i++] = key;
             }
 
@@ -118,12 +117,6 @@ public void Animate(Transform unityTransform, FbxNode fbxNode, FbxAnimLayer fbxA
                 }
             }
 
-            // Uni-35616 unroll curves to preserve continuous rotations
-            var fbxCurveNode = fbxNode.LclRotation.GetCurveNode(fbxAnimLayer, false /*should already exist*/);
-
-            FbxAnimCurveFilterUnroll fbxAnimUnrollFilter = new FbxAnimCurveFilterUnroll();
-            fbxAnimUnrollFilter.Apply(fbxCurveNode);
-
             if (Verbose) {
                 Debug.Log("Exported rotation animation for " + fbxNode.GetName());
             }
@@ -170,16 +163,15 @@ protected override FbxQuaternion GetConvertedQuaternionRotation (float seconds,
             // The final animation, including the effect of pre-rotation.
             // If we have no curve, assume the node has the correct rotation right now.
             // We need to evaluate since we might only have keys in one of the axes.
-            var unityFinalAnimation = Quaternion.Euler (
+            var unityFinalAnimation = new Vector3 (
                 (x == null) ? eulerRest [0] : x.Evaluate (seconds),
                 (y == null) ? eulerRest [1] : y.Evaluate (seconds),
                 (z == null) ? eulerRest [2] : z.Evaluate (seconds)
             );
 
             // convert the final animation to righthanded coords
-            var finalEuler = ModelExporter.ConvertQuaternionToXYZEuler(unityFinalAnimation);
 
-            return ModelExporter.EulerToQuaternion (new FbxVector4(finalEuler));
+            return ModelExporter.EulerToQuaternionZXY (unityFinalAnimation);
         }
     }
 
@@ -236,10 +228,7 @@ protected override FbxQuaternion GetConvertedQuaternionRotation (float seconds,
                 (z == null) ? restRotation[2] : z.Evaluate(seconds),
                 (w == null) ? restRotation[3] : w.Evaluate(seconds));
 
-            // convert the final animation to righthanded coords
-            var finalEuler = ModelExporter.ConvertQuaternionToXYZEuler(fbxFinalAnimation);
-
-            return ModelExporter.EulerToQuaternion (finalEuler);
+            return fbxFinalAnimation;
         }
     }
 

com.unity.formats.fbx/Editor/FbxRotationCurve.cs

@@ -416,6 +416,9 @@ public int Main (KeyData keyData, string testName, string path)
                     bool hasQuatBinding = 
                         MapEulerToQuaternionPropertyName.TryGetValue (propertyBinding, out propertyBinding);
 
+                    bool isRotation = AnimationTestDataClass.m_rotationEulerNames.Contains(curveBinding.propertyName) ||
+                        AnimationTestDataClass.m_rotationQuaternionNames.Contains(curveBinding.propertyName);
+
                     if (id==-1)
                         id = keyData.GetIndexOf (propertyBinding);
 
@@ -439,13 +442,13 @@ public int Main (KeyData keyData, string testName, string path)
                             else
                             {
                                 // compare by sampled keyvalues against original keydata
-                                KeyValuesTest (keyData.keyTimes, keyData.GetAltKeyValues (id), animCurveImported, curveBinding.propertyName);
+                                KeyValuesTest (keyData.keyTimes, keyData.GetAltKeyValues (id), animCurveImported, curveBinding.propertyName, isRotation);
                             }
                         }
                         else
                         {
                             // compare by sampled keyvalues against original animCurve
-                            KeyValuesTest (animCurvesOriginal[id], animCurveImported, curveBinding.propertyName);
+                            KeyValuesTest (animCurvesOriginal[id], animCurveImported, curveBinding.propertyName, isRotation);
                         }
                         result++;
                     }
@@ -497,14 +500,20 @@ public static void ClipTest(AnimationClip animClipOriginal, AnimationClip animCl
                             continue;
                         }
 
+                        bool isRotation = AnimationTestDataClass.m_rotationEulerNames.Contains(curveBinding.propertyName) ||
+                        AnimationTestDataClass.m_rotationQuaternionNames.Contains(curveBinding.propertyName);
+
                         AnimationCurve animCurveOrig = AnimationUtility.GetEditorCurve (animClipOriginal, curveBinding);
                         Assert.That (animCurveOrig, Is.Not.Null);
 
                         AnimationCurve animCurveImported = AnimationUtility.GetEditorCurve (animClipImported, impCurveBinding);
                         Assert.That (animCurveImported, Is.Not.Null);
 
-                        AnimTester.KeyValuesTest(animCurveImported, animCurveOrig,
-                            string.Format("path: {0}, property: {1}", curveBinding.path, curveBinding.propertyName));
+                        AnimTester.KeyValuesTest(
+                            animCurveImported, 
+                            animCurveOrig,
+                            string.Format("path: {0}, property: {1}", curveBinding.path, curveBinding.propertyName),
+                            isRotation);
                     }
                 }
             }
@@ -545,7 +554,7 @@ public static void KeysTest (float [] expectedKeyTimes, float [] expectedKeyValu
                 return ;
             }
 
-            public static void KeyValuesTest (float [] expectedKeyTimes, float [] expectedKeyValues, AnimationCurve actualAnimCurve, string message)
+            public static void KeyValuesTest (float [] expectedKeyTimes, float [] expectedKeyValues, AnimationCurve actualAnimCurve, string message, bool isRotationCurve = false)
             {
                 for (var i=0; i < expectedKeyTimes.Length; ++i)
                 {
@@ -554,23 +563,45 @@ public static void KeyValuesTest (float [] expectedKeyTimes, float [] expectedKe
 
                     float actualKeyValue = actualAnimCurve.Evaluate(expectedKeyTime);
 
-                    #if DEBUG_UNITTEST
+#if DEBUG_UNITTEST
                     Debug.Log(string.Format("key time={0} expected={1} actual={2} delta={3}", expectedKeyTime.ToString(), expectedKeyValue.ToString(), actualKeyValue.ToString(), Mathf.Abs(expectedKeyValue-actualKeyValue).ToString()));
-                    #endif
-                    Assert.That(expectedKeyValue, Is.EqualTo(actualKeyValue).Within(0.000001), string.Format("{0} key ({1}) doesn't match", message, expectedKeyTime));
+#endif
+                    // also handles values that are equal but different signs (i.e. -90 == 270)
+                    if (isRotationCurve)
+                    {
+                        var expectedQuat = Quaternion.Euler(new Vector3(expectedKeyValue, 0, 0));
+                        var actualQuat = Quaternion.Euler(new Vector3(actualKeyValue, 0, 0));
+                        Assert.That(Quaternion.Angle(expectedQuat, actualQuat), Is.LessThan(0.1), string.Format("{0} key ({1}) doesn't match", message, expectedKeyTime));
+                    }
+                    else
+                    {
+                        Assert.That(expectedKeyValue, Is.EqualTo(actualKeyValue).Within(0.0001), string.Format("{0} key ({1}) doesn't match", message, expectedKeyTime));
+                    }
                 }
             }
 
-            public static void KeyValuesTest (AnimationCurve expectedAnimCurve, AnimationCurve actualAnimCurve, string message)
+            public static void KeyValuesTest (AnimationCurve expectedAnimCurve, AnimationCurve actualAnimCurve, string message, bool isRotationCurve = false)
             {
                 foreach (var key in expectedAnimCurve.keys)
                 {
                     float actualKeyValue = actualAnimCurve.Evaluate(key.time);
 
-                    #if DEBUG_UNITTEST
+#if DEBUG_UNITTEST
                     Debug.Log(string.Format("key time={0} actual={1} expected={2} delta={3}", key.time.ToString(), key.value.ToString(), actualKeyValue.ToString(), Mathf.Abs(key.value-actualKeyValue).ToString()));
-                    #endif
-                    Assert.That(key.value, Is.EqualTo(actualKeyValue).Within(0.1), string.Format("{0} key ({1}) doesn't match", message, key.time));
+#endif
+                    var expectedKeyValue = key.value;
+
+                    // also handles values that are equal but different signs (i.e. -90 == 270)
+                    if (isRotationCurve)
+                    {
+                        var expectedQuat = Quaternion.Euler(new Vector3(expectedKeyValue, 0, 0));
+                        var actualQuat = Quaternion.Euler(new Vector3(actualKeyValue, 0, 0));
+                        Assert.That(Quaternion.Angle(expectedQuat, actualQuat), Is.LessThan(0.1), string.Format("{0} key ({1}) doesn't match", message, key.time));
+                    }
+                    else
+                    {
+                        Assert.That(expectedKeyValue, Is.EqualTo(actualKeyValue).Within(0.1), string.Format("{0} key ({1}) doesn't match", message, key.time));
+                    }
                 }
             }
 

com.unity.formats.fbx/Tests/FbxTests/FbxAnimationTest.cs

@@ -43,21 +43,6 @@ public void TestBasics ()
             var b = new Vector3(0,0,1);
             var crossLeft = Vector3.Cross(a,b);
 
-            var afbx = ModelExporter.ConvertToRightHanded(a);
-            var bfbx = ModelExporter.ConvertToRightHanded(b);
-            Assert.AreEqual(ModelExporter.ConvertToRightHanded(crossLeft), bfbx.CrossProduct(afbx));
-
-            // Test scale conversion. Nothing complicated here...
-            var afbxPosition = ModelExporter.ConvertToRightHanded(a, ModelExporter.UnitScaleFactor);
-            Assert.AreEqual(100, afbxPosition.Length());
-
-            // Test rotation conversion.
-            var q = Quaternion.Euler(new Vector3(0, 90, 0));
-            var fbxAngles = ModelExporter.ConvertQuaternionToXYZEuler(q);
-            Assert.AreEqual(fbxAngles.X, 0);
-            Assert.That(fbxAngles.Y, Is.InRange(-90.001, -89.999));
-            Assert.AreEqual(fbxAngles.Z, 0);
-
             Assert.That(ModelExporter.DefaultMaterial);
 
             // Test non-static functions.
@@ -103,6 +88,32 @@ public void TestBasics ()
                 ModelExporter.ExportObject(GetRandomFbxFilePath(), character);
                 Assert.AreEqual(meshCount, Object.FindObjectsOfType<Mesh>().Length);
             }
+
+            // Test euler to quaternion conversion
+            {
+                // EulerToQuaternionZXY
+                var v = new Vector3(50, 45, 190);
+                var quat = ModelExporter.EulerToQuaternionZXY(v);
+                var unityQuat = Quaternion.Euler(v);
+                Assert.That((float)quat.X, Is.EqualTo(unityQuat.x));
+                Assert.That((float)quat.Y, Is.EqualTo(unityQuat.y));
+                Assert.That((float)quat.Z, Is.EqualTo(unityQuat.z));
+                Assert.That((float)quat.W, Is.EqualTo(unityQuat.w));
+
+                // EulerToQuaternionXYZ
+                var fbxV = new FbxVector4(v.x, v.y, v.z);
+                var xyzQuat = ModelExporter.EulerToQuaternionXYZ(fbxV);
+
+                // get the vector from the quaternion
+                FbxAMatrix m = new FbxAMatrix();
+                m.SetR(fbxV);
+                var actualQuat = m.GetQ();
+                
+                // since this quaternion is XYZ instead of ZXY, it should not match the quaternion
+                // created with EulerToQuaternionZXY
+                Assert.That(xyzQuat, Is.Not.EqualTo(quat));
+                Assert.That(xyzQuat, Is.EqualTo(actualQuat));
+            }
         }
 
         [Test]