Library/metadata/a0/a0a02e768c802b641b6793fa864f1c2c

í>42019.2.3f1þÿÿÿÿÿ’3$øÌuñì˜²e+ Í=^7€ÿÿÿÿ€¦€²€Ð€¦€¦€¦€#¦€+H€3ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€	Q€j€
H€<ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€
Q€j€Õ€Iÿÿÿÿ€1€1€ÿÿÿÿÀÞ€€H€j€ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€Q€j€™€PAssetMetaDataguiddata[0]data[1]data[2]data[3]pathNameoriginalNamelabelsassetStoreRefÿÿfš†!ë5˜9Ý4QÁóBí7€ÿÿÿÿ€¦€²€
E€Þ€#€.€,€5a€Þ€#€.€,€†€r€Þ€#	€.€,
€H€«€ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€
Q€j€ñ€JÿÿÿÿÀ1€1€ÿÿÿÿ€Þ€€€j€ÿÿÿÿ€\›€ÿÿÿÿ€H€rÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€Q€j€H€wÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€Q€j€H€€ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€Q€j€y€
€ Þ€#!€.€,"€€…ÿÿÿÿ#@1€1€ÿÿÿÿ$Þ€€%.€j€&Õ€“ÿÿÿÿ'€1€1€ÿÿÿÿ(ÀÞ€€)€j€ÿÿÿÿ*€H€›€ÿÿÿÿ+€1€1€ÿÿÿÿ,@Þ€€-Q€j€.y€
€/Þ€#0€.€,1€ €§2@¾€¶3@Þ€#4€.€,5€H€»ÿÿÿÿ6€1€1€ÿÿÿÿ7@Þ€€8Q€j€9H€Æÿÿÿÿ:€1€1€ÿÿÿÿ;@Þ€€<Q€j€=H€Øÿÿÿÿ>€1€1€ÿÿÿÿ?@Þ€€@Q€j€AMonoImporterPPtr<EditorExtension>m_FileIDm_PathIDPPtr<PrefabInstance>m_ExternalObjectsSourceAssetIdentifiertypeassemblynamem_UsedFileIDsm_DefaultReferencesexecutionOrdericonm_UserDatam_AssetBundleNamem_AssetBundleVariantsÿÿ£Gñ×Ü�Z56 :!@iÁJ*�€7€ÿÿÿÿ€¦€²€E€Þ€€.€€(a€Þ€€.€€†€r€Þ€	€.€
€H€«€ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€
Q€j€H€ê€ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€Q€j€ñ€=ÿÿÿÿ€1€1€ÿÿÿÿ€Þ€€€j€ÿÿÿÿ€H€›€ÿÿÿÿ€1€1€ÿÿÿÿ@Þ€€Q€j€y€
€Þ€€.€€y€QÞ€€.€ €Þ€X!H€iÿÿÿÿ"€1€1€ÿÿÿÿ#@Þ€€$Q€j€%H€uÿÿÿÿ&€1€1€ÿÿÿÿ'@Þ€€(Q€j€)PPtr<EditorExtension>m_FileIDm_PathIDPPtr<PrefabInstance>m_DefaultReferencesm_Iconm_ExecutionOrderm_ClassNamem_Namespacepp\ày¯ÐT*

âgÈ²F±v9¯hôÁÂFPackages/com.unity.timeline/Editor/Recording/AnimationTrackRecorder.csày¯AnimationTrackRecorderÂ)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;

        public TimelineClip recordClip { get; private set; }

        public void PrepareForRecord(WindowState state)
        {
            m_CurveCount = 0;
            m_TargetClip = null;
        }

        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);

            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);
            }
        }

        // 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;