Inital commit

1 files changed, 455 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/TimelineAsset.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/TimelineAsset.cs
new file mode 100644
index 0000000..ca2572e
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/TimelineAsset.cs
@@ -0,0 +1,455 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// A PlayableAsset that represents a timeline.
+    /// </summary>
+    [ExcludeFromPreset]
+    [Serializable]
+    public partial class TimelineAsset : PlayableAsset, ISerializationCallbackReceiver, ITimelineClipAsset, IPropertyPreview
+    {
+        /// <summary>
+        /// How the duration of the timeline is determined.
+        /// </summary>
+        public enum DurationMode
+        {
+            /// <summary>
+            /// The duration of the timeline is determined based on the clips present.
+            /// </summary>
+            BasedOnClips,
+            /// <summary>
+            /// The duration of the timeline is a fixed length.
+            /// </summary>
+            FixedLength
+        }
+
+        /// <summary>
+        /// Properties of the timeline that are used by the editor
+        /// </summary>
+        [Serializable]
+        public class EditorSettings
+        {
+            internal static readonly float kMinFps = (float)TimeUtility.kFrameRateEpsilon;
+            internal static readonly float kMaxFps = 1000.0f;
+            internal static readonly float kDefaultFps = 60.0f;
+            [HideInInspector, SerializeField] float m_Framerate = kDefaultFps;
+
+            /// <summary>
+            /// The frames per second used for snapping and time ruler display
+            /// </summary>
+            public float fps
+            {
+                get
+                {
+                    return m_Framerate;
+                }
+                set
+                {
+                    m_Framerate = GetValidFramerate(value);
+                }
+            }
+        }
+
+        [HideInInspector, SerializeField] List<ScriptableObject> m_Tracks;
+        [HideInInspector, SerializeField] double m_FixedDuration; // only applied if duration mode is Fixed
+        [HideInInspector, NonSerialized] TrackAsset[] m_CacheOutputTracks;
+        [HideInInspector, NonSerialized] List<TrackAsset> m_CacheRootTracks;
+        [HideInInspector, NonSerialized] List<TrackAsset> m_CacheFlattenedTracks;
+        [HideInInspector, SerializeField] EditorSettings m_EditorSettings = new EditorSettings();
+        [SerializeField] DurationMode m_DurationMode;
+
+        [HideInInspector, SerializeField] MarkerTrack m_MarkerTrack;
+
+        /// <summary>
+        /// Settings used by timeline for editing purposes
+        /// </summary>
+        public EditorSettings editorSettings
+        {
+            get { return m_EditorSettings; }
+        }
+
+        /// <summary>
+        /// The length, in seconds, of the timeline
+        /// </summary>
+        public override double duration
+        {
+            get
+            {
+                // @todo cache this value when rebuilt
+                if (m_DurationMode == DurationMode.BasedOnClips)
+                    return CalculateDuration();
+
+                return m_FixedDuration;
+            }
+        }
+
+        /// <summary>
+        /// The length of the timeline when durationMode is set to fixed length.
+        /// </summary>
+        public double fixedDuration
+        {
+            get
+            {
+                DiscreteTime discreteDuration = (DiscreteTime)m_FixedDuration;
+                if (discreteDuration <= 0)
+                    return 0.0;
+
+                //avoid having no clip evaluated at the end by removing a tick from the total duration
+                return (double)discreteDuration.OneTickBefore();
+            }
+            set { m_FixedDuration = Math.Max(0.0, value); }
+        }
+
+        /// <summary>
+        /// The mode used to determine the duration of the Timeline
+        /// </summary>
+        public DurationMode durationMode
+        {
+            get { return m_DurationMode; }
+            set { m_DurationMode = value; }
+        }
+
+        /// <summary>
+        /// A description of the PlayableOutputs that will be created by the timeline when instantiated.
+        /// </summary>
+        /// <remarks>
+        /// Each track will create an PlayableOutput
+        /// </remarks>
+        public override IEnumerable<PlayableBinding> outputs
+        {
+            get
+            {
+                foreach (var outputTracks in GetOutputTracks())
+                    foreach (var output in outputTracks.outputs)
+                        yield return output;
+            }
+        }
+
+        public ClipCaps clipCaps
+        {
+            get
+            {
+                var caps = ClipCaps.All;
+                foreach (var track in GetRootTracks())
+                {
+                    foreach (var clip in track.clips)
+                        caps &= clip.clipCaps;
+                }
+                return caps;
+            }
+        }
+
+        /// <summary>
+        /// Returns the the number of output tracks in the Timeline.
+        /// </summary>
+        /// <remarks>
+        /// An output track is a track the generates a PlayableOutput. In general, an output track is any track that is not a GroupTrack, a subtrack, or override track.
+        /// </remarks>
+        public int outputTrackCount
+        {
+            get
+            {
+                UpdateOutputTrackCache(); // updates the cache if necessary
+                return m_CacheOutputTracks.Length;
+            }
+        }
+
+        /// <summary>
+        /// Returns the number of tracks at the root level of the timeline.
+        /// </summary>
+        /// <remarks>
+        /// A root track refers to all tracks that occur at the root of the timeline. These are the outmost level GroupTracks, and output tracks that do not belong to any group
+        /// </remarks>
+        public int rootTrackCount
+        {
+            get
+            {
+                UpdateRootTrackCache();
+                return m_CacheRootTracks.Count;
+            }
+        }
+
+        void OnValidate()
+        {
+            editorSettings.fps = GetValidFramerate(editorSettings.fps);
+        }
+
+        static float GetValidFramerate(float framerate)
+        {
+            return Mathf.Clamp(framerate, EditorSettings.kMinFps, EditorSettings.kMaxFps);
+        }
+
+        /// <summary>
+        /// Retrieves at root track at the specified index.
+        /// </summary>
+        /// <param name="index">Index of the root track to get. Must be between 0 and rootTrackCount</param>
+        /// <remarks>
+        /// A root track refers to all tracks that occur at the root of the timeline. These are the outmost level GroupTracks, and output tracks that do not belong to any group.
+        /// </remarks>
+        public TrackAsset GetRootTrack(int index)
+        {
+            UpdateRootTrackCache();
+            return m_CacheRootTracks[index];
+        }
+
+        /// <summary>
+        /// Get an enumerable list of all root tracks.
+        /// </summary>
+        /// <returns>An IEnumerable of all root tracks.</returns>
+        /// <remarks>A root track refers to all tracks that occur at the root of the timeline. These are the outmost level GroupTracks, and output tracks that do not belong to any group.</remarks>
+        public IEnumerable<TrackAsset> GetRootTracks()
+        {
+            UpdateRootTrackCache();
+            return m_CacheRootTracks;
+        }
+
+        /// <summary>
+        /// Retrives the output track from the given index.
+        /// </summary>
+        /// <param name="index">Index of the output track to retrieve. Must be between 0 and outputTrackCount</param>
+        /// <returns>The output track from the given index</returns>
+        public TrackAsset GetOutputTrack(int index)
+        {
+            UpdateOutputTrackCache();
+            return m_CacheOutputTracks[index];
+        }
+
+        /// <summary>
+        /// Gets a list of all output tracks in the Timeline.
+        /// </summary>
+        /// <returns>An IEnumerable of all output tracks</returns>
+        /// <remarks>
+        /// An output track is a track the generates a PlayableOutput. In general, an output track is any track that is not a GroupTrack or subtrack.
+        /// </remarks>
+        public IEnumerable<TrackAsset> GetOutputTracks()
+        {
+            UpdateOutputTrackCache();
+            return m_CacheOutputTracks;
+        }
+
+        void UpdateRootTrackCache()
+        {
+            if (m_CacheRootTracks == null)
+            {
+                if (m_Tracks == null)
+                    m_CacheRootTracks = new List<TrackAsset>();
+                else
+                {
+                    m_CacheRootTracks = new List<TrackAsset>(m_Tracks.Count);
+                    if (markerTrack != null)
+                    {
+                        m_CacheRootTracks.Add(markerTrack);
+                    }
+
+                    foreach (var t in m_Tracks)
+                    {
+                        var trackAsset = t as TrackAsset;
+                        if (trackAsset != null)
+                            m_CacheRootTracks.Add(trackAsset);
+                    }
+                }
+            }
+        }
+
+        void UpdateOutputTrackCache()
+        {
+            if (m_CacheOutputTracks == null)
+            {
+                var outputTracks = new List<TrackAsset>();
+                foreach (var flattenedTrack in flattenedTracks)
+                {
+                    if (flattenedTrack != null && flattenedTrack.GetType() != typeof(GroupTrack) && !flattenedTrack.isSubTrack)
+                        outputTracks.Add(flattenedTrack);
+                }
+                m_CacheOutputTracks = outputTracks.ToArray();
+            }
+        }
+
+        internal IEnumerable<TrackAsset> flattenedTracks
+        {
+            get
+            {
+                if (m_CacheFlattenedTracks == null)
+                {
+                    m_CacheFlattenedTracks = new List<TrackAsset>(m_Tracks.Count * 2);
+                    UpdateRootTrackCache();
+
+                    m_CacheFlattenedTracks.AddRange(m_CacheRootTracks);
+                    for (int i = 0; i < m_CacheRootTracks.Count; i++)
+                    {
+                        AddSubTracksRecursive(m_CacheRootTracks[i], ref m_CacheFlattenedTracks);
+                    }
+                }
+                return m_CacheFlattenedTracks;
+            }
+        }
+
+        /// <summary>
+        /// Gets the marker track for this TimelineAsset.
+        /// </summary>
+        /// <returns>Returns the marker track.</returns>
+        /// <remarks>
+        /// Use <see cref="TrackAsset.GetMarkers"/> to get a list of the markers on the returned track.
+        /// </remarks>
+        public MarkerTrack markerTrack
+        {
+            get { return m_MarkerTrack; }
+        }
+
+        // access to the track list as scriptable object
+        internal List<ScriptableObject> trackObjects
+        {
+            get { return m_Tracks; }
+        }
+
+        internal void AddTrackInternal(TrackAsset track)
+        {
+            m_Tracks.Add(track);
+            track.parent = this;
+            Invalidate();
+        }
+
+        internal void RemoveTrack(TrackAsset track)
+        {
+            m_Tracks.Remove(track);
+            Invalidate();
+            var parentTrack = track.parent as TrackAsset;
+            if (parentTrack != null)
+            {
+                parentTrack.RemoveSubTrack(track);
+            }
+        }
+
+        /// <summary>
+        /// Creates an instance of the timeline
+        /// </summary>
+        /// <param name="graph">PlayableGraph that will own the playable</param>
+        /// <param name="go">The gameobject that triggered the graph build</param>
+        /// <returns>The Root Playable of the Timeline</returns>
+        public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
+        {
+            bool autoRebalanceTree = false;
+            #if UNITY_EDITOR
+            autoRebalanceTree = true;
+            #endif
+
+            // only create outputs if we are not nested
+            bool createOutputs = graph.GetPlayableCount() == 0;
+            var timeline = TimelinePlayable.Create(graph, GetOutputTracks(), go, autoRebalanceTree, createOutputs);
+            timeline.SetPropagateSetTime(true);
+            return timeline.IsValid() ? timeline : Playable.Null;
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+            m_Version = k_LatestVersion;
+        }
+
+        // resets cache on an Undo
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            Invalidate(); // resets cache on an Undo
+            if (m_Version < k_LatestVersion)
+            {
+                UpgradeToLatestVersion();
+            }
+        }
+
+        void __internalAwake()
+        {
+            if (m_Tracks == null)
+                m_Tracks = new List<ScriptableObject>();
+
+            // validate the array. DON'T remove Unity null objects, just actual null objects
+            for (int i = m_Tracks.Count - 1; i >= 0; i--)
+            {
+                TrackAsset asset = m_Tracks[i] as TrackAsset;
+                if (asset != null)
+                    asset.parent = this;
+#if UNITY_EDITOR
+                object o = m_Tracks[i];
+                if (o == null)
+                {
+                    Debug.LogWarning("Empty track found while loading timeline. It will be removed.");
+                    m_Tracks.RemoveAt(i);
+                }
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Called by the Timeline Editor to gather properties requiring preview.
+        /// </summary>
+        /// <param name="director">The PlayableDirector invoking the preview</param>
+        /// <param name="driver">PropertyCollector used to gather previewable properties</param>
+        public void GatherProperties(PlayableDirector director, IPropertyCollector driver)
+        {
+            var outputTracks = GetOutputTracks();
+            foreach (var track in outputTracks)
+            {
+                track.GatherProperties(director, driver);
+            }
+        }
+
+        /// <summary>
+        /// Creates a marker track for the TimelineAsset.
+        /// </summary>
+        /// In the editor, the marker track appears under the Timeline ruler.
+        /// <remarks>
+        /// This track is always bound to the GameObject that contains the PlayableDirector component for the current timeline.
+        /// The marker track is created the first time this method is called. If the marker track is already created, this method does nothing.
+        /// </remarks>
+        public void CreateMarkerTrack()
+        {
+            if (m_MarkerTrack == null)
+            {
+                m_MarkerTrack = CreateInstance<MarkerTrack>();
+                TimelineCreateUtilities.SaveAssetIntoObject(m_MarkerTrack, this);
+                m_MarkerTrack.parent = this;
+                m_MarkerTrack.name = "Markers"; // This name will show up in the bindings list if it contains signals
+                Invalidate();
+            }
+        }
+
+        // Invalidates the asset, call this if changing the asset data
+        internal void Invalidate()
+        {
+            m_CacheRootTracks = null;
+            m_CacheOutputTracks = null;
+            m_CacheFlattenedTracks = null;
+        }
+
+        double CalculateDuration()
+        {
+            var discreteDuration = new DiscreteTime(0);
+            foreach (var track in flattenedTracks)
+            {
+                if (track.muted)
+                    continue;
+
+                discreteDuration = DiscreteTime.Max(discreteDuration, (DiscreteTime)track.end);
+            }
+
+            if (discreteDuration <= 0)
+                return 0.0;
+
+            //avoid having no clip evaluated at the end by removing a tick from the total duration
+            return (double)discreteDuration.OneTickBefore();
+        }
+
+        static void AddSubTracksRecursive(TrackAsset track, ref List<TrackAsset> allTracks)
+        {
+            if (track == null)
+                return;
+
+            allTracks.AddRange(track.GetChildTracks());
+            foreach (TrackAsset subTrack in track.GetChildTracks())
+            {
+                AddSubTracksRecursive(subTrack, ref allTracks);
+            }
+        }
+    }
+}