Inital commit

1 files changed, 255 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/TimelineAsset_CreateRemove.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/TimelineAsset_CreateRemove.cs
new file mode 100644
index 0000000..8727eae
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/TimelineAsset_CreateRemove.cs
@@ -0,0 +1,255 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Timeline;
+using UnityEngine.Playables;
+using UnityEngineInternal; // for metro type extensions
+
+namespace UnityEngine.Timeline
+{
+    public partial class TimelineAsset
+    {
+        /// <summary>
+        /// Allows you to create a track and add it to the Timeline.
+        /// </summary>
+        /// <param name="type">The type of track to create. Must derive from TrackAsset.</param>
+        /// <param name="parent">Track to parent to. This can be null.</param>
+        /// <param name="name">Name to give the track.</param>
+        /// <returns>The created track.</returns>
+        /// <remarks>
+        /// This method will throw an InvalidOperationException if the parent is not valid. The parent can be any GroupTrack, or a supported parent type of track. For example, this can be used to create override tracks in AnimationTracks.
+        /// </remarks>
+        public TrackAsset CreateTrack(Type type, TrackAsset parent, string name)
+        {
+            if (parent != null && parent.timelineAsset != this)
+                throw new InvalidOperationException("Addtrack cannot parent to a track not in the Timeline");
+
+            if (!typeof(TrackAsset).IsAssignableFrom(type))
+                throw new InvalidOperationException("Supplied type must be a track asset");
+
+            if (parent != null)
+            {
+                if (!TimelineCreateUtilities.ValidateParentTrack(parent, type))
+                    throw new InvalidOperationException("Cannot assign a child of type " + type.Name + " to a parent of type " + parent.GetType().Name);
+            }
+
+
+            var actualParent = parent != null ? parent as PlayableAsset : this;
+            TimelineUndo.PushUndo(actualParent, "Create Track");
+
+            var baseName = name;
+            if (string.IsNullOrEmpty(baseName))
+            {
+                baseName = type.Name;
+#if UNITY_EDITOR
+                baseName = UnityEditor.ObjectNames.NicifyVariableName(baseName);
+#endif
+            }
+
+            var trackName = baseName;
+            if (parent != null)
+                trackName = TimelineCreateUtilities.GenerateUniqueActorName(parent.subTracksObjects, baseName);
+            else
+                trackName = TimelineCreateUtilities.GenerateUniqueActorName(trackObjects, baseName);
+
+            TrackAsset newTrack = AllocateTrack(parent, trackName, type);
+            if (newTrack != null)
+            {
+                newTrack.name = trackName;
+                TimelineCreateUtilities.SaveAssetIntoObject(newTrack, actualParent);
+            }
+            return newTrack;
+        }
+
+        /// <summary>
+        /// Creates a track and adds it to the Timeline Asset.
+        /// </summary>
+        /// <param name="parent">Track to parent to. This can be null.</param>
+        /// <param name="trackName">The name of the track being created.</param>
+        /// <typeparam name="T">The type of track being created. The track type must be derived from TrackAsset.</typeparam>
+        /// <returns>Returns the created track.</returns>
+        /// <remarks>
+        /// This method will throw an InvalidOperationException if the parent is not valid. The parent can be any GroupTrack, or a supported parent type of track. For example, this can be used to create override tracks in AnimationTracks.
+        /// </remarks>
+        public T CreateTrack<T>(TrackAsset parent, string trackName) where T : TrackAsset, new()
+        {
+            return (T)CreateTrack(typeof(T), parent, trackName);
+        }
+
+        /// <summary>
+        /// Creates a track and adds it to the Timeline Asset.
+        /// </summary>
+        /// <param name="trackName">The name of the track being created.</param>
+        /// <typeparam name="T">The type of track being created. The track type must be derived from TrackAsset.</typeparam>
+        /// <returns>Returns the created track.</returns>
+        public T CreateTrack<T>(string trackName) where T : TrackAsset, new()
+        {
+            return (T)CreateTrack(typeof(T), null, trackName);
+        }
+
+        /// <summary>
+        /// Creates a track and adds it to the Timeline Asset.
+        /// </summary>
+        /// <typeparam name="T">The type of track being created. The track type must be derived from TrackAsset.</typeparam>
+        /// <returns>Returns the created track.</returns>
+        public T CreateTrack<T>() where T : TrackAsset, new()
+        {
+            return (T)CreateTrack(typeof(T), null, null);
+        }
+
+        /// <summary>
+        /// Delete a clip from this timeline.
+        /// </summary>
+        /// <param name="clip">The clip to delete.</param>
+        /// <returns>Returns true if the removal was successful</returns>
+        /// <remarks>
+        /// This method will delete a clip and any assets owned by the clip.
+        /// </remarks>
+        public bool DeleteClip(TimelineClip clip)
+        {
+            if (clip == null || clip.parentTrack == null)
+            {
+                return false;
+            }
+            if (this != clip.parentTrack.timelineAsset)
+            {
+                Debug.LogError("Cannot delete a clip from this timeline");
+                return false;
+            }
+
+            TimelineUndo.PushUndo(clip.parentTrack, "Delete Clip");
+            if (clip.curves != null)
+            {
+                TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.curves, "Delete Curves");
+            }
+
+            // handle wrapped assets
+            if (clip.asset != null)
+            {
+                DeleteRecordedAnimation(clip);
+
+                // TODO -- we should flag assets and owned, instead of this check...
+#if UNITY_EDITOR
+                string path = UnityEditor.AssetDatabase.GetAssetPath(clip.asset);
+                if (path == UnityEditor.AssetDatabase.GetAssetPath(this))
+#endif
+                {
+                    TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.asset, "Delete Clip Asset");
+                }
+            }
+
+            var clipParentTrack = clip.parentTrack;
+            clipParentTrack.RemoveClip(clip);
+            clipParentTrack.CalculateExtrapolationTimes();
+
+            return true;
+        }
+
+        /// <summary>
+        /// Deletes a track from a timeline, including all clips and subtracks.
+        /// </summary>
+        /// <param name="track">The track to delete. It must be owned by this Timeline.</param>
+        /// <returns>True if the track was deleted successfully.</returns>
+        public bool DeleteTrack(TrackAsset track)
+        {
+            if (track.timelineAsset != this)
+                return false;
+
+            // push before we modify properties
+            TimelineUndo.PushUndo(track, "Delete Track");
+            TimelineUndo.PushUndo(this, "Delete Track");
+
+            TrackAsset parent = track.parent as TrackAsset;
+            if (parent != null)
+                TimelineUndo.PushUndo(parent, "Delete Track");
+
+            var children = track.GetChildTracks();
+            foreach (var child in children)
+            {
+                DeleteTrack(child);
+            }
+
+            DeleteRecordedAnimation(track);
+
+            var clipsToDelete = new List<TimelineClip>(track.clips);
+            foreach (var clip in clipsToDelete)
+            {
+                DeleteClip(clip);
+            }
+            RemoveTrack(track);
+
+            TimelineUndo.PushDestroyUndo(this, this, track, "Delete Track");
+
+            return true;
+        }
+
+        internal void MoveLastTrackBefore(TrackAsset asset)
+        {
+            if (m_Tracks == null || m_Tracks.Count < 2 || asset == null)
+                return;
+
+            var lastTrack = m_Tracks[m_Tracks.Count - 1];
+            if (lastTrack == asset)
+                return;
+
+            for (int i = 0; i < m_Tracks.Count - 1; i++)
+            {
+                if (m_Tracks[i] == asset)
+                {
+                    for (int j = m_Tracks.Count - 1; j > i; j--)
+                        m_Tracks[j] = m_Tracks[j - 1];
+                    m_Tracks[i] = lastTrack;
+                    Invalidate();
+                    break;
+                }
+            }
+        }
+
+        internal TrackAsset AllocateTrack(TrackAsset trackAssetParent, string trackName, Type trackType)
+        {
+            if (trackAssetParent != null && trackAssetParent.timelineAsset != this)
+                throw new InvalidOperationException("Addtrack cannot parent to a track not in the Timeline");
+
+            if (!typeof(TrackAsset).IsAssignableFrom(trackType))
+                throw new InvalidOperationException("Supplied type must be a track asset");
+
+            var asset = (TrackAsset)CreateInstance(trackType);
+            asset.name = trackName;
+
+            if (trackAssetParent != null)
+                trackAssetParent.AddChild(asset);
+            else
+                AddTrackInternal(asset);
+
+            return asset;
+        }
+
+        void DeleteRecordedAnimation(TrackAsset track)
+        {
+            var animTrack = track as AnimationTrack;
+            if (animTrack != null && animTrack.infiniteClip != null)
+                TimelineUndo.PushDestroyUndo(this, track, animTrack.infiniteClip, "Delete Track");
+
+            if (track.curves != null)
+                TimelineUndo.PushDestroyUndo(this, track, track.curves, "Delete Track Parameters");
+        }
+
+        void DeleteRecordedAnimation(TimelineClip clip)
+        {
+            if (clip == null)
+                return;
+
+            if (clip.curves != null)
+                TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.curves, "Delete Clip Parameters");
+
+            if (!clip.recordable)
+                return;
+
+            AnimationPlayableAsset asset = clip.asset as AnimationPlayableAsset;
+            if (asset == null || asset.clip == null)
+                return;
+
+            TimelineUndo.PushDestroyUndo(this, asset, asset.clip, "Delete Recording");
+        }
+    }
+}