public void Update(float delta)
{
delta *= timeScale;
for (int i = 0; i < tracks.Count; i++)
{
TrackEntry current = tracks[i];
if (current == null)
{
continue;
}
float trackDelta = delta * current.timeScale;
float time = current.time + trackDelta;
float endTime = current.endTime;
current.time = time;
if (current.previous != null)
{
current.previous.time += trackDelta;
current.mixTime += trackDelta;
}
// Check if completed the animation or a loop iteration.
if (current.loop
? (current.lastTime % endTime > time % endTime)
: (current.lastTime < endTime && time >= endTime))
{
var count = (int)(time / endTime);
current.OnComplete(this, i, count);
if (Complete != null)
{
Complete(this, i, count);
}
}
TrackEntry next = current.next;
if (next != null)
{
next.time = current.lastTime - next.delay;
if (next.time >= 0)
{
SetCurrent(i, next);
}
}
else
{
// End non-looping animation when it reaches its end time and there is no next entry.
if (!current.loop && current.lastTime >= current.endTime)
{
ClearTrack(i);
}
}
}
}
public void Drain()
{
if (drainDisabled)
{
return;
}
drainDisabled = true;
var entries = this.eventQueueEntries;
var entriesItems = entries.Items;
AnimationState state = this.state;
for (int i = 0, n = entries.Count; i < n; i++)
{
var queueEntry = entriesItems[i];
TrackEntry trackEntry = queueEntry.entry;
switch (queueEntry.type)
{
case EventType.Start:
trackEntry.OnStart();
state.OnStart(trackEntry);
break;
case EventType.Interrupt:
trackEntry.OnInterrupt();
state.OnInterrupt(trackEntry);
break;
case EventType.End:
trackEntry.OnEnd();
state.OnEnd(trackEntry);
goto case EventType.Dispose; // Fall through. (C#)
case EventType.Dispose:
trackEntry.OnDispose();
state.OnDispose(trackEntry);
break;
case EventType.Complete:
trackEntry.OnComplete();
state.OnComplete(trackEntry);
break;
case EventType.Event:
trackEntry.OnEvent(queueEntry.e);
state.OnEvent(trackEntry, queueEntry.e);
break;
}
}
eventQueueEntries.Clear();
drainDisabled = false;
}
internal void Drain()
{
if (drainDisabled)
{
return;
}
drainDisabled = true;
List <EventQueueEntry> list = eventQueueEntries;
AnimationState animationState = state;
for (int i = 0; i < list.Count; i++)
{
EventQueueEntry eventQueueEntry = list[i];
TrackEntry entry = eventQueueEntry.entry;
switch (eventQueueEntry.type)
{
case EventType.Start:
entry.OnStart();
animationState.OnStart(entry);
break;
case EventType.Interrupt:
entry.OnInterrupt();
animationState.OnInterrupt(entry);
break;
case EventType.End:
entry.OnEnd();
animationState.OnEnd(entry);
goto case EventType.Dispose;
case EventType.Dispose:
entry.OnDispose();
animationState.OnDispose(entry);
trackEntryPool.Free(entry);
break;
case EventType.Complete:
entry.OnComplete();
animationState.OnComplete(entry);
break;
case EventType.Event:
entry.OnEvent(eventQueueEntry.e);
animationState.OnEvent(entry, eventQueueEntry.e);
break;
}
}
eventQueueEntries.Clear();
drainDisabled = false;
}
public void Update(float delta)
{
delta *= this.timeScale;
for (int i = 0; i < this.tracks.Count; i++)
{
TrackEntry trackEntry = this.tracks.Items[i];
if (trackEntry != null)
{
float num = delta * trackEntry.timeScale;
float num2 = trackEntry.time + num;
float endTime = trackEntry.endTime;
trackEntry.time = num2;
if (trackEntry.previous != null)
{
trackEntry.previous.time += num;
trackEntry.mixTime += num;
}
if ((!trackEntry.loop) ? (trackEntry.lastTime < endTime && num2 >= endTime) : (trackEntry.lastTime % endTime > num2 % endTime))
{
int loopCount = (int)(num2 / endTime);
trackEntry.OnComplete(this, i, loopCount);
if (this.Complete != null)
{
this.Complete(this, i, loopCount);
}
}
TrackEntry next = trackEntry.next;
if (next != null)
{
next.time = trackEntry.lastTime - next.delay;
if (next.time >= 0f)
{
this.SetCurrent(i, next);
}
}
else if (!trackEntry.loop && trackEntry.lastTime >= trackEntry.endTime)
{
this.ClearTrack(i);
}
}
}
}
internal void Drain()
{
if (!this.drainDisabled)
{
this.drainDisabled = true;
List <EventQueueEntry> eventQueueEntries = this.eventQueueEntries;
AnimationState state = this.state;
for (int i = 0; i < eventQueueEntries.Count; i++)
{
EventQueueEntry entry = eventQueueEntries[i];
TrackEntry entry2 = entry.entry;
switch (entry.type)
{
case EventType.Start:
{
entry2.OnStart();
state.OnStart(entry2);
continue;
}
case EventType.Interrupt:
{
entry2.OnInterrupt();
state.OnInterrupt(entry2);
continue;
}
case EventType.End:
entry2.OnEnd();
state.OnEnd(entry2);
break;
case EventType.Dispose:
break;
case EventType.Complete:
goto Label_00C3;
case EventType.Event:
goto Label_00D7;
default:
{
continue;
}
}
entry2.OnDispose();
state.OnDispose(entry2);
this.trackEntryPool.Free(entry2);
continue;
Label_00C3:
entry2.OnComplete();
state.OnComplete(entry2);
continue;
Label_00D7:
entry2.OnEvent(entry.e);
state.OnEvent(entry2, entry.e);
}
this.eventQueueEntries.Clear();
this.drainDisabled = false;
}
}
