问题
If you're not familiar with the Gaffer on Games article "Fix your Timestep", you can find it here: https://gafferongames.com/post/fix_your_timestep/
I'm building a game engine, and in an effort to get more comfortable with std::chrono I've been trying to implement a fixed time step using std::chrono for.. a couple of days now and I can't seem to wrap my head around it. Here is the pseudo-code I'm working towards:
double t = 0.0;
double dt = 0.01;
double currentTime = hires_time_in_seconds();
double accumulator = 0.0;
State previous;
State current;
while ( !quit )
{
double newTime = time();
double frameTime = newTime - currentTime;
if ( frameTime > 0.25 )
frameTime = 0.25;
currentTime = newTime;
accumulator += frameTime;
while ( accumulator >= dt )
{
previousState = currentState;
integrate( currentState, t, dt );
t += dt;
accumulator -= dt;
}
const double alpha = accumulator / dt;
State state = currentState * alpha +
previousState * ( 1.0 - alpha );
render( state );
}
Goals:
- I don't want rendering to be frame-rate bound. I should render in the busy loop
- I want a fully fixed time-step where I call my update function with a
floatdelta time - No sleeps
My current attempt (semi-fixed):
#include <algorithm>
#include <chrono>
#include <SDL.h>
namespace {
using frame_period = std::chrono::duration<long long, std::ratio<1, 60>>;
const float s_desiredFrameRate = 60.0f;
const float s_msPerSecond = 1000;
const float s_desiredFrameTime = s_msPerSecond / s_desiredFrameRate;
const int s_maxUpdateSteps = 6;
const float s_maxDeltaTime = 1.0f;
}
auto framePrev = std::chrono::high_resolution_clock::now();
auto frameCurrent = framePrev;
auto frameDiff = frameCurrent - framePrev;
float previousTicks = SDL_GetTicks();
while (m_mainWindow->IsOpen())
{
float newTicks = SDL_GetTicks();
float frameTime = newTicks - previousTicks;
previousTicks = newTicks;
// 32 ms in a frame would cause this to be .5, 16ms would be 1.0
float totalDeltaTime = frameTime / s_desiredFrameTime;
// Don't execute anything below
while (frameDiff < frame_period{ 1 })
{
frameCurrent = std::chrono::high_resolution_clock::now();
frameDiff = frameCurrent - framePrev;
}
using hr_duration = std::chrono::high_resolution_clock::duration;
framePrev = std::chrono::time_point_cast<hr_duration>(framePrev + frame_period{ 1 });
frameDiff = frameCurrent - framePrev;
// Time step
int i = 0;
while (totalDeltaTime > 0.0f && i < s_maxUpdateSteps)
{
float deltaTime = std::min(totalDeltaTime, s_maxDeltaTime);
m_gameController->Update(deltaTime);
totalDeltaTime -= deltaTime;
i++;
}
// ProcessCallbackQueue();
// ProcessSDLEvents();
// m_renderEngine->Render();
}
Problems with this implementation
- Rendering, handling input, etc is tied to the frame rate
- I'm using SDL_GetTicks() instead of std::chrono
My actual question
- How can I replace
SDL_GetTicks()withstd::chrono::high_resolution_clock::now()? It seems like no matter what I need to usecount()but I read from Howard Hinnant himself this quote:
If you use count(), and/or you have conversion factors in your chrono code, then you're trying too hard. So I thought maybe there was a more intuitive way.
- How can I replace all the
floats with actual std::chrono_literal time values except for the end where I get the float deltaTime to pass into the update function as a modifier for the simulation?
回答1:
Below I implement a couple of different versions of "final touch" from Fix your Timestep using <chrono>. My hope is that this example will translate to your desired code.
The main challenge is figuring out what unit each double represents in Fix your Timestep. Once that is done, the transformation to <chrono> is fairly mechanical.
Front matter
So that we can easily change out the clock, start with a Clock type, for example:
using Clock = std::chrono::steady_clock;
Later I'll show that one can even have Clock be implemented in terms of SDL_GetTicks() if desired.
If you have control over the signature if the integrate function, I recommend double-based seconds units for the time parameters:
void
integrate(State& state,
std::chrono::time_point<Clock, std::chrono::duration<double>>,
std::chrono::duration<double> dt);
This will allow you to pass anything you want in (as long the time_point is based on Clock), and not have to worry about explicit casting to the correct units. Plus physics computations are often done in floating point, so this lends itself to that as well. For example if State simply holds an acceleration and a velocity:
struct State
{
double acceleration = 1; // m/s^2
double velocity = 0; // m/s
};
and integrate is supposed to compute the new velocity:
void
integrate(State& state,
std::chrono::time_point<Clock, std::chrono::duration<double>>,
std::chrono::duration<double> dt)
{
using namespace std::literals;
state.velocity += state.acceleration * dt/1s;
};
The expression dt/1s simply converts the double-based chrono seconds into a double so it can participate in the physics computation.
std::literals and 1s are C++14. If you are stuck at C++11, you can replace these with seconds{1}.
Version 1
using namespace std::literals;
auto constexpr dt = 1.0s/60.;
using duration = std::chrono::duration<double>;
using time_point = std::chrono::time_point<Clock, duration>;
time_point t{};
time_point currentTime = Clock::now();
duration accumulator = 0s;
State previousState;
State currentState;
while (!quit)
{
time_point newTime = Clock::now();
auto frameTime = newTime - currentTime;
if (frameTime > 0.25s)
frameTime = 0.25s;
currentTime = newTime;
accumulator += frameTime;
while (accumulator >= dt)
{
previousState = currentState;
integrate(currentState, t, dt);
t += dt;
accumulator -= dt;
}
const double alpha = accumulator / dt;
State state = currentState * alpha + previousState * (1 - alpha);
render(state);
}
This version keeps everything almost exactly the same from Fix your Timestep, except some of the doubles get changed to type duration<double> (if they represent time durations), and others get changed to time_point<Clock, duration<double>> (if they represent points in time).
dt has units of duration<double> (double-based seconds), and I presume that the 0.01 from Fix your Timestep is a type-o, and the desired value is 1./60. In C++11 1.0s/60. can be changed to seconds{1}/60..
local type-aliases for duration and time_point are set up to use Clock and double-based seconds.
And from here on out, the code is nearly identical to Fix your Timestep, except for using duration or time_point in place of double for types.
Note that alpha is not a unit of time, but a dimension-less double coefficient.
- How can I replace SDL_GetTicks() with std::chrono::high_resolution_clock::now()? It seems like no matter what I need to use count()
As above. There is no use of SDL_GetTicks() nor .count().
- How can I replace all the floats with actual std::chrono_literal time values except for the end where I get the float deltaTime to pass into the update function as a modifier for the simulation?
As above, and you don't need to pass a float delaTime to the update function unless that function signature is out of your control. And if that is the case, then:
m_gameController->Update(deltaTime/1s);
Version 2
Now let's go a little further: Do we really need to use floating point for the duration and time_point units?
Nope. Here's how you can do the same thing with integral-based time units:
using namespace std::literals;
auto constexpr dt = std::chrono::duration<long long, std::ratio<1, 60>>{1};
using duration = decltype(Clock::duration{} + dt);
using time_point = std::chrono::time_point<Clock, duration>;
time_point t{};
time_point currentTime = Clock::now();
duration accumulator = 0s;
State previousState;
State currentState;
while (!quit)
{
time_point newTime = Clock::now();
auto frameTime = newTime - currentTime;
if (frameTime > 250ms)
frameTime = 250ms;
currentTime = newTime;
accumulator += frameTime;
while (accumulator >= dt)
{
previousState = currentState;
integrate(currentState, t, dt);
t += dt;
accumulator -= dt;
}
const double alpha = std::chrono::duration<double>{accumulator} / dt;
State state = currentState * alpha + previousState * (1 - alpha);
render(state);
}
There is really very little that has changed from Version 1:
dtnow has the value 1, represented by along long, and has units of 1/60 of a second.durationnow has a strange type that we don't even have to know the details about. It is the same type as the resultant sum of aClock::durationanddt. This will be the coarsest precision that can exactly represent both aClock::durationand 1/60 of a second. Who cares what it is. What is important is that the time-based arithmetic will have no truncation error, or not even any round-off error ifClock::durationis integral-based. (Who said that one can not exactly represent 1/3 on a computer?!)The
0.25slimit gets transformed instead into250ms(milliseconds{250}in C++11).The computation of
alphashould aggressively convert to double-based units to avoid the truncation associated with integral-based division.
More about Clock
Use
steady_clockif you don't need to maptto a calendrical time in your physics, and/or you don't care iftslowly drifts away from the exact physical time. No clock is perfect, andsteady_clocknever gets adjusted to the correct time (such as by an NTP service).Use
system_clockif you need to maptto a calendrical time, or if you wanttto stay in sync with UTC. This will require a few small (probably millisecond-level or smaller) adjustments toClockas the game plays.Use
high_resolution_clockif you don't care whether you getsteady_clockorsystem_clockand want to be surprised which you get each time you port your code to a new platform or compiler. :-)Finally, you can even stick with
SDL_GetTicks()if you want by writing your ownClocklike this:
E.g.:
struct Clock
{
using duration = std::chrono::milliseconds;
using rep = duration::rep;
using period = duration::period;
using time_point = std::chrono::time_point<Clock>;
static constexpr bool is_steady = true;
static
time_point
now() noexcept
{
return time_point{duration{SDL_GetTicks()}};
}
};
Switching between:
using Clock = std::chrono::steady_clock;using Clock = std::chrono::system_clock;using Clock = std::chrono::high_resolution_clock;struct Clock {...}; // SDL_GetTicks based
requires zero changes to the event loop, the physics engine, or the render engine. Just recompile. Conversion constants get updated automatically. So you can easily experiment with which Clock is best for your application.
Appendix
My full State code for completeness:
struct State
{
double acceleration = 1; // m/s^2
double velocity = 0; // m/s
};
void
integrate(State& state,
std::chrono::time_point<Clock, std::chrono::duration<double>>,
std::chrono::duration<double> dt)
{
using namespace std::literals;
state.velocity += state.acceleration * dt/1s;
};
State operator+(State x, State y)
{
return {x.acceleration + y.acceleration, x.velocity + y.velocity};
}
State operator*(State x, double y)
{
return {x.acceleration * y, x.velocity * y};
}
void render(State state)
{
using namespace std::chrono;
static auto t = time_point_cast<seconds>(steady_clock::now());
static int frame_count = 0;
static int frame_rate = 0;
auto pt = t;
t = time_point_cast<seconds>(steady_clock::now());
++frame_count;
if (t != pt)
{
frame_rate = frame_count;
frame_count = 0;
}
std::cout << "Frame rate is " << frame_rate << " frames per second. Velocity = "
<< state.velocity << " m/s\n";
}
来源：https://stackoverflow.com/questions/59441699/gaffer-on-games-timestep-stdchrono-implementation