Unity-jump-proj

09.09 Less_unity/Library/PackageCache/com.unity.timeline@1.7.6/Editor/State/SequenceHierarchy.cs

@@ -0,0 +1,302 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+
+namespace UnityEditor.Timeline
+{
+    class SequenceHierarchy : ScriptableObject
+    {
+        readonly List<ISequenceState> m_Sequences = new List<ISequenceState>();
+
+        WindowState m_WindowState;
+
+        [SerializeField]
+        SequencePath m_SerializedPath;
+
+        public ISequenceState masterSequence
+        {
+            get { return m_Sequences.FirstOrDefault(); }
+        }
+
+        public ISequenceState editSequence
+        {
+            get { return m_Sequences.LastOrDefault(); }
+        }
+
+        public int count
+        {
+            get { return m_Sequences.Count; }
+        }
+
+        public IEnumerable<ISequenceState> allSequences
+        {
+            get { return m_Sequences; }
+        }
+
+        public static SequenceHierarchy CreateInstance()
+        {
+            var hierarchy = ScriptableObject.CreateInstance<SequenceHierarchy>();
+            hierarchy.hideFlags = HideFlags.HideAndDontSave;
+            return hierarchy;
+        }
+
+        public void Init(WindowState owner)
+        {
+            m_WindowState = owner;
+        }
+
+        // This is called when performing Undo operations.
+        // It needs to be called here since some operations are not
+        // allowed (EditorUtility.InstanceIDToObject, for example)
+        // during the ISerializationCallbackReceiver methods.
+        void OnValidate()
+        {
+            if (m_SerializedPath == null || m_WindowState == null || m_WindowState.GetWindow() == null)
+                return;
+
+            bool hasDifferentRoot = m_WindowState.GetCurrentSequencePath().selectionRoot != m_SerializedPath.selectionRoot;
+            if (m_WindowState.GetWindow().locked && hasDifferentRoot)
+                return;
+
+            EditorApplication.delayCall += () => { m_WindowState.SetCurrentSequencePath(m_SerializedPath, true); };
+        }
+
+        public void Add(TimelineAsset asset, PlayableDirector director, TimelineClip hostClip)
+        {
+            if (hostClip == null)
+                AddToCurrentUndoGroup(this); // Merge with selection undo
+            else
+                TimelineUndo.PushUndo(this, L10n.Tr("Edit Sub-Timeline"));
+
+            Add_Internal(asset, director, hostClip);
+
+            UpdateSerializedPath();
+        }
+
+        public void Remove()
+        {
+            if (m_Sequences.Count == 0) return;
+
+            TimelineUndo.PushUndo(this, L10n.Tr("Go to Sub-Timeline"));
+
+            Remove_Internal();
+
+            UpdateSerializedPath();
+        }
+
+        public ISequenceState GetStateAtIndex(int index)
+        {
+            return m_Sequences[index];
+        }
+
+        public void RemoveUntilCount(int expectedCount)
+        {
+            if (expectedCount < 0 || m_Sequences.Count <= expectedCount) return;
+
+            TimelineUndo.PushUndo(this, L10n.Tr("Go to Sub-Timeline"));
+
+            RemoveUntilCount_Internal(expectedCount);
+
+            UpdateSerializedPath();
+        }
+
+        public void Clear()
+        {
+            if (m_Sequences.Count == 0) return;
+
+            AddToCurrentUndoGroup(this);
+            Clear_Internal();
+            UpdateSerializedPath();
+        }
+
+        public SequencePath ToSequencePath()
+        {
+            var path = new SequencePath();
+
+            if (m_Sequences.Count == 0)
+                return path;
+
+            var rootSequence = m_Sequences[0];
+            var root = 0;
+            if (rootSequence.director != null && rootSequence.director.gameObject != null)
+                root = rootSequence.director.gameObject.GetInstanceID();
+            else if (rootSequence.asset != null)
+                root = rootSequence.asset.GetInstanceID();
+
+            path.SetSelectionRoot(root);
+
+            var resolver = rootSequence.director;
+
+            if (m_Sequences.Count > 1)
+            {
+                for (int i = 1, n = m_Sequences.Count; i < n; ++i)
+                {
+                    path.AddSubSequence(m_Sequences[i], resolver);
+                    resolver = m_Sequences[i].director;
+                }
+            }
+
+            return path;
+        }
+
+        public bool NeedsUpdate(SequencePath path, bool forceRebuild)
+        {
+            return forceRebuild || !SequencePath.AreEqual(m_SerializedPath, path);
+        }
+
+        public void FromSequencePath(SequencePath path, bool forceRebuild)
+        {
+            if (!NeedsUpdate(path, forceRebuild))
+                return;
+
+            Clear_Internal();
+
+            var rootObject = EditorUtility.InstanceIDToObject(path.selectionRoot);
+            if (rootObject == null)
+            {
+                UpdateSerializedPath();
+                return;
+            }
+
+            var candidateAsset = rootObject as TimelineAsset;
+            if (candidateAsset != null)
+            {
+                Add_Internal(candidateAsset, null, null);
+                UpdateSerializedPath();
+                return;
+            }
+
+            var candidateGameObject = rootObject as GameObject;
+            if (candidateGameObject == null)
+            {
+                UpdateSerializedPath();
+                return;
+            }
+
+            var director = TimelineUtility.GetDirectorComponentForGameObject(candidateGameObject);
+            var asset = TimelineUtility.GetTimelineAssetForDirectorComponent(director);
+            Add_Internal(asset, director, null);
+
+            if (!path.subElements.Any())
+            {
+                UpdateSerializedPath();
+                return;
+            }
+
+            List<SequenceBuildingBlock> buildingBlocks;
+            if (ValidateSubElements(path.subElements, director, out buildingBlocks))
+            {
+                foreach (var buildingBlock in buildingBlocks)
+                    Add_Internal(buildingBlock.asset, buildingBlock.director, buildingBlock.hostClip);
+            }
+
+            UpdateSerializedPath();
+        }
+
+        void Add_Internal(TimelineAsset asset, PlayableDirector director, TimelineClip hostClip)
+        {
+            if (hostClip == null)
+                Clear_Internal();
+
+            var parent = m_Sequences.Count > 0 ? editSequence : null;
+            m_Sequences.Add(new SequenceState(m_WindowState, asset, director, hostClip, (SequenceState)parent));
+        }
+
+        void Remove_Internal()
+        {
+            m_Sequences.Last().Dispose();
+            m_Sequences.RemoveAt(m_Sequences.Count - 1);
+        }
+
+        void RemoveUntilCount_Internal(int expectedCount)
+        {
+            while (m_Sequences.Count > expectedCount)
+            {
+                Remove_Internal();
+            }
+        }
+
+        void Clear_Internal()
+        {
+            RemoveUntilCount_Internal(0);
+        }
+
+        void UpdateSerializedPath()
+        {
+            m_SerializedPath = ToSequencePath();
+        }
+
+        static bool ValidateSubElements(List<SequencePathSubElement> subElements, PlayableDirector director, out List<SequenceBuildingBlock> buildingBlocks)
+        {
+            buildingBlocks = new List<SequenceBuildingBlock>(subElements.Count);
+            var currentDirector = director;
+
+            foreach (var element in subElements)
+            {
+                var timeline = currentDirector.playableAsset as TimelineAsset;
+                if (timeline == null)
+                    return false;
+                if (timeline.trackObjects == null)
+                    return false;
+
+                var track = timeline.GetOutputTracks().FirstOrDefault(t => t.GetInstanceID() == element.trackInstanceID);
+                if (track == null)
+                    return false;
+                if (track.Hash() != element.trackHash)
+                    return false;
+                if (track.clips == null)
+                    return false;
+                if (track.clips.Length <= element.clipIndex)
+                    return false;
+
+                var clip = track.clips[element.clipIndex];
+                if (clip == null)
+                    return false;
+                if (clip.Hash() != element.clipHash)
+                    return false;
+
+                var candidateDirectors = TimelineUtility.GetSubTimelines(clip, director);
+
+                if (element.subDirectorIndex < 0 || element.subDirectorIndex >= candidateDirectors.Count)
+                    return false;
+
+                var candidateDirector = candidateDirectors[element.subDirectorIndex];
+
+                if (candidateDirector == null || !(candidateDirector.playableAsset is TimelineAsset))
+                    return false;
+
+                currentDirector = candidateDirector;
+
+                buildingBlocks.Add(
+                    new SequenceBuildingBlock
+                    {
+                        asset = currentDirector.playableAsset as TimelineAsset,
+                        director = currentDirector,
+                        hostClip = clip
+                    });
+            }
+
+            return true;
+        }
+
+        struct SequenceBuildingBlock
+        {
+            public TimelineAsset asset;
+            public PlayableDirector director;
+            public TimelineClip hostClip;
+        }
+
+        static void AddToCurrentUndoGroup(Object target)
+        {
+            if (target == null) return;
+
+            var group = Undo.GetCurrentGroup();
+            var groupName = Undo.GetCurrentGroupName();
+            EditorUtility.SetDirty(target);
+            Undo.RegisterCompleteObjectUndo(target, groupName);
+            Undo.CollapseUndoOperations(group);
+        }
+    }
+}