|
|
using System;using System.Collections.Generic;using System.IO;using UnityEngine.Animations;using UnityEngine.Playables;
namespace UnityEngine.Timeline{ /// <summary>
/// A PlayableAsset representing a track inside a timeline.
/// </summary>
[Serializable] [IgnoreOnPlayableTrack] public abstract partial class TrackAsset : PlayableAsset, IPropertyPreview, ICurvesOwner { // Internal caches used to avoid memory allocation during graph construction
private struct TransientBuildData { public List<TrackAsset> trackList; public List<TimelineClip> clipList; public List<IMarker> markerList;
public static TransientBuildData Create() { return new TransientBuildData() { trackList = new List<TrackAsset>(20), clipList = new List<TimelineClip>(500), markerList = new List<IMarker>(100), }; }
public void Clear() { trackList.Clear(); clipList.Clear(); markerList.Clear(); } }
private static TransientBuildData s_BuildData = TransientBuildData.Create();
internal const string kDefaultCurvesName = "Track Parameters";
internal static event Action<TimelineClip, GameObject, Playable> OnClipPlayableCreate; internal static event Action<TrackAsset, GameObject, Playable> OnTrackAnimationPlayableCreate;
[SerializeField, HideInInspector] bool m_Locked; [SerializeField, HideInInspector] bool m_Muted; [SerializeField, HideInInspector] string m_CustomPlayableFullTypename = string.Empty; [SerializeField, HideInInspector] AnimationClip m_Curves; [SerializeField, HideInInspector] PlayableAsset m_Parent; [SerializeField, HideInInspector] List<ScriptableObject> m_Children;
[NonSerialized] int m_ItemsHash; [NonSerialized] TimelineClip[] m_ClipsCache;
DiscreteTime m_Start; DiscreteTime m_End; bool m_CacheSorted; bool? m_SupportsNotifications;
static TrackAsset[] s_EmptyCache = new TrackAsset[0]; IEnumerable<TrackAsset> m_ChildTrackCache;
static Dictionary<Type, TrackBindingTypeAttribute> s_TrackBindingTypeAttributeCache = new Dictionary<Type, TrackBindingTypeAttribute>();
[SerializeField, HideInInspector] protected internal List<TimelineClip> m_Clips = new List<TimelineClip>();
[SerializeField, HideInInspector] MarkerList m_Markers = new MarkerList(0);
#if UNITY_EDITOR
internal int DirtyIndex { get; private set; } internal void MarkDirty() { DirtyIndex++; foreach (var clip in GetClips()) { if (clip != null) clip.MarkDirty(); } }
#endif
/// <summary>
/// The start time, in seconds, of this track
/// </summary>
public double start { get { UpdateDuration(); return (double)m_Start; } }
/// <summary>
/// The end time, in seconds, of this track
/// </summary>
public double end { get { UpdateDuration(); return (double)m_End; } }
/// <summary>
/// The length, in seconds, of this track
/// </summary>
public sealed override double duration { get { UpdateDuration(); return (double)(m_End - m_Start); } }
/// <summary>
/// Whether the track is muted or not.
/// </summary>
/// <remarks>
/// A muted track is excluded from the generated PlayableGraph
/// </remarks>
public bool muted { get { return m_Muted; } set { m_Muted = value; } }
/// <summary>
/// The muted state of a track.
/// </summary>
/// <remarks>
/// A track is also muted when one of its parent tracks are muted.
/// </remarks>
public bool mutedInHierarchy { get { if (muted) return true;
TrackAsset p = this; while (p.parent as TrackAsset != null) { p = (TrackAsset)p.parent; if (p as GroupTrack != null) return p.mutedInHierarchy; }
return false; } }
/// <summary>
/// The TimelineAsset that this track belongs to.
/// </summary>
public TimelineAsset timelineAsset { get { var node = this; while (node != null) { if (node.parent == null) return null;
var seq = node.parent as TimelineAsset; if (seq != null) return seq;
node = node.parent as TrackAsset; } return null; } }
/// <summary>
/// The owner of this track.
/// </summary>
/// <remarks>
/// If this track is a subtrack, the parent is a TrackAsset. Otherwise the parent is a TimelineAsset.
/// </remarks>
public PlayableAsset parent { get { return m_Parent; } internal set { m_Parent = value; } }
/// <summary>
/// A list of clips owned by this track
/// </summary>
/// <returns>Returns an enumerable list of clips owned by the track.</returns>
public IEnumerable<TimelineClip> GetClips() { return clips; }
internal TimelineClip[] clips { get { if (m_Clips == null) m_Clips = new List<TimelineClip>();
if (m_ClipsCache == null) { m_CacheSorted = false; m_ClipsCache = m_Clips.ToArray(); }
return m_ClipsCache; } }
/// <summary>
/// Whether this track is considered empty.
/// </summary>
/// <remarks>
/// A track is considered empty when it does not contain a TimelineClip, Marker, or Curve.
/// </remarks>
/// <remarks>
/// Empty tracks are not included in the playable graph.
/// </remarks>
public virtual bool isEmpty { get { return !hasClips && !hasCurves && GetMarkerCount() == 0; } }
/// <summary>
/// Whether this track contains any TimelineClip.
/// </summary>
public bool hasClips { get { return m_Clips != null && m_Clips.Count != 0; } }
/// <summary>
/// Whether this track contains animated properties for the attached PlayableAsset.
/// </summary>
/// <remarks>
/// This property is false if the curves property is null or if it contains no information.
/// </remarks>
public bool hasCurves { get { return m_Curves != null && !m_Curves.empty; } }
/// <summary>
/// Returns whether this track is a subtrack
/// </summary>
public bool isSubTrack { get { var owner = parent as TrackAsset; return owner != null && owner.GetType() == GetType(); } }
/// <summary>
/// Returns a description of the PlayableOutputs that will be created by this track.
/// </summary>
public override IEnumerable<PlayableBinding> outputs { get { TrackBindingTypeAttribute attribute; if (!s_TrackBindingTypeAttributeCache.TryGetValue(GetType(), out attribute)) { attribute = (TrackBindingTypeAttribute)Attribute.GetCustomAttribute(GetType(), typeof(TrackBindingTypeAttribute)); s_TrackBindingTypeAttributeCache.Add(GetType(), attribute); }
var trackBindingType = attribute != null ? attribute.type : null; yield return ScriptPlayableBinding.Create(name, this, trackBindingType); } }
/// <summary>
/// The list of subtracks or child tracks attached to this track.
/// </summary>
/// <returns>Returns an enumerable list of child tracks owned directly by this track.</returns>
/// <remarks>
/// In the case of GroupTracks, this returns all tracks contained in the group. This will return the all subtracks or override tracks, if supported by the track.
/// </remarks>
public IEnumerable<TrackAsset> GetChildTracks() { UpdateChildTrackCache(); return m_ChildTrackCache; }
internal string customPlayableTypename { get { return m_CustomPlayableFullTypename; } set { m_CustomPlayableFullTypename = value; } }
/// <summary>
/// An animation clip storing animated properties of the attached PlayableAsset
/// </summary>
public AnimationClip curves { get { return m_Curves; } internal set { m_Curves = value; } }
string ICurvesOwner.defaultCurvesName { get { return kDefaultCurvesName; } }
Object ICurvesOwner.asset { get { return this; } }
Object ICurvesOwner.assetOwner { get { return timelineAsset; } }
TrackAsset ICurvesOwner.targetTrack { get { return this; } }
// for UI where we need to detect 'null' objects
internal List<ScriptableObject> subTracksObjects { get { return m_Children; } }
/// <summary>
/// The local locked state of the track.
/// </summary>
/// <remarks>
/// Note that locking a track only affects operations in the Timeline Editor. It does not prevent other API calls from changing a track or it's clips.
///
/// This returns or sets the local locked state of the track. A track may still be locked for editing because one or more of it's parent tracks in the hierarchy is locked. Use lockedInHierarchy to test if a track is locked because of it's own locked state or because of a parent tracks locked state.
/// </remarks>
public bool locked { get { return m_Locked; } set { m_Locked = value; } }
/// <summary>
/// The locked state of a track. (RO)
/// </summary>
/// <remarks>
/// Note that locking a track only affects operations in the Timeline Editor. It does not prevent other API calls from changing a track or it's clips.
///
/// This indicates whether a track is locked in the Timeline Editor because either it's locked property is enabled or a parent track is locked.
/// </remarks>
public bool lockedInHierarchy { get { if (locked) return true;
TrackAsset p = this; while (p.parent as TrackAsset != null) { p = (TrackAsset)p.parent; if (p as GroupTrack != null) return p.lockedInHierarchy; }
return false; } }
/// <summary>
/// Indicates if a track accepts markers that implement <see cref="UnityEngine.Playables.INotification"/>.
/// </summary>
/// <remarks>
/// Only tracks with a bound object of type <see cref="UnityEngine.GameObject"/> or <see cref="UnityEngine.Component"/> can accept notifications.
/// </remarks>
public bool supportsNotifications { get { if (!m_SupportsNotifications.HasValue) { m_SupportsNotifications = NotificationUtilities.TrackTypeSupportsNotifications(GetType()); }
return m_SupportsNotifications.Value; } }
void __internalAwake() //do not use OnEnable, since users will want it to initialize their class
{ if (m_Clips == null) m_Clips = new List<TimelineClip>();
m_ChildTrackCache = null; if (m_Children == null) m_Children = new List<ScriptableObject>();#if UNITY_EDITOR
// validate the array. DON'T remove Unity null objects, just actual null objects
for (int i = m_Children.Count - 1; i >= 0; i--) { object o = m_Children[i]; if (o == null) { Debug.LogWarning("Empty child track found while loading timeline. It will be removed."); m_Children.RemoveAt(i); } }#endif
}
/// <summary>
/// Creates an AnimationClip to store animated properties for the attached PlayableAsset.
/// </summary>
/// <remarks>
/// If curves already exists for this track, this method produces no result regardless of
/// the value specified for curvesClipName.
/// </remarks>
/// <remarks>
/// When used from the editor, this method attempts to save the created curves clip to the TimelineAsset.
/// The TimelineAsset must already exist in the AssetDatabase to save the curves clip. If the TimelineAsset
/// does not exist, the curves clip is still created but it is not saved.
/// </remarks>
/// <param name="curvesClipName">
/// The name of the AnimationClip to create.
/// This method does not ensure unique names. If you want a unique clip name, you must provide one.
/// See ObjectNames.GetUniqueName for information on a method that creates unique names.
/// </param>
public void CreateCurves(string curvesClipName) { if (m_Curves != null) return;
m_Curves = TimelineCreateUtilities.CreateAnimationClipForTrack(string.IsNullOrEmpty(curvesClipName) ? kDefaultCurvesName : curvesClipName, this, true); }
/// <summary>
/// Creates a mixer used to blend playables generated by clips on the track.
/// </summary>
/// <param name="graph">The graph to inject playables into</param>
/// <param name="go">The GameObject that requested the graph.</param>
/// <param name="inputCount">The number of playables from clips that will be inputs to the returned mixer</param>
/// <returns>A handle to the [[Playable]] representing the mixer.</returns>
/// <remarks>
/// Override this method to provide a custom playable for mixing clips on a graph.
/// </remarks>
public virtual Playable CreateTrackMixer(PlayableGraph graph, GameObject go, int inputCount) { return Playable.Create(graph, inputCount); }
/// <summary>
/// Overrides PlayableAsset.CreatePlayable(). Not used in Timeline.
/// </summary>
public sealed override Playable CreatePlayable(PlayableGraph graph, GameObject go) { return Playable.Null; }
/// <summary>
/// Creates a TimelineClip on this track.
/// </summary>
/// <returns>Returns a new TimelineClip that is attached to the track.</returns>
/// <remarks>
/// The type of the playable asset attached to the clip is determined by TrackClip attributes that decorate the TrackAsset derived class
/// </remarks>
public TimelineClip CreateDefaultClip() { var trackClipTypeAttributes = GetType().GetCustomAttributes(typeof(TrackClipTypeAttribute), true); Type playableAssetType = null; foreach (var trackClipTypeAttribute in trackClipTypeAttributes) { var attribute = trackClipTypeAttribute as TrackClipTypeAttribute; if (attribute != null && typeof(IPlayableAsset).IsAssignableFrom(attribute.inspectedType) && typeof(ScriptableObject).IsAssignableFrom(attribute.inspectedType)) { playableAssetType = attribute.inspectedType; break; } }
if (playableAssetType == null) { Debug.LogWarning("Cannot create a default clip for type " + GetType()); return null; } return CreateAndAddNewClipOfType(playableAssetType); }
/// <summary>
/// Creates a clip on the track with a playable asset attached, whose derived type is specified by T
/// </summary>
/// <typeparam name="T">A PlayableAsset derived type</typeparam>
/// <returns>Returns a TimelineClip whose asset is of type T</returns>
/// <remarks>
/// Throws an InvalidOperationException if the specified type is not supported by the track.
/// Supported types are determined by TrackClip attributes that decorate the TrackAsset derived class
/// </remarks>
public TimelineClip CreateClip<T>() where T : ScriptableObject, IPlayableAsset { return CreateClip(typeof(T)); }
/// <summary>
/// Creates a marker of the requested type, at a specific time, and adds the marker to the current asset.
/// </summary>
/// <param name="type">The type of marker.</param>
/// <param name="time">The time where the marker is created.</param>
/// <returns>Returns the instance of the created marker.</returns>
/// <remarks>
/// All markers that implement IMarker and inherit from <see cref="UnityEngine.ScriptableObject"/> are supported.
/// Markers that implement the INotification interface cannot be added to tracks that do not support notifications.
/// CreateMarker will throw an <code>InvalidOperationException</code> with tracks that do not support notifications if <code>type</code> implements the INotification interface.
/// </remarks>
/// <seealso cref="UnityEngine.Timeline.Marker"/>
/// <seealso cref="UnityEngine.Timeline.TrackAsset.supportsNotifications"/>
public IMarker CreateMarker(Type type, double time) { return m_Markers.CreateMarker(type, time, this); }
/// <summary>
/// Creates a marker of the requested type, at a specific time, and adds the marker to the current asset.
/// </summary>
/// <param name="time">The time where the marker is created.</param>
/// <returns>Returns the instance of the created marker.</returns>
/// <remarks>
/// All markers that implement IMarker and inherit from <see cref="UnityEngine.ScriptableObject"/> are supported.
/// CreateMarker will throw an <code>InvalidOperationException</code> with tracks that do not support notifications if <code>T</code> implements the INotification interface.
/// </remarks>
/// <seealso cref="UnityEngine.Timeline.Marker"/>
/// <seealso cref="UnityEngine.Timeline.TrackAsset.supportsNotifications"/>
public T CreateMarker<T>(double time) where T : ScriptableObject, IMarker { return (T)CreateMarker(typeof(T), time); }
/// <summary>
/// Removes a marker from the current asset.
/// </summary>
/// <param name="marker">The marker instance to be removed.</param>
/// <returns>Returns true if the marker instance was successfully removed. Returns false otherwise.</returns>
public bool DeleteMarker(IMarker marker) { return m_Markers.Remove(marker); }
/// <summary>
/// Returns an enumerable list of markers on the current asset.
/// </summary>
/// <returns>The list of markers on the asset.
/// </returns>
public IEnumerable<IMarker> GetMarkers() { return m_Markers.GetMarkers(); }
/// <summary>
/// Returns the number of markers on the current asset.
/// </summary>
/// <returns>The number of markers.</returns>
public int GetMarkerCount() { return m_Markers.Count; }
/// <summary>
/// Returns the marker at a given position, on the current asset.
/// </summary>
/// <param name="idx">The index of the marker to be returned.</param>
/// <returns>The marker.</returns>
/// <remarks>The ordering of the markers is not guaranteed.
/// </remarks>
public IMarker GetMarker(int idx) { return m_Markers[idx]; }
internal TimelineClip CreateClip(System.Type requestedType) { if (ValidateClipType(requestedType)) return CreateAndAddNewClipOfType(requestedType);
throw new InvalidOperationException("Clips of type " + requestedType + " are not permitted on tracks of type " + GetType()); }
internal TimelineClip CreateAndAddNewClipOfType(Type requestedType) { var newClip = CreateClipOfType(requestedType); AddClip(newClip); return newClip; }
internal TimelineClip CreateClipOfType(Type requestedType) { if (!ValidateClipType(requestedType)) throw new System.InvalidOperationException("Clips of type " + requestedType + " are not permitted on tracks of type " + GetType());
var playableAsset = CreateInstance(requestedType); if (playableAsset == null) { throw new System.InvalidOperationException("Could not create an instance of the ScriptableObject type " + requestedType.Name); } playableAsset.name = requestedType.Name; TimelineCreateUtilities.SaveAssetIntoObject(playableAsset, this); TimelineUndo.RegisterCreatedObjectUndo(playableAsset, "Create Clip");
return CreateClipFromAsset(playableAsset); }
/// <summary>
/// Creates a timeline clip from an existing playable asset.
/// </summary>
/// <param name="asset"></param>
/// <returns></returns>
internal TimelineClip CreateClipFromPlayableAsset(IPlayableAsset asset) { if (asset == null) throw new ArgumentNullException("asset");
if ((asset as ScriptableObject) == null) throw new System.ArgumentException("CreateClipFromPlayableAsset " + " only supports ScriptableObject-derived Types");
if (!ValidateClipType(asset.GetType())) throw new System.InvalidOperationException("Clips of type " + asset.GetType() + " are not permitted on tracks of type " + GetType());
return CreateClipFromAsset(asset as ScriptableObject); }
private TimelineClip CreateClipFromAsset(ScriptableObject playableAsset) { TimelineUndo.PushUndo(this, "Create Clip");
var newClip = CreateNewClipContainerInternal(); newClip.displayName = playableAsset.name; newClip.asset = playableAsset;
IPlayableAsset iPlayableAsset = playableAsset as IPlayableAsset; if (iPlayableAsset != null) { var candidateDuration = iPlayableAsset.duration;
if (!double.IsInfinity(candidateDuration) && candidateDuration > 0) newClip.duration = Math.Min(Math.Max(candidateDuration, TimelineClip.kMinDuration), TimelineClip.kMaxTimeValue); }
try { OnCreateClip(newClip); } catch (Exception e) { Debug.LogError(e.Message, playableAsset); return null; }
return newClip; }
internal IEnumerable<ScriptableObject> GetMarkersRaw() { return m_Markers.GetRawMarkerList(); }
internal void ClearMarkers() { m_Markers.Clear(); }
internal void AddMarker(ScriptableObject e) { m_Markers.Add(e); }
internal bool DeleteMarkerRaw(ScriptableObject marker) { return m_Markers.Remove(marker, timelineAsset, this); }
int GetTimeRangeHash() { double start = double.MaxValue, end = double.MinValue; foreach (var marker in GetMarkers()) { if (!(marker is INotification)) { continue; }
if (marker.time < start) start = marker.time; if (marker.time > end) end = marker.time; }
return start.GetHashCode().CombineHash(end.GetHashCode()); }
internal void AddClip(TimelineClip newClip) { if (!m_Clips.Contains(newClip)) { m_Clips.Add(newClip); m_ClipsCache = null; } }
Playable CreateNotificationsPlayable(PlayableGraph graph, Playable mixerPlayable, GameObject go, Playable timelinePlayable) { s_BuildData.markerList.Clear(); GatherNotificiations(s_BuildData.markerList); var notificationPlayable = NotificationUtilities.CreateNotificationsPlayable(graph, s_BuildData.markerList, go); if (notificationPlayable.IsValid()) { notificationPlayable.GetBehaviour().timeSource = timelinePlayable; if (mixerPlayable.IsValid()) { notificationPlayable.SetInputCount(1); graph.Connect(mixerPlayable, 0, notificationPlayable, 0); notificationPlayable.SetInputWeight(mixerPlayable, 1); } }
return notificationPlayable; }
internal Playable CreatePlayableGraph(PlayableGraph graph, GameObject go, IntervalTree<RuntimeElement> tree, Playable timelinePlayable) { UpdateDuration(); var mixerPlayable = Playable.Null; if (CanCompileClipsRecursive()) mixerPlayable = OnCreateClipPlayableGraph(graph, go, tree);
var notificationsPlayable = CreateNotificationsPlayable(graph, mixerPlayable, go, timelinePlayable); if (!notificationsPlayable.IsValid() && !mixerPlayable.IsValid()) { Debug.LogErrorFormat("Track {0} of type {1} has no notifications and returns an invalid mixer Playable", name, GetType().FullName);
return Playable.Create(graph); }
return notificationsPlayable.IsValid() ? notificationsPlayable : mixerPlayable; }
internal virtual Playable CompileClips(PlayableGraph graph, GameObject go, IList<TimelineClip> timelineClips, IntervalTree<RuntimeElement> tree) { var blend = CreateTrackMixer(graph, go, timelineClips.Count); for (var c = 0; c < timelineClips.Count; c++) { var source = CreatePlayable(graph, go, timelineClips[c]); if (source.IsValid()) { source.SetDuration(timelineClips[c].duration); var clip = new RuntimeClip(timelineClips[c], source, blend); tree.Add(clip); graph.Connect(source, 0, blend, c); blend.SetInputWeight(c, 0.0f); } } ConfigureTrackAnimation(tree, go, blend); return blend; }
void GatherCompilableTracks(IList<TrackAsset> tracks) { if (!muted && CanCompileClips()) tracks.Add(this);
foreach (var c in GetChildTracks()) { if (c != null) c.GatherCompilableTracks(tracks); } }
void GatherNotificiations(List<IMarker> markers) { if (!muted && CanCompileNotifications()) markers.AddRange(GetMarkers()); foreach (var c in GetChildTracks()) { if (c != null) c.GatherNotificiations(markers); } }
internal virtual Playable OnCreateClipPlayableGraph(PlayableGraph graph, GameObject go, IntervalTree<RuntimeElement> tree) { if (tree == null) throw new ArgumentException("IntervalTree argument cannot be null", "tree");
if (go == null) throw new ArgumentException("GameObject argument cannot be null", "go");
s_BuildData.Clear(); GatherCompilableTracks(s_BuildData.trackList);
// nothing to compile
if (s_BuildData.trackList.Count == 0) return Playable.Null;
// check if layers are supported
Playable layerMixer = Playable.Null; ILayerable layerable = this as ILayerable; if (layerable != null) layerMixer = layerable.CreateLayerMixer(graph, go, s_BuildData.trackList.Count);
if (layerMixer.IsValid()) { for (int i = 0; i < s_BuildData.trackList.Count; i++) { var mixer = s_BuildData.trackList[i].CompileClips(graph, go, s_BuildData.trackList[i].clips, tree); if (mixer.IsValid()) { graph.Connect(mixer, 0, layerMixer, i); layerMixer.SetInputWeight(i, 1.0f); } } return layerMixer; }
// one track compiles. Add track mixer and clips
if (s_BuildData.trackList.Count == 1) return s_BuildData.trackList[0].CompileClips(graph, go, s_BuildData.trackList[0].clips, tree);
// no layer mixer provided. merge down all clips.
for (int i = 0; i < s_BuildData.trackList.Count; i++) s_BuildData.clipList.AddRange(s_BuildData.trackList[i].clips);
#if UNITY_EDITOR
bool applyWarning = false; for (int i = 0; i < s_BuildData.trackList.Count; i++) applyWarning |= i > 0 && s_BuildData.trackList[i].hasCurves;
if (applyWarning) Debug.LogWarning("A layered track contains animated fields, but no layer mixer has been provided. Animated fields on layers will be ignored. Override CreateLayerMixer in " + s_BuildData.trackList[0].GetType().Name + " and return a valid playable to support animated fields on layered tracks.");#endif
// compile all the clips into a single mixer
return CompileClips(graph, go, s_BuildData.clipList, tree); }
internal void ConfigureTrackAnimation(IntervalTree<RuntimeElement> tree, GameObject go, Playable blend) { if (!hasCurves) return;
blend.SetAnimatedProperties(m_Curves); tree.Add(new InfiniteRuntimeClip(blend));
if (OnTrackAnimationPlayableCreate != null) OnTrackAnimationPlayableCreate.Invoke(this, go, blend); }
// sorts clips by start time
internal void SortClips() { var clipsAsArray = clips; // will alloc
if (!m_CacheSorted) { Array.Sort(clips, (clip1, clip2) => clip1.start.CompareTo(clip2.start)); m_CacheSorted = true; } }
// clears the clips after a clone
internal void ClearClipsInternal() { m_Clips = new List<TimelineClip>(); m_ClipsCache = null; }
internal void ClearSubTracksInternal() { m_Children = new List<ScriptableObject>(); Invalidate(); }
// called by an owned clip when it moves
internal void OnClipMove() { m_CacheSorted = false; }
internal TimelineClip CreateNewClipContainerInternal() { var clipContainer = new TimelineClip(this); clipContainer.asset = null;
// position clip at end of sequence
var newClipStart = 0.0; for (var a = 0; a < m_Clips.Count - 1; a++) { var clipDuration = m_Clips[a].duration; if (double.IsInfinity(clipDuration)) clipDuration = TimelineClip.kDefaultClipDurationInSeconds; newClipStart = Math.Max(newClipStart, m_Clips[a].start + clipDuration); }
clipContainer.mixInCurve = AnimationCurve.EaseInOut(0, 0, 1, 1); clipContainer.mixOutCurve = AnimationCurve.EaseInOut(0, 1, 1, 0); clipContainer.start = newClipStart; clipContainer.duration = TimelineClip.kDefaultClipDurationInSeconds; clipContainer.displayName = "untitled"; return clipContainer; }
internal void AddChild(TrackAsset child) { if (child == null) return;
m_Children.Add(child); child.parent = this; Invalidate(); }
internal void MoveLastTrackBefore(TrackAsset asset) { if (m_Children == null || m_Children.Count < 2 || asset == null) return;
var lastTrack = m_Children[m_Children.Count - 1]; if (lastTrack == asset) return;
for (int i = 0; i < m_Children.Count - 1; i++) { if (m_Children[i] == asset) { for (int j = m_Children.Count - 1; j > i; j--) m_Children[j] = m_Children[j - 1]; m_Children[i] = lastTrack; Invalidate(); break; } } }
internal bool RemoveSubTrack(TrackAsset child) { if (m_Children.Remove(child)) { Invalidate(); child.parent = null; return true; } return false; }
internal void RemoveClip(TimelineClip clip) { m_Clips.Remove(clip); m_ClipsCache = null; }
// Is this track compilable for the sequence
// calculate the time interval that this track will be evaluated in.
internal virtual void GetEvaluationTime(out double outStart, out double outDuration) { outStart = double.PositiveInfinity; var outEnd = double.NegativeInfinity;
if (hasCurves) { outStart = 0.0; outEnd = TimeUtility.GetAnimationClipLength(curves); }
foreach (var clip in clips) { outStart = Math.Min(clip.start, outStart); outEnd = Math.Max(clip.end, outEnd); }
if (HasNotifications()) { var notificationDuration = GetNotificationDuration(); outStart = Math.Min(notificationDuration, outStart); outEnd = Math.Max(notificationDuration, outEnd); }
if (double.IsInfinity(outStart) || double.IsInfinity(outEnd)) outStart = outDuration = 0.0; else outDuration = outEnd - outStart; }
// calculate the time interval that the sequence will use to determine length.
// by default this is the same as the evaluation, but subclasses can have different
// behaviour
internal virtual void GetSequenceTime(out double outStart, out double outDuration) { GetEvaluationTime(out outStart, out outDuration); }
/// <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 virtual void GatherProperties(PlayableDirector director, IPropertyCollector driver) { // only push on game objects if there is a binding. Subtracks
// will use objects on the stack
var gameObject = GetGameObjectBinding(director); if (gameObject != null) driver.PushActiveGameObject(gameObject);
if (hasCurves) driver.AddObjectProperties(this, m_Curves);
foreach (var clip in clips) { if (clip.curves != null && clip.asset != null) driver.AddObjectProperties(clip.asset, clip.curves);
IPropertyPreview modifier = clip.asset as IPropertyPreview; if (modifier != null) modifier.GatherProperties(director, driver); }
foreach (var subtrack in GetChildTracks()) { if (subtrack != null) subtrack.GatherProperties(director, driver); }
if (gameObject != null) driver.PopActiveGameObject(); }
internal GameObject GetGameObjectBinding(PlayableDirector director) { if (director == null) return null;
var binding = director.GetGenericBinding(this);
var gameObject = binding as GameObject; if (gameObject != null) return gameObject;
var comp = binding as Component; if (comp != null) return comp.gameObject;
return null; }
internal bool ValidateClipType(Type clipType) { var attrs = GetType().GetCustomAttributes(typeof(TrackClipTypeAttribute), true); for (var c = 0; c < attrs.Length; ++c) { var attr = (TrackClipTypeAttribute)attrs[c]; if (attr.inspectedType.IsAssignableFrom(clipType)) return true; }
// special case for playable tracks, they accept all clips (in the runtime)
return typeof(PlayableTrack).IsAssignableFrom(GetType()) && typeof(IPlayableAsset).IsAssignableFrom(clipType) && typeof(ScriptableObject).IsAssignableFrom(clipType); }
/// <summary>
/// Called when a clip is created on a track.
/// </summary>
/// <param name="clip">The timeline clip added to this track</param>
/// <remarks>Use this method to set default values on a timeline clip, or it's PlayableAsset.</remarks>
protected virtual void OnCreateClip(TimelineClip clip) {}
void UpdateDuration() { // check if something changed in the clips that require a re-calculation of the evaluation times.
var itemsHash = CalculateItemsHash(); if (itemsHash == m_ItemsHash) return; m_ItemsHash = itemsHash;
double trackStart, trackDuration; GetSequenceTime(out trackStart, out trackDuration);
m_Start = (DiscreteTime)trackStart; m_End = (DiscreteTime)(trackStart + trackDuration);
// calculate the extrapolations time.
// TODO Extrapolation time should probably be extracted from the SequenceClip so only a track is aware of it.
this.CalculateExtrapolationTimes(); }
protected internal virtual int CalculateItemsHash() { return HashUtility.CombineHash(GetClipsHash(), GetAnimationClipHash(m_Curves), GetTimeRangeHash()); }
/// <summary>
/// Constructs a Playable from a TimelineClip.
/// </summary>
/// <param name="graph">PlayableGraph that will own the playable.</param>
/// <param name="gameObject">The GameObject that builds the PlayableGraph.</param>
/// <param name="clip">The TimelineClip to construct a playable for.</param>
/// <returns>A playable that will be set as an input to the Track Mixer playable, or Playable.Null if the clip does not have a valid PlayableAsset</returns>
/// <exception cref="ArgumentException">Thrown if the specified PlayableGraph is not valid.</exception>
/// <exception cref="ArgumentNullException">Thrown if the specified TimelineClip is not valid.</exception>
/// <remarks>
/// By default, this method invokes Playable.CreatePlayable, sets animated properties, and sets the speed of the created playable. Override this method to change this default implementation.
/// </remarks>
protected virtual Playable CreatePlayable(PlayableGraph graph, GameObject gameObject, TimelineClip clip) { if (!graph.IsValid()) throw new ArgumentException("graph must be a valid PlayableGraph"); if (clip == null) throw new ArgumentNullException("clip");
var asset = clip.asset as IPlayableAsset; if (asset != null) { var handle = asset.CreatePlayable(graph, gameObject); if (handle.IsValid()) { handle.SetAnimatedProperties(clip.curves); handle.SetSpeed(clip.timeScale); if (OnClipPlayableCreate != null) OnClipPlayableCreate(clip, gameObject, handle); } return handle; } return Playable.Null; }
internal void Invalidate() { m_ChildTrackCache = null; var timeline = timelineAsset; if (timeline != null) { timeline.Invalidate(); } }
internal double GetNotificationDuration() { if (!supportsNotifications) { return 0; }
var maxTime = 0.0; foreach (var marker in GetMarkers()) { if (!(marker is INotification)) { continue; } maxTime = Math.Max(maxTime, marker.time); }
return maxTime; }
internal virtual bool CanCompileClips() { return hasClips || hasCurves; }
internal bool IsCompilable() { var isContainer = typeof(GroupTrack).IsAssignableFrom(GetType());
if (isContainer) return false;
var ret = !mutedInHierarchy && (CanCompileClips() || CanCompileNotifications()); if (!ret) { foreach (var t in GetChildTracks()) { if (t.IsCompilable()) return true; } }
return ret; }
private void UpdateChildTrackCache() { if (m_ChildTrackCache == null) { if (m_Children == null || m_Children.Count == 0) m_ChildTrackCache = s_EmptyCache; else { var childTracks = new List<TrackAsset>(m_Children.Count); for (int i = 0; i < m_Children.Count; i++) { var subTrack = m_Children[i] as TrackAsset; if (subTrack != null) childTracks.Add(subTrack); } m_ChildTrackCache = childTracks; } } }
internal virtual int Hash() { return clips.Length + (m_Markers.Count << 16); }
int GetClipsHash() { var hash = 0; foreach (var clip in m_Clips) { hash = hash.CombineHash(clip.Hash()); } return hash; }
protected static int GetAnimationClipHash(AnimationClip clip) { var hash = 0; if (clip != null && !clip.empty) hash = hash.CombineHash(clip.frameRate.GetHashCode()) .CombineHash(clip.length.GetHashCode());
return hash; }
bool HasNotifications() { return m_Markers.HasNotifications(); }
bool CanCompileNotifications() { return supportsNotifications && m_Markers.HasNotifications(); }
bool CanCompileClipsRecursive() { if (CanCompileClips()) return true; foreach (var track in GetChildTracks()) { if (track.CanCompileClipsRecursive()) return true; }
return false; } }}
|
