niko
623 lines
16 KiB
C#
623 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine.Playables;
|
|
|
|
namespace UnityEngine.Timeline
|
|
{
|
|
// Token: 0x0200000C RID: 12
|
|
[Serializable]
|
|
public class TimelineAsset : PlayableAsset, ISerializationCallbackReceiver, ITimelineClipAsset, IPropertyPreview
|
|
{
|
|
// Token: 0x17000014 RID: 20
|
|
// (get) Token: 0x0600005E RID: 94 RVA: 0x00004618 File Offset: 0x00002818
|
|
public TimelineAsset.EditorSettings editorSettings
|
|
{
|
|
get
|
|
{
|
|
return this.m_EditorSettings;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000015 RID: 21
|
|
// (get) Token: 0x0600005F RID: 95 RVA: 0x00004634 File Offset: 0x00002834
|
|
public override double duration
|
|
{
|
|
get
|
|
{
|
|
double num;
|
|
if (this.m_DurationMode == TimelineAsset.DurationMode.BasedOnClips)
|
|
{
|
|
num = this.CalculateDuration();
|
|
}
|
|
else
|
|
{
|
|
num = this.m_FixedDuration;
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000016 RID: 22
|
|
// (get) Token: 0x06000060 RID: 96 RVA: 0x00004668 File Offset: 0x00002868
|
|
// (set) Token: 0x06000061 RID: 97 RVA: 0x000046B5 File Offset: 0x000028B5
|
|
public double fixedDuration
|
|
{
|
|
get
|
|
{
|
|
DiscreteTime discreteTime = (DiscreteTime)this.m_FixedDuration;
|
|
double num;
|
|
if (discreteTime <= 0)
|
|
{
|
|
num = 0.0;
|
|
}
|
|
else
|
|
{
|
|
num = (double)discreteTime.OneTickBefore();
|
|
}
|
|
return num;
|
|
}
|
|
set
|
|
{
|
|
this.m_FixedDuration = Math.Max(0.0, value);
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000017 RID: 23
|
|
// (get) Token: 0x06000062 RID: 98 RVA: 0x000046D0 File Offset: 0x000028D0
|
|
// (set) Token: 0x06000063 RID: 99 RVA: 0x000046EB File Offset: 0x000028EB
|
|
public TimelineAsset.DurationMode durationMode
|
|
{
|
|
get
|
|
{
|
|
return this.m_DurationMode;
|
|
}
|
|
set
|
|
{
|
|
this.m_DurationMode = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000018 RID: 24
|
|
// (get) Token: 0x06000064 RID: 100 RVA: 0x000046F8 File Offset: 0x000028F8
|
|
public override IEnumerable<PlayableBinding> outputs
|
|
{
|
|
get
|
|
{
|
|
return this.GetOutputTracks().SelectMany((TrackAsset x) => x.outputs).ToArray<PlayableBinding>();
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000019 RID: 25
|
|
// (get) Token: 0x06000065 RID: 101 RVA: 0x0000473C File Offset: 0x0000293C
|
|
public ClipCaps clipCaps
|
|
{
|
|
get
|
|
{
|
|
ClipCaps clipCaps = ClipCaps.All;
|
|
foreach (TrackAsset trackAsset in this.m_Tracks)
|
|
{
|
|
foreach (TimelineClip timelineClip in trackAsset.clips)
|
|
{
|
|
clipCaps &= timelineClip.clipCaps;
|
|
}
|
|
}
|
|
return clipCaps;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001A RID: 26
|
|
// (get) Token: 0x06000066 RID: 102 RVA: 0x000047D4 File Offset: 0x000029D4
|
|
public int outputTrackCount
|
|
{
|
|
get
|
|
{
|
|
this.GetOutputTracks();
|
|
return this.m_CacheOutputTracks.Length;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001B RID: 27
|
|
// (get) Token: 0x06000067 RID: 103 RVA: 0x000047F8 File Offset: 0x000029F8
|
|
public int rootTrackCount
|
|
{
|
|
get
|
|
{
|
|
return this.m_Tracks.Count;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000068 RID: 104 RVA: 0x00004818 File Offset: 0x00002A18
|
|
public TrackAsset GetRootTrack(int index)
|
|
{
|
|
return this.m_Tracks[index];
|
|
}
|
|
|
|
// Token: 0x06000069 RID: 105 RVA: 0x0000483C File Offset: 0x00002A3C
|
|
public IEnumerable<TrackAsset> GetRootTracks()
|
|
{
|
|
return this.m_Tracks;
|
|
}
|
|
|
|
// Token: 0x0600006A RID: 106 RVA: 0x00004858 File Offset: 0x00002A58
|
|
public TrackAsset GetOutputTrack(int index)
|
|
{
|
|
this.GetOutputTracks();
|
|
return this.m_CacheOutputTracks[index];
|
|
}
|
|
|
|
// Token: 0x0600006B RID: 107 RVA: 0x0000487C File Offset: 0x00002A7C
|
|
public IEnumerable<TrackAsset> GetOutputTracks()
|
|
{
|
|
if (this.m_CacheOutputTracks == null)
|
|
{
|
|
this.m_CacheOutputTracks = this.flattenedTracks.Where((TrackAsset t) => t != null && t.mediaType != TimelineAsset.MediaType.Group && !t.isSubTrack).ToArray<TrackAsset>();
|
|
}
|
|
return this.m_CacheOutputTracks;
|
|
}
|
|
|
|
// Token: 0x0600006C RID: 108 RVA: 0x000048D8 File Offset: 0x00002AD8
|
|
public void OnEnable()
|
|
{
|
|
if (this.m_Tracks == null)
|
|
{
|
|
this.m_Tracks = new List<TrackAsset>();
|
|
}
|
|
this.m_Tracks.RemoveAll((TrackAsset t) => t == null);
|
|
}
|
|
|
|
// Token: 0x1700001C RID: 28
|
|
// (get) Token: 0x0600006D RID: 109 RVA: 0x00004928 File Offset: 0x00002B28
|
|
// (set) Token: 0x0600006E RID: 110 RVA: 0x00004943 File Offset: 0x00002B43
|
|
internal int id
|
|
{
|
|
get
|
|
{
|
|
return this.m_Id;
|
|
}
|
|
set
|
|
{
|
|
this.m_Id = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001D RID: 29
|
|
// (get) Token: 0x0600006F RID: 111 RVA: 0x00004950 File Offset: 0x00002B50
|
|
internal IEnumerable<TrackAsset> flattenedTracks
|
|
{
|
|
get
|
|
{
|
|
if (this.m_CacheFlattenedTracks == null)
|
|
{
|
|
this.m_CacheFlattenedTracks = this.m_Tracks.ToList<TrackAsset>();
|
|
foreach (TrackAsset trackAsset in this.m_Tracks)
|
|
{
|
|
TimelineAsset.AddSubTracksRecursive(trackAsset, ref this.m_CacheFlattenedTracks);
|
|
}
|
|
}
|
|
return this.m_CacheFlattenedTracks;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700001E RID: 30
|
|
// (get) Token: 0x06000070 RID: 112 RVA: 0x000049E0 File Offset: 0x00002BE0
|
|
internal List<TrackAsset> tracks
|
|
{
|
|
get
|
|
{
|
|
return this.m_Tracks;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000071 RID: 113 RVA: 0x000049FB File Offset: 0x00002BFB
|
|
internal void AddTrackInternal(TrackAsset track)
|
|
{
|
|
this.m_Tracks.Add(track);
|
|
track.parent = this;
|
|
this.Invalidate();
|
|
}
|
|
|
|
// Token: 0x06000072 RID: 114 RVA: 0x00004A18 File Offset: 0x00002C18
|
|
internal void AddTrackBefore(TrackAsset track, TrackAsset before)
|
|
{
|
|
this.AddTrackInternal(track);
|
|
this.MoveTracks(new List<TrackAsset> { track }, before, true);
|
|
}
|
|
|
|
// Token: 0x06000073 RID: 115 RVA: 0x00004A44 File Offset: 0x00002C44
|
|
internal void AddTrackAfter(TrackAsset track, TrackAsset after)
|
|
{
|
|
this.AddTrackInternal(track);
|
|
this.MoveTracks(new List<TrackAsset> { track }, after, false);
|
|
}
|
|
|
|
// Token: 0x06000074 RID: 116 RVA: 0x00004A70 File Offset: 0x00002C70
|
|
internal void MoveTracks(List<TrackAsset> tracks, TrackAsset insertAfterAsset, bool up)
|
|
{
|
|
List<TrackAsset> list = new List<TrackAsset>(this.m_Tracks);
|
|
for (int i = 0; i < tracks.Count; i++)
|
|
{
|
|
list.Remove(tracks[i]);
|
|
}
|
|
int num = list.IndexOf(insertAfterAsset);
|
|
num = ((!up) ? (num + 1) : Math.Max(num - 1, 0));
|
|
if (num < 0)
|
|
{
|
|
Debug.LogError("target track not found");
|
|
}
|
|
else
|
|
{
|
|
for (int j = 0; j < tracks.Count; j++)
|
|
{
|
|
num = ((!up) ? Math.Min(num, list.Count) : Math.Max(num, 0));
|
|
list.Insert(num, tracks[j]);
|
|
}
|
|
this.m_Tracks = list;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000075 RID: 117 RVA: 0x00004B38 File Offset: 0x00002D38
|
|
internal void RemoveTrack(TrackAsset track)
|
|
{
|
|
this.m_Tracks.Remove(track);
|
|
this.Invalidate();
|
|
TrackAsset trackAsset = track.parent as TrackAsset;
|
|
if (trackAsset != null)
|
|
{
|
|
trackAsset.RemoveSubTrack(track);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000076 RID: 118 RVA: 0x00004B7C File Offset: 0x00002D7C
|
|
internal int GenerateNewId()
|
|
{
|
|
this.m_NextId++;
|
|
return base.GetInstanceID().GetHashCode().CombineHash(this.m_NextId.GetHashCode());
|
|
}
|
|
|
|
// Token: 0x06000077 RID: 119 RVA: 0x00004BCC File Offset: 0x00002DCC
|
|
public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
|
|
{
|
|
bool flag = false;
|
|
bool flag2 = graph.GetPlayableCount() == 0;
|
|
ScriptPlayable<TimelinePlayable> scriptPlayable = TimelinePlayable.Create(graph, this.flattenedTracks.ToList<TrackAsset>(), go, flag, flag2);
|
|
return (!scriptPlayable.IsValid<ScriptPlayable<TimelinePlayable>>()) ? Playable.Null : scriptPlayable;
|
|
}
|
|
|
|
// Token: 0x06000078 RID: 120 RVA: 0x00004C1E File Offset: 0x00002E1E
|
|
void ISerializationCallbackReceiver.OnAfterDeserialize()
|
|
{
|
|
this.Invalidate();
|
|
}
|
|
|
|
// Token: 0x06000079 RID: 121 RVA: 0x00004C27 File Offset: 0x00002E27
|
|
void ISerializationCallbackReceiver.OnBeforeSerialize()
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600007A RID: 122 RVA: 0x00004C2C File Offset: 0x00002E2C
|
|
public void GatherProperties(PlayableDirector director, IPropertyCollector driver)
|
|
{
|
|
IEnumerable<TrackAsset> outputTracks = this.GetOutputTracks();
|
|
foreach (TrackAsset trackAsset in outputTracks)
|
|
{
|
|
trackAsset.GatherProperties(director, driver);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600007B RID: 123 RVA: 0x00004C8C File Offset: 0x00002E8C
|
|
internal void Invalidate()
|
|
{
|
|
this.m_CacheOutputTracks = null;
|
|
this.m_CacheFlattenedTracks = null;
|
|
}
|
|
|
|
// Token: 0x0600007C RID: 124 RVA: 0x00004CA0 File Offset: 0x00002EA0
|
|
private double CalculateDuration()
|
|
{
|
|
IEnumerable<TrackAsset> flattenedTracks = this.flattenedTracks;
|
|
double num;
|
|
if (!flattenedTracks.Any<TrackAsset>())
|
|
{
|
|
num = 0.0;
|
|
}
|
|
else
|
|
{
|
|
DiscreteTime discreteTime = (DiscreteTime)flattenedTracks.Max((TrackAsset t) => t.end);
|
|
if (discreteTime <= 0)
|
|
{
|
|
num = 0.0;
|
|
}
|
|
else
|
|
{
|
|
num = (double)discreteTime.OneTickBefore();
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600007D RID: 125 RVA: 0x00004D2C File Offset: 0x00002F2C
|
|
private static void AddSubTracksRecursive(TrackAsset track, ref List<TrackAsset> allTracks)
|
|
{
|
|
if (!(track == null))
|
|
{
|
|
if (track.subTracks != null && track.subTracks.Count != 0)
|
|
{
|
|
allTracks.AddRange(track.subTracks);
|
|
foreach (TrackAsset trackAsset in track.subTracks)
|
|
{
|
|
TimelineAsset.AddSubTracksRecursive(trackAsset, ref allTracks);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600007E RID: 126 RVA: 0x00004DCC File Offset: 0x00002FCC
|
|
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);
|
|
}
|
|
}
|
|
PlayableAsset playableAsset = ((!(parent != null)) ? this : parent);
|
|
string text = name;
|
|
if (string.IsNullOrEmpty(text))
|
|
{
|
|
text = type.Name;
|
|
}
|
|
string text2 = TimelineCreateUtilities.GenerateUniqueActorName(this, text);
|
|
TrackAsset trackAsset = this.AllocateTrack(parent, text2, type);
|
|
if (trackAsset != null)
|
|
{
|
|
trackAsset.name = text2;
|
|
TimelineCreateUtilities.SaveAssetIntoObject(trackAsset, playableAsset);
|
|
}
|
|
return trackAsset;
|
|
}
|
|
|
|
// Token: 0x0600007F RID: 127 RVA: 0x00004EC4 File Offset: 0x000030C4
|
|
public T CreateTrack<T>(TrackAsset parent, string name) where T : TrackAsset, new()
|
|
{
|
|
return (T)((object)this.CreateTrack(typeof(T), parent, name));
|
|
}
|
|
|
|
// Token: 0x06000080 RID: 128 RVA: 0x00004EF0 File Offset: 0x000030F0
|
|
public bool DeleteClip(TimelineClip clip)
|
|
{
|
|
bool flag;
|
|
if (clip == null || clip.parentTrack == null)
|
|
{
|
|
flag = false;
|
|
}
|
|
else if (this != clip.parentTrack.timelineAsset)
|
|
{
|
|
Debug.LogError("Cannot delete a clip from this timeline");
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
if (clip.curves != null)
|
|
{
|
|
TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.curves, "Delete Curves");
|
|
}
|
|
if (clip.asset != null)
|
|
{
|
|
this.DeleteRecordedAnimation(clip);
|
|
TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.asset, "Delete Clip Asset");
|
|
}
|
|
TrackAsset parentTrack = clip.parentTrack;
|
|
parentTrack.RemoveClip(clip);
|
|
parentTrack.CalculateExtrapolationTimes();
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000081 RID: 129 RVA: 0x00004FC0 File Offset: 0x000031C0
|
|
public bool DeleteTrack(TrackAsset track)
|
|
{
|
|
bool flag;
|
|
if (track.timelineAsset != this)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
TrackAsset trackAsset = track.parent as TrackAsset;
|
|
if (trackAsset != null)
|
|
{
|
|
}
|
|
if (track.subTracks != null)
|
|
{
|
|
IEnumerable<TrackAsset> childTracks = track.GetChildTracks();
|
|
foreach (TrackAsset trackAsset2 in childTracks)
|
|
{
|
|
this.DeleteTrack(trackAsset2);
|
|
}
|
|
}
|
|
this.DeleteRecordingClip(track);
|
|
List<TimelineClip> list = new List<TimelineClip>(track.clips);
|
|
foreach (TimelineClip timelineClip in list)
|
|
{
|
|
this.DeleteClip(timelineClip);
|
|
}
|
|
this.RemoveTrack(track);
|
|
TimelineUndo.PushDestroyUndo(this, this, track, "Delete Track");
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x06000082 RID: 130 RVA: 0x000050E0 File Offset: 0x000032E0
|
|
internal TrackAsset AllocateTrack(TrackAsset parent, string name, Type trackType)
|
|
{
|
|
if (parent != null && parent.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");
|
|
}
|
|
TrackAsset trackAsset = ScriptableObject.CreateInstance(trackType) as TrackAsset;
|
|
if (parent != null)
|
|
{
|
|
trackAsset.parent = parent;
|
|
}
|
|
else
|
|
{
|
|
trackAsset.parent = this;
|
|
}
|
|
trackAsset.name = name;
|
|
if (parent != null)
|
|
{
|
|
parent.subTracks.Add(trackAsset);
|
|
}
|
|
else
|
|
{
|
|
this.AddTrackInternal(trackAsset);
|
|
}
|
|
this.Invalidate();
|
|
return trackAsset;
|
|
}
|
|
|
|
// Token: 0x06000083 RID: 131 RVA: 0x000051A4 File Offset: 0x000033A4
|
|
private void DeleteRecordingClip(TrackAsset track)
|
|
{
|
|
AnimationTrack animationTrack = track as AnimationTrack;
|
|
if (!(animationTrack == null) && !(animationTrack.animClip == null))
|
|
{
|
|
TimelineUndo.PushDestroyUndo(this, track, animationTrack.animClip, "Delete Track");
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000084 RID: 132 RVA: 0x000051F0 File Offset: 0x000033F0
|
|
private void DeleteRecordedAnimation(TimelineClip clip)
|
|
{
|
|
if (clip != null)
|
|
{
|
|
if (clip.curves != null)
|
|
{
|
|
TimelineUndo.PushDestroyUndo(this, clip.parentTrack, clip.curves, "Delete Parameters");
|
|
}
|
|
if (clip.recordable)
|
|
{
|
|
AnimationPlayableAsset animationPlayableAsset = clip.asset as AnimationPlayableAsset;
|
|
if (!(animationPlayableAsset == null) && !(animationPlayableAsset.clip == null))
|
|
{
|
|
TimelineUndo.PushDestroyUndo(this, animationPlayableAsset, animationPlayableAsset.clip, "Delete Recording");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0400001E RID: 30
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int m_Id;
|
|
|
|
// Token: 0x0400001F RID: 31
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private int m_NextId;
|
|
|
|
// Token: 0x04000020 RID: 32
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private List<TrackAsset> m_Tracks;
|
|
|
|
// Token: 0x04000021 RID: 33
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private double m_FixedDuration;
|
|
|
|
// Token: 0x04000022 RID: 34
|
|
[HideInInspector]
|
|
[NonSerialized]
|
|
private TrackAsset[] m_CacheOutputTracks;
|
|
|
|
// Token: 0x04000023 RID: 35
|
|
[HideInInspector]
|
|
[NonSerialized]
|
|
private List<TrackAsset> m_CacheFlattenedTracks;
|
|
|
|
// Token: 0x04000024 RID: 36
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private TimelineAsset.EditorSettings m_EditorSettings = new TimelineAsset.EditorSettings();
|
|
|
|
// Token: 0x04000025 RID: 37
|
|
[SerializeField]
|
|
public TimelineAsset.SequenceUpdateMode m_UpdateMode = TimelineAsset.SequenceUpdateMode.TimeBased;
|
|
|
|
// Token: 0x04000026 RID: 38
|
|
[SerializeField]
|
|
public string m_ParameterName = "";
|
|
|
|
// Token: 0x04000027 RID: 39
|
|
[SerializeField]
|
|
public TimelineAsset.DurationMode m_DurationMode;
|
|
|
|
// Token: 0x0200000D RID: 13
|
|
public enum SequenceUpdateMode
|
|
{
|
|
// Token: 0x0400002D RID: 45
|
|
TimeBased,
|
|
// Token: 0x0400002E RID: 46
|
|
ParameterBased,
|
|
// Token: 0x0400002F RID: 47
|
|
ParentSequence
|
|
}
|
|
|
|
// Token: 0x0200000E RID: 14
|
|
public enum MediaType
|
|
{
|
|
// Token: 0x04000031 RID: 49
|
|
Animation,
|
|
// Token: 0x04000032 RID: 50
|
|
Audio,
|
|
// Token: 0x04000033 RID: 51
|
|
Video,
|
|
// Token: 0x04000034 RID: 52
|
|
Script,
|
|
// Token: 0x04000035 RID: 53
|
|
Hybrid,
|
|
// Token: 0x04000036 RID: 54
|
|
Group
|
|
}
|
|
|
|
// Token: 0x0200000F RID: 15
|
|
public enum DurationMode
|
|
{
|
|
// Token: 0x04000038 RID: 56
|
|
BasedOnClips,
|
|
// Token: 0x04000039 RID: 57
|
|
FixedLength
|
|
}
|
|
|
|
// Token: 0x02000010 RID: 16
|
|
[Serializable]
|
|
public class EditorSettings
|
|
{
|
|
// Token: 0x0400003A RID: 58
|
|
internal static readonly float kDefaultFPS = 60f;
|
|
|
|
// Token: 0x0400003B RID: 59
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
public float fps = TimelineAsset.EditorSettings.kDefaultFPS;
|
|
}
|
|
}
|
|
}
|