Inital commit

18 files changed, 1268 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ActivationControlPlayable.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ActivationControlPlayable.cs
new file mode 100644
index 0000000..3efb818
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ActivationControlPlayable.cs
@@ -0,0 +1,140 @@
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Playable that controls the active state of a GameObject.
+    /// </summary>
+    public class ActivationControlPlayable : PlayableBehaviour
+    {
+        /// <summary>
+        /// The state of a GameObject's activeness when a PlayableGraph stops.
+        /// </summary>
+        public enum PostPlaybackState
+        {
+            /// <summary>
+            /// Set the GameObject to active when the PlayableGraph stops.
+            /// </summary>
+            Active,
+
+            /// <summary>
+            /// Set the GameObject to inactive when the [[PlayableGraph]] stops.
+            /// </summary>
+            Inactive,
+
+            /// <summary>
+            /// Revert the GameObject to the active state it was before the [[PlayableGraph]] started.
+            /// </summary>
+            Revert
+        }
+
+        enum InitialState
+        {
+            Unset,
+            Active,
+            Inactive
+        }
+
+        public GameObject gameObject = null;
+        public PostPlaybackState postPlayback = PostPlaybackState.Revert;
+        InitialState m_InitialState;
+
+        /// <summary>
+        /// Creates a ScriptPlayable with an ActivationControlPlayable behaviour attached
+        /// </summary>
+        /// <param name="graph">PlayableGraph that will own the playable</param>
+        /// <param name="gameObject">The GameObject that triggered the graph build</param>
+        /// <param name="postPlaybackState">The state to leave the gameObject after the graph is stopped</param>
+        /// <returns>Returns a playable that controls activation of a game object</returns>
+        public static ScriptPlayable<ActivationControlPlayable> Create(PlayableGraph graph, GameObject gameObject, ActivationControlPlayable.PostPlaybackState postPlaybackState)
+        {
+            if (gameObject == null)
+                return ScriptPlayable<ActivationControlPlayable>.Null;
+
+            var handle = ScriptPlayable<ActivationControlPlayable>.Create(graph);
+            var playable = handle.GetBehaviour();
+            playable.gameObject = gameObject;
+            playable.postPlayback = postPlaybackState;
+
+            return handle;
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to Playables.PlayState.Playing.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">The information about this frame</param>
+        public override void OnBehaviourPlay(Playable playable, FrameData info)
+        {
+            if (gameObject == null)
+                return;
+
+            gameObject.SetActive(true);
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to PlayState.Paused.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">The information about this frame</param>
+        public override void OnBehaviourPause(Playable playable, FrameData info)
+        {
+            // OnBehaviourPause can be called if the graph is stopped for a variety of reasons
+            //  the effectivePlayState will test if the pause is due to the clip being out of bounds
+            if (gameObject != null && info.effectivePlayState == PlayState.Paused)
+            {
+                gameObject.SetActive(false);
+            }
+        }
+
+        /// <summary>
+        /// This function is called during the ProcessFrame phase of the PlayableGraph.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        /// <param name="userData">unused</param>
+        public override void ProcessFrame(Playable playable, FrameData info, object userData)
+        {
+            if (gameObject != null)// && !gameObject.activeSelf)
+                gameObject.SetActive(true);
+        }
+
+        /// <summary>
+        /// This function is called when the PlayableGraph that owns this PlayableBehaviour starts.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        public override void OnGraphStart(Playable playable)
+        {
+            if (gameObject != null)
+            {
+                if (m_InitialState == InitialState.Unset)
+                    m_InitialState = gameObject.activeSelf ? InitialState.Active : InitialState.Inactive;
+            }
+        }
+
+        /// <summary>
+        /// This function is called when the Playable that owns the PlayableBehaviour is destroyed.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        public override void OnPlayableDestroy(Playable playable)
+        {
+            if (gameObject == null || m_InitialState == InitialState.Unset)
+                return;
+
+            switch (postPlayback)
+            {
+                case PostPlaybackState.Active:
+                    gameObject.SetActive(true);
+                    break;
+
+                case PostPlaybackState.Inactive:
+                    gameObject.SetActive(false);
+                    break;
+
+                case PostPlaybackState.Revert:
+                    gameObject.SetActive(m_InitialState == InitialState.Active);
+                    break;
+            }
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ActivationControlPlayable.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ActivationControlPlayable.cs.meta
new file mode 100644
index 0000000..a7763a6
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ActivationControlPlayable.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d20e4e177b86a2843805dd3894f41b42
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/BasicScriptPlayable.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/BasicScriptPlayable.cs
new file mode 100644
index 0000000..0157958
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/BasicScriptPlayable.cs
@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// This class is deprecated. It is recommended to use Playable Asset and Playable Behaviour derived classes instead.
+    /// </summary>
+    [Serializable]
+    [Obsolete("For best performance use PlayableAsset and PlayableBehaviour.")]
+    public class BasicPlayableBehaviour : ScriptableObject, IPlayableAsset, IPlayableBehaviour
+    {
+        public BasicPlayableBehaviour() {}
+
+        /// <summary>
+        /// The playback duration in seconds of the instantiated Playable.
+        /// </summary>
+        public virtual double duration { get { return PlayableBinding.DefaultDuration; } }
+
+        /// <summary>
+        ///A description of the outputs of the instantiated Playable.
+        /// </summary>
+        public virtual IEnumerable<PlayableBinding> outputs { get { return PlayableBinding.None; } }
+
+        /// <summary>
+        ///   <para>This function is called when the PlayableGraph that owns this PlayableBehaviour starts.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        public virtual void OnGraphStart(Playable playable) {}
+
+        /// <summary>
+        ///   <para>This function is called when the PlayableGraph that owns this PlayableBehaviour stops.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        public virtual void OnGraphStop(Playable playable)  {}
+
+        /// <summary>
+        ///   <para>This function is called when the Playable that owns the PlayableBehaviour is created.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        public virtual void OnPlayableCreate(Playable playable) {}
+
+        /// <summary>
+        ///   <para>This function is called when the Playable that owns the PlayableBehaviour is destroyed.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        public virtual void OnPlayableDestroy(Playable playable) {}
+
+        /// <summary>
+        ///   <para>This function is called when the Playable play state is changed to Playables.PlayState.Playing.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public virtual void OnBehaviourPlay(Playable playable, FrameData info) {}
+
+        /// <summary>
+        ///   <para>This function is called when the Playable play state is changed to Playables.PlayState.Paused.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public virtual void OnBehaviourPause(Playable playable, FrameData info) {}
+
+        /// <summary>
+        ///   <para>This function is called during the PrepareFrame phase of the PlayableGraph.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public virtual void PrepareFrame(Playable playable, FrameData info) {}
+
+        /// <summary>
+        ///   <para>This function is called during the ProcessFrame phase of the PlayableGraph.</para>
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        /// <param name="playerData">The user data of the ScriptPlayableOutput that initiated the process pass.</param>
+        public virtual void ProcessFrame(Playable playable, FrameData info, object playerData) {}
+
+        /// <summary>
+        /// Implement this method to have your asset inject playables into the given graph.
+        /// </summary>
+        /// <param name="graph">The graph to inject playables into.</param>
+        /// <param name="owner">The game object which initiated the build.</param>
+        /// <returns>The playable injected into the graph, or the root playable if multiple playables are injected.</returns>
+        public virtual Playable CreatePlayable(PlayableGraph graph, GameObject owner)
+        {
+            return ScriptPlayable<BasicPlayableBehaviour>.Create(graph, this);
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/BasicScriptPlayable.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/BasicScriptPlayable.cs.meta
new file mode 100644
index 0000000..414366e
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/BasicScriptPlayable.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fe03a7b0ba57a4d488b6c327ae16c335
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/DirectorControlPlayable.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/DirectorControlPlayable.cs
new file mode 100644
index 0000000..e619617
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/DirectorControlPlayable.cs
@@ -0,0 +1,206 @@
+using System;
+using UnityEngine;
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Playable Behaviour used to control a PlayableDirector.
+    /// </summary>
+    /// <remarks>
+    /// This playable is used to control other PlayableDirector components from a Timeline sequence.
+    /// </remarks>
+    public class DirectorControlPlayable : PlayableBehaviour
+    {
+        /// <summary>
+        /// The PlayableDirector being controlled by this PlayableBehaviour
+        /// </summary>
+        public PlayableDirector director;
+
+        private bool m_SyncTime = false;
+
+        private double m_AssetDuration = double.MaxValue;
+
+        /// <summary>
+        /// Creates a Playable with a DirectorControlPlayable attached
+        /// </summary>
+        /// <param name="graph">The graph to inject the playable into</param>
+        /// <param name="director">The director to control</param>
+        /// <returns>Returns a Playable with a DirectorControlPlayable attached</returns>
+        public static ScriptPlayable<DirectorControlPlayable> Create(PlayableGraph graph, PlayableDirector director)
+        {
+            if (director == null)
+                return ScriptPlayable<DirectorControlPlayable>.Null;
+
+            var handle = ScriptPlayable<DirectorControlPlayable>.Create(graph);
+            handle.GetBehaviour().director = director;
+
+#if UNITY_EDITOR
+            if (!Application.isPlaying && UnityEditor.PrefabUtility.IsPartOfPrefabInstance(director))
+                UnityEditor.PrefabUtility.prefabInstanceUpdated += handle.GetBehaviour().OnPrefabUpdated;
+#endif
+
+            return handle;
+        }
+
+        public override void OnPlayableDestroy(Playable playable)
+        {
+#if UNITY_EDITOR
+            if (!Application.isPlaying)
+                UnityEditor.PrefabUtility.prefabInstanceUpdated -= OnPrefabUpdated;
+#endif
+            if (director != null && director.playableAsset != null)
+                director.Stop();
+        }
+
+        /// <summary>
+        /// This function is called during the PrepareFrame phase of the PlayableGraph.
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void PrepareFrame(Playable playable, FrameData info)
+        {
+            if (director == null || !director.isActiveAndEnabled || director.playableAsset == null)
+                return;
+
+            // resync the time on an evaluate or a time jump (caused by loops, or some setTime calls)
+            m_SyncTime |= (info.evaluationType == FrameData.EvaluationType.Evaluate) ||
+                DetectDiscontinuity(playable, info);
+
+            SyncSpeed(info.effectiveSpeed);
+            SyncPlayState(playable.GetGraph(), playable.GetTime());
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to Playables.PlayState.Playing.
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPlay(Playable playable, FrameData info)
+        {
+            m_SyncTime = true;
+
+            if (director != null && director.playableAsset != null)
+                m_AssetDuration = director.playableAsset.duration;
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to PlayState.Paused.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPause(Playable playable, FrameData info)
+        {
+            if (director != null && director.playableAsset != null)
+            {
+                if (info.effectivePlayState == PlayState.Playing) // graph was paused
+                    director.Pause();
+                else
+                    director.Stop();
+            }
+        }
+
+        /// <summary>
+        /// This function is called during the ProcessFrame phase of the PlayableGraph.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        /// <param name="playerData">unused</param>
+        public override void ProcessFrame(Playable playable, FrameData info, object playerData)
+        {
+            if (director == null || !director.isActiveAndEnabled || director.playableAsset == null)
+                return;
+
+            if (m_SyncTime || DetectOutOfSync(playable))
+            {
+                UpdateTime(playable);
+                director.Evaluate();
+            }
+
+            m_SyncTime = false;
+        }
+
+#if UNITY_EDITOR
+        void OnPrefabUpdated(GameObject go)
+        {
+            // When the prefab asset is updated, we rebuild the graph to reflect the changes in editor
+            if (UnityEditor.PrefabUtility.GetRootGameObject(director) == go)
+                director.RebuildGraph();
+        }
+
+#endif
+
+        void SyncSpeed(double speed)
+        {
+            if (director.playableGraph.IsValid())
+            {
+                int roots = director.playableGraph.GetRootPlayableCount();
+                for (int i = 0; i < roots; i++)
+                {
+                    var rootPlayable = director.playableGraph.GetRootPlayable(i);
+                    if (rootPlayable.IsValid())
+                    {
+                        rootPlayable.SetSpeed(speed);
+                    }
+                }
+            }
+        }
+
+        void SyncPlayState(PlayableGraph graph, double playableTime)
+        {
+            bool expectedFinished = (playableTime >= m_AssetDuration) && director.extrapolationMode == DirectorWrapMode.None;
+            if (graph.IsPlaying() && !expectedFinished)
+                director.Play();
+            else
+                director.Pause();
+        }
+
+        bool DetectDiscontinuity(Playable playable, FrameData info)
+        {
+            return Math.Abs(playable.GetTime() - playable.GetPreviousTime() - info.m_DeltaTime * info.m_EffectiveSpeed) > DiscreteTime.tickValue;
+        }
+
+        bool DetectOutOfSync(Playable playable)
+        {
+            double expectedTime = playable.GetTime();
+            if (playable.GetTime() >= m_AssetDuration)
+            {
+                if (director.extrapolationMode == DirectorWrapMode.None)
+                    return false;
+                else if (director.extrapolationMode == DirectorWrapMode.Hold)
+                    expectedTime = m_AssetDuration;
+                else if (m_AssetDuration > float.Epsilon) // loop
+                    expectedTime = expectedTime % m_AssetDuration;
+            }
+
+            if (!Mathf.Approximately((float)expectedTime, (float)director.time))
+            {
+#if UNITY_EDITOR
+                double lastDelta = playable.GetTime() - playable.GetPreviousTime();
+                if (UnityEditor.Unsupported.IsDeveloperBuild())
+                    Debug.LogWarningFormat("Internal Warning - Control track desync detected on {2} ({0:F10} vs {1:F10} with delta {3:F10}). Time will be resynchronized. Known to happen with nested control tracks", playable.GetTime(), director.time, director.name, lastDelta);
+#endif
+                return true;
+            }
+            return false;
+        }
+
+        // We need to handle loop modes explicitly since we are setting the time directly
+        void UpdateTime(Playable playable)
+        {
+            double duration = Math.Max(0.1, director.playableAsset.duration);
+            switch (director.extrapolationMode)
+            {
+                case DirectorWrapMode.Hold:
+                    director.time = Math.Min(duration, Math.Max(0, playable.GetTime()));
+                    break;
+                case DirectorWrapMode.Loop:
+                    director.time = Math.Max(0, playable.GetTime() % duration);
+                    break;
+                case DirectorWrapMode.None:
+                    director.time = playable.GetTime();
+                    break;
+            }
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/DirectorControlPlayable.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/DirectorControlPlayable.cs.meta
new file mode 100644
index 0000000..5f71a6f
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/DirectorControlPlayable.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: be156cc527d606b4aaac403e9843186e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ITimeControl.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ITimeControl.cs
new file mode 100644
index 0000000..5d986ae
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ITimeControl.cs
@@ -0,0 +1,27 @@
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Interface that can be implemented by MonoBehaviours indicating that they receive time-related control calls from a PlayableGraph.
+    /// </summary>
+    /// <remarks>
+    /// Implementing this interface on MonoBehaviours attached to GameObjects under control by control-tracks will cause them to be notified when associated Timeline clips are active.
+    /// </remarks>
+    public interface ITimeControl
+    {
+        /// <summary>
+        /// Called each frame the Timeline clip is active.
+        /// </summary>
+        /// <param name="time">The local time of the associated Timeline clip.</param>
+        void SetTime(double time);
+
+        /// <summary>
+        /// Called when the associated Timeline clip becomes active.
+        /// </summary>
+        void OnControlTimeStart();
+
+        /// <summary>
+        /// Called when the associated Timeline clip becomes deactivated.
+        /// </summary>
+        void OnControlTimeStop();
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ITimeControl.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ITimeControl.cs.meta
new file mode 100644
index 0000000..8d4a953
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ITimeControl.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5415c904c4fbc3e498253bc2866b37cd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/NotificationFlags.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/NotificationFlags.cs
new file mode 100644
index 0000000..a83fc8b
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/NotificationFlags.cs
@@ -0,0 +1,31 @@
+using System;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Use these flags to specify the notification behaviour.
+    /// </summary>
+    /// <see cref="UnityEngine.Playables.INotification"/>
+    [Flags]
+    [Serializable]
+    public enum NotificationFlags : short
+    {
+        /// <summary>
+        /// Use this flag to send the notification in Edit Mode.
+        /// </summary>
+        /// <remarks>
+        /// Sent on discontinuous jumps in time.
+        /// </remarks>
+        TriggerInEditMode = 1 << 0,
+
+        /// <summary>
+        /// Use this flag to send the notification if playback starts after the notification time.
+        /// </summary>
+        Retroactive = 1 << 1,
+
+        /// <summary>
+        /// Use this flag to send the notification only once when looping.
+        /// </summary>
+        TriggerOnce = 1 << 2,
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/NotificationFlags.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/NotificationFlags.cs.meta
new file mode 100644
index 0000000..4eae696
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/NotificationFlags.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 983c76d87fb6f4f4597a526a4b2b5fd7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ParticleControlPlayable.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ParticleControlPlayable.cs
new file mode 100644
index 0000000..a513d7c
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ParticleControlPlayable.cs
@@ -0,0 +1,177 @@
+using System;
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Playable that synchronizes a particle system simulation.
+    /// </summary>
+    public class ParticleControlPlayable : PlayableBehaviour
+    {
+        const float kUnsetTime = -1;
+        float m_LastTime = kUnsetTime;
+        uint m_RandomSeed = 1;
+
+        // particleSystem.time can not be relied on for an accurate time. It does not advance until a delta threshold is reached(fixedUpdate) and until the start delay has elapsed.
+        float m_SystemTime;
+
+        /// <summary>
+        /// Creates a Playable with a ParticleControlPlayable behaviour attached
+        /// </summary>
+        /// <param name="graph">The PlayableGraph to inject the Playable into.</param>
+        /// <param name="component">The particle systtem to control</param>
+        /// <param name="randomSeed">A random seed to use for particle simulation</param>
+        /// <returns>Returns the created Playable.</returns>
+        public static ScriptPlayable<ParticleControlPlayable> Create(PlayableGraph graph, ParticleSystem component, uint randomSeed)
+        {
+            if (component == null)
+                return ScriptPlayable<ParticleControlPlayable>.Null;
+
+            var handle = ScriptPlayable<ParticleControlPlayable>.Create(graph);
+            handle.GetBehaviour().Initialize(component, randomSeed);
+            return handle;
+        }
+
+        /// <summary>
+        /// The particle system to control
+        /// </summary>
+        public ParticleSystem particleSystem { get; private set; }
+
+        /// <summary>
+        /// Initializes the behaviour with a particle system and random seed.
+        /// </summary>
+        /// <param name="ps"></param>
+        /// <param name="randomSeed"></param>
+        public void Initialize(ParticleSystem ps, uint randomSeed)
+        {
+            m_RandomSeed = Math.Max(1, randomSeed);
+            particleSystem = ps;
+            m_SystemTime = 0;
+            SetRandomSeed();
+
+            #if UNITY_EDITOR
+            if (!Application.isPlaying && UnityEditor.PrefabUtility.IsPartOfPrefabInstance(ps))
+                UnityEditor.PrefabUtility.prefabInstanceUpdated += OnPrefabUpdated;
+            #endif
+        }
+
+        #if UNITY_EDITOR
+        /// <summary>
+        /// This function is called when the Playable that owns the PlayableBehaviour is destroyed.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        public override void OnPlayableDestroy(Playable playable)
+        {
+            if (!Application.isPlaying)
+                UnityEditor.PrefabUtility.prefabInstanceUpdated -= OnPrefabUpdated;
+        }
+
+        void OnPrefabUpdated(GameObject go)
+        {
+            // When the instance is updated from, this will cause the next evaluate to resimulate.
+            if (UnityEditor.PrefabUtility.GetRootGameObject(particleSystem) == go)
+                m_LastTime = kUnsetTime;
+        }
+
+        #endif
+
+        void SetRandomSeed()
+        {
+            particleSystem.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
+            var systems = particleSystem.gameObject.GetComponentsInChildren<ParticleSystem>();
+            uint seed = m_RandomSeed;
+            foreach (var ps in systems)
+            {
+                // don't overwrite user set random seeds
+                if (ps.useAutoRandomSeed)
+                {
+                    ps.useAutoRandomSeed = false;
+                    ps.randomSeed = seed;
+                    seed++;
+                }
+            }
+        }
+
+        /// <summary>
+        /// This function is called during the PrepareFrame phase of the PlayableGraph.
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="data">A FrameData structure that contains information about the current frame context.</param>
+        public override void PrepareFrame(Playable playable, FrameData data)
+        {
+            if (particleSystem == null || !particleSystem.gameObject.activeInHierarchy)
+                return;
+
+            float localTime = (float)playable.GetTime();
+            bool shouldUpdate = Mathf.Approximately(m_LastTime, kUnsetTime) ||
+                !Mathf.Approximately(m_LastTime, localTime);
+            if (shouldUpdate)
+            {
+                float epsilon = Time.fixedDeltaTime * 0.5f;
+                float simTime = localTime;
+                float expectedDelta = simTime - m_LastTime;
+
+                //  The first iteration includes the start delay. Evaluate(particleSystem.randomSeed) is how the particle system generates the random value internally.
+                float startDelay = particleSystem.main.startDelay.Evaluate(particleSystem.randomSeed);
+                float particleSystemDurationLoop0 = particleSystem.main.duration + startDelay;
+
+                // The particle system time does not include the start delay so we need to remove this for our own system time.
+                float expectedSystemTime = simTime > particleSystemDurationLoop0 ? m_SystemTime : m_SystemTime - startDelay;
+
+                // if it's not looping, then the system time won't advance past the end of the duration
+                if (!particleSystem.main.loop)
+                    expectedSystemTime = Math.Min(expectedSystemTime, particleSystem.main.duration);
+
+
+                // conditions for restart
+                bool restart = (simTime < m_LastTime) || // time went backwards
+                    (simTime < epsilon) || // time is set to 0
+                    Mathf.Approximately(m_LastTime, kUnsetTime) || // object disabled
+                    (expectedDelta > particleSystem.main.duration) || // large jump (bug workaround)
+                    !(Mathf.Abs(expectedSystemTime - particleSystem.time) < Time.maximumParticleDeltaTime); // particle system isn't where we left it
+                if (restart)
+                {
+                    // work around for a bug where simulate(simTime, true, true) doesn't work on loops
+                    particleSystem.Simulate(0, true, true);
+                    particleSystem.Simulate(simTime, true, false);
+                    m_SystemTime = simTime;
+                }
+                else
+                {
+                    // ps.time will wrap, so we need to account for that in computing delta time
+                    float particleSystemDuration = simTime > particleSystemDurationLoop0 ? particleSystem.main.duration : particleSystemDurationLoop0;
+                    float fracTime = simTime % particleSystemDuration;
+                    float deltaTime = fracTime - m_SystemTime;
+
+                    if (deltaTime < -epsilon) // detect wrapping of ps.time
+                        deltaTime = fracTime + particleSystemDurationLoop0 - m_SystemTime;
+
+                    particleSystem.Simulate(deltaTime, true, false);
+                    m_SystemTime += deltaTime;
+                }
+
+                m_LastTime = localTime;
+            }
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to Playables.PlayState.Playing.
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPlay(Playable playable, FrameData info)
+        {
+            m_LastTime = kUnsetTime;
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to PlayState.Paused.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPause(Playable playable, FrameData info)
+        {
+            m_LastTime = kUnsetTime;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ParticleControlPlayable.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ParticleControlPlayable.cs.meta
new file mode 100644
index 0000000..33db5b9
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/ParticleControlPlayable.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f603edd7163537f44927ad2808147a25
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/PrefabControlPlayable.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/PrefabControlPlayable.cs
new file mode 100644
index 0000000..f84c9ff
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/PrefabControlPlayable.cs
@@ -0,0 +1,158 @@
+using System;
+using UnityEngine.Playables;
+using UnityEngine.SceneManagement;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Playable that controls and instantiates a Prefab.
+    /// </summary>
+    public class PrefabControlPlayable : PlayableBehaviour
+    {
+        GameObject m_Instance;
+
+#if UNITY_EDITOR
+        private bool m_IsActiveCached;
+#endif
+
+        /// <summary>
+        /// Creates a Playable with a PrefabControlPlayable behaviour attached
+        /// </summary>
+        /// <param name="graph">The PlayableGraph to inject the Playable into.</param>
+        /// <param name="prefabGameObject">The prefab to instantiate from</param>
+        /// <param name="parentTransform">Transform to parent instance to. Can be null.</param>
+        /// <returns>Returns a Playabe with PrefabControlPlayable behaviour attached.</returns>
+        public static ScriptPlayable<PrefabControlPlayable> Create(PlayableGraph graph, GameObject prefabGameObject, Transform parentTransform)
+        {
+            if (prefabGameObject == null)
+                return ScriptPlayable<PrefabControlPlayable>.Null;
+
+            var handle = ScriptPlayable<PrefabControlPlayable>.Create(graph);
+            handle.GetBehaviour().Initialize(prefabGameObject, parentTransform);
+            return handle;
+        }
+
+        /// <summary>
+        /// The instance of the prefab created by this behaviour
+        /// </summary>
+        public GameObject prefabInstance
+        {
+            get { return m_Instance; }
+        }
+
+        /// <summary>
+        /// Initializes the behaviour with a prefab and parent transform
+        /// </summary>
+        /// <param name="prefabGameObject">The prefab to instantiate from</param>
+        /// <param name="parentTransform">Transform to parent instance to. Can be null.</param>
+        /// <returns>The created instance</returns>
+        public GameObject Initialize(GameObject prefabGameObject, Transform parentTransform)
+        {
+            if (prefabGameObject == null)
+                throw new ArgumentNullException("Prefab cannot be null");
+
+            if (m_Instance != null)
+            {
+                Debug.LogWarningFormat("Prefab Control Playable ({0}) has already been initialized with a Prefab ({1}).", prefabGameObject.name, m_Instance.name);
+            }
+            else
+            {
+                #if UNITY_EDITOR
+                if (!Application.isPlaying)
+                {
+                    m_Instance = (GameObject)UnityEditor.PrefabUtility.InstantiatePrefab(prefabGameObject, parentTransform);
+                    UnityEditor.PrefabUtility.prefabInstanceUpdated += OnPrefabUpdated;
+                }
+                else
+                #endif
+                {
+                    m_Instance = Object.Instantiate(prefabGameObject, parentTransform, false);
+                }
+                m_Instance.name = prefabGameObject.name + " [Timeline]";
+                m_Instance.SetActive(false);
+                SetHideFlagsRecursive(m_Instance);
+            }
+            return m_Instance;
+        }
+
+        /// <summary>
+        /// This function is called when the Playable that owns the PlayableBehaviour is destroyed.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        public override void OnPlayableDestroy(Playable playable)
+        {
+            if (m_Instance)
+            {
+                if (Application.isPlaying)
+                    Object.Destroy(m_Instance);
+                else
+                    Object.DestroyImmediate(m_Instance);
+            }
+
+#if UNITY_EDITOR
+            UnityEditor.PrefabUtility.prefabInstanceUpdated -= OnPrefabUpdated;
+#endif
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to Playables.PlayState.Playing.
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPlay(Playable playable, FrameData info)
+        {
+            if (m_Instance == null)
+                return;
+
+            m_Instance.SetActive(true);
+
+#if UNITY_EDITOR
+            m_IsActiveCached = true;
+#endif
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to PlayState.Paused.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPause(Playable playable, FrameData info)
+        {
+            // OnBehaviourPause can be called if the graph is stopped for a variety of reasons
+            //  the effectivePlayState will test if the pause is due to the clip being out of bounds
+            if (m_Instance != null && info.effectivePlayState == PlayState.Paused)
+            {
+                m_Instance.SetActive(false);
+#if UNITY_EDITOR
+                m_IsActiveCached = false;
+#endif
+            }
+        }
+
+#if UNITY_EDITOR
+        void OnPrefabUpdated(GameObject go)
+        {
+            if (go == m_Instance)
+            {
+                SetHideFlagsRecursive(go);
+                go.SetActive(m_IsActiveCached);
+            }
+        }
+
+#endif
+
+        static void SetHideFlagsRecursive(GameObject gameObject)
+        {
+            if (gameObject == null)
+                return;
+
+            gameObject.hideFlags = HideFlags.DontSaveInBuild | HideFlags.DontSaveInEditor;
+            if (!Application.isPlaying)
+                gameObject.hideFlags |= HideFlags.HideInHierarchy;
+            foreach (Transform child in gameObject.transform)
+            {
+                SetHideFlagsRecursive(child.gameObject);
+            }
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/PrefabControlPlayable.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/PrefabControlPlayable.cs.meta
new file mode 100644
index 0000000..c148dc2
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/PrefabControlPlayable.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 439c018cf4619e94d9a92110ce0aa188
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeControlPlayable.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeControlPlayable.cs
new file mode 100644
index 0000000..68ec80d
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeControlPlayable.cs
@@ -0,0 +1,85 @@
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// A PlayableBehaviour that manages a component that implements the ITimeControl interface
+    /// </summary>
+    public class TimeControlPlayable : PlayableBehaviour
+    {
+        ITimeControl m_timeControl;
+
+        bool m_started;
+
+        /// <summary>
+        /// Creates a Playable with a TimeControlPlayable behaviour attached
+        /// </summary>
+        /// <param name="graph">The PlayableGraph to inject the Playable into.</param>
+        /// <param name="timeControl"></param>
+        /// <returns></returns>
+        public static ScriptPlayable<TimeControlPlayable> Create(PlayableGraph graph, ITimeControl timeControl)
+        {
+            if (timeControl == null)
+                return ScriptPlayable<TimeControlPlayable>.Null;
+
+            var handle = ScriptPlayable<TimeControlPlayable>.Create(graph);
+            handle.GetBehaviour().Initialize(timeControl);
+            return handle;
+        }
+
+        /// <summary>
+        /// Initializes the behaviour
+        /// </summary>
+        /// <param name="timeControl">Component that implements the ITimeControl interface</param>
+        public void Initialize(ITimeControl timeControl)
+        {
+            m_timeControl = timeControl;
+        }
+
+        /// <summary>
+        /// This function is called during the PrepareFrame phase of the PlayableGraph.
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void PrepareFrame(Playable playable, FrameData info)
+        {
+            Debug.Assert(m_started, "PrepareFrame has been called without OnControlTimeStart being called first.");
+            if (m_timeControl != null)
+                m_timeControl.SetTime(playable.GetTime());
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to Playables.PlayState.Playing.
+        /// </summary>
+        /// <param name="playable">The Playable that owns the current PlayableBehaviour.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPlay(Playable playable, FrameData info)
+        {
+            if (m_timeControl == null)
+                return;
+
+            if (!m_started)
+            {
+                m_timeControl.OnControlTimeStart();
+                m_started = true;
+            }
+        }
+
+        /// <summary>
+        /// This function is called when the Playable play state is changed to PlayState.Paused.
+        /// </summary>
+        /// <param name="playable">The playable this behaviour is attached to.</param>
+        /// <param name="info">A FrameData structure that contains information about the current frame context.</param>
+        public override void OnBehaviourPause(Playable playable, FrameData info)
+        {
+            if (m_timeControl == null)
+                return;
+
+            if (m_started)
+            {
+                m_timeControl.OnControlTimeStop();
+                m_started = false;
+            }
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeControlPlayable.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeControlPlayable.cs.meta
new file mode 100644
index 0000000..5ce09ad
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeControlPlayable.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1db879070d9a45f4c86cdf5e59616df5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeNotificationBehaviour.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeNotificationBehaviour.cs
new file mode 100644
index 0000000..66a31d1
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeNotificationBehaviour.cs
@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Use this PlayableBehaviour to send notifications at a given time.
+    /// </summary>
+    /// <seealso cref="UnityEngine.Timeline.NotificationFlags"/>
+    public class TimeNotificationBehaviour : PlayableBehaviour
+    {
+        struct NotificationEntry
+        {
+            public double time;
+            public INotification payload;
+            public bool notificationFired;
+            public NotificationFlags flags;
+
+            public bool triggerInEditor
+            {
+                get { return (flags & NotificationFlags.TriggerInEditMode) != 0; }
+            }
+            public bool prewarm
+            {
+                get { return (flags & NotificationFlags.Retroactive) != 0; }
+            }
+            public bool triggerOnce
+            {
+                get { return (flags & NotificationFlags.TriggerOnce) != 0; }
+            }
+        }
+
+        readonly List<NotificationEntry> m_Notifications = new List<NotificationEntry>();
+        double m_PreviousTime;
+        bool m_NeedSortNotifications;
+
+        Playable m_TimeSource;
+
+        /// <summary>
+        /// Sets an optional Playable that provides duration and Wrap mode information.
+        /// </summary>
+        /// <remarks>
+        /// timeSource is optional. By default, the duration and Wrap mode will come from the current Playable.
+        /// </remarks>
+        public Playable timeSource
+        {
+            set { m_TimeSource = value; }
+        }
+
+        /// <summary>
+        /// Creates and initializes a ScriptPlayable with a TimeNotificationBehaviour.
+        /// </summary>
+        /// <param name="graph">The playable graph.</param>
+        /// <param name="duration">The duration of the playable.</param>
+        /// <param name="loopMode">The loop mode of the playable.</param>
+        /// <returns>A new TimeNotificationBehaviour linked to the PlayableGraph.</returns>
+        public static ScriptPlayable<TimeNotificationBehaviour> Create(PlayableGraph graph, double duration, DirectorWrapMode loopMode)
+        {
+            var notificationsPlayable = ScriptPlayable<TimeNotificationBehaviour>.Create(graph);
+            notificationsPlayable.SetDuration(duration);
+            notificationsPlayable.SetTimeWrapMode(loopMode);
+            notificationsPlayable.SetPropagateSetTime(true);
+            return notificationsPlayable;
+        }
+
+        /// <summary>
+        /// Adds a notification to be sent with flags, at a specific time.
+        /// </summary>
+        /// <param name="time">The time to send the notification.</param>
+        /// <param name="payload">The notification.</param>
+        /// <param name="flags">The notification flags that determine the notification behaviour. This parameter is set to Retroactive by default.</param>
+        /// <seealso cref="UnityEngine.Timeline.NotificationFlags"/>
+        public void AddNotification(double time, INotification payload, NotificationFlags flags = NotificationFlags.Retroactive)
+        {
+            m_Notifications.Add(new NotificationEntry
+            {
+                time = time,
+                payload = payload,
+                flags = flags
+            });
+            m_NeedSortNotifications = true;
+        }
+
+        /// <summary>
+        /// This method is called when the PlayableGraph that owns this PlayableBehaviour starts.
+        /// </summary>
+        /// <param name="playable">The reference to the playable associated with this PlayableBehaviour.</param>
+        public override void OnGraphStart(Playable playable)
+        {
+            SortNotifications();
+            for (var i = 0; i < m_Notifications.Count; i++)
+            {
+                var notification = m_Notifications[i];
+                notification.notificationFired = false;
+                m_Notifications[i] = notification;
+            }
+
+            m_PreviousTime = playable.GetTime();
+        }
+
+        /// <summary>
+        /// This method is called when the Playable play state is changed to PlayState.Paused
+        /// </summary>
+        /// <param name="playable">The reference to the playable associated with this PlayableBehaviour.</param>
+        /// <param name="info">Playable context information such as weight, evaluationType, and so on.</param>
+        public override void OnBehaviourPause(Playable playable, FrameData info)
+        {
+            if (playable.IsDone())
+            {
+                SortNotifications();
+                for (var i = 0; i < m_Notifications.Count; i++)
+                {
+                    var e = m_Notifications[i];
+                    if (!e.notificationFired)
+                    {
+                        var duration = playable.GetDuration();
+                        var canTrigger = m_PreviousTime <= e.time && e.time <= duration;
+                        if (canTrigger)
+                        {
+                            Trigger_internal(playable, info.output, ref e);
+                            m_Notifications[i] = e;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// This method is called during the PrepareFrame phase of the PlayableGraph.
+        /// </summary>
+        /// <remarks>
+        /// Called once before processing starts.
+        /// </remarks>
+        /// <param name="playable">The reference to the playable associated with this PlayableBehaviour.</param>
+        /// <param name="info">Playable context information such as weight, evaluationType, and so on.</param>
+        public override void PrepareFrame(Playable playable, FrameData info)
+        {
+            // Never trigger on scrub
+            if (info.evaluationType == FrameData.EvaluationType.Evaluate)
+            {
+                return;
+            }
+
+            SyncDurationWithExternalSource(playable);
+            SortNotifications();
+            var currentTime = playable.GetTime();
+
+            // Fire notifications from previousTime till the end
+            if (info.timeLooped)
+            {
+                var duration = playable.GetDuration();
+                TriggerNotificationsInRange(m_PreviousTime, duration, info, playable, true);
+                var dx = playable.GetDuration() - m_PreviousTime;
+                var nFullTimelines = (int)((info.deltaTime * info.effectiveSpeed - dx) / playable.GetDuration());
+                for (var i = 0; i < nFullTimelines; i++)
+                {
+                    TriggerNotificationsInRange(0, duration, info, playable, false);
+                }
+                TriggerNotificationsInRange(0, currentTime, info, playable, false);
+            }
+            else
+            {
+                var pt = playable.GetTime();
+                TriggerNotificationsInRange(m_PreviousTime, pt, info,
+                    playable, true);
+            }
+
+            for (var i = 0; i < m_Notifications.Count; ++i)
+            {
+                var e = m_Notifications[i];
+                if (e.notificationFired && CanRestoreNotification(e, info, currentTime, m_PreviousTime))
+                {
+                    Restore_internal(ref e);
+                    m_Notifications[i] = e;
+                }
+            }
+
+            m_PreviousTime = playable.GetTime();
+        }
+
+        void SortNotifications()
+        {
+            if (m_NeedSortNotifications)
+            {
+                m_Notifications.Sort((x, y) => x.time.CompareTo(y.time));
+                m_NeedSortNotifications = false;
+            }
+        }
+
+        static bool CanRestoreNotification(NotificationEntry e, FrameData info, double currentTime, double previousTime)
+        {
+            if (e.triggerOnce)
+                return false;
+            if (info.timeLooped)
+                return true;
+
+            //case 1111595: restore the notification if the time is manually set before it
+            return previousTime > currentTime && currentTime <= e.time;
+        }
+
+        void TriggerNotificationsInRange(double start, double end, FrameData info, Playable playable, bool checkState)
+        {
+            if (start <= end)
+            {
+                var playMode = Application.isPlaying;
+                for (var i = 0; i < m_Notifications.Count; i++)
+                {
+                    var e = m_Notifications[i];
+                    if (e.notificationFired && (checkState || e.triggerOnce))
+                        continue;
+
+                    var notificationTime = e.time;
+                    if (e.prewarm && notificationTime < end && (e.triggerInEditor || playMode))
+                    {
+                        Trigger_internal(playable, info.output, ref e);
+                        m_Notifications[i] = e;
+                    }
+                    else
+                    {
+                        if (notificationTime < start || notificationTime > end)
+                            continue;
+
+                        if (e.triggerInEditor || playMode)
+                        {
+                            Trigger_internal(playable, info.output, ref e);
+                            m_Notifications[i] = e;
+                        }
+                    }
+                }
+            }
+        }
+
+        void SyncDurationWithExternalSource(Playable playable)
+        {
+            if (m_TimeSource.IsValid())
+            {
+                playable.SetDuration(m_TimeSource.GetDuration());
+                playable.SetTimeWrapMode(m_TimeSource.GetTimeWrapMode());
+            }
+        }
+
+        static void Trigger_internal(Playable playable, PlayableOutput output,  ref NotificationEntry e)
+        {
+            output.PushNotification(playable, e.payload);
+            e.notificationFired = true;
+        }
+
+        static void Restore_internal(ref NotificationEntry e)
+        {
+            e.notificationFired = false;
+        }
+    }
+}
diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeNotificationBehaviour.cs.meta b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeNotificationBehaviour.cs.meta
new file mode 100644
index 0000000..593b6c2
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Playables/TimeNotificationBehaviour.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: afeb55855d7a63b45ba6f8bd97599202
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: