private void InitialiseLoopProperties()
{
_timer = _timerFactory.Create();
_timer.Reset();
//For FIXED_ADAPTIVE update time steps, we do not start at the smallest possible timestep. Here is hardcorded 120FPS
var timeStep = _startUpPropertiesCache.User.UpdatePeriodType == UpdatePeriod.Fixed_Adaptive &&
_startUpPropertiesCache.User.FixedOrSmallestUpdateTimeStepInSeconds < 1.0f / 120.0f ?
1.0f / 120.0f : _startUpPropertiesCache.User.FixedOrSmallestUpdateTimeStepInSeconds;
_loopProperties = new LoopProperties
{
UpdatePeriodType = _startUpPropertiesCache.User.UpdatePeriodType,
ProcessFractionalUpdatesBeforeDraw = _startUpPropertiesCache.User.ProcessFractionalUpdatesBeforeDraw,
SmallestFixedUpdateTimeStepInSeconds = _startUpPropertiesCache.User.FixedOrSmallestUpdateTimeStepInSeconds,
FixedUpdateTimeStepInSeconds = timeStep,
DoNotDrawFrameUnlessThereHasBeenOneUpdate = _startUpPropertiesCache.User.RequireAtleastOneUpdatePerDraw,
Running = false,
TimeOfLastUpdate = 0.0,
TimeOfLastDraw = 0.0,
HasThereBeenAnUpdateSinceTheLastDraw = false
};
_updater = _updatePeriodFactory.Create(_loopProperties.UpdatePeriodType);
}
public void AnalysePeriod(ITimer _loopTimer, LoopProperties _loopProps)
{
if (_valuesSinceLastAnalysis >= NUMBER_OF_UPDATES_TO_SMOOTH_FRAMETIME)
{
var average = 0.0;
for (var n = 0; n < NUMBER_OF_UPDATES_TO_SMOOTH_FRAMETIME; n++)
{
average += _times[n];
}
average *= 1.0 / (1.0 * NUMBER_OF_UPDATES_TO_SMOOTH_FRAMETIME);
var variance = 0.0;
for (var n = 0; n < NUMBER_OF_UPDATES_TO_SMOOTH_FRAMETIME; n++)
{
var delta = _times[n] - average;
variance += delta * delta;
}
variance /= 1.0 * NUMBER_OF_UPDATES_TO_SMOOTH_FRAMETIME;
_valuesSinceLastAnalysis = 0;
_debugAnalytics.Updater_AverageFrameTime = average;
_debugAnalytics.Updater_FrameTimeVariance = variance;
}
_debugAnalytics.Updater_TimestepType = UpdatePeriod.Variable;
_debugAnalytics.Updater_OverutilisedFlag = false;
_debugAnalytics.Updater_UnderutilisedFlag = false;
_debugAnalytics.Updater_UpdateProcessingPercentage = 1.0f;
}
public void AnalysePeriod(ITimer loopTimer, LoopProperties loopProps)
{
var timeDelta = loopTimer.Seconds - _analysisPeriodTimeStart;
var percentageProcessingUpdates = _updatingTimeCount / timeDelta;
if (percentageProcessingUpdates > OVER_UTILISATION_THRESHOLD)
{
_overutilisedFrameCount++;
}
else
{
_overutilisedFrameCount--;
if (_overutilisedFrameCount < 0)
{
_overutilisedFrameCount = 0;
}
}
_debugAnalytics.Updater_TimestepType = UpdatePeriod.Fixed;
_debugAnalytics.Updater_OverutilisedFlag = percentageProcessingUpdates > OVERUTILISED_FRAME_SUM_OVERFLOW_FOR_FLAGGING;
_debugAnalytics.Updater_UpdateProcessingPercentage = percentageProcessingUpdates;
_debugAnalytics.Updater_AverageFrameTime = loopProps.FixedUpdateTimeStepInSeconds;
_debugAnalytics.Updater_FrameTimeVariance = 0.0f;
}
public void ProcessSingleUpdate(double updatePeriod, LoopProperties loopProps, IFramesPerSecondMonitor framesPerSecondMonitor, Func <float, bool> update, ITimer loopTimer)
{
loopProps.Running = update((float)updatePeriod);
loopProps.TimeOfLastUpdate += updatePeriod;
framesPerSecondMonitor.RegisterUpdateFrame();
AddPeriodToBuffer(updatePeriod);
}
private void DecreaseFixedTimeStep(LoopProperties loopProps)
{
var halfed = 0.5 * loopProps.FixedUpdateTimeStepInSeconds;
if (halfed >= loopProps.SmallestFixedUpdateTimeStepInSeconds)
{
loopProps.FixedUpdateTimeStepInSeconds = halfed;
}
}
public void ProcessRequiredUpdates(double timeSinceLastUpdate, LoopProperties loopProps, IFramesPerSecondMonitor framesPerSecondMonitor, Func <float, bool> update, ITimer loopTimer)
{
if (timeSinceLastUpdate < loopProps.SmallestFixedUpdateTimeStepInSeconds)
{
return;
}
ProcessSingleUpdate(timeSinceLastUpdate, loopProps, framesPerSecondMonitor, update, loopTimer);
loopProps.HasThereBeenAnUpdateSinceTheLastDraw = true;
}
public void ProcessRequiredUpdates(double timeSinceLastUpdate, LoopProperties loopProps, IFramesPerSecondMonitor framesPerSecondMonitor, Func <float, bool> update, ITimer loopTimer)
{
var period = timeSinceLastUpdate;
while (period > loopProps.FixedUpdateTimeStepInSeconds && loopProps.Running)
{
ProcessSingleUpdate(loopProps.FixedUpdateTimeStepInSeconds, loopProps, framesPerSecondMonitor, update, loopTimer);
period -= loopProps.FixedUpdateTimeStepInSeconds;
loopProps.HasThereBeenAnUpdateSinceTheLastDraw = true;
}
}
public void ProcessSingleUpdate(double updatePeriod, LoopProperties loopProps, IFramesPerSecondMonitor framesPerSecondMonitor, Func <float, bool> update, ITimer loopTimer)
{
var startTime = loopTimer.Seconds;
loopProps.Running = update((float)updatePeriod);
var timeDelta = loopTimer.Seconds - startTime;
_updatingTimeCount += timeDelta;
loopProps.TimeOfLastUpdate += updatePeriod;
framesPerSecondMonitor.RegisterUpdateFrame();
}
public void ProcessMessageQueue(LoopProperties loopProperties)
{
while (_messageQueue.Count > 0)
{
var msg = _messageQueue.Dequeue();
switch (msg)
{
case CoreMessage.Shutdown:
loopProperties.Running = false;
break;
case CoreMessage.DeviceOrRenderTargetsReset:
_systemComponents.RecreateDeviceAndReinitialiseAllResources(_systemResourcesReinitialiser.ReInitialise);
break;
}
}
}
public void AnalysePeriod(ITimer loopTimer, LoopProperties loopProps)
{
var timeDelta = loopTimer.Seconds - _analysisPeriodTimeStart;
var percentageProcessingUpdates = _updatingTimeCount / timeDelta;
if (percentageProcessingUpdates > OVER_UTILISATION_THRESHOLD)
{
_overutilisedFrameCount++;
if (_overutilisedFrameCount > CONSECUTIVE_SLOW_FRAMES_REQUIRED_FOR_DOUBLING)
{
IncreaseFixedTimeStep(loopProps);
_overutilisedFrameCount = 0;
}
}
else
{
_overutilisedFrameCount = 0;
}
if (percentageProcessingUpdates < UNDER_UTILISATION_THRESHOLD)
{
_underutilisedFrameCount++;
if (_underutilisedFrameCount > CONSECUTIVE_FAST_FRAMES_REQUIRED_FOR_HALFING)
{
DecreaseFixedTimeStep(loopProps);
_underutilisedFrameCount = 0;
}
}
else
{
_underutilisedFrameCount = 0;
}
_debugAnalytics.Updater_TimestepType = UpdatePeriod.Fixed_Adaptive;
_debugAnalytics.Updater_OverutilisedFlag = percentageProcessingUpdates > OVER_UTILISATION_THRESHOLD;
_debugAnalytics.Updater_UnderutilisedFlag = percentageProcessingUpdates > UNDER_UTILISATION_THRESHOLD;
_debugAnalytics.Updater_UpdateProcessingPercentage = percentageProcessingUpdates;
_debugAnalytics.Updater_AverageFrameTime = loopProps.FixedUpdateTimeStepInSeconds;
_debugAnalytics.Updater_FrameTimeVariance = 0.0f;
}
private void IncreaseFixedTimeStep(LoopProperties loopProps)
{
loopProps.FixedUpdateTimeStepInSeconds *= 2.0;
}
