Merge pull request #495 from Unity-Technologies/v3.0.0-preview

v3.0.0 preview

Author: vkovec

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changes in Fbx Exporter
 
+## [3.0.1-preview.2] - 2020-01-22
+### Added
+- Added option to export geometry when recording with the FBX recorder (in previous version geometry was always exported).
+- Added settings to transfer animation between two transforms in the recorded hierarchy.
+
+### Fixed
+- It is now possible to record animated characters with the FBX recorder.
+
 ## [3.0.0-preview.2] - 2020-01-13
 ### Added
 - Added FBX Recorder to record animations from the Unity Recorder directly to FBX (adds dependency to Unity Recorder).

com.unity.formats.fbx/Documentation~/images/FBXExporter_RecorderSettings.png

@@ -18,9 +18,12 @@ Alternatively, the FBX Recorder can be added as a track in the Timeline.
 
 | Property:                     | Function:                                                    |
 | :---------------------------- | :----------------------------------------------------------- |
+| __Export Geometry__              | Check this option to export the geometry of the recorded GameObject to FBX, if any. |
 | __File Name__            | The filename for the exported FBX. |
 | __Path__                 | The path to export the FBX to. Can be outside of the Assets folder. |
 | __Take Number__          | The take number can be set and used in the filename. It automatically increments after each recording. |
 | __Game Object__ | Set the Game Object in the scene to record. |
 | __Recorded Target(s)__     | Select which components of the selected GameObject to record. |
 | __Recorded Hierarchy__     | Check to record other objects in the hierarchy of the GameObject in addition to the selected GameObject. |
+| __Source__                | Transfer the transform animation from this object to the __Destination__ transform. <br/><br/>**NOTES:**<br/> - __Source__ must be an ancestor of __Destination__<br/> - __Source__ may be an ancestor of the selected object. |
+| __Destination__           | Which object to transfer the transform animation to.<br/><br/>This object receives the transform animation on objects between __Source__ and __Destination__ as well as the animation on the Source itself. |

com.unity.formats.fbx/Documentation~/recorder.md

@@ -2274,7 +2274,7 @@ private void TransferMotion(Transform source, Transform dest, float sampleRate,
 
                 for (int k = 0; k < 3; k++) {
                     posKeyFrames [k][keyIndex] = new Keyframe(currSampleTime, (float)translation [k]);
-                    rotKeyFrames [k][keyIndex] = new Keyframe(currSampleTime, (float)rot [k]);
+                    rotKeyFrames [k][keyIndex] = new Keyframe(currSampleTime, rot [k]);
                     scaleKeyFrames [k][keyIndex] = new Keyframe(currSampleTime, (float)scale [k]);
                 }
                 keyIndex++;
@@ -2690,18 +2690,6 @@ internal int ExportAnimationOnly(
                 }
             }
 
-            // export animation
-            // export default clip first
-            if (exportData.defaultClip != null) {
-                var defaultClip = exportData.defaultClip;
-                ExportAnimationClip (defaultClip, exportData.animationClips[defaultClip], fbxScene);
-                exportData.animationClips.Remove (defaultClip);
-            }
-
-            foreach (var animClip in exportData.animationClips) {
-                ExportAnimationClip (animClip.Key, animClip.Value, fbxScene);
-            }
-
             return numObjectsExported;
         }
 
@@ -2967,7 +2955,7 @@ internal static Dictionary<GameObject, IExportData> GetExportData(Object[] objec
 
             Dictionary<GameObject, IExportData>  exportData = new Dictionary<GameObject, IExportData>();
 
-            if (exportOptions.ModelAnimIncludeOption != ExportSettings.Include.Anim)
+            if (exportOptions.ModelAnimIncludeOption == ExportSettings.Include.Model)
             {
                 return null;
             }
@@ -3129,21 +3117,7 @@ private bool ExportComponents(FbxScene fbxScene, bool exportAnim = true)
                 }
 
                 ExportConstraints(unityGo, fbxScene, fbxNode);
-
-                // check if this object contains animation, keep track of it
-                // if it does
-                if (exportAnim && GameObjectHasAnimation (unityGo) ) {
-                    animationNodes.Add (unityGo);
-                }
             }
-
-            // export all GameObjects that have animation
-            if (animationNodes.Count > 0) {
-                foreach (var go in animationNodes) {
-                    ExportAnimation (go, fbxScene);
-                }
-            }
-
             return true;
         }
 
