public void Apply(Skeleton skeleton)
{
List <Event> events = this.events;
for (int i = 0; i < tracks.Count; i++)
{
TrackEntry current = tracks[i];
if (current == null)
{
continue;
}
events.Clear();
float time = current.time;
bool loop = current.loop;
if (!loop && time > current.endTime)
{
time = current.endTime;
}
TrackEntry previous = current.previous;
if (previous == null)
{
current.animation.Apply(skeleton, current.lastTime, time, loop, events);
}
else
{
float previousTime = previous.time;
if (!previous.loop && previousTime > previous.endTime)
{
previousTime = previous.endTime;
}
previous.animation.Apply(skeleton, previousTime, previousTime, previous.loop, null);
float alpha = current.mixTime / current.mixDuration;
if (alpha >= 1)
{
alpha = 1;
current.previous = null;
}
current.animation.Mix(skeleton, current.lastTime, time, loop, events, alpha);
}
for (int ii = 0, nn = events.Count; ii < nn; ii++)
{
Event e = events[ii];
current.OnEvent(this, i, e);
if (Event != null)
{
Event(this, new EventTriggeredArgs(i, e));
}
}
current.lastTime = current.time;
}
}
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 Apply(Skeleton skeleton)
{
ExposedList <Event> events = this.events;
for (int i = 0; i < tracks.Count; i++)
{
TrackEntry current = tracks.Items[i];
if (current == null)
{
continue;
}
events.Clear();
float time = current.time;
bool loop = current.loop;
if (!loop && time > current.endTime)
{
time = current.endTime;
}
TrackEntry previous = current.previous;
if (previous == null)
{
if (current.mix == 1)
{
current.animation.Apply(skeleton, current.lastTime, time, loop, events);
}
else
{
current.animation.Mix(skeleton, current.lastTime, time, loop, events, current.mix);
}
}
else
{
float previousTime = previous.time;
if (!previous.loop && previousTime > previous.endTime)
{
previousTime = previous.endTime;
}
previous.animation.Apply(skeleton, previous.lastTime, previousTime, previous.loop, null);
// Remove the line above, and uncomment the line below, to allow previous animations to fire events during mixing.
//previous.animation.Apply(skeleton, previous.lastTime, previousTime, previous.loop, events);
previous.lastTime = previousTime;
float alpha = current.mixTime / current.mixDuration * current.mix;
if (alpha >= 1)
{
alpha = 1;
current.previous = null;
}
current.animation.Mix(skeleton, current.lastTime, time, loop, events, alpha);
}
for (int ii = 0, nn = events.Count; ii < nn; ii++)
{
Event e = events.Items[ii];
current.OnEvent(this, i, e);
if (Event != null)
{
Event(this, i, e);
}
}
current.lastTime = current.time;
}
}
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;
}
}
public void Apply(Skeleton skeleton)
{
ExposedList <Event> exposedList = this.events;
for (int i = 0; i < this.tracks.Count; i++)
{
TrackEntry trackEntry = this.tracks.Items[i];
if (trackEntry != null)
{
exposedList.Clear(true);
float num = trackEntry.time;
bool loop = trackEntry.loop;
if (!loop && num > trackEntry.endTime)
{
num = trackEntry.endTime;
}
TrackEntry previous = trackEntry.previous;
if (previous == null)
{
if (trackEntry.mix == 1f)
{
trackEntry.animation.Apply(skeleton, trackEntry.lastTime, num, loop, exposedList);
}
else
{
trackEntry.animation.Mix(skeleton, trackEntry.lastTime, num, loop, exposedList, trackEntry.mix);
}
}
else
{
float num2 = previous.time;
if (!previous.loop && num2 > previous.endTime)
{
num2 = previous.endTime;
}
previous.animation.Apply(skeleton, previous.lastTime, num2, previous.loop, null);
previous.lastTime = num2;
float num3 = trackEntry.mixTime / trackEntry.mixDuration * trackEntry.mix;
if (num3 >= 1f)
{
num3 = 1f;
trackEntry.previous = null;
}
trackEntry.animation.Mix(skeleton, trackEntry.lastTime, num, loop, exposedList, num3);
}
int j = 0;
int count = exposedList.Count;
while (j < count)
{
Event e = exposedList.Items[j];
trackEntry.OnEvent(this, i, e);
if (this.Event != null)
{
this.Event(this, i, e);
}
j++;
}
trackEntry.lastTime = trackEntry.time;
}
}
}