Merge pull request #494 from Unity-Technologies/UT-3147-add-transfer-anim-to-recorder

Ut 3147 add transfer anim to recorder

Author: vkovec

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

@@ -25,3 +25,5 @@ Alternatively, the FBX Recorder can be added as a track in the Timeline.
 | __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

@@ -2323,7 +2323,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++;
@@ -2734,18 +2734,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;
         }
 
@@ -3012,7 +3000,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;
             }
@@ -3174,21 +3162,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;
         }
 
@@ -3366,7 +3340,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 ()) {
@@ -3508,6 +3482,33 @@ internal int ExportAll (
                         }
                     }
 
+                    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,40 +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;
@@ -7,7 +7,7 @@
 namespace UnityEditor.Formats.Fbx.Exporter
 {
     [RecorderSettings(typeof(FbxRecorder), "FBX", "fbx_recorder")]
-    public class FbxRecorderSettings : RecorderSettings
+    internal class FbxRecorderSettings : RecorderSettings
     {
         [SerializeField] bool m_exportGeometry = true;
         public bool ExportGeometry
@@ -22,6 +22,184 @@ public bool ExportGeometry
             }
         }
 
+        [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

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

@@ -17,5 +17,22 @@ protected override void FileTypeAndFormatGUI()
 
             settings.ExportGeometry = EditorGUILayout.Toggle("Export Geometry", settings.ExportGeometry);
         }
+
+        protected override void OnEncodingGui()
+        {
+            base.OnEncodingGui();
+
+            DrawSeparator();
+
+            EditorGUILayout.LabelField(new GUIContent(
+                "Transfer Animation",
+                "Transfer transform animation from source to destination. Animation on objects between source and destination will also be transferred to destination."
+            ));
+
+            FbxRecorderSettings settings = target as FbxRecorderSettings;
+
+            settings.TransferAnimationSource = EditorGUILayout.ObjectField("Source", settings.TransferAnimationSource, typeof(Transform), allowSceneObjects: true) as Transform;
+            settings.TransferAnimationDest = EditorGUILayout.ObjectField("Destination", settings.TransferAnimationDest, typeof(Transform), allowSceneObjects: true) as Transform;
+        }
     }
 }