public void Process(float sequenceTime, float playbackRate)
{
this.allClips.Clear();
for (int i = 0; i < this.AnimationTimeline.AnimationTracks.Count; i++)
{
AnimationTrack animationTrack = this.AnimationTimeline.AnimationTracks[i];
for (int j = 0; j < animationTrack.TrackClips.Count; j++)
{
AnimationClipData animationClipData = animationTrack.TrackClips[j];
this.allClips.Add(animationClipData);
animationClipData.RunningLayer = animationTrack.Layer;
}
}
float num = sequenceTime - this.previousTime;
float num2 = Mathf.Abs(num);
bool flag = num < 0f;
float num3 = USSequencer.SequenceUpdateRate;
float num4 = this.previousTime + num3;
if (flag)
{
this.AnimationTimeline.ResetAnimation();
this.previousTime = 0f;
this.AnimationTimeline.Process(sequenceTime, playbackRate);
}
else
{
while (num2 > 0f)
{
this.cachedRunningClips.Clear();
for (int k = 0; k < this.allClips.Count; k++)
{
AnimationClipData animationClipData2 = this.allClips[k];
if (AnimationClipData.IsClipRunning(num4, animationClipData2))
{
this.cachedRunningClips.Add(animationClipData2);
}
}
this.cachedRunningClips.Sort((AnimationClipData x, AnimationClipData y) => x.StartTime.CompareTo(y.StartTime));
for (int l = 0; l < this.cachedRunningClips.Count; l++)
{
AnimationClipData animationClipData3 = this.cachedRunningClips[l];
this.PlayClip(animationClipData3, animationClipData3.RunningLayer, num4);
}
this.Animator.Update(num3);
num2 -= USSequencer.SequenceUpdateRate;
if (!Mathf.Approximately(num2, 1.401298E-45f) && num2 < USSequencer.SequenceUpdateRate)
{
num3 = num2;
}
num4 += num3;
}
}
this.previousTime = sequenceTime;
}
private void SortNewProcessingClips(float sequenceTime)
{
var orderedNewProcessingClips = newProcessingClips.OrderBy(processingClip => processingClip.StartTime);
foreach (var clipData in orderedNewProcessingClips)
{
if (AnimationClipData.IsClipNotRunning(sequenceTime, clipData))
{
notRunningClips.Add(clipData);
}
else if (!AnimationClipData.IsClipNotRunning(sequenceTime, clipData) && notRunningClips.Contains(clipData))
{
notRunningClips.Remove(clipData);
}
if (AnimationClipData.IsClipRunning(sequenceTime, clipData))
{
runningClips.Add(clipData);
PlayClip(clipData, clipData.RunningLayer, sequenceTime);
}
else if (!AnimationClipData.IsClipRunning(sequenceTime, clipData) && runningClips.Contains(clipData))
{
runningClips.Remove(clipData);
}
if (AnimationClipData.IsClipFinished(sequenceTime, clipData))
{
finishedClips.Add(clipData);
}
else if (!AnimationClipData.IsClipFinished(sequenceTime, clipData) && finishedClips.Contains(clipData))
{
finishedClips.Remove(clipData);
}
}
newProcessingClips.Clear();
}
private void SortNewProcessingClips(float sequenceTime)
{
IOrderedEnumerable <AnimationClipData> orderedEnumerable = from processingClip in this.newProcessingClips
orderby processingClip.StartTime
select processingClip;
foreach (AnimationClipData current in orderedEnumerable)
{
if (AnimationClipData.IsClipNotRunning(sequenceTime, current))
{
this.notRunningClips.Add(current);
}
else if (!AnimationClipData.IsClipNotRunning(sequenceTime, current) && this.notRunningClips.Contains(current))
{
this.notRunningClips.Remove(current);
}
if (AnimationClipData.IsClipRunning(sequenceTime, current))
{
this.runningClips.Add(current);
this.PlayClip(current, current.RunningLayer, sequenceTime);
}
else if (!AnimationClipData.IsClipRunning(sequenceTime, current) && this.runningClips.Contains(current))
{
this.runningClips.Remove(current);
}
if (AnimationClipData.IsClipFinished(sequenceTime, current))
{
this.finishedClips.Add(current);
}
else if (!AnimationClipData.IsClipFinished(sequenceTime, current) && this.finishedClips.Contains(current))
{
this.finishedClips.Remove(current);
}
}
this.newProcessingClips.Clear();
}
public void Process(float sequenceTime, float playbackRate)
{
allClips.Clear();
for (var index = 0; index < AnimationTimeline.AnimationTracks.Count; index++)
{
var track = AnimationTimeline.AnimationTracks[index];
for (var trackClipIndex = 0; trackClipIndex < track.TrackClips.Count; trackClipIndex++)
{
var trackClip = track.TrackClips[trackClipIndex];
allClips.Add(trackClip);
trackClip.RunningLayer = track.Layer;
}
}
var totalDeltaTime = sequenceTime - previousTime;
var absDeltaTime = Mathf.Abs(totalDeltaTime);
var timelinePlayingInReverse = totalDeltaTime < 0.0f;
var runningTime = USSequencer.SequenceUpdateRate;
var runningTotalTime = previousTime + runningTime;
if (timelinePlayingInReverse)
{
AnimationTimeline.ResetAnimation();
previousTime = 0.0f;
AnimationTimeline.Process(sequenceTime, playbackRate);
}
else
{
while (absDeltaTime > 0.0f)
{
cachedRunningClips.Clear();
for (var allClipIndex = 0; allClipIndex < allClips.Count; allClipIndex++)
{
var clip = allClips[allClipIndex];
if (!AnimationClipData.IsClipRunning(runningTotalTime, clip))
{
continue;
}
cachedRunningClips.Add(clip);
}
cachedRunningClips.Sort((x, y) => x.StartTime.CompareTo(y.StartTime));
for (var runningClipIndex = 0; runningClipIndex < cachedRunningClips.Count; runningClipIndex++)
{
var clip = cachedRunningClips[runningClipIndex];
PlayClip(clip, clip.RunningLayer, runningTotalTime);
}
Animator.Update(runningTime);
absDeltaTime -= USSequencer.SequenceUpdateRate;
if (!Mathf.Approximately(absDeltaTime, Mathf.Epsilon) && absDeltaTime < USSequencer.SequenceUpdateRate)
{
runningTime = absDeltaTime;
}
runningTotalTime += runningTime;
}
}
previousTime = sequenceTime;
}
