niko
249 lines
8.7 KiB
C#
249 lines
8.7 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine.Animations;
|
|
using UnityEngine.Audio;
|
|
using UnityEngine.Playables;
|
|
|
|
namespace UnityEngine.Timeline
|
|
{
|
|
// Token: 0x0200001D RID: 29
|
|
public class TimelinePlayable : PlayableBehaviour
|
|
{
|
|
// Token: 0x060000ED RID: 237 RVA: 0x00006490 File Offset: 0x00004690
|
|
public static ScriptPlayable<TimelinePlayable> Create(PlayableGraph graph, IList<TrackAsset> tracks, GameObject go, bool autoRebalance, bool createOutputs)
|
|
{
|
|
if (tracks == null)
|
|
{
|
|
throw new ArgumentNullException("Tracks list is null", "tracks");
|
|
}
|
|
if (go == null)
|
|
{
|
|
throw new ArgumentNullException("GameObject parameter is null", "go");
|
|
}
|
|
ScriptPlayable<TimelinePlayable> scriptPlayable = ScriptPlayable<TimelinePlayable>.Create(graph, 0);
|
|
TimelinePlayable behaviour = scriptPlayable.GetBehaviour();
|
|
behaviour.Compile(graph, scriptPlayable, tracks, go, autoRebalance, createOutputs);
|
|
return scriptPlayable;
|
|
}
|
|
|
|
// Token: 0x060000EE RID: 238 RVA: 0x000064FC File Offset: 0x000046FC
|
|
public void Compile(PlayableGraph graph, Playable timelinePlayable, IList<TrackAsset> tracks, GameObject go, bool autoRebalance, bool createOutputs)
|
|
{
|
|
if (tracks == null)
|
|
{
|
|
throw new ArgumentNullException("Tracks list is null", "tracks");
|
|
}
|
|
if (go == null)
|
|
{
|
|
throw new ArgumentNullException("GameObject parameter is null", "go");
|
|
}
|
|
int num = tracks.Count * 2 + tracks.Count;
|
|
this.m_CurrentListOfActiveClips = this.m_IntervalTree.AllocateCache<RuntimeClipBase>(num);
|
|
this.m_ActiveClips = this.m_IntervalTree.AllocateCache<RuntimeClipBase>(num);
|
|
IList<TrackAsset> list = tracks.Where((TrackAsset t) => t.soloed).ToList<TrackAsset>();
|
|
if (list.Count == 0)
|
|
{
|
|
list = tracks;
|
|
}
|
|
this.m_EvaluateCallbacks.Clear();
|
|
this.m_PlayableCache.Clear();
|
|
this.CompileTrackList(graph, timelinePlayable, list, go, createOutputs);
|
|
}
|
|
|
|
// Token: 0x060000EF RID: 239 RVA: 0x000065CC File Offset: 0x000047CC
|
|
private void CompileTrackList(PlayableGraph graph, Playable timelinePlayable, IEnumerable<TrackAsset> tracks, GameObject go, bool createOutputs)
|
|
{
|
|
foreach (TrackAsset trackAsset in tracks)
|
|
{
|
|
if (trackAsset.compilable)
|
|
{
|
|
if (!this.m_IntervalTree.Contains(trackAsset))
|
|
{
|
|
trackAsset.SortClips();
|
|
this.m_IntervalTree.Add(trackAsset);
|
|
this.CreateTrackPlayable(graph, timelinePlayable, trackAsset, go, createOutputs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000F0 RID: 240 RVA: 0x00006660 File Offset: 0x00004860
|
|
private void CreateTrackOutput(PlayableGraph graph, GameObject go, TrackAsset track, Playable playable, int port)
|
|
{
|
|
if (!track.isSubTrack)
|
|
{
|
|
IEnumerable<PlayableBinding> outputs = track.outputs;
|
|
foreach (PlayableBinding playableBinding in outputs)
|
|
{
|
|
if (playableBinding.streamType == DataStreamType.Animation)
|
|
{
|
|
AnimationPlayableOutput animationPlayableOutput = AnimationPlayableOutput.Create(graph, playableBinding.streamName, null);
|
|
animationPlayableOutput.SetReferenceObject(playableBinding.sourceObject);
|
|
animationPlayableOutput.SetSourcePlayable(playable);
|
|
animationPlayableOutput.SetSourceInputPort(port);
|
|
this.m_EvaluateCallbacks.Add(new AnimationOutputWeightProcessor(animationPlayableOutput));
|
|
}
|
|
else if (playableBinding.streamType == DataStreamType.Audio)
|
|
{
|
|
AudioPlayableOutput audioPlayableOutput = AudioPlayableOutput.Create(graph, playableBinding.streamName, null);
|
|
audioPlayableOutput.SetReferenceObject(playableBinding.sourceObject);
|
|
audioPlayableOutput.SetSourcePlayable(playable);
|
|
audioPlayableOutput.SetSourceInputPort(port);
|
|
}
|
|
else
|
|
{
|
|
if (playableBinding.streamType != DataStreamType.None)
|
|
{
|
|
throw new NotImplementedException("Unsupported stream type");
|
|
}
|
|
ScriptPlayableOutput scriptPlayableOutput = ScriptPlayableOutput.Create(graph, playableBinding.streamName);
|
|
scriptPlayableOutput.SetReferenceObject(playableBinding.sourceObject);
|
|
scriptPlayableOutput.SetSourcePlayable(playable);
|
|
scriptPlayableOutput.SetSourceInputPort(port);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000F1 RID: 241 RVA: 0x000067B8 File Offset: 0x000049B8
|
|
private static Playable CreatePlayableGraph(PlayableGraph graph, TrackAsset asset, GameObject go, IntervalTree tree)
|
|
{
|
|
return asset.CreatePlayableGraph(graph, go, tree);
|
|
}
|
|
|
|
// Token: 0x060000F2 RID: 242 RVA: 0x000067D8 File Offset: 0x000049D8
|
|
private Playable CreateTrackPlayable(PlayableGraph graph, Playable timelinePlayable, TrackAsset track, GameObject go, bool createOutputs)
|
|
{
|
|
Playable playable;
|
|
TimelinePlayable.ConnectionCache connectionCache;
|
|
if (!track.compilable)
|
|
{
|
|
playable = timelinePlayable;
|
|
}
|
|
else if (this.m_PlayableCache.TryGetValue(track, out connectionCache))
|
|
{
|
|
playable = connectionCache.playable;
|
|
}
|
|
else if (track.name == "root")
|
|
{
|
|
playable = timelinePlayable;
|
|
}
|
|
else
|
|
{
|
|
TrackAsset trackAsset = track.parent as TrackAsset;
|
|
Playable playable2 = ((!(trackAsset != null)) ? timelinePlayable : this.CreateTrackPlayable(graph, timelinePlayable, trackAsset, go, createOutputs));
|
|
Playable playable3 = TimelinePlayable.CreatePlayableGraph(graph, track, go, this.m_IntervalTree);
|
|
bool flag = false;
|
|
if (!playable3.IsValid<Playable>())
|
|
{
|
|
throw new InvalidOperationException(string.Concat(new object[]
|
|
{
|
|
track.name,
|
|
"(",
|
|
track.GetType(),
|
|
") did not produce a valid playable. Use the compilable property to indicate whether the track is valid for processing"
|
|
}));
|
|
}
|
|
if (playable2.IsValid<Playable>() && playable3.IsValid<Playable>())
|
|
{
|
|
int inputCount = playable2.GetInputCount<Playable>();
|
|
playable2.SetInputCount(inputCount + 1);
|
|
flag = graph.Connect<Playable, Playable>(playable3, 0, playable2, inputCount);
|
|
playable2.SetInputWeight(inputCount, 1f);
|
|
}
|
|
if (createOutputs && flag)
|
|
{
|
|
this.CreateTrackOutput(graph, go, track, playable2, playable2.GetInputCount<Playable>() - 1);
|
|
}
|
|
this.CacheTrack(track, playable3, (!flag) ? (-1) : (playable2.GetInputCount<Playable>() - 1), playable2);
|
|
playable = playable3;
|
|
}
|
|
return playable;
|
|
}
|
|
|
|
// Token: 0x060000F3 RID: 243 RVA: 0x00006946 File Offset: 0x00004B46
|
|
public override void PrepareFrame(Playable playable, FrameData info)
|
|
{
|
|
this.Evaluate(playable, info);
|
|
}
|
|
|
|
// Token: 0x060000F4 RID: 244 RVA: 0x00006954 File Offset: 0x00004B54
|
|
private void Evaluate(Playable playable, FrameData frameData)
|
|
{
|
|
if (this.m_IntervalTree != null)
|
|
{
|
|
double time = playable.GetTime<Playable>();
|
|
this.m_ActiveBit = ((this.m_ActiveBit != 0) ? 0 : 1);
|
|
this.m_CurrentListOfActiveClips.Clear();
|
|
this.m_IntervalTree.IntersectsWith<RuntimeClipBase>(DiscreteTime.GetNearestTick(time), this.m_ActiveBit, ref this.m_CurrentListOfActiveClips);
|
|
for (int i = 0; i < this.m_ActiveClips.Count; i++)
|
|
{
|
|
RuntimeClipBase runtimeClipBase = this.m_ActiveClips[i];
|
|
if (runtimeClipBase.intervalBit != this.m_ActiveBit)
|
|
{
|
|
runtimeClipBase.enable = false;
|
|
}
|
|
}
|
|
for (int j = 0; j < this.m_CurrentListOfActiveClips.Count; j++)
|
|
{
|
|
this.m_CurrentListOfActiveClips[j].EvaluateAt(time, frameData);
|
|
}
|
|
this.m_ActiveClips.Clear();
|
|
this.m_ActiveClips.AddRange(this.m_CurrentListOfActiveClips);
|
|
int count = this.m_EvaluateCallbacks.Count;
|
|
for (int k = 0; k < count; k++)
|
|
{
|
|
this.m_EvaluateCallbacks[k].Evaluate();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000F5 RID: 245 RVA: 0x00006A84 File Offset: 0x00004C84
|
|
private void CacheTrack(TrackAsset track, Playable playable, int port, Playable parent)
|
|
{
|
|
this.m_PlayableCache[track] = new TimelinePlayable.ConnectionCache
|
|
{
|
|
playable = playable,
|
|
port = port,
|
|
parent = parent,
|
|
evalWeight = 0f
|
|
};
|
|
}
|
|
|
|
// Token: 0x0400006D RID: 109
|
|
private IntervalTree m_IntervalTree = new IntervalTree();
|
|
|
|
// Token: 0x0400006E RID: 110
|
|
private List<RuntimeClipBase> m_ActiveClips = new List<RuntimeClipBase>();
|
|
|
|
// Token: 0x0400006F RID: 111
|
|
private List<RuntimeClipBase> m_CurrentListOfActiveClips;
|
|
|
|
// Token: 0x04000070 RID: 112
|
|
private int m_ActiveBit = 0;
|
|
|
|
// Token: 0x04000071 RID: 113
|
|
private List<ITimelineEvaluateCallback> m_EvaluateCallbacks = new List<ITimelineEvaluateCallback>();
|
|
|
|
// Token: 0x04000072 RID: 114
|
|
private Dictionary<TrackAsset, TimelinePlayable.ConnectionCache> m_PlayableCache = new Dictionary<TrackAsset, TimelinePlayable.ConnectionCache>();
|
|
|
|
// Token: 0x0200001E RID: 30
|
|
private struct ConnectionCache
|
|
{
|
|
// Token: 0x04000074 RID: 116
|
|
public Playable playable;
|
|
|
|
// Token: 0x04000075 RID: 117
|
|
public int port;
|
|
|
|
// Token: 0x04000076 RID: 118
|
|
public Playable parent;
|
|
|
|
// Token: 0x04000077 RID: 119
|
|
public float evalWeight;
|
|
}
|
|
}
|
|
}
|