Inital commit

12 files changed, 2018 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/AnimationTrackRecorder.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/AnimationTrackRecorder.cs
new file mode 100644
index 0000000..d09cc62
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/AnimationTrackRecorder.cs
@@ -0,0 +1,306 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    class AnimationTrackRecorder
+    {
+        public static readonly string kRecordClipDefaultName = L10n.Tr("Recorded");
+
+        AnimationClip m_TargetClip;
+        int m_CurveCount = 0;
+
+        double m_ClipTime;
+        bool m_needRebuildRects;
+
+        bool m_TrackHasPreviewComponents;
+
+        public TimelineClip recordClip { get; private set; }
+
+        public void PrepareForRecord(WindowState state)
+        {
+            m_CurveCount = 0;
+            m_TargetClip = null;
+            m_TrackHasPreviewComponents = false;
+        }
+
+        public AnimationClip PrepareTrack(TrackAsset track, WindowState state, GameObject gameObject, out double startTime)
+        {
+            AnimationClip animationClip = null;
+
+            // if we are not in clip mode, we simply use the track clip
+            var animationTrack = (AnimationTrack)track;
+
+            // ignore recording if we are in Legacy auto mode
+            startTime = -1;
+            var parentTrack = TimelineUtility.GetSceneReferenceTrack(track) as AnimationTrack;
+            if (parentTrack != null && parentTrack.trackOffset == TrackOffset.Auto)
+                return null;
+
+            if (!animationTrack.inClipMode)
+            {
+                var trackClip = animationTrack.GetOrCreateClip();
+                startTime = trackClip.frameRate * state.editSequence.time;
+
+                // Make the first key be at time 0 of the clip
+                if (trackClip.empty)
+                {
+                    animationTrack.infiniteClipTimeOffset = 0; // state.time;
+                    animationTrack.infiniteClipPreExtrapolation = TimelineClip.ClipExtrapolation.Hold;
+                    animationTrack.infiniteClipPostExtrapolation = TimelineClip.ClipExtrapolation.Hold;
+                }
+
+                animationClip = trackClip;
+            }
+            else
+            {
+                TimelineClip activeClip = null;
+
+                // if it fails, but returns no clip, we can add one.
+                if (!track.FindRecordingClipAtTime(state.editSequence.time, out activeClip) && activeClip != null)
+                {
+                    return null;
+                }
+
+                if (activeClip == null)
+                {
+                    activeClip = AddRecordableClip(track, state, state.editSequence.time);
+                }
+
+                var clip = activeClip.animationClip;
+
+                // flags this as the clip being recorded for the track
+                var clipTime = state.editSequence.time - activeClip.start;
+
+                // if we are in the past
+                if (clipTime < 0)
+                {
+                    Undo.RegisterCompleteObjectUndo(clip, "Record Key");
+                    TimelineUndo.PushUndo(track, "Prepend Key");
+                    ShiftAnimationClip(clip, (float)-clipTime);
+                    activeClip.start = state.editSequence.time;
+                    activeClip.duration += -clipTime;
+                    clipTime = 0;
+                }
+
+                m_ClipTime = clipTime;
+                recordClip = activeClip;
+                startTime = TimeUtility.ToFrames(recordClip.ToLocalTimeUnbound(state.editSequence.time), clip.frameRate);
+                m_needRebuildRects = clip.empty;
+
+                animationClip = clip;
+            }
+
+            m_TargetClip = animationClip;
+            m_CurveCount = GetCurveCount(animationClip);
+            m_TrackHasPreviewComponents = animationTrack.hasPreviewComponents;
+
+            return animationClip;
+        }
+
+        static int GetCurveCount(AnimationClip animationClip)
+        {
+            int count = 0;
+            if (animationClip != null)
+            {
+                var clipCache = AnimationClipCurveCache.Instance.GetCurveInfo(animationClip);
+                count = clipCache.curves.Length + clipCache.objectCurves.Count;
+            }
+
+            return count;
+        }
+
+        public void FinializeTrack(TrackAsset track, WindowState state)
+        {
+            // make sure we dirty the clip if we are in non clip mode
+            var animTrack = track as AnimationTrack;
+            if (!animTrack.inClipMode)
+            {
+                EditorUtility.SetDirty(animTrack.GetOrCreateClip());
+            }
+
+            // in clip mode we need to do some extra work
+            if (recordClip != null)
+            {
+                // stretch the clip out to meet the new recording time
+                if (m_ClipTime > recordClip.duration)
+                {
+                    TimelineUndo.PushUndo(track, "Add Key");
+                    recordClip.duration = m_ClipTime;
+                }
+
+                track.CalculateExtrapolationTimes();
+            }
+
+            recordClip = null;
+            m_ClipTime = 0;
+            if (m_needRebuildRects)
+            {
+                state.CalculateRowRects();
+                m_needRebuildRects = false;
+            }
+        }
+
+        public void FinalizeRecording(WindowState state)
+        {
+            // rebuild the graph if we add/remove a clip. Rebuild the graph with an evaluation immediately
+            // so previews and scene position is maintained.
+            if (m_CurveCount != GetCurveCount(m_TargetClip))
+            {
+                state.rebuildGraph = true;
+                state.GetWindow().RebuildGraphIfNecessary(true);
+            }
+            else if (m_TrackHasPreviewComponents)
+            {
+                // Track with preview components potentially has modifications impacting other properties that need
+                // to be refreshed before inspector or scene view to not interfere with manipulation.
+                state.EvaluateImmediate();
+            }
+        }
+
+        // For a given track asset get a unique clip name
+        public static string GetUniqueRecordedClipName(Object owner, string name)
+        {
+            // first attempt -- uniquely named in file
+            var path = AssetDatabase.GetAssetPath(owner);
+            if (!string.IsNullOrEmpty(path))
+            {
+                var names = AssetDatabase.LoadAllAssetsAtPath(path).Where(x => x != null).Select(x => x.name);
+                return ObjectNames.GetUniqueName(names.ToArray(), name);
+            }
+
+            TrackAsset asset = owner as TrackAsset;
+            if (asset == null || asset.clips.Length == 0)
+                return name;
+
+            // final attempt - uniquely named in track
+            return ObjectNames.GetUniqueName(asset.clips.Select(x => x.displayName).ToArray(), name);
+        }
+
+        // Given an appropriate parent track, create a recordable clip
+        public static TimelineClip AddRecordableClip(TrackAsset parentTrack, WindowState state, double atTime)
+        {
+            var sequenceAsset = state.editSequence.asset;
+            if (sequenceAsset == null)
+            {
+                Debug.LogError("Parent Track needs to be bound to an asset to add a recordable");
+                return null;
+            }
+
+            var animTrack = parentTrack as AnimationTrack;
+            if (animTrack == null)
+            {
+                Debug.LogError("Recordable clips are only valid on Animation Tracks");
+                return null;
+            }
+
+            var newClip = animTrack.CreateRecordableClip(GetUniqueRecordedClipName(parentTrack, kRecordClipDefaultName));
+            if (newClip == null)
+            {
+                Debug.LogError("Could not create a recordable clip");
+                return null;
+            }
+
+            newClip.mixInCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
+            newClip.mixOutCurve = AnimationCurve.EaseInOut(0, 1, 1, 0);
+
+            newClip.preExtrapolationMode = TimelineClip.ClipExtrapolation.Hold;
+            newClip.postExtrapolationMode = TimelineClip.ClipExtrapolation.Hold;
+
+            double startTime = 0;
+            double endTime = 0;
+
+            GetAddedRecordingClipRange(animTrack, state, atTime, out startTime, out endTime);
+
+            newClip.start = startTime;
+            newClip.duration = endTime - startTime;
+
+            state.Refresh();
+
+            return newClip;
+        }
+
+        // get the start and end times of what an added recording clip at a given time would be
+        internal static void GetAddedRecordingClipRange(TrackAsset track, WindowState state, double atTime, out double start, out double end)
+        {
+            // size to make the clip in pixels. Reasonably big so that both handles are easily manipulated,
+            // and the full title is normally visible
+            double defaultDuration = state.PixelDeltaToDeltaTime(100);
+
+            start = atTime;
+            end = atTime + defaultDuration;
+
+            double gapStart = 0;
+            double gapEnd = 0;
+
+            // no gap, pick are reasonable amount
+            if (!track.GetGapAtTime(atTime, out gapStart, out gapEnd))
+            {
+                start = atTime;
+                return;
+            }
+
+            if (!double.IsInfinity(gapEnd))
+                end = gapEnd;
+
+            start = state.SnapToFrameIfRequired(start);
+            end = state.SnapToFrameIfRequired(end);
+        }
+
+        // Given a clip, shifts the keys in that clip by the given amount.
+        internal static void ShiftAnimationClip(AnimationClip clip, float amount)
+        {
+            if (clip == null)
+                return;
+
+            var curveBindings = AnimationUtility.GetCurveBindings(clip);
+            var objectCurveBindings = AnimationUtility.GetObjectReferenceCurveBindings(clip);
+
+            foreach (var binding in curveBindings)
+            {
+                AnimationCurve curve = AnimationUtility.GetEditorCurve(clip, binding);
+                curve.keys = ShiftKeys(curve.keys, amount);
+                AnimationUtility.SetEditorCurve(clip, binding, curve);
+            }
+
+            foreach (var binding in objectCurveBindings)
+            {
+                ObjectReferenceKeyframe[] keyframes = AnimationUtility.GetObjectReferenceCurve(clip, binding);
+                keyframes = ShiftObjectKeys(keyframes, amount);
+                AnimationUtility.SetObjectReferenceCurve(clip, binding, keyframes);
+            }
+
+            EditorUtility.SetDirty(clip);
+        }
+
+        // shift all the keys over by the given time, stretching the time 0 key
+        static Keyframe[] ShiftKeys(Keyframe[] keys, float time)
+        {
+            if (keys == null || keys.Length == 0 || time == 0)
+                return keys;
+
+            for (int i = 0; i < keys.Length; i++)
+            {
+                keys[i].time += time;
+            }
+
+            return keys;
+        }
+
+        // Shift object keys over by the appropriate amount
+        static ObjectReferenceKeyframe[] ShiftObjectKeys(ObjectReferenceKeyframe[] keys, float time)
+        {
+            if (keys == null || keys.Length == 0 || time == 0)
+                return keys;
+
+            for (int i = 0; i < keys.Length; i++)
+            {
+                keys[i].time += time;
+            }
+
+            return keys;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/AnimationTrackRecorder.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/AnimationTrackRecorder.cs.meta
new file mode 100644
index 0000000..e80ec10
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/AnimationTrackRecorder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a0a02e768c802b641b6793fa864f1c2c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording.cs
new file mode 100644
index 0000000..e63ad6a
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording.cs
@@ -0,0 +1,497 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Timeline;
+using UnityEngine.Playables;
+
+namespace UnityEditor.Timeline
+{
+    // Handles Undo animated properties on Monobehaviours to create track clips
+    static partial class TimelineRecording
+    {
+        static readonly List<PropertyModification> s_TempPropertyModifications = new List<PropertyModification>(6);
+
+        internal static UndoPropertyModification[] ProcessUndoModification(UndoPropertyModification[] modifications, WindowState state)
+        {
+            if (HasAnyPlayableAssetModifications(modifications))
+                return ProcessPlayableAssetModification(modifications, state);
+            return ProcessMonoBehaviourModification(modifications, state);
+        }
+
+        static UnityEngine.Object GetTarget(UndoPropertyModification undo)
+        {
+            if (undo.currentValue != null)
+                return undo.currentValue.target;
+            if (undo.previousValue != null)
+                return undo.previousValue.target;
+            return null;
+        }
+
+        // Gets the appropriate track for a given game object
+        static TrackAsset GetTrackForGameObject(GameObject gameObject, WindowState state)
+        {
+            if (gameObject == null)
+                return null;
+
+            var director = state.editSequence.director;
+            if (director == null)
+                return null;
+
+            var level = int.MaxValue;
+
+            TrackAsset result = null;
+
+            // search the output tracks
+            var outputTracks = state.editSequence.asset.flattenedTracks;
+            foreach (var track in outputTracks)
+            {
+                if (track.GetType() != typeof(AnimationTrack))
+                    continue;
+                if (!state.IsTrackRecordable(track))
+                    continue;
+
+                var obj = TimelineUtility.GetSceneGameObject(director, track);
+                if (obj != null)
+                {
+                    // checks if the effected gameobject is our child
+                    var childLevel = GetChildLevel(obj, gameObject);
+                    if (childLevel != -1 && childLevel < level)
+                    {
+                        result = track;
+                        level = childLevel;
+                    }
+                }
+            }
+
+            // the resulting track is not armed. checking here avoids accidentally recording objects with their own
+            // tracks
+            if (result && !state.IsTrackRecordable(result))
+            {
+                result = null;
+            }
+
+            return result;
+        }
+
+        // Gets the track this property would record to.
+        // Returns null if there is a track, but it's not currently active for recording
+        public static TrackAsset GetRecordingTrack(SerializedProperty property, WindowState state)
+        {
+            var serializedObject = property.serializedObject;
+            var component = serializedObject.targetObject as Component;
+            if (component == null)
+                return null;
+
+            var gameObject = component.gameObject;
+            return GetTrackForGameObject(gameObject, state);
+        }
+
+        // Given a serialized property, gathers all animatable properties
+        static void GatherModifications(SerializedProperty property, List<PropertyModification> modifications)
+        {
+            // handles child properties (Vector3 is 3 recordable properties)
+            if (property.hasChildren)
+            {
+                var iter = property.Copy();
+                var end = property.GetEndProperty(false);
+
+                // recurse over all children properties
+                while (iter.Next(true) && !SerializedProperty.EqualContents(iter, end))
+                {
+                    GatherModifications(iter, modifications);
+                }
+            }
+
+            var isObject = property.propertyType == SerializedPropertyType.ObjectReference;
+            var isFloat = property.propertyType == SerializedPropertyType.Float ||
+                property.propertyType == SerializedPropertyType.Boolean ||
+                property.propertyType == SerializedPropertyType.Integer;
+
+            if (isObject || isFloat)
+            {
+                var serializedObject = property.serializedObject;
+                var modification = new PropertyModification();
+
+                modification.target = serializedObject.targetObject;
+                modification.propertyPath = property.propertyPath;
+                if (isObject)
+                {
+                    modification.value = string.Empty;
+                    modification.objectReference = property.objectReferenceValue;
+                }
+                else
+                {
+                    modification.value = TimelineUtility.PropertyToString(property);
+                }
+
+                // Path for monobehaviour based - better to grab the component to get the curvebinding to allow validation
+                if (serializedObject.targetObject is Component)
+                {
+                    EditorCurveBinding temp;
+                    var go = ((Component)serializedObject.targetObject).gameObject;
+                    if (AnimationUtility.PropertyModificationToEditorCurveBinding(modification, go, out temp) != null)
+                    {
+                        modifications.Add(modification);
+                    }
+                }
+                else
+                {
+                    modifications.Add(modification);
+                }
+            }
+        }
+
+        public static bool CanRecord(SerializedProperty property, WindowState state)
+        {
+            if (IsPlayableAssetProperty(property))
+                return AnimatedParameterUtility.IsTypeAnimatable(property.propertyType);
+
+            if (GetRecordingTrack(property, state) == null)
+                return false;
+
+            s_TempPropertyModifications.Clear();
+            GatherModifications(property, s_TempPropertyModifications);
+            return s_TempPropertyModifications.Any();
+        }
+
+        public static void AddKey(SerializedProperty prop, WindowState state)
+        {
+            s_TempPropertyModifications.Clear();
+            GatherModifications(prop, s_TempPropertyModifications);
+            if (s_TempPropertyModifications.Any())
+            {
+                AddKey(s_TempPropertyModifications, state);
+            }
+        }
+
+        public static void AddKey(IEnumerable<PropertyModification> modifications, WindowState state)
+        {
+            var undos = modifications.Select(PropertyModificationToUndoPropertyModification).ToArray();
+            ProcessUndoModification(undos, state);
+        }
+
+        static UndoPropertyModification PropertyModificationToUndoPropertyModification(PropertyModification prop)
+        {
+            return new UndoPropertyModification
+            {
+                previousValue = prop,
+                currentValue = new PropertyModification
+                {
+                    objectReference = prop.objectReference,
+                    propertyPath = prop.propertyPath,
+                    target = prop.target,
+                    value = prop.value
+                },
+                keepPrefabOverride = true
+            };
+        }
+
+        // Given an animation track, return the clip that we are currently recording to
+        static AnimationClip GetRecordingClip(TrackAsset asset, WindowState state, out double startTime, out double timeScale)
+        {
+            startTime = 0;
+            timeScale = 1;
+
+            TimelineClip displayBackground = null;
+            asset.FindRecordingClipAtTime(state.editSequence.time, out displayBackground);
+            var animClip = asset.FindRecordingAnimationClipAtTime(state.editSequence.time);
+
+            if (displayBackground != null)
+            {
+                startTime =  displayBackground.start;
+                timeScale =  displayBackground.timeScale;
+            }
+
+            return animClip;
+        }
+
+        // Helper that finds the animation clip we are recording and the relative time to that clip
+        static bool GetClipAndRelativeTime(UnityEngine.Object target, WindowState state,
+            out AnimationClip outClip, out double keyTime, out bool keyInRange)
+        {
+            const float floatToDoubleError = 0.00001f;
+            outClip = null;
+            keyTime = 0;
+            keyInRange = false;
+
+            double startTime = 0;
+            double timeScale = 1;
+            AnimationClip clip = null;
+
+            IPlayableAsset playableAsset = target as IPlayableAsset;
+            Component component = target as Component;
+
+            // Handle recordable playable assets
+            if (playableAsset != null)
+            {
+                var curvesOwner = AnimatedParameterUtility.ToCurvesOwner(playableAsset, state.editSequence.asset);
+                if (curvesOwner != null && state.IsTrackRecordable(curvesOwner.targetTrack))
+                {
+                    if (curvesOwner.curves == null)
+                        curvesOwner.CreateCurves(curvesOwner.GetUniqueRecordedClipName());
+
+                    clip = curvesOwner.curves;
+
+                    var timelineClip = curvesOwner as TimelineClip;
+                    if (timelineClip != null)
+                    {
+                        startTime = timelineClip.start;
+                        timeScale = timelineClip.timeScale;
+                    }
+                }
+            }
+            // Handle recording components, including infinite clip
+            else if (component != null)
+            {
+                var asset = GetTrackForGameObject(component.gameObject, state);
+                if (asset != null)
+                {
+                    clip = GetRecordingClip(asset, state, out startTime, out timeScale);
+                }
+            }
+
+            if (clip == null)
+                return false;
+
+            keyTime = (state.editSequence.time - startTime) * timeScale;
+            outClip = clip;
+            keyInRange = keyTime >= 0 && keyTime <= (clip.length * timeScale + floatToDoubleError);
+
+            return true;
+        }
+
+        public static bool HasCurve(IEnumerable<PropertyModification> modifications, UnityEngine.Object target,
+            WindowState state)
+        {
+            return GetKeyTimes(target, modifications, state).Any();
+        }
+
+        public static bool HasKey(IEnumerable<PropertyModification> modifications, UnityEngine.Object target,
+            WindowState state)
+        {
+            AnimationClip clip;
+            double keyTime;
+            bool inRange;
+            if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange))
+                return false;
+
+            return GetKeyTimes(target, modifications, state).Any(t => (CurveEditUtility.KeyCompare((float)state.editSequence.time, (float)t, clip.frameRate) == 0));
+        }
+
+        // Checks if a key already exists for this property
+        static bool HasBinding(UnityEngine.Object target, PropertyModification modification, AnimationClip clip, out EditorCurveBinding binding)
+        {
+            var component = target as Component;
+            var playableAsset = target as IPlayableAsset;
+
+            if (component != null)
+            {
+                var type = AnimationUtility.PropertyModificationToEditorCurveBinding(modification, component.gameObject, out binding);
+                binding = RotationCurveInterpolation.RemapAnimationBindingForRotationCurves(binding, clip);
+                return type != null;
+            }
+
+            if (playableAsset != null)
+            {
+                binding = EditorCurveBinding.FloatCurve(string.Empty, target.GetType(),
+                    AnimatedParameterUtility.GetAnimatedParameterBindingName(target, modification.propertyPath));
+            }
+            else
+            {
+                binding = new EditorCurveBinding();
+                return false;
+            }
+
+            return true;
+        }
+
+        public static void RemoveKey(UnityEngine.Object target, IEnumerable<PropertyModification> modifications,
+            WindowState state)
+        {
+            AnimationClip clip;
+            double keyTime;
+            bool inRange;
+            if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange) || !inRange)
+                return;
+            var refreshPreview = false;
+            TimelineUndo.PushUndo(clip, "Remove Key");
+            foreach (var mod in modifications)
+            {
+                EditorCurveBinding temp;
+                if (HasBinding(target, mod, clip, out temp))
+                {
+                    if (temp.isPPtrCurve)
+                    {
+                        CurveEditUtility.RemoveObjectKey(clip, temp, keyTime);
+                        if (CurveEditUtility.GetObjectKeyCount(clip, temp) == 0)
+                        {
+                            refreshPreview = true;
+                        }
+                    }
+                    else
+                    {
+                        AnimationCurve curve = AnimationUtility.GetEditorCurve(clip, temp);
+                        if (curve != null)
+                        {
+                            CurveEditUtility.RemoveKeyFrameFromCurve(curve, (float)keyTime, clip.frameRate);
+                            AnimationUtility.SetEditorCurve(clip, temp, curve);
+                            if (curve.length == 0)
+                            {
+                                AnimationUtility.SetEditorCurve(clip, temp, null);
+                                refreshPreview = true;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (refreshPreview)
+            {
+                state.ResetPreviewMode();
+            }
+        }
+
+        static HashSet<double> GetKeyTimes(UnityEngine.Object target, IEnumerable<PropertyModification> modifications, WindowState state)
+        {
+            var keyTimes = new HashSet<double>();
+
+            AnimationClip animationClip;
+            double keyTime;
+            bool inRange;
+            GetClipAndRelativeTime(target, state, out animationClip, out keyTime, out inRange);
+            if (animationClip == null)
+                return keyTimes;
+
+            var component = target as Component;
+            var playableAsset = target as IPlayableAsset;
+            var info = AnimationClipCurveCache.Instance.GetCurveInfo(animationClip);
+
+            TimelineClip clip = null;
+            if (component != null)
+            {
+                GetTrackForGameObject(component.gameObject, state).FindRecordingClipAtTime(state.editSequence.time, out clip);
+            }
+            else if (playableAsset != null)
+            {
+                clip = FindClipWithAsset(state.editSequence.asset, playableAsset);
+            }
+
+            foreach (var mod in modifications)
+            {
+                EditorCurveBinding temp;
+                if (HasBinding(target, mod, animationClip, out temp))
+                {
+                    IEnumerable<double> keys = new HashSet<double>();
+                    if (temp.isPPtrCurve)
+                    {
+                        var curve = info.GetObjectCurveForBinding(temp);
+                        if (curve != null)
+                        {
+                            keys = curve.Select(x => (double)x.time);
+                        }
+                    }
+                    else
+                    {
+                        var curve = info.GetCurveForBinding(temp);
+                        if (curve != null)
+                        {
+                            keys = curve.keys.Select(x => (double)x.time);
+                        }
+                    }
+
+                    // Transform the times in to 'global' space using the clip
+                    if (clip != null)
+                    {
+                        foreach (var k in keys)
+                        {
+                            var time = clip.FromLocalTimeUnbound(k);
+                            const double eps = 1e-5;
+                            if (time >= clip.start - eps && time <= clip.end + eps)
+                            {
+                                keyTimes.Add(time);
+                            }
+                        }
+                    }
+                    // infinite clip mode, global == local space
+                    else
+                    {
+                        keyTimes.UnionWith(keys);
+                    }
+                }
+            }
+
+            return keyTimes;
+        }
+
+        public static void NextKey(UnityEngine.Object target, IEnumerable<PropertyModification> modifications, WindowState state)
+        {
+            const double eps = 1e-5;
+            var keyTimes = GetKeyTimes(target, modifications, state);
+            if (keyTimes.Count == 0)
+                return;
+            var nextKeys = keyTimes.Where(x => x > state.editSequence.time + eps);
+            if (nextKeys.Any())
+            {
+                state.editSequence.time = nextKeys.Min();
+            }
+        }
+
+        public static void PrevKey(UnityEngine.Object target, IEnumerable<PropertyModification> modifications, WindowState state)
+        {
+            const double eps = 1e-5;
+            var keyTimes = GetKeyTimes(target, modifications, state);
+            if (keyTimes.Count == 0)
+                return;
+            var prevKeys = keyTimes.Where(x => x < state.editSequence.time - eps);
+            if (prevKeys.Any())
+            {
+                state.editSequence.time = prevKeys.Max();
+            }
+        }
+
+        public static void RemoveCurve(UnityEngine.Object target, IEnumerable<PropertyModification> modifications, WindowState state)
+        {
+            AnimationClip clip = null;
+            double keyTime = 0;
+            var inRange = false; // not used for curves
+            if (!GetClipAndRelativeTime(target, state, out clip, out keyTime, out inRange))
+                return;
+
+            TimelineUndo.PushUndo(clip, "Remove Curve");
+            foreach (var mod in modifications)
+            {
+                EditorCurveBinding temp;
+                if (HasBinding(target, mod, clip, out temp))
+                {
+                    if (temp.isPPtrCurve)
+                        AnimationUtility.SetObjectReferenceCurve(clip, temp, null);
+                    else
+                        AnimationUtility.SetEditorCurve(clip, temp, null);
+                }
+            }
+
+            state.ResetPreviewMode();
+        }
+
+        public static IEnumerable<GameObject> GetRecordableGameObjects(WindowState state)
+        {
+            if (state == null || state.editSequence.asset == null || state.editSequence.director == null)
+                yield break;
+
+            var outputTracks = state.editSequence.asset.GetOutputTracks();
+            foreach (var track in outputTracks)
+            {
+                if (track.GetType() != typeof(AnimationTrack))
+                    continue;
+                if (!state.IsTrackRecordable(track) && !track.GetChildTracks().Any(state.IsTrackRecordable))
+                    continue;
+
+                var obj = TimelineUtility.GetSceneGameObject(state.editSequence.director, track);
+                if (obj != null)
+                {
+                    yield return obj;
+                }
+            }
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording.cs.meta
new file mode 100644
index 0000000..d8bca18
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ef4c81c9368d5a340b14c2fec1cad345
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecordingContextualResponder.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecordingContextualResponder.cs
new file mode 100644
index 0000000..e55ff56
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecordingContextualResponder.cs
@@ -0,0 +1,134 @@
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    class TimelineRecordingContextualResponder : IAnimationContextualResponder
+    {
+        public WindowState state { get; internal set; }
+
+        public TimelineRecordingContextualResponder(WindowState _state)
+        {
+            state = _state;
+        }
+
+        //Unsupported stuff
+        public bool HasAnyCandidates() { return false; }
+        public bool HasAnyCurves() {return false; }
+        public void AddCandidateKeys() {}
+        public void AddAnimatedKeys() {}
+
+        public bool IsAnimatable(PropertyModification[] modifications)
+        {
+            // search playable assets
+            for (int i = 0; i < modifications.Length; i++)
+            {
+                var iAsset = modifications[i].target as IPlayableAsset;
+                if (iAsset != null)
+                {
+                    var curvesOwner = AnimatedParameterUtility.ToCurvesOwner(iAsset, state.editSequence.asset);
+                    if (curvesOwner != null && curvesOwner.HasAnyAnimatableParameters() && curvesOwner.IsParameterAnimatable(modifications[i].propertyPath))
+                        return true;
+                }
+            }
+
+            // search recordable game objects
+            foreach (var gameObject in TimelineRecording.GetRecordableGameObjects(state))
+            {
+                for (int i = 0; i < modifications.Length; ++i)
+                {
+                    var modification = modifications[i];
+                    if (AnimationWindowUtility.PropertyIsAnimatable(modification.target, modification.propertyPath, gameObject))
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        public bool IsEditable(Object targetObject)
+        {
+            return true; // i.e. all animatable properties are editable
+        }
+
+        public bool KeyExists(PropertyModification[] modifications)
+        {
+            if (modifications.Length == 0 || modifications[0].target == null)
+                return false;
+
+            return TimelineRecording.HasKey(modifications, modifications[0].target, state);
+        }
+
+        public bool CandidateExists(PropertyModification[] modifications)
+        {
+            return true;
+        }
+
+        public bool CurveExists(PropertyModification[] modifications)
+        {
+            if (modifications.Length == 0 || modifications[0].target == null)
+                return false;
+
+            return TimelineRecording.HasCurve(modifications, modifications[0].target, state);
+        }
+
+        public void AddKey(PropertyModification[] modifications)
+        {
+            TimelineRecording.AddKey(modifications, state);
+            state.Refresh();
+        }
+
+        public void RemoveKey(PropertyModification[] modifications)
+        {
+            if (modifications.Length == 0)
+                return;
+
+            var target = modifications[0].target;
+            if (target == null)
+                return;
+
+            TimelineRecording.RemoveKey(modifications[0].target, modifications, state);
+
+            var curvesOwner = target as ICurvesOwner;
+            if (curvesOwner != null)
+                curvesOwner.SanitizeCurvesData();
+
+            state.Refresh();
+        }
+
+        public void RemoveCurve(PropertyModification[] modifications)
+        {
+            if (modifications.Length == 0)
+                return;
+
+            var target = modifications[0].target;
+            if (target == null)
+                return;
+
+            TimelineRecording.RemoveCurve(target, modifications, state);
+
+            var curvesOwner = target as ICurvesOwner;
+            if (curvesOwner != null)
+                curvesOwner.SanitizeCurvesData();
+
+            state.Refresh();
+        }
+
+        public void GoToNextKeyframe(PropertyModification[] modifications)
+        {
+            if (modifications.Length == 0 || modifications[0].target == null)
+                return;
+
+            TimelineRecording.NextKey(modifications[0].target, modifications, state);
+            state.Refresh();
+        }
+
+        public void GoToPreviousKeyframe(PropertyModification[] modifications)
+        {
+            TimelineRecording.PrevKey(modifications[0].target, modifications, state);
+            state.Refresh();
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecordingContextualResponder.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecordingContextualResponder.cs.meta
new file mode 100644
index 0000000..2e8e492
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecordingContextualResponder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a59c2e62fbd97f84f92c3b546e3903cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_Monobehaviour.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_Monobehaviour.cs
new file mode 100644
index 0000000..0d2da17
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_Monobehaviour.cs
@@ -0,0 +1,709 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.Timeline;
+using System.Globalization;
+
+namespace UnityEditor.Timeline
+{
+    // Methods and data for handling recording to monobehaviours
+    static partial class TimelineRecording
+    {
+        internal class RecordingState : IAnimationRecordingState
+        {
+            public GameObject activeGameObject { get; set; }
+            public GameObject activeRootGameObject { get; set; }
+            public AnimationClip activeAnimationClip { get; set; }
+
+            public void SaveCurve(AnimationWindowCurve curve)
+            {
+                Undo.RegisterCompleteObjectUndo(activeAnimationClip, "Edit Curve");
+                AnimationWindowUtility.SaveCurve(activeAnimationClip, curve);
+            }
+
+            public void AddPropertyModification(EditorCurveBinding binding, PropertyModification propertyModification, bool keepPrefabOverride)
+            {
+                AnimationMode.AddPropertyModification(binding, propertyModification, keepPrefabOverride);
+            }
+
+            public bool addZeroFrame
+            {
+                get { return false; }
+            }
+
+            public int currentFrame { get; set; }
+
+            public bool DiscardModification(PropertyModification modification)
+            {
+                return false;
+            }
+        }
+
+        static readonly RecordingState s_RecordState = new RecordingState();
+        static readonly AnimationTrackRecorder s_TrackRecorder = new AnimationTrackRecorder();
+        static readonly List<UndoPropertyModification> s_UnprocessedMods = new List<UndoPropertyModification>();
+        static readonly List<UndoPropertyModification> s_ModsToProcess = new List<UndoPropertyModification>();
+        static AnimationTrack s_LastTrackWarning;
+
+        public const string kLocalPosition = "m_LocalPosition";
+        public const string kLocalRotation = "m_LocalRotation";
+        public const string kLocalEulerHint = "m_LocalEulerAnglesHint";
+        const string kRotationWarning = "You are recording with an initial rotation offset. This may result in a misrepresentation of euler angles. When recording transform properties, it is recommended to reset rotation prior to recording";
+
+
+        public static bool IsRecordingAnimationTrack { get; private set; }
+
+
+        internal static UndoPropertyModification[] ProcessMonoBehaviourModification(UndoPropertyModification[] modifications, WindowState state)
+        {
+            if (state == null || state.editSequence.director == null)
+                return modifications;
+
+            s_UnprocessedMods.Clear();
+
+            s_TrackRecorder.PrepareForRecord(state);
+
+            s_ModsToProcess.Clear();
+            s_ModsToProcess.AddRange(modifications.Reverse());
+
+            while (s_ModsToProcess.Count > 0)
+            {
+                var modification = s_ModsToProcess[s_ModsToProcess.Count - 1];
+                s_ModsToProcess.RemoveAt(s_ModsToProcess.Count - 1);
+
+                // grab the clip we need to apply to
+                var modifiedGO = GetGameObjectFromModification(modification);
+                var track = GetTrackForGameObject(modifiedGO, state);
+                if (track != null)
+                {
+                    IsRecordingAnimationTrack = true;
+
+                    double startTime = 0;
+                    var clip = s_TrackRecorder.PrepareTrack(track, state, modifiedGO, out startTime);
+                    if (clip == null)
+                    {
+                        s_ModsToProcess.Reverse();
+                        return s_ModsToProcess.ToArray();
+                    }
+                    s_RecordState.activeAnimationClip = clip;
+                    s_RecordState.activeRootGameObject = state.GetSceneReference(track);
+                    s_RecordState.activeGameObject = modifiedGO;
+                    s_RecordState.currentFrame = Mathf.RoundToInt((float)startTime);
+
+                    EditorUtility.SetDirty(clip);
+                    var toProcess = GatherRelatedModifications(modification, s_ModsToProcess);
+
+                    var animator = s_RecordState.activeRootGameObject.GetComponent<Animator>();
+                    var animTrack = track as AnimationTrack;
+
+                    // update preview mode before recording so the correct values get placed (in case we modify offsets)
+                    // Case 900624
+                    UpdatePreviewMode(toProcess, modifiedGO);
+
+                    // if this is the first position/rotation recording, copy the current position / rotation to the track offset
+                    AddTrackOffset(animTrack, toProcess, clip, animator);
+
+                    // same for clip mod clips being created
+                    AddClipOffset(animTrack, toProcess, s_TrackRecorder.recordClip, animator);
+
+                    // Check if we need to handle position/rotation offsets
+                    var handleOffsets = animator != null && modification.currentValue != null &&
+                        modification.currentValue.target == s_RecordState.activeRootGameObject.transform &&
+                        HasOffsets(animTrack, s_TrackRecorder.recordClip);
+                    if (handleOffsets)
+                    {
+                        toProcess = HandleEulerModifications(animTrack, s_TrackRecorder.recordClip, clip, s_RecordState.currentFrame * clip.frameRate, toProcess);
+                        RemoveOffsets(modification, animTrack, s_TrackRecorder.recordClip, toProcess);
+                    }
+
+                    var remaining = AnimationRecording.Process(s_RecordState, toProcess);
+                    if (remaining != null && remaining.Length != 0)
+                    {
+                        s_UnprocessedMods.AddRange(remaining);
+                    }
+
+                    if (handleOffsets)
+                    {
+                        ReapplyOffsets(modification, animTrack, s_TrackRecorder.recordClip, toProcess);
+                    }
+
+                    s_TrackRecorder.FinializeTrack(track, state);
+
+                    IsRecordingAnimationTrack = false;
+                }
+                else
+                {
+                    s_UnprocessedMods.Add(modification);
+                }
+            }
+
+
+            s_TrackRecorder.FinalizeRecording(state);
+
+            return s_UnprocessedMods.ToArray();
+        }
+
+        internal static bool IsPosition(UndoPropertyModification modification)
+        {
+            if (modification.currentValue != null)
+                return modification.currentValue.propertyPath.StartsWith(kLocalPosition);
+            else if (modification.previousValue != null)
+                return modification.previousValue.propertyPath.StartsWith(kLocalPosition);
+            return false;
+        }
+
+        internal static bool IsRotation(UndoPropertyModification modification)
+        {
+            if (modification.currentValue != null)
+                return modification.currentValue.propertyPath.StartsWith(kLocalRotation) ||
+                    modification.currentValue.propertyPath.StartsWith(kLocalEulerHint);
+            if (modification.previousValue != null)
+                return modification.previousValue.propertyPath.StartsWith(kLocalRotation) ||
+                    modification.previousValue.propertyPath.StartsWith(kLocalEulerHint);
+            return false;
+        }
+
+        // Test if this modification position or rotation
+        internal static bool IsPositionOrRotation(UndoPropertyModification modification)
+        {
+            return IsPosition(modification) || IsRotation(modification);
+        }
+
+        internal static void UpdatePreviewMode(UndoPropertyModification[] mods, GameObject go)
+        {
+            if (mods.Any(x => IsPositionOrRotation(x) && IsRootModification(x)))
+            {
+                bool hasPosition = false;
+                bool hasRotation = false;
+
+                foreach (var mod in mods)
+                {
+                    EditorCurveBinding binding = new EditorCurveBinding();
+                    if (AnimationUtility.PropertyModificationToEditorCurveBinding(mod.previousValue, go, out binding) != null)
+                    {
+                        hasPosition |= IsPosition(mod);
+                        hasRotation |= IsRotation(mod);
+                        AnimationMode.AddPropertyModification(binding, mod.previousValue, true);
+                    }
+                }
+
+                // case 931859 - if we are only changing one field, all fields must be registered before
+                // any recording modifications
+                var driver = WindowState.previewDriver;
+                if (driver != null && AnimationMode.InAnimationMode(driver))
+                {
+                    if (hasPosition)
+                    {
+                        DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalPosition + ".x");
+                        DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalPosition + ".y");
+                        DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalPosition + ".z");
+                    }
+                    else if (hasRotation)
+                    {
+                        DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".x");
+                        DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".y");
+                        DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".z");
+                        DrivenPropertyManager.RegisterProperty(driver, go.transform, kLocalRotation + ".w");
+                    }
+                }
+            }
+        }
+
+        internal static bool IsRootModification(UndoPropertyModification modification)
+        {
+            string path = string.Empty;
+            if (modification.currentValue != null)
+                path = modification.currentValue.propertyPath;
+            else if (modification.previousValue != null)
+                path = modification.previousValue.propertyPath;
+
+            return !path.Contains('/') && !path.Contains('\\');
+        }
+
+        // test if the clip has any position or rotation bindings
+        internal static bool ClipHasPositionOrRotation(AnimationClip clip)
+        {
+            if (clip == null || clip.empty)
+                return false;
+
+            var info = AnimationClipCurveCache.Instance.GetCurveInfo(clip);
+            for (var i = 0; i < info.bindings.Length; i++)
+            {
+                bool isPositionOrRotation =
+                    info.bindings[i].type != null &&
+                    typeof(Transform).IsAssignableFrom(info.bindings[i].type) &&
+                    (
+                        info.bindings[i].propertyName.StartsWith(kLocalPosition) ||
+                        info.bindings[i].propertyName.StartsWith(kLocalRotation) ||
+                        info.bindings[i].propertyName.StartsWith("localEuler")
+                    );
+
+                if (isPositionOrRotation)
+                    return true;
+            }
+
+            return false;
+        }
+
+        internal static TimelineAnimationUtilities.RigidTransform ComputeInitialClipOffsets(AnimationTrack track, UndoPropertyModification[] mods, Animator animator)
+        {
+            // take into account the track transform
+            var target = GetInitialTransform(mods, animator);
+            var trackToClip = TimelineAnimationUtilities.RigidTransform.identity;
+            if (track.trackOffset == TrackOffset.ApplyTransformOffsets)
+                trackToClip = TimelineAnimationUtilities.RigidTransform.Compose(track.position, track.rotation);
+            else if (track.trackOffset == TrackOffset.ApplySceneOffsets)
+                trackToClip = TimelineAnimationUtilities.RigidTransform.Compose(track.sceneOffsetPosition, Quaternion.Euler(track.sceneOffsetRotation));
+
+            target = TimelineAnimationUtilities.RigidTransform.Mul(TimelineAnimationUtilities.RigidTransform.Inverse(trackToClip), target);
+
+            // set the previous position in case the animation system adds a default key
+            SetPreviousPositionAndRotation(mods, animator, trackToClip.position, trackToClip.rotation);
+            return target;
+        }
+
+        internal static TimelineAnimationUtilities.RigidTransform GetInitialTransform(UndoPropertyModification[] mods, Animator animator)
+        {
+            var pos = Vector3.zero;
+            var rot = Quaternion.identity;
+
+            // if we are operating on the root, grab the transform from the undo
+            if (mods[0].previousValue.target == animator.transform)
+            {
+                GetPreviousPositionAndRotation(mods, ref pos, ref rot);
+            }
+            // otherwise we need to grab it from the root object, which is the one with the actual animator
+            else
+            {
+                pos = animator.transform.localPosition;
+                rot = animator.transform.localRotation;
+            }
+
+            // take into account the track transform
+            return TimelineAnimationUtilities.RigidTransform.Compose(pos, rot);
+        }
+
+        internal static void SetPreviousPositionAndRotation(UndoPropertyModification[] mods, Animator animator, Vector3 pos, Quaternion rot)
+        {
+            if (mods[0].previousValue.target == animator.transform)
+            {
+                SetPreviousPositionAndRotation(mods, pos, rot);
+            }
+        }
+
+        // If we are adding to an infinite clip, strip the objects position and rotation and set it as the clip offset
+        internal static void AddTrackOffset(AnimationTrack track, UndoPropertyModification[] mods, AnimationClip clip, Animator animator)
+        {
+            var copyTrackOffset = !track.inClipMode &&
+                !ClipHasPositionOrRotation(clip) &&
+                mods.Any(x => IsPositionOrRotation(x) && IsRootModification(x)) &&
+                animator != null;
+            if (copyTrackOffset)
+            {
+                // in scene offset mode, makes sure we have the correct initial transform set
+                if (track.trackOffset == TrackOffset.ApplySceneOffsets)
+                {
+                    var rigidTransform = GetInitialTransform(mods, animator);
+                    track.sceneOffsetPosition = rigidTransform.position;
+                    track.sceneOffsetRotation = rigidTransform.rotation.eulerAngles;
+                    SetPreviousPositionAndRotation(mods, animator, rigidTransform.position, rigidTransform.rotation);
+                }
+                else
+                {
+                    var rigidTransform = ComputeInitialClipOffsets(track, mods, animator);
+                    track.infiniteClipOffsetPosition = rigidTransform.position;
+                    track.infiniteClipOffsetEulerAngles = rigidTransform.rotation.eulerAngles;
+                }
+            }
+        }
+
+        internal static void AddClipOffset(AnimationTrack track, UndoPropertyModification[] mods, TimelineClip clip, Animator animator)
+        {
+            if (clip == null || clip.asset == null)
+                return;
+
+            var clipAsset = clip.asset as AnimationPlayableAsset;
+            var copyClipOffset = track.inClipMode &&
+                clipAsset != null && !ClipHasPositionOrRotation(clipAsset.clip) &&
+                mods.Any(x => IsPositionOrRotation(x) && IsRootModification(x)) &&
+                animator != null;
+            if (copyClipOffset)
+            {
+                var rigidTransform = ComputeInitialClipOffsets(track, mods, animator);
+
+                clipAsset.position = rigidTransform.position;
+                clipAsset.rotation = rigidTransform.rotation;
+            }
+        }
+
+        internal static TimelineAnimationUtilities.RigidTransform GetLocalToTrack(AnimationTrack track, TimelineClip clip)
+        {
+            if (track == null)
+                return TimelineAnimationUtilities.RigidTransform.Compose(Vector3.zero, Quaternion.identity);
+
+            var trackPos = track.position;
+            var trackRot = track.rotation;
+
+            if (track.trackOffset == TrackOffset.ApplySceneOffsets)
+            {
+                trackPos = track.sceneOffsetPosition;
+                trackRot = Quaternion.Euler(track.sceneOffsetRotation);
+            }
+
+            var clipWrapper = clip == null ? null : clip.asset as AnimationPlayableAsset;
+            var clipTransform = TimelineAnimationUtilities.RigidTransform.Compose(Vector3.zero, Quaternion.identity);
+            if (clipWrapper != null)
+            {
+                clipTransform = TimelineAnimationUtilities.RigidTransform.Compose(clipWrapper.position, clipWrapper.rotation);
+            }
+            else
+            {
+                clipTransform = TimelineAnimationUtilities.RigidTransform.Compose(track.infiniteClipOffsetPosition, track.infiniteClipOffsetRotation);
+            }
+
+            var trackTransform = TimelineAnimationUtilities.RigidTransform.Compose(trackPos, trackRot);
+
+            return TimelineAnimationUtilities.RigidTransform.Mul(trackTransform, clipTransform);
+        }
+
+        // Checks whether there are any offsets applied to a clip
+        internal static bool HasOffsets(AnimationTrack track, TimelineClip clip)
+        {
+            if (track == null)
+                return false;
+
+            bool hasClipOffsets = false;
+            bool hasTrackOffsets = false;
+
+            var clipWrapper = clip == null ? null : clip.asset as AnimationPlayableAsset;
+            if (clipWrapper != null)
+                hasClipOffsets |= clipWrapper.position != Vector3.zero || clipWrapper.rotation != Quaternion.identity;
+
+            if (track.trackOffset == TrackOffset.ApplySceneOffsets)
+            {
+                hasTrackOffsets = track.sceneOffsetPosition != Vector3.zero || track.sceneOffsetRotation != Vector3.zero;
+            }
+            else
+            {
+                hasTrackOffsets = (track.position != Vector3.zero || track.rotation != Quaternion.identity);
+                if (!track.inClipMode)
+                    hasClipOffsets |= track.infiniteClipOffsetPosition != Vector3.zero || track.infiniteClipOffsetRotation != Quaternion.identity;
+            }
+
+            return hasTrackOffsets || hasClipOffsets;
+        }
+
+        internal static void RemoveOffsets(UndoPropertyModification modification, AnimationTrack track, TimelineClip clip, UndoPropertyModification[] mods)
+        {
+            if (IsPositionOrRotation(modification))
+            {
+                var modifiedGO = GetGameObjectFromModification(modification);
+                var target = TimelineAnimationUtilities.RigidTransform.Compose(modifiedGO.transform.localPosition, modifiedGO.transform.localRotation);
+                var localToTrack = GetLocalToTrack(track, clip);
+                var trackToLocal = TimelineAnimationUtilities.RigidTransform.Inverse(localToTrack);
+                var localSpace = TimelineAnimationUtilities.RigidTransform.Mul(trackToLocal, target);
+
+                // Update the undo call values
+                var prevPos = modifiedGO.transform.localPosition;
+                var prevRot = modifiedGO.transform.localRotation;
+                GetPreviousPositionAndRotation(mods, ref prevPos, ref prevRot);
+                var previousRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(trackToLocal, TimelineAnimationUtilities.RigidTransform.Compose(prevPos, prevRot));
+                SetPreviousPositionAndRotation(mods, previousRigidTransform.position, previousRigidTransform.rotation);
+
+                var currentPos = modifiedGO.transform.localPosition;
+                var currentRot = modifiedGO.transform.localRotation;
+                GetCurrentPositionAndRotation(mods, ref currentPos, ref currentRot);
+                var currentRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(trackToLocal, TimelineAnimationUtilities.RigidTransform.Compose(currentPos, currentRot));
+                SetCurrentPositionAndRotation(mods, currentRigidTransform.position, currentRigidTransform.rotation);
+
+                modifiedGO.transform.localPosition = localSpace.position;
+                modifiedGO.transform.localRotation = localSpace.rotation;
+            }
+        }
+
+        internal static void ReapplyOffsets(UndoPropertyModification modification, AnimationTrack track, TimelineClip clip, UndoPropertyModification[] mods)
+        {
+            if (IsPositionOrRotation(modification))
+            {
+                var modifiedGO = GetGameObjectFromModification(modification);
+                var target = TimelineAnimationUtilities.RigidTransform.Compose(modifiedGO.transform.localPosition, modifiedGO.transform.localRotation);
+                var localToTrack = GetLocalToTrack(track, clip);
+                var trackSpace = TimelineAnimationUtilities.RigidTransform.Mul(localToTrack, target);
+
+                // Update the undo call values
+                var prevPos = modifiedGO.transform.localPosition;
+                var prevRot = modifiedGO.transform.localRotation;
+                GetPreviousPositionAndRotation(mods, ref prevPos, ref prevRot);
+                var previousRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(localToTrack, TimelineAnimationUtilities.RigidTransform.Compose(prevPos, prevRot));
+                SetPreviousPositionAndRotation(mods, previousRigidTransform.position, previousRigidTransform.rotation);
+
+                var currentPos = modifiedGO.transform.localPosition;
+                var currentRot = modifiedGO.transform.localRotation;
+                GetCurrentPositionAndRotation(mods, ref currentPos, ref currentRot);
+                var currentRigidTransform = TimelineAnimationUtilities.RigidTransform.Mul(localToTrack, TimelineAnimationUtilities.RigidTransform.Compose(currentPos, currentRot));
+                SetCurrentPositionAndRotation(mods, currentRigidTransform.position, currentRigidTransform.rotation);
+
+                modifiedGO.transform.localPosition = trackSpace.position;
+                modifiedGO.transform.localRotation = trackSpace.rotation;
+            }
+        }
+
+        // This will gather the modifications that modify the same property on the same object (rgba of a color, xyzw of a vector)
+        //  Note: This will modify the list, removing any elements that match
+        static UndoPropertyModification[] GatherRelatedModifications(UndoPropertyModification toMatch, List<UndoPropertyModification> list)
+        {
+            var matching = new List<UndoPropertyModification> {toMatch};
+
+            for (var i = list.Count - 1; i >= 0; i--)
+            {
+                var undo = list[i];
+                if (undo.previousValue.target == toMatch.previousValue.target &&
+                    DoesPropertyPathMatch(undo.previousValue.propertyPath, toMatch.previousValue.propertyPath))
+                {
+                    matching.Add(undo);
+                    list.RemoveAt(i);
+                }
+            }
+
+            return matching.ToArray();
+        }
+
+        // Grab the game object out of the modification object
+        static GameObject GetGameObjectFromModification(UndoPropertyModification mod)
+        {
+            // grab the GO this is modifying
+            GameObject modifiedGO = null;
+            if (mod.previousValue.target is GameObject)
+                modifiedGO = mod.previousValue.target as GameObject;
+            else if (mod.previousValue.target is Component)
+                modifiedGO = (mod.previousValue.target as Component).gameObject;
+
+            return modifiedGO;
+        }
+
+        // returns the level of the child in the hierarchy relative to the parent,
+        //  or -1 if the child is not the parent or a descendent of it
+        static int GetChildLevel(GameObject parent, GameObject child)
+        {
+            var level = 0;
+            while (child != null)
+            {
+                if (parent == child)
+                    break;
+                if (child.transform.parent == null)
+                    return -1;
+                child = child.transform.parent.gameObject;
+                level++;
+            }
+
+            if (child != null)
+                return level;
+            return -1;
+        }
+
+        static bool DoesPropertyPathMatch(string a, string b)
+        {
+            return AnimationWindowUtility.GetPropertyGroupName(a).Equals(AnimationWindowUtility.GetPropertyGroupName(a));
+        }
+
+        internal static void GetPreviousPositionAndRotation(UndoPropertyModification[] mods, ref Vector3 position, ref Quaternion rotation)
+        {
+            var t = mods[0].previousValue.target as Transform;
+            if (t == null)
+                t = (Transform)mods[0].currentValue.target;
+
+            position = t.localPosition;
+            rotation = t.localRotation;
+
+            foreach (var mod in mods)
+            {
+                switch (mod.previousValue.propertyPath)
+                {
+                    case kLocalPosition + ".x":
+                        position.x = ParseFloat(mod.previousValue.value, position.x);
+                        break;
+                    case kLocalPosition + ".y":
+                        position.y = ParseFloat(mod.previousValue.value, position.y);
+                        break;
+                    case kLocalPosition + ".z":
+                        position.z = ParseFloat(mod.previousValue.value, position.z);
+                        break;
+                    case kLocalRotation + ".x":
+                        rotation.x = ParseFloat(mod.previousValue.value, rotation.x);
+                        break;
+                    case kLocalRotation + ".y":
+                        rotation.y = ParseFloat(mod.previousValue.value, rotation.y);
+                        break;
+                    case kLocalRotation + ".z":
+                        rotation.z = ParseFloat(mod.previousValue.value, rotation.z);
+                        break;
+                    case kLocalRotation + ".w":
+                        rotation.w = ParseFloat(mod.previousValue.value, rotation.w);
+                        break;
+                }
+            }
+        }
+
+        internal static void GetCurrentPositionAndRotation(UndoPropertyModification[] mods, ref Vector3 position, ref Quaternion rotation)
+        {
+            var t = (Transform)mods[0].currentValue.target;
+            position = t.localPosition;
+            rotation = t.localRotation;
+
+            foreach (var mod in mods)
+            {
+                switch (mod.currentValue.propertyPath)
+                {
+                    case kLocalPosition + ".x":
+                        position.x = ParseFloat(mod.currentValue.value, position.x);
+                        break;
+                    case kLocalPosition + ".y":
+                        position.y = ParseFloat(mod.currentValue.value, position.y);
+                        break;
+                    case kLocalPosition + ".z":
+                        position.z = ParseFloat(mod.currentValue.value, position.z);
+                        break;
+                    case kLocalRotation + ".x":
+                        rotation.x = ParseFloat(mod.currentValue.value, rotation.x);
+                        break;
+                    case kLocalRotation + ".y":
+                        rotation.y = ParseFloat(mod.currentValue.value, rotation.y);
+                        break;
+                    case kLocalRotation + ".z":
+                        rotation.z = ParseFloat(mod.currentValue.value, rotation.z);
+                        break;
+                    case kLocalRotation + ".w":
+                        rotation.w = ParseFloat(mod.currentValue.value, rotation.w);
+                        break;
+                }
+            }
+        }
+
+        // when making the previous position and rotation
+        internal static void SetPreviousPositionAndRotation(UndoPropertyModification[] mods, Vector3 pos, Quaternion rot)
+        {
+            foreach (var mod in mods)
+            {
+                switch (mod.previousValue.propertyPath)
+                {
+                    case kLocalPosition + ".x":
+                        mod.previousValue.value = pos.x.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalPosition + ".y":
+                        mod.previousValue.value = pos.y.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalPosition + ".z":
+                        mod.previousValue.value = pos.z.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".x":
+                        mod.previousValue.value = rot.x.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".y":
+                        mod.previousValue.value = rot.y.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".z":
+                        mod.previousValue.value = rot.z.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".w":
+                        mod.previousValue.value = rot.w.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                }
+            }
+        }
+
+        internal static void SetCurrentPositionAndRotation(UndoPropertyModification[] mods, Vector3 pos, Quaternion rot)
+        {
+            foreach (var mod in mods)
+            {
+                switch (mod.previousValue.propertyPath)
+                {
+                    case kLocalPosition + ".x":
+                        mod.currentValue.value = pos.x.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalPosition + ".y":
+                        mod.currentValue.value = pos.y.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalPosition + ".z":
+                        mod.currentValue.value = pos.z.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".x":
+                        mod.currentValue.value = rot.x.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".y":
+                        mod.currentValue.value = rot.y.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".z":
+                        mod.currentValue.value = rot.z.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                    case kLocalRotation + ".w":
+                        mod.currentValue.value = rot.w.ToString(EditorGUI.kFloatFieldFormatString);
+                        break;
+                }
+            }
+        }
+
+        internal static float ParseFloat(string str, float defaultVal)
+        {
+            float temp = 0.0f;
+            if (float.TryParse(str, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out temp))
+                return temp;
+            return defaultVal;
+        }
+
+        internal static UndoPropertyModification[] HandleEulerModifications(AnimationTrack track, TimelineClip clip, AnimationClip animClip, float time, UndoPropertyModification[] mods)
+        {
+            if (mods.Any(x => x.currentValue.propertyPath.StartsWith(kLocalEulerHint) || x.currentValue.propertyPath.StartsWith(kLocalRotation)))
+            {
+                // if there is a rotational offsets, we need to strip the euler hints, since they are used by the animation recording system
+                //  over the quaternion.
+                var localToTrack = GetLocalToTrack(track, clip);
+                if (localToTrack.rotation != Quaternion.identity)
+                {
+                    if (s_LastTrackWarning != track)
+                    {
+                        s_LastTrackWarning = track;
+                        Debug.LogWarning(kRotationWarning);
+                    }
+
+                    Transform transform = mods[0].currentValue.target as Transform;
+                    if (transform != null)
+                    {
+                        var trackToLocal = TimelineAnimationUtilities.RigidTransform.Inverse(localToTrack);
+                        // since the euler angles are going to be transformed, we do a best guess at a euler that gives the shortest path
+                        var quatMods = mods.Where(x => !x.currentValue.propertyPath.StartsWith(kLocalEulerHint));
+                        var eulerMods = FindBestEulerHint(trackToLocal.rotation * transform.localRotation, animClip, time, transform);
+                        return quatMods.Union(eulerMods).ToArray();
+                    }
+                    return mods.Where(x => !x.currentValue.propertyPath.StartsWith(kLocalEulerHint)).ToArray();
+                }
+            }
+            return mods;
+        }
+
+        internal static IEnumerable<UndoPropertyModification> FindBestEulerHint(Quaternion rotation, AnimationClip clip, float time, Transform transform)
+        {
+            Vector3 euler = rotation.eulerAngles;
+
+            var xCurve = AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAnglesRaw.x"));
+            var yCurve = AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAnglesRaw.y"));
+            var zCurve = AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(string.Empty, typeof(Transform), "localEulerAnglesRaw.z"));
+
+            if (xCurve != null)
+                euler.x = xCurve.Evaluate(time);
+            if (yCurve != null)
+                euler.y = yCurve.Evaluate(time);
+            if (zCurve != null)
+                euler.z = zCurve.Evaluate(time);
+
+            euler = QuaternionCurveTangentCalculation.GetEulerFromQuaternion(rotation, euler);
+
+            return new[]
+            {
+                PropertyModificationToUndoPropertyModification(new PropertyModification {target = transform, propertyPath = kLocalEulerHint + ".x", value = euler.x.ToString() }),
+                PropertyModificationToUndoPropertyModification(new PropertyModification {target = transform, propertyPath = kLocalEulerHint + ".y", value = euler.y.ToString() }),
+                PropertyModificationToUndoPropertyModification(new PropertyModification {target = transform, propertyPath = kLocalEulerHint + ".z", value = euler.z.ToString() })
+            };
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_Monobehaviour.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_Monobehaviour.cs.meta
new file mode 100644
index 0000000..346e5bd
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_Monobehaviour.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9805855c8e379ed4cad77f639aaddb73
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_PlayableAsset.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_PlayableAsset.cs
new file mode 100644
index 0000000..940854e
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_PlayableAsset.cs
@@ -0,0 +1,115 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Timeline;
+using UnityEngine.Playables;
+
+namespace UnityEditor.Timeline
+{
+    // Handles Undo animated properties on PlayableAssets from clips to create parameter animation
+
+    static partial class TimelineRecording
+    {
+        internal static bool HasAnyPlayableAssetModifications(UndoPropertyModification[] modifications)
+        {
+            return modifications.Any(x => GetTarget(x) as IPlayableAsset != null);
+        }
+
+        internal static UndoPropertyModification[] ProcessPlayableAssetModification(UndoPropertyModification[] modifications, WindowState state)
+        {
+            // can't record without a director since the asset being modified might be a scene instance
+            if (state == null || state.editSequence.director == null)
+                return modifications;
+
+            var remaining = new List<UndoPropertyModification>();
+            foreach (UndoPropertyModification mod in modifications)
+            {
+                if (!ProcessPlayableAssetModification(mod, state))
+                    remaining.Add(mod);
+            }
+
+            if (remaining.Count != modifications.Length)
+            {
+                state.rebuildGraph = true;
+                state.GetWindow().Repaint();
+            }
+
+            return remaining.ToArray();
+        }
+
+        static bool ProcessPlayableAssetModification(UndoPropertyModification mod, WindowState state)
+        {
+            var target = GetTarget(mod) as IPlayableAsset;
+            if (target == null)
+                return false;
+
+            var curvesOwner = AnimatedParameterUtility.ToCurvesOwner(target, state.editSequence.asset);
+            if (curvesOwner == null || !curvesOwner.HasAnyAnimatableParameters())
+                return false;
+
+            return ProcessPlayableAssetRecording(mod, state, curvesOwner);
+        }
+
+        internal static TimelineClip FindClipWithAsset(TimelineAsset asset, IPlayableAsset target)
+        {
+            if (target == null || asset == null)
+                return null;
+
+            var clips = asset.flattenedTracks.SelectMany(x => x.clips);
+            return clips.FirstOrDefault(x => x != null && x.asset != null && target == x.asset as IPlayableAsset);
+        }
+
+        static bool ProcessPlayableAssetRecording(UndoPropertyModification mod, WindowState state, ICurvesOwner curvesOwner)
+        {
+            if (mod.currentValue == null)
+                return false;
+
+            if (!curvesOwner.IsParameterAnimatable(mod.currentValue.propertyPath))
+                return false;
+
+            var localTime = state.editSequence.time;
+            var timelineClip = curvesOwner as TimelineClip;
+            if (timelineClip != null)
+            {
+                // don't use time global to local since it will possibly loop.
+                localTime = timelineClip.ToLocalTimeUnbound(state.editSequence.time);
+            }
+
+            if (localTime < 0)
+                return false;
+
+            // grab the value from the current modification
+            float fValue = 0;
+            if (!float.TryParse(mod.currentValue.value, out fValue))
+            {
+                // case 916913 -- 'Add Key' menu item will passes 'True' or 'False' (instead of 1, 0)
+                // so we need a special case to parse the boolean string
+                bool bValue;
+                if (!bool.TryParse(mod.currentValue.value, out bValue))
+                {
+                    Debug.Assert(false, "Invalid type in PlayableAsset recording");
+                    return false;
+                }
+
+                fValue = bValue ? 1 : 0;
+            }
+
+            var added = curvesOwner.AddAnimatedParameterValueAt(mod.currentValue.propertyPath, fValue, (float)localTime);
+            if (added && AnimationMode.InAnimationMode())
+            {
+                EditorCurveBinding binding = curvesOwner.GetCurveBinding(mod.previousValue.propertyPath);
+                AnimationMode.AddPropertyModification(binding, mod.previousValue, true);
+                curvesOwner.targetTrack.SetShowInlineCurves(true);
+                if (state.GetWindow() != null && state.GetWindow().treeView != null)
+                    state.GetWindow().treeView.CalculateRowRects();
+            }
+
+            return added;
+        }
+
+        static bool IsPlayableAssetProperty(SerializedProperty property)
+        {
+            return property.serializedObject.targetObject is IPlayableAsset;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_PlayableAsset.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_PlayableAsset.cs.meta
new file mode 100644
index 0000000..e78220d
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TimelineRecording_PlayableAsset.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7341c0cd0aad4994e8fa461cb443aa7d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TrackAssetRecordingExtensions.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TrackAssetRecordingExtensions.cs
new file mode 100644
index 0000000..f44b82b
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TrackAssetRecordingExtensions.cs
@@ -0,0 +1,191 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    static class TrackAssetRecordingExtensions
+    {
+        static readonly Dictionary<TrackAsset, AnimationClip> s_ActiveClips = new Dictionary<TrackAsset, AnimationClip>();
+
+        internal static void OnRecordingArmed(this TrackAsset track, PlayableDirector director)
+        {
+            if (track == null)
+                return;
+
+            var animClip = track.FindRecordingAnimationClipAtTime(director.time);
+            if (animClip == null)
+                return;
+
+            s_ActiveClips[track] = animClip;
+        }
+
+        internal static void OnRecordingTimeChanged(this TrackAsset track, PlayableDirector director)
+        {
+            if (track == null)
+                return;
+
+            var animClip = track.FindRecordingAnimationClipAtTime(director.time);
+            AnimationClip prevClip = track.GetActiveRecordingAnimationClip();
+            if (prevClip != animClip)
+            {
+                s_ActiveClips[track] = animClip;
+            }
+        }
+
+        internal static void OnRecordingUnarmed(this TrackAsset track, PlayableDirector director)
+        {
+            s_ActiveClips.Remove(track);
+        }
+
+        internal static bool CanRecordAtTime(this TrackAsset track, double time)
+        {
+            // Animation Track
+            var animTrack = track as AnimationTrack;
+            if (animTrack != null)
+            {
+                if (!animTrack.inClipMode)
+                    return true;
+
+                TimelineClip clip = null;
+                return FindRecordingClipAtTime(track, time, out clip);
+            }
+
+            // Custom track
+            return track.clips.Any(x => x.start < time + TimeUtility.kTimeEpsilon && x.HasAnyAnimatableParameters());
+        }
+
+        internal static AnimationClip GetActiveRecordingAnimationClip(this TrackAsset track)
+        {
+            AnimationClip clip = null;
+            s_ActiveClips.TryGetValue(track, out clip);
+            return clip;
+        }
+
+        internal static bool IsRecordingToClip(this TrackAsset track, TimelineClip clip)
+        {
+            if (track == null || clip == null)
+                return false;
+            var animClip = track.GetActiveRecordingAnimationClip();
+            if (animClip == null)
+                return false;
+            if (animClip == clip.curves)
+                return true;
+
+            var animAsset = clip.asset as AnimationPlayableAsset;
+            return animAsset != null && animClip == animAsset.clip;
+        }
+
+        // Finds the clip at the given time that recording should use
+        //    returns whether recording at this particular point is valid
+        // The target clip will be returned, even if recording at that time is invalid
+        // in case of recording in a blend OR recording to a non-timeline clip
+        internal static bool FindRecordingClipAtTime(this TrackAsset track, double time, out TimelineClip target)
+        {
+            target = null;
+            if (track == null)
+            {
+                return false;
+            }
+
+            var discreteTime = new DiscreteTime(time);
+
+            // only animation tracks require the recordable flag as they are recording
+            //  to an animation clip
+            bool requiresRecordable = (track as AnimationTrack) != null;
+            if (requiresRecordable)
+            {
+                track.SortClips();
+                var sortedByStartTime = track.clips;
+                int i = 0;
+                for (i = 0; i < sortedByStartTime.Length; i++)
+                {
+                    var clip = sortedByStartTime[i];
+                    if (new DiscreteTime(clip.start) <= discreteTime && new DiscreteTime(clip.end) > discreteTime)
+                    {
+                        target = clip;
+                        // not recordable
+                        if (!clip.recordable)
+                            return false;
+
+                        // in a blend
+                        if (!Mathf.Approximately(1.0f, clip.EvaluateMixIn(time) * clip.EvaluateMixOut(time)))
+                            return false;
+
+                        return true;
+                    }
+
+                    if (new DiscreteTime(clip.start) > discreteTime)
+                    {
+                        break;
+                    }
+                }
+
+                return false;
+            }
+
+
+            // Recordable playable assets -- takes the last clip that matches
+            track.SortClips();
+            for (int i = 0; i < track.clips.Length; i++)
+            {
+                var clip = track.clips[i];
+                if (clip.start <= time && clip.end >= time && clip.HasAnyAnimatableParameters())
+                    target = clip;
+
+                if (clip.start > time)
+                    break;
+            }
+
+            return target != null;
+        }
+
+        // Given a track, return the animation clip
+        internal static AnimationClip FindRecordingAnimationClipAtTime(this TrackAsset trackAsset, double time)
+        {
+            if (trackAsset == null)
+                return null;
+
+            AnimationTrack animTrack = trackAsset as AnimationTrack;
+            if (animTrack != null && !animTrack.inClipMode)
+            {
+                return animTrack.infiniteClip;
+            }
+
+            TimelineClip displayBackground;
+            trackAsset.FindRecordingClipAtTime(time, out displayBackground);
+            if (displayBackground != null)
+            {
+                if (displayBackground.recordable)
+                {
+                    AnimationPlayableAsset asset = displayBackground.asset as AnimationPlayableAsset;
+                    if (asset != null)
+                        return asset.clip;
+                }
+                else if (animTrack == null)
+                {
+                    if (displayBackground.curves == null)
+                        displayBackground.CreateCurves(AnimationTrackRecorder.GetUniqueRecordedClipName(displayBackground.parentTrack, TimelineClip.kDefaultCurvesName));
+
+                    return displayBackground.curves;
+                }
+            }
+            else if (trackAsset.HasAnyAnimatableParameters())
+            {
+                if (trackAsset.curves == null)
+                    trackAsset.CreateCurves(AnimationTrackRecorder.GetUniqueRecordedClipName(trackAsset.timelineAsset, TrackAsset.kDefaultCurvesName));
+
+                return trackAsset.curves;
+            }
+
+            return null;
+        }
+
+        internal static void ClearRecordingState()
+        {
+            s_ActiveClips.Clear();
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TrackAssetRecordingExtensions.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TrackAssetRecordingExtensions.cs.meta
new file mode 100644
index 0000000..edbe4da
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Editor/Recording/TrackAssetRecordingExtensions.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 49f1d2c7420db4444b011955726d0046
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: