/// <returns>
/// The simulated time.
/// TimeSpan.Zero if no time progress was achieved due to delta events.
/// TimeSpan.MinValue if no events were available.
/// </returns>
private TimeSpan RunSignalAssignmentPhase(bool progressTime)
{
_phase = SchedulerPhase.SignalAssignment;
TimeSpan simulatedTime = TimeSpan.Zero;
while (progressTime && _deltaEvents.Count == 0)
{
TimeSpan timespan;
if (_timeQueue.TryNextEventTime(out timespan))
{
OnSimulationTimeProgress(timespan);
simulatedTime += timespan;
}
else
{
_phase = SchedulerPhase.Idle;
return(TimeSpan.MinValue);
}
}
while (_deltaEvents.Count > 0)
{
SignalEventItem item = _deltaEvents.Pop();
if (item.SetValue(item.NewValue))
{
_eventSignals.Add(item);
}
}
_phase = SchedulerPhase.Idle;
return(simulatedTime);
}
public void handleDrawFrame()
{
D.assert(this._schedulerPhase == SchedulerPhase.midFrameMicrotasks);
try {
this._schedulerPhase = SchedulerPhase.persistentCallbacks;
foreach (FrameCallback callback in this._persistentCallbacks)
{
this._invokeFrameCallback(callback, this._currentFrameTimeStamp.Value);
}
this._schedulerPhase = SchedulerPhase.postFrameCallbacks;
var localPostFrameCallbacks = new List <FrameCallback>(this._postFrameCallbacks);
this._postFrameCallbacks.Clear();
foreach (FrameCallback callback in localPostFrameCallbacks)
{
this._invokeFrameCallback(callback, this._currentFrameTimeStamp.Value);
}
}
finally {
this._schedulerPhase = SchedulerPhase.idle;
D.assert(() => {
if (D.debugPrintEndFrameBanner)
{
Debug.Log(new string('▀', this._debugBanner.Length));
}
this._debugBanner = null;
return(true);
});
this._currentFrameTimeStamp = null;
}
}
private void RunProcessExecutionPhase()
{
_phase = SchedulerPhase.ProcessExecution;
foreach (SignalEventItem item in _eventSignals)
{
item.SetEventFlag(true);
}
foreach (SignalEventItem item in _eventSignals)
{
item.NotifyNewValue();
}
foreach (SignalEventItem item in _eventSignals)
{
item.SetEventFlag(false);
}
_eventSignals.Clear();
_phase = SchedulerPhase.Idle;
}
private void RunProcessExecutionPhase()
{
_phase = SchedulerPhase.ProcessExecution;
foreach (ISchedulable item in _schedulablesWithEvent)
{
item.HasEvent = true;
}
foreach (ISchedulable item in _schedulablesWithEvent)
{
item.NotifyOutputsNewValue();
}
foreach (ISchedulable item in _schedulablesWithEvent)
{
item.HasEvent = false;
}
_schedulablesWithEvent.Clear();
_phase = SchedulerPhase.Idle;
}
/// <returns>
/// The simulated time.
/// TimeSpan.Zero if no time progress was achieved due to delta events.
/// TimeSpan.MinValue if no events were available.
/// </returns>
private TimeSpan RunSignalAssignmentPhase(bool progressTime)
{
_phase = SchedulerPhase.SignalAssignment;
TimeSpan simulatedTime = TimeSpan.Zero;
while (progressTime && _deltaEvents.Count == 0)
{
TimeSpan timespan;
if (_timeline.TryNextEventTime(out timespan))
{
_schedule.ProgressTime(timespan, this);
OnSimulationTimeProgress(timespan);
simulatedTime += timespan;
}
else
{
_phase = SchedulerPhase.Idle;
return(TimeSpan.MinValue);
// TODO: check, why MinValue?
}
}
if (_deltaEvents.Count > 0)
{
int index = _random.Next(_deltaEvents.Count);
SchedulerEventItem item = _deltaEvents[index];
_deltaEvents.RemoveAt(index);
ISchedulable subject = item.Subject;
if (subject.CurrentValue == null || !subject.CurrentValue.Equals(item.Value))
{
item.Subject.CurrentValue = item.Value;
_schedulablesWithEvent.Add(item.Subject);
}
}
_phase = SchedulerPhase.Idle;
return(simulatedTime);
}
public void handleBeginFrame(TimeSpan?rawTimeStamp)
{
this._firstRawTimeStampInEpoch = this._firstRawTimeStampInEpoch ?? rawTimeStamp;
this._currentFrameTimeStamp = this._adjustForEpoch(rawTimeStamp ?? this._lastRawTimeStamp);
if (rawTimeStamp != null)
{
this._lastRawTimeStamp = rawTimeStamp.Value;
}
D.assert(() => {
this._profileFrameNumber += 1;
return(true);
});
D.assert(() => {
if (D.debugPrintBeginFrameBanner || D.debugPrintEndFrameBanner)
{
var frameTimeStampDescription = new StringBuilder();
if (rawTimeStamp != null)
{
_debugDescribeTimeStamp(
this._currentFrameTimeStamp.Value, frameTimeStampDescription);
}
else
{
frameTimeStampDescription.Append("(warm-up frame)");
}
this._debugBanner =
$"▄▄▄▄▄▄▄▄ Frame {this._profileFrameNumber.ToString().PadRight(7)} {frameTimeStampDescription.ToString().PadLeft(18)} ▄▄▄▄▄▄▄▄";
if (D.debugPrintBeginFrameBanner)
{
Debug.Log(this._debugBanner);
}
}
return(true);
});
D.assert(this._schedulerPhase == SchedulerPhase.idle);
this._hasScheduledFrame = false;
try {
this._schedulerPhase = SchedulerPhase.transientCallbacks;
var callbacks = this._transientCallbacks;
this._transientCallbacks = new Dictionary <int, _FrameCallbackEntry>();
foreach (var entry in callbacks)
{
if (!this._removedIds.Contains(entry.Key))
{
this._invokeFrameCallback(
entry.Value.callback, this._currentFrameTimeStamp.Value, entry.Value.debugStack);
}
}
this._removedIds.Clear();
}
finally {
this._schedulerPhase = SchedulerPhase.midFrameMicrotasks;
}
}
/// <returns>
/// The simulated time.
/// TimeSpan.Zero if no time progress was achieved due to delta events.
/// TimeSpan.MinValue if no events were available.
/// </returns>
private TimeSpan RunSignalAssignmentPhase(bool progressTime)
{
_phase = SchedulerPhase.SignalAssignment;
TimeSpan simulatedTime = TimeSpan.Zero;
while(progressTime && _deltaEvents.Count == 0)
{
TimeSpan timespan;
if(_timeline.TryNextEventTime(out timespan))
{
_schedule.ProgressTime(timespan, this);
OnSimulationTimeProgress(timespan);
simulatedTime += timespan;
}
else
{
_phase = SchedulerPhase.Idle;
return TimeSpan.MinValue;
// TODO: check, why MinValue?
}
}
while(_deltaEvents.Count > 0)
{
SchedulerEventItem item = _deltaEvents.Pop();
ISchedulable subject = item.Subject;
if(subject.CurrentValue == null || !subject.CurrentValue.Equals(item.Value))
{
item.Subject.CurrentValue = item.Value;
_schedulablesWithEvent.Add(item.Subject);
}
}
_phase = SchedulerPhase.Idle;
return simulatedTime;
}
private void RunProcessExecutionPhase()
{
_phase = SchedulerPhase.ProcessExecution;
foreach(ISchedulable item in _schedulablesWithEvent)
item.HasEvent = true;
foreach(ISchedulable item in _schedulablesWithEvent)
item.NotifyOutputsNewValue();
foreach(ISchedulable item in _schedulablesWithEvent)
item.HasEvent = false;
_schedulablesWithEvent.Clear();
_phase = SchedulerPhase.Idle;
}
/// <returns>
/// The simulated time.
/// TimeSpan.Zero if no time progress was achieved due to delta events.
/// TimeSpan.MinValue if no events were available.
/// </returns>
private TimeSpan RunSignalAssignmentPhase(bool progressTime)
{
_phase = SchedulerPhase.SignalAssignment;
TimeSpan simulatedTime = TimeSpan.Zero;
while(progressTime && _deltaEvents.Count == 0)
{
TimeSpan timespan;
if(_timeQueue.TryNextEventTime(out timespan))
{
OnSimulationTimeProgress(timespan);
simulatedTime += timespan;
}
else
{
_phase = SchedulerPhase.Idle;
return TimeSpan.MinValue;
}
}
while(_deltaEvents.Count > 0)
{
SignalEventItem item = _deltaEvents.Pop();
if(item.SetValue(item.NewValue))
_eventSignals.Add(item);
}
_phase = SchedulerPhase.Idle;
return simulatedTime;
}
private void RunProcessExecutionPhase()
{
_phase = SchedulerPhase.ProcessExecution;
foreach(SignalEventItem item in _eventSignals)
item.SetEventFlag(true);
foreach(SignalEventItem item in _eventSignals)
item.NotifyNewValue();
foreach(SignalEventItem item in _eventSignals)
item.SetEventFlag(false);
_eventSignals.Clear();
_phase = SchedulerPhase.Idle;
}