@@ -3321,7 +3295,7 @@ internal int ExportAll (
             }
 
             try {
-                bool animOnly = exportData != null ;
+                bool animOnly = exportData != null && ExportOptions.ModelAnimIncludeOption == ExportSettings.Include.Anim;
                 bool status = false;
                 // Create the FBX manager
                 using (var fbxManager = FbxManager.Create ()) {
@@ -3462,6 +3436,37 @@ internal int ExportAll (
                         }
                     }
 
+                    // Export animation if any
+                    if (exportData != null)
+                    {
+                        foreach (var unityGo in revisedExportSet)
+                        {
+                            IExportData iData;
+                            if (!exportData.TryGetValue(unityGo, out iData))
+                            {
+                                continue;
+                            }
+                            var data = iData as AnimationOnlyExportData;
+                            if (data == null)
+                            {
+                                Debug.LogWarningFormat("FBX Exporter: no animation export data found for {0}", unityGo.name);
+                                continue;
+                            }
+                            // export animation
+                            // export default clip first
+                            if (data.defaultClip != null)
+                            {
+                                var defaultClip = data.defaultClip;
+                                ExportAnimationClip(defaultClip, data.animationClips[defaultClip], fbxScene);
+                                data.animationClips.Remove(defaultClip);
+                            }
+
+                            foreach (var animClip in data.animationClips)
+                            {
+                                ExportAnimationClip(animClip.Key, animClip.Value, fbxScene);
+                            }
+                        }
+                    }
                     // Set the scene's default camera.
                     SetDefaultCamera (fbxScene);
 

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

@@ -45,36 +45,25 @@ protected override void EndRecording(RecordingSession session)
 #endif
                 var root = ((AnimationInputSettings)aInput.settings).gameObject;
                 clip.name = "recorded_clip";
-                clip.legacy = true;
-                Animation animator = root.GetComponent<Animation>();
-                bool hasAnimComponent = true;
-                if (!animator)
-                {
-                    animator = root.AddComponent<Animation>();
-                    hasAnimComponent = false;
-                }
-
-                AnimationClip[] prevAnimClips = null;
-                if (hasAnimComponent)
-                {
-                    prevAnimClips = AnimationUtility.GetAnimationClips(root);
-                }
 
-                AnimationUtility.SetAnimationClips(animator, new AnimationClip[] { clip });
                 var exportSettings = new ExportModelSettingsSerialize();
+                exportSettings.SetAnimationSource(settings.TransferAnimationSource);
+                exportSettings.SetAnimationDest(settings.TransferAnimationDest);
+                exportSettings.SetObjectPosition(ExportSettings.ObjectPosition.WorldAbsolute);
                 var toInclude = ExportSettings.Include.ModelAndAnim;
+                if (!settings.ExportGeometry)
+                {
+                    toInclude = ExportSettings.Include.Anim;
+                } 
                 exportSettings.SetModelAnimIncludeOption(toInclude);
-                ModelExporter.ExportObject(clipName, root, exportSettings);
 
+                var exportData = new AnimationOnlyExportData();
+                exportData.CollectDependencies(clip, root, exportSettings);
+                var exportDataContainer = new Dictionary<GameObject, IExportData>();
+                exportDataContainer.Add(root, exportData);
+
+                ModelExporter.ExportObjects(clipName, new UnityEngine.Object[] { root }, exportSettings, exportDataContainer);
 
-                if (hasAnimComponent)
-                {
-                    AnimationUtility.SetAnimationClips(animator, prevAnimClips);
-                }
-                else
-                {
-                    Object.DestroyImmediate(animator);
-                }
                 aInput.GameObjectRecorder.ResetRecording();
             }
             base.EndRecording(session);

com.unity.formats.fbx/Editor/Sources/Recorders/FbxRecorder/FbxRecorder.cs

