Inital commit

1 files changed, 406 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Control/ControlPlayableAsset.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Control/ControlPlayableAsset.cs
new file mode 100644
index 0000000..fd806f6
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/Control/ControlPlayableAsset.cs
@@ -0,0 +1,406 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Playables;
+
+namespace UnityEngine.Timeline
+{
+    /// <summary>
+    /// Playable Asset that generates playables for controlling time-related elements on a GameObject.
+    /// </summary>
+    [Serializable]
+    [NotKeyable]
+    public class ControlPlayableAsset : PlayableAsset, IPropertyPreview, ITimelineClipAsset
+    {
+        const int k_MaxRandInt = 10000;
+        static readonly List<PlayableDirector> k_EmptyDirectorsList = new List<PlayableDirector>(0);
+        static readonly List<ParticleSystem> k_EmptyParticlesList = new List<ParticleSystem>(0);
+
+        /// <summary>
+        /// GameObject in the scene to control, or the parent of the instantiated prefab.
+        /// </summary>
+        [SerializeField] public ExposedReference<GameObject> sourceGameObject;
+
+        /// <summary>
+        /// Prefab object that will be instantiated.
+        /// </summary>
+        [SerializeField] public GameObject prefabGameObject;
+
+        /// <summary>
+        /// Indicates whether Particle Systems will be controlled.
+        /// </summary>
+        [SerializeField] public bool updateParticle = true;
+
+        /// <summary>
+        /// Random seed to supply particle systems that are set to use autoRandomSeed
+        /// </summary>
+        /// <remarks>
+        /// This is used to maintain determinism when playing back in timeline. Sub emitters will be assigned incrementing random seeds to maintain determinism and distinction.
+        /// </remarks>
+        [SerializeField] public uint particleRandomSeed;
+
+        /// <summary>
+        /// Indicates whether playableDirectors are controlled.
+        /// </summary>
+        [SerializeField] public bool updateDirector = true;
+
+        /// <summary>
+        /// Indicates whether Monobehaviours implementing ITimeControl will be controlled.
+        /// </summary>
+        [SerializeField] public bool updateITimeControl = true;
+
+        /// <summary>
+        /// Indicates whether to search the entire hierarchy for controllable components.
+        /// </summary>
+        [SerializeField] public bool searchHierarchy = false;
+
+        /// <summary>
+        /// Indicate whether GameObject activation is controlled
+        /// </summary>
+        [SerializeField] public bool active = true;
+
+        /// <summary>
+        /// Indicates the active state of the GameObject when Timeline is stopped.
+        /// </summary>
+        [SerializeField] public ActivationControlPlayable.PostPlaybackState postPlayback = ActivationControlPlayable.PostPlaybackState.Revert;
+
+        PlayableAsset m_ControlDirectorAsset;
+        double m_Duration = PlayableBinding.DefaultDuration;
+        bool m_SupportLoop;
+
+        private static HashSet<PlayableDirector> s_ProcessedDirectors = new HashSet<PlayableDirector>();
+        private static HashSet<GameObject> s_CreatedPrefabs = new HashSet<GameObject>();
+
+        // does the last instance created control directors and/or particles
+        internal bool controllingDirectors { get; private set; }
+        internal bool controllingParticles { get; private set; }
+
+        /// <summary>
+        /// This function is called when the object is loaded.
+        /// </summary>
+        public void OnEnable()
+        {
+            // can't be set in a constructor
+            if (particleRandomSeed == 0)
+                particleRandomSeed = (uint)Random.Range(1, k_MaxRandInt);
+        }
+
+        /// <summary>
+        /// Returns the duration in seconds needed to play the underlying director or particle system exactly once.
+        /// </summary>
+        public override double duration { get { return m_Duration; } }
+
+        /// <summary>
+        /// Returns the capabilities of TimelineClips that contain a ControlPlayableAsset
+        /// </summary>
+        public ClipCaps clipCaps
+        {
+            get { return ClipCaps.ClipIn | ClipCaps.SpeedMultiplier | (m_SupportLoop ? ClipCaps.Looping : ClipCaps.None); }
+        }
+
+        /// <summary>
+        /// Creates the root of a Playable subgraph to control the contents of the game object.
+        /// </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 subgraph</returns>
+        public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
+        {
+            // case 989856
+            if (prefabGameObject != null)
+            {
+                if (s_CreatedPrefabs.Contains(prefabGameObject))
+                {
+                    Debug.LogWarningFormat("Control Track Clip ({0}) is causing a prefab to instantiate itself recursively. Aborting further instances.", name);
+                    return Playable.Create(graph);
+                }
+                s_CreatedPrefabs.Add(prefabGameObject);
+            }
+
+            Playable root = Playable.Null;
+            var playables = new List<Playable>();
+
+            GameObject sourceObject = sourceGameObject.Resolve(graph.GetResolver());
+            if (prefabGameObject != null)
+            {
+                Transform parenTransform = sourceObject != null ? sourceObject.transform : null;
+                var controlPlayable = PrefabControlPlayable.Create(graph, prefabGameObject, parenTransform);
+
+                sourceObject = controlPlayable.GetBehaviour().prefabInstance;
+                playables.Add(controlPlayable);
+            }
+
+            m_Duration = PlayableBinding.DefaultDuration;
+            m_SupportLoop = false;
+
+            controllingParticles = false;
+            controllingDirectors = false;
+
+            if (sourceObject != null)
+            {
+                var directors = updateDirector ? GetComponent<PlayableDirector>(sourceObject) : k_EmptyDirectorsList;
+                var particleSystems = updateParticle ? GetParticleSystemRoots(sourceObject) : k_EmptyParticlesList;
+
+                // update the duration and loop values (used for UI purposes) here
+                // so they are tied to the latest gameObject bound
+                UpdateDurationAndLoopFlag(directors, particleSystems);
+
+                var director = go.GetComponent<PlayableDirector>();
+                if (director != null)
+                    m_ControlDirectorAsset = director.playableAsset;
+
+                if (go == sourceObject && prefabGameObject == null)
+                {
+                    Debug.LogWarningFormat("Control Playable ({0}) is referencing the same PlayableDirector component than the one in which it is playing.", name);
+                    active = false;
+                    if (!searchHierarchy)
+                        updateDirector = false;
+                }
+
+                if (active)
+                    CreateActivationPlayable(sourceObject, graph, playables);
+
+                if (updateDirector)
+                    SearchHierarchyAndConnectDirector(directors, graph, playables, prefabGameObject != null);
+
+                if (updateParticle)
+                    SearchHiearchyAndConnectParticleSystem(particleSystems, graph, playables);
+
+                if (updateITimeControl)
+                    SearchHierarchyAndConnectControlableScripts(GetControlableScripts(sourceObject), graph, playables);
+
+                // Connect Playables to Generic to Mixer
+                root = ConnectPlayablesToMixer(graph, playables);
+            }
+
+            if (prefabGameObject != null)
+                s_CreatedPrefabs.Remove(prefabGameObject);
+
+            if (!root.IsValid())
+                root = Playable.Create(graph);
+
+            return root;
+        }
+
+        static Playable ConnectPlayablesToMixer(PlayableGraph graph, List<Playable> playables)
+        {
+            var mixer = Playable.Create(graph, playables.Count);
+
+            for (int i = 0; i != playables.Count; ++i)
+            {
+                ConnectMixerAndPlayable(graph, mixer, playables[i], i);
+            }
+
+            mixer.SetPropagateSetTime(true);
+
+            return mixer;
+        }
+
+        void CreateActivationPlayable(GameObject root, PlayableGraph graph,
+            List<Playable> outplayables)
+        {
+            var activation = ActivationControlPlayable.Create(graph, root, postPlayback);
+            if (activation.IsValid())
+                outplayables.Add(activation);
+        }
+
+        void SearchHiearchyAndConnectParticleSystem(IEnumerable<ParticleSystem> particleSystems, PlayableGraph graph,
+            List<Playable> outplayables)
+        {
+            foreach (var particleSystem in particleSystems)
+            {
+                if (particleSystem != null)
+                {
+                    controllingParticles = true;
+                    outplayables.Add(ParticleControlPlayable.Create(graph, particleSystem, particleRandomSeed));
+                }
+            }
+        }
+
+        void SearchHierarchyAndConnectDirector(IEnumerable<PlayableDirector> directors, PlayableGraph graph,
+            List<Playable> outplayables, bool disableSelfReferences)
+        {
+            foreach (var director in directors)
+            {
+                if (director != null)
+                {
+                    if (director.playableAsset != m_ControlDirectorAsset)
+                    {
+                        outplayables.Add(DirectorControlPlayable.Create(graph, director));
+                        controllingDirectors = true;
+                    }
+                    // if this self references, disable the director.
+                    else if (disableSelfReferences)
+                    {
+                        director.enabled = false;
+                    }
+                }
+            }
+        }
+
+        static void SearchHierarchyAndConnectControlableScripts(IEnumerable<MonoBehaviour> controlableScripts, PlayableGraph graph, List<Playable> outplayables)
+        {
+            foreach (var script in controlableScripts)
+            {
+                outplayables.Add(TimeControlPlayable.Create(graph, (ITimeControl)script));
+            }
+        }
+
+        static void ConnectMixerAndPlayable(PlayableGraph graph, Playable mixer, Playable playable,
+            int portIndex)
+        {
+            graph.Connect(playable, 0, mixer, portIndex);
+            mixer.SetInputWeight(playable, 1.0f);
+        }
+
+        internal IList<T> GetComponent<T>(GameObject gameObject)
+        {
+            var components = new List<T>();
+            if (gameObject != null)
+            {
+                if (searchHierarchy)
+                {
+                    gameObject.GetComponentsInChildren<T>(true, components);
+                }
+                else
+                {
+                    gameObject.GetComponents<T>(components);
+                }
+            }
+            return components;
+        }
+
+        static IEnumerable<MonoBehaviour> GetControlableScripts(GameObject root)
+        {
+            if (root == null)
+                yield break;
+
+            foreach (var script in root.GetComponentsInChildren<MonoBehaviour>())
+            {
+                if (script is ITimeControl)
+                    yield return script;
+            }
+        }
+
+        internal void UpdateDurationAndLoopFlag(IList<PlayableDirector> directors, IList<ParticleSystem> particleSystems)
+        {
+            if (directors.Count == 0 && particleSystems.Count == 0)
+                return;
+
+            const double invalidDuration = double.NegativeInfinity;
+
+            var maxDuration = invalidDuration;
+            var supportsLoop = false;
+
+            foreach (var director in directors)
+            {
+                if (director.playableAsset != null)
+                {
+                    var assetDuration = director.playableAsset.duration;
+
+                    if (director.playableAsset is TimelineAsset && assetDuration > 0.0)
+                        // Timeline assets report being one tick shorter than they actually are, unless they are empty
+                        assetDuration = (double)((DiscreteTime)assetDuration).OneTickAfter();
+
+                    maxDuration = Math.Max(maxDuration, assetDuration);
+                    supportsLoop = supportsLoop || director.extrapolationMode == DirectorWrapMode.Loop;
+                }
+            }
+
+            foreach (var particleSystem in particleSystems)
+            {
+                maxDuration = Math.Max(maxDuration, particleSystem.main.duration);
+                supportsLoop = supportsLoop || particleSystem.main.loop;
+            }
+
+            m_Duration = double.IsNegativeInfinity(maxDuration) ? PlayableBinding.DefaultDuration : maxDuration;
+            m_SupportLoop = supportsLoop;
+        }
+
+        IList<ParticleSystem> GetParticleSystemRoots(GameObject go)
+        {
+            if (searchHierarchy)
+            {
+                // We only want the parent systems as they will handle all the child systems.
+                var roots = new List<ParticleSystem>();
+                GetParticleSystemRoots(go.transform, roots);
+                return roots;
+            }
+            return GetComponent<ParticleSystem>(go);
+        }
+
+        static void GetParticleSystemRoots(Transform t, ICollection<ParticleSystem> roots)
+        {
+            var ps = t.GetComponent<ParticleSystem>();
+            if (ps != null)
+            {
+                // its a root
+                roots.Add(ps);
+                return;
+            }
+
+            for (int i = 0; i < t.childCount; ++i)
+            {
+                GetParticleSystemRoots(t.GetChild(i), roots);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void GatherProperties(PlayableDirector director, IPropertyCollector driver)
+        {
+            if (director == null)
+                return;
+
+            // prevent infinite recursion
+            if (s_ProcessedDirectors.Contains(director))
+                return;
+            s_ProcessedDirectors.Add(director);
+
+            var gameObject = sourceGameObject.Resolve(director);
+            if (gameObject != null)
+            {
+                if (updateParticle)
+                {
+                    // case 1076850 -- drive all emitters, not just roots.
+                    foreach (var ps in gameObject.GetComponentsInChildren<ParticleSystem>(true))
+                    {
+                        driver.AddFromName<ParticleSystem>(ps.gameObject, "randomSeed");
+                        driver.AddFromName<ParticleSystem>(ps.gameObject, "autoRandomSeed");
+                    }
+                }
+
+                if (active)
+                {
+                    driver.AddFromName(gameObject, "m_IsActive");
+                }
+
+                if (updateITimeControl)
+                {
+                    foreach (var script in GetControlableScripts(gameObject))
+                    {
+                        var propertyPreview = script as IPropertyPreview;
+                        if (propertyPreview != null)
+                            propertyPreview.GatherProperties(director, driver);
+                        else
+                            driver.AddFromComponent(script.gameObject, script);
+                    }
+                }
+
+                if (updateDirector)
+                {
+                    foreach (var childDirector in GetComponent<PlayableDirector>(gameObject))
+                    {
+                        if (childDirector == null)
+                            continue;
+
+                        var timeline = childDirector.playableAsset as TimelineAsset;
+                        if (timeline == null)
+                            continue;
+
+                        timeline.GatherProperties(childDirector, driver);
+                    }
+                }
+            }
+            s_ProcessedDirectors.Remove(director);
+        }
+    }
+}