private void SetCurrent(int index, TrackEntry entry)
{
TrackEntry trackEntry = this.ExpandToIndex(index);
if (trackEntry != null)
{
TrackEntry previous = trackEntry.previous;
trackEntry.previous = null;
trackEntry.OnEnd(this, index);
if (this.End != null)
{
this.End(this, index);
}
entry.mixDuration = this.data.GetMix(trackEntry.animation, entry.animation);
if (entry.mixDuration > 0f)
{
entry.mixTime = 0f;
if (previous != null && trackEntry.mixTime / trackEntry.mixDuration < 0.5f)
{
entry.previous = previous;
}
else
{
entry.previous = trackEntry;
}
}
}
this.tracks.Items[index] = entry;
entry.OnStart(this, index);
if (this.Start != null)
{
this.Start(this, index);
}
}
private void SetCurrent(int index, TrackEntry entry)
{
TrackEntry current = ExpandToIndex(index);
if (current != null)
{
current.previous = null;
current.OnEnd(this, index);
if (End != null)
{
End(this, new StartEndArgs(index));
}
entry.mixDuration = data.GetMix(current.animation, entry.animation);
if (entry.mixDuration > 0)
{
entry.mixTime = 0;
entry.previous = current;
}
}
tracks[index] = entry;
entry.OnStart(this, index);
if (Start != null)
{
Start(this, new StartEndArgs(index));
}
}
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 ClearTrack(int trackIndex)
{
if (trackIndex >= this.tracks.Count)
{
return;
}
TrackEntry trackEntry = this.tracks.Items[trackIndex];
if (trackEntry == null)
{
return;
}
trackEntry.OnEnd(this, trackIndex);
if (this.End != null)
{
this.End(this, trackIndex);
}
this.tracks.Items[trackIndex] = null;
}
public void ClearTrack(int trackIndex)
{
if (trackIndex >= tracks.Count)
{
return;
}
TrackEntry current = tracks[trackIndex];
if (current == null)
{
return;
}
current.OnEnd(this, trackIndex);
if (End != null)
{
End(this, trackIndex);
}
tracks[trackIndex] = null;
}
private void SetCurrent(int index, TrackEntry entry)
{
TrackEntry current = ExpandToIndex(index);
if (current != null)
{
TrackEntry previous = current.previous;
current.previous = null;
current.OnEnd(this, index);
if (End != null)
{
End(this, index);
}
entry.mixDuration = data.GetMix(current.animation, entry.animation);
if (entry.mixDuration > 0)
{
entry.mixTime = 0;
// If a mix is in progress, mix from the closest animation.
if (previous != null && current.mixTime / current.mixDuration < 0.5f)
{
entry.previous = previous;
}
else
{
entry.previous = current;
}
}
}
tracks[index] = entry;
entry.OnStart(this, index);
if (Start != null)
{
Start(this, index);
}
}
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;
}
}