@@ -1,4 +1,4 @@
-using System.Collections;
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor.Recorder;
@@ -9,6 +9,197 @@ namespace UnityEditor.Formats.Fbx.Exporter
     [RecorderSettings(typeof(FbxRecorder), "FBX", "fbx_recorder")]
     internal class FbxRecorderSettings : RecorderSettings
     {
+        [SerializeField] bool m_exportGeometry = true;
+        public bool ExportGeometry
+        {
+            get
+            {
+                return m_exportGeometry;
+            }
+            set
+            {
+                m_exportGeometry = value;
+            }
+        }
+
+        [SerializeField]
+        private string m_animSourceBindingId;
+        [SerializeField]
+        private string m_animDestBindingId;
+
+        public Transform TransferAnimationSource
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(m_animSourceBindingId))
+                    return null;
+
+                return GetBinding(m_animSourceBindingId);
+            }
+
+            set
+            {
+                if (!TransferAnimationSourceIsValid(value))
+                {
+                    return;
+                }
+                if (string.IsNullOrEmpty(m_animSourceBindingId))
+                    m_animSourceBindingId = GenerateBindingId();
+
+                SetBinding(m_animSourceBindingId, value);
+            }
+        }
+
+        public Transform TransferAnimationDest
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(m_animDestBindingId))
+                    return null;
+
+                return GetBinding(m_animDestBindingId);
+            }
+
+            set
+            {
+                if (!TransferAnimationDestIsValid(value))
+                {
+                    return;
+                }
+                if (string.IsNullOrEmpty(m_animDestBindingId))
+                    m_animDestBindingId = GenerateBindingId();
+
+                SetBinding(m_animDestBindingId, value);
+            }
+        }
+
+        /// <summary>
+        /// Get a binding ID for the transform, so that the reference survives domain reload. Maintaining a direct reference would not work
+        /// as all scene objects are destroyed and recreated on reload (e.g. when entering/exiting playmode).
+        /// </summary>
+        /// <returns>Binding ID</returns>
+        static string GenerateBindingId()
+        {
+            return GUID.Generate().ToString();
+        }
+
+        /// <summary>
+        /// Get the Unity object (in this case transform), associated with the given binding ID.
+        /// </summary>
+        /// <param name="id">Binding ID</param>
+        /// <returns>Transform associated with binding ID</returns>
+        static Transform GetBinding(string id)
+        {
+            // return BindingManager.Get(m_BindingId) as GameObject;
+            var method = Type.GetType("UnityEditor.Recorder.BindingManager,Unity.Recorder.Editor").GetMethod("Get", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
+            return method.Invoke(null, new object[] { id }) as Transform;
+        }
+
+        /// <summary>
+        /// Set the binding ID to be associated with the given Unity object.
+        /// This information will be saved on domain reload, so that the object can still be found
+        /// with the binding ID.
+        /// </summary>
+        /// <param name="id">Binding ID</param>
+        /// <param name="obj">Unity Object</param>
+        static void SetBinding(string id, UnityEngine.Object obj)
+        {
+            // BindingManager.Set(m_BindingId, value);
+            var method = Type.GetType("UnityEditor.Recorder.BindingManager,Unity.Recorder.Editor").GetMethod("Set", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
+            method.Invoke(null, new object[] { id, obj });
+        }
+
+        /// <summary>
+        /// Determines whether p is an ancestor to t.
+        /// </summary>
+        /// <returns><c>true</c> if p is ancestor to t; otherwise, <c>false</c>.</returns>
+        /// <param name="p">P.</param>
+        /// <param name="t">T.</param>
+        protected bool IsAncestor(Transform p, Transform t)
+        {
+            var curr = t;
+            while (curr != null)
+            {
+                if (curr == p)
+                {
+                    return true;
+                }
+                curr = curr.parent;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether t1 and t2 are in the same hierarchy.
+        /// </summary>
+        /// <returns><c>true</c> if t1 is in same hierarchy as t2; otherwise, <c>false</c>.</returns>
+        /// <param name="t1">T1.</param>
+        /// <param name="t2">T2.</param>
+        protected bool IsInSameHierarchy(Transform t1, Transform t2)
+        {
+            return (IsAncestor(t1, t2) || IsAncestor(t2, t1));
+        }
+
+        protected bool TransferAnimationSourceIsValid(Transform newValue)
+        {
+            if (!newValue)
+            {
+                return true;
+            }
+
+            var selectedGO = m_AnimationInputSettings.gameObject;
+
+            if (!selectedGO)
+            {
+                Debug.LogWarning("FbxRecorderSettings: no Objects selected for export, can't transfer animation");
+                return false;
+            }
+
+            // source must be ancestor to dest
+            if (TransferAnimationDest && !IsAncestor(newValue, TransferAnimationDest))
+            {
+                Debug.LogWarningFormat("FbxRecorderSettings: Source {0} must be an ancestor of {1}", newValue.name, TransferAnimationDest.name);
+                return false;
+            }
+            // must be in same hierarchy as selected GO
+            if (!selectedGO || !IsInSameHierarchy(newValue, selectedGO.transform))
+            {
+                Debug.LogWarningFormat("FbxRecorderSettings: Source {0} must be in the same hierarchy as {1}", newValue.name, selectedGO ? selectedGO.name : "the selected object");
+                return false;
+            }
+            return true;
+        }
+
+        protected bool TransferAnimationDestIsValid(Transform newValue)
+        {
+            if (!newValue)
+            {
+                return true;
+            }
+
+            var selectedGO = m_AnimationInputSettings.gameObject;
+
+            if (!selectedGO)
+            {
+                Debug.LogWarning("FbxRecorderSettings: no Objects selected for export, can't transfer animation");
+                return false;
+            }
+
+            // source must be ancestor to dest
+            if (TransferAnimationSource && !IsAncestor(TransferAnimationSource, newValue))
+            {
+                Debug.LogWarningFormat("FbxRecorderSettings: Destination {0} must be a descendant of {1}", newValue.name, TransferAnimationSource.name);
+                return false;
+            }
+            // must be in same hierarchy as selected GO
+            if (!selectedGO || !IsInSameHierarchy(newValue, selectedGO.transform))
+            {
+                Debug.LogWarningFormat("FbxRecorderSettings: Destination {0} must be in the same hierarchy as {1}", newValue.name, selectedGO ? selectedGO.name : "the selected object");
+                return false;
+            }
+            return true;
+        }
+
         [SerializeField] AnimationInputSettings m_AnimationInputSettings = new AnimationInputSettings();
 
         public AnimationInputSettings animationInputSettings