|
|
using System;using System.Collections.Generic;using UnityEngine.Playables;
namespace UnityEngine.Timeline{ /// <summary>
/// A PlayableAsset that represents a timeline.
/// </summary>
[ExcludeFromPreset] [Serializable] public partial class TimelineAsset : PlayableAsset, ISerializationCallbackReceiver, ITimelineClipAsset, IPropertyPreview { /// <summary>
/// How the duration of the timeline is determined.
/// </summary>
public enum DurationMode { /// <summary>
/// The duration of the timeline is determined based on the clips present.
/// </summary>
BasedOnClips, /// <summary>
/// The duration of the timeline is a fixed length.
/// </summary>
FixedLength }
/// <summary>
/// Properties of the timeline that are used by the editor
/// </summary>
[Serializable] public class EditorSettings { internal static readonly float kMinFps = (float)TimeUtility.kFrameRateEpsilon; internal static readonly float kMaxFps = 1000.0f; internal static readonly float kDefaultFps = 60.0f; [HideInInspector, SerializeField] float m_Framerate = kDefaultFps;
/// <summary>
/// The frames per second used for snapping and time ruler display
/// </summary>
public float fps { get { return m_Framerate; } set { m_Framerate = GetValidFramerate(value); } } }
[HideInInspector, SerializeField] List<ScriptableObject> m_Tracks; [HideInInspector, SerializeField] double m_FixedDuration; // only applied if duration mode is Fixed
[HideInInspector, NonSerialized] TrackAsset[] m_CacheOutputTracks; [HideInInspector, NonSerialized] List<TrackAsset> m_CacheRootTracks; [HideInInspector, NonSerialized] List<TrackAsset> m_CacheFlattenedTracks; [HideInInspector, SerializeField] EditorSettings m_EditorSettings = new EditorSettings(); [SerializeField] DurationMode m_DurationMode;
[HideInInspector, SerializeField] MarkerTrack m_MarkerTrack;
/// <summary>
/// Settings used by timeline for editing purposes
/// </summary>
public EditorSettings editorSettings { get { return m_EditorSettings; } }
/// <summary>
/// The length, in seconds, of the timeline
/// </summary>
public override double duration { get { // @todo cache this value when rebuilt
if (m_DurationMode == DurationMode.BasedOnClips) return CalculateDuration();
return m_FixedDuration; } }
/// <summary>
/// The length of the timeline when durationMode is set to fixed length.
/// </summary>
public double fixedDuration { get { DiscreteTime discreteDuration = (DiscreteTime)m_FixedDuration; if (discreteDuration <= 0) return 0.0;
//avoid having no clip evaluated at the end by removing a tick from the total duration
return (double)discreteDuration.OneTickBefore(); } set { m_FixedDuration = Math.Max(0.0, value); } }
/// <summary>
/// The mode used to determine the duration of the Timeline
/// </summary>
public DurationMode durationMode { get { return m_DurationMode; } set { m_DurationMode = value; } }
/// <summary>
/// A description of the PlayableOutputs that will be created by the timeline when instantiated.
/// </summary>
/// <remarks>
/// Each track will create an PlayableOutput
/// </remarks>
public override IEnumerable<PlayableBinding> outputs { get { foreach (var outputTracks in GetOutputTracks()) foreach (var output in outputTracks.outputs) yield return output; } }
public ClipCaps clipCaps { get { var caps = ClipCaps.All; foreach (var track in GetRootTracks()) { foreach (var clip in track.clips) caps &= clip.clipCaps; } return caps; } }
/// <summary>
/// Returns the the number of output tracks in the Timeline.
/// </summary>
/// <remarks>
/// An output track is a track the generates a PlayableOutput. In general, an output track is any track that is not a GroupTrack, a subtrack, or override track.
/// </remarks>
public int outputTrackCount { get { UpdateOutputTrackCache(); // updates the cache if necessary
return m_CacheOutputTracks.Length; } }
/// <summary>
/// Returns the number of tracks at the root level of the timeline.
/// </summary>
/// <remarks>
/// A root track refers to all tracks that occur at the root of the timeline. These are the outmost level GroupTracks, and output tracks that do not belong to any group
/// </remarks>
public int rootTrackCount { get { UpdateRootTrackCache(); return m_CacheRootTracks.Count; } }
void OnValidate() { editorSettings.fps = GetValidFramerate(editorSettings.fps); }
static float GetValidFramerate(float framerate) { return Mathf.Clamp(framerate, EditorSettings.kMinFps, EditorSettings.kMaxFps); }
/// <summary>
/// Retrieves at root track at the specified index.
/// </summary>
/// <param name="index">Index of the root track to get. Must be between 0 and rootTrackCount</param>
/// <remarks>
/// A root track refers to all tracks that occur at the root of the timeline. These are the outmost level GroupTracks, and output tracks that do not belong to any group.
/// </remarks>
public TrackAsset GetRootTrack(int index) { UpdateRootTrackCache(); return m_CacheRootTracks[index]; }
/// <summary>
/// Get an enumerable list of all root tracks.
/// </summary>
/// <returns>An IEnumerable of all root tracks.</returns>
/// <remarks>A root track refers to all tracks that occur at the root of the timeline. These are the outmost level GroupTracks, and output tracks that do not belong to any group.</remarks>
public IEnumerable<TrackAsset> GetRootTracks() { UpdateRootTrackCache(); return m_CacheRootTracks; }
/// <summary>
/// Retrives the output track from the given index.
/// </summary>
/// <param name="index">Index of the output track to retrieve. Must be between 0 and outputTrackCount</param>
/// <returns>The output track from the given index</returns>
public TrackAsset GetOutputTrack(int index) { UpdateOutputTrackCache(); return m_CacheOutputTracks[index]; }
/// <summary>
/// Gets a list of all output tracks in the Timeline.
/// </summary>
/// <returns>An IEnumerable of all output tracks</returns>
/// <remarks>
/// An output track is a track the generates a PlayableOutput. In general, an output track is any track that is not a GroupTrack or subtrack.
/// </remarks>
public IEnumerable<TrackAsset> GetOutputTracks() { UpdateOutputTrackCache(); return m_CacheOutputTracks; }
void UpdateRootTrackCache() { if (m_CacheRootTracks == null) { if (m_Tracks == null) m_CacheRootTracks = new List<TrackAsset>(); else { m_CacheRootTracks = new List<TrackAsset>(m_Tracks.Count); if (markerTrack != null) { m_CacheRootTracks.Add(markerTrack); }
foreach (var t in m_Tracks) { var trackAsset = t as TrackAsset; if (trackAsset != null) m_CacheRootTracks.Add(trackAsset); } } } }
void UpdateOutputTrackCache() { if (m_CacheOutputTracks == null) { var outputTracks = new List<TrackAsset>(); foreach (var flattenedTrack in flattenedTracks) { if (flattenedTrack != null && flattenedTrack.GetType() != typeof(GroupTrack) && !flattenedTrack.isSubTrack) outputTracks.Add(flattenedTrack); } m_CacheOutputTracks = outputTracks.ToArray(); } }
internal IEnumerable<TrackAsset> flattenedTracks { get { if (m_CacheFlattenedTracks == null) { m_CacheFlattenedTracks = new List<TrackAsset>(m_Tracks.Count * 2); UpdateRootTrackCache();
m_CacheFlattenedTracks.AddRange(m_CacheRootTracks); for (int i = 0; i < m_CacheRootTracks.Count; i++) { AddSubTracksRecursive(m_CacheRootTracks[i], ref m_CacheFlattenedTracks); } } return m_CacheFlattenedTracks; } }
/// <summary>
/// Gets the marker track for this TimelineAsset.
/// </summary>
/// <returns>Returns the marker track.</returns>
/// <remarks>
/// Use <see cref="TrackAsset.GetMarkers"/> to get a list of the markers on the returned track.
/// </remarks>
public MarkerTrack markerTrack { get { return m_MarkerTrack; } }
// access to the track list as scriptable object
internal List<ScriptableObject> trackObjects { get { return m_Tracks; } }
internal void AddTrackInternal(TrackAsset track) { m_Tracks.Add(track); track.parent = this; Invalidate(); }
internal void RemoveTrack(TrackAsset track) { m_Tracks.Remove(track); Invalidate(); var parentTrack = track.parent as TrackAsset; if (parentTrack != null) { parentTrack.RemoveSubTrack(track); } }
/// <summary>
/// Creates an instance of the timeline
/// </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 Timeline</returns>
public override Playable CreatePlayable(PlayableGraph graph, GameObject go) { bool autoRebalanceTree = false; #if UNITY_EDITOR
autoRebalanceTree = true; #endif
// only create outputs if we are not nested
bool createOutputs = graph.GetPlayableCount() == 0; var timeline = TimelinePlayable.Create(graph, GetOutputTracks(), go, autoRebalanceTree, createOutputs); timeline.SetPropagateSetTime(true); return timeline.IsValid() ? timeline : Playable.Null; }
void ISerializationCallbackReceiver.OnBeforeSerialize() { m_Version = k_LatestVersion; }
// resets cache on an Undo
void ISerializationCallbackReceiver.OnAfterDeserialize() { Invalidate(); // resets cache on an Undo
if (m_Version < k_LatestVersion) { UpgradeToLatestVersion(); } }
void __internalAwake() { if (m_Tracks == null) m_Tracks = new List<ScriptableObject>();
// validate the array. DON'T remove Unity null objects, just actual null objects
for (int i = m_Tracks.Count - 1; i >= 0; i--) { TrackAsset asset = m_Tracks[i] as TrackAsset; if (asset != null) asset.parent = this;#if UNITY_EDITOR
object o = m_Tracks[i]; if (o == null) { Debug.LogWarning("Empty track found while loading timeline. It will be removed."); m_Tracks.RemoveAt(i); }#endif
} }
/// <summary>
/// Called by the Timeline Editor to gather properties requiring preview.
/// </summary>
/// <param name="director">The PlayableDirector invoking the preview</param>
/// <param name="driver">PropertyCollector used to gather previewable properties</param>
public void GatherProperties(PlayableDirector director, IPropertyCollector driver) { var outputTracks = GetOutputTracks(); foreach (var track in outputTracks) { track.GatherProperties(director, driver); } }
/// <summary>
/// Creates a marker track for the TimelineAsset.
/// </summary>
/// In the editor, the marker track appears under the Timeline ruler.
/// <remarks>
/// This track is always bound to the GameObject that contains the PlayableDirector component for the current timeline.
/// The marker track is created the first time this method is called. If the marker track is already created, this method does nothing.
/// </remarks>
public void CreateMarkerTrack() { if (m_MarkerTrack == null) { m_MarkerTrack = CreateInstance<MarkerTrack>(); TimelineCreateUtilities.SaveAssetIntoObject(m_MarkerTrack, this); m_MarkerTrack.parent = this; m_MarkerTrack.name = "Markers"; // This name will show up in the bindings list if it contains signals
Invalidate(); } }
// Invalidates the asset, call this if changing the asset data
internal void Invalidate() { m_CacheRootTracks = null; m_CacheOutputTracks = null; m_CacheFlattenedTracks = null; }
double CalculateDuration() { var discreteDuration = new DiscreteTime(0); foreach (var track in flattenedTracks) { if (track.muted) continue;
discreteDuration = DiscreteTime.Max(discreteDuration, (DiscreteTime)track.end); }
if (discreteDuration <= 0) return 0.0;
//avoid having no clip evaluated at the end by removing a tick from the total duration
return (double)discreteDuration.OneTickBefore(); }
static void AddSubTracksRecursive(TrackAsset track, ref List<TrackAsset> allTracks) { if (track == null) return;
allTracks.AddRange(track.GetChildTracks()); foreach (TrackAsset subTrack in track.GetChildTracks()) { AddSubTracksRecursive(subTrack, ref allTracks); } } }}
|
