256 lines
9.8 KiB
C#
256 lines
9.8 KiB
C#
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");
|
|
}
|
|
}
|
|
}
|