Understanding simple simulation and rendering loop

问题

This is an example (pseudo code) of how you could simulate and render a video game.

//simulate 20ms into the future
const long delta = 20;
long simulationTime = 0; 
while(true) 
{
    while(simulationTime < GetMilliSeconds())   //GetMilliSeconds = Wall Clock Time
        {   
            //the frame we simulated is still in the past
            input = GetUserlnput(); 
            UpdateSimulation(delta, input); 
            //we are trying to catch up and eventually pass the wall clock time
            simulationTime += delta;
        }

    //since my current simulation is in the future and
    //my last simulation is in the past
    //the current looking of the world has got to be somewhere inbetween
    RenderGraphics(InterpolateWorldState(GetMilliSeconds() - simulationTime)); 
}

That's my question:

I have 40ms to go through the outer 'while true' loop (means 25FPS). The RenderGraphics method takes 10ms. So that means I have 30ms for the inner loop. The UpdateSimulation method takes 5ms. Everything else can be ignored since it's a value under 0.1ms.

What is the maximum I can set the variable 'delta' to in order to stay in my time schedule of 40ms (outer loop)? And why?

回答1:

This largely depends on how often you want and need to update your simulation status and user input, given the constraints mentioned below. For example, if your game contains internal state based on physical behavior, you would need a smaller delta to ensure that movements and collisions, if any, are properly evaluated and reflected within the game state. Also, if your user input requires fine-grained evaluation and state update, you would also need smaller delta values. For example, a shooting game with analogue user input (e.g. mouse, joystick), would benefit from update frequencies larger than 30Hz. If your game does not need such high-frequency evaluation of input and game state, then you could get away with larger delta values, or even by simply updating your game state once any input by the player was being detected.

In your specific pseudo-code, your simulation would update according to a fixed time-slice of length delta, which requires your simulation update to be processed in less wallclock time than the wallclock time to be simulated. Otherwise, wallclock time would proceed faster, than your simulation time can be updated. This ultimately limits your delta depending on how quick any simulation update of delta simulation time can actually be computed. This relationship also depends on your use case and may not be linear or constant. For example, physics engines often would divide your delta time given internally to what update rate they can reasonably process, as longer delta times may cause numerical instabilities and harder to solve linear systems raising processing effort non-linearly. In other use cases, simulation updates may take a linear or even constant time. Even so, many (possibly external) events could cause your simulation update to be processed too slowly, if it is inherently demanding. For example, loading resources during simulation updates, your operating system deciding to lay your execution thread aside, another process run by the user, anti-virus software kicking in, low memory pressure, a slow CPU and so on. Until now, I saw mostly two strategies to evade this problem or remedy its effects. First, simply ignoring it could work if the simulation update effort is low and it is assumed that the cause of the slowdown is temporary only. This would result in more or less noticeable "slow motion" behavior of your simulation, which could - in worst case - lead to simulation time lag piling up forever. The second strategy I often saw was to simply cap the measured frame time to be simulated to some artificial value, say 1000ms. This leads to smooth behavior as soon as the cause of slow down disappears, but has the drawback that the 'capped' simulation time is 'lost', which may lead to animation hiccups if not handled or accounted for. To choose a strategy, analyzing your use case could consist of measuring the wallclock time it takes to process simulation updates of delta and x * delta time and how changing the delta time and simulation load to process actually reflects in wallclock time needed to compute it, which will hint you to what the maximum value of delta is for your specific hardware and software environment.

来源：https://stackoverflow.com/questions/38878499/understanding-simple-simulation-and-rendering-loop