游戏时间越快，帧率越慢，不同帧率的增量时间不一致

Question

Here is how I am calculating the delta time:

currentTime = std::chrono::high_resolution_clock::now();
deltaTime = std::chrono::duration<float, std::chrono::seconds::period>(currentTime - lastCurrentTime).count();
lastCurrentTime = currentTime;

From the very beginning of this project I noticed the delta time did not give me consistent results across different frame rates. Everything that uses this deltaTime speeds up the slower the framerate is, but as an example, here is how the camera moves forward:

playerPosition += playerForward * speed * deltaTime;

I could show you the entire main loop, but that shouldn't matter, however long it takes should be accounted for. I remember one time I had a problem with std::chrono and it was because the compiler "optimized" the start timer to a completely different place. Could that be happening here? And if so, is there a better way of calculating delta time in C++?

Answer 1

Don't use std::chrono::high_resolution_clock , it is implementation-defined. Stick to std::chrono::steady_clock instead. Additionally, your problem is here: std::chrono::duration<float, std::chrono::seconds::period>(currentTime - lastCurrentTime).count(); . You are defining the period as a variable-length instead of a constant length which will cause your deltaTime to change "length" between calls.

You can simplify your problem by defining a using for a float-based seconds:

namespace TimeUtils {

using FPSeconds = std::chrono::duration<float>;
using FPMilliseconds = std::chrono::duration<float, std::milli>;
using FPMicroseconds = std::chrono::duration<float, std::micro>;
using FPNanoseconds = std::chrono::duration<float, std::nano>;
using FPFrames = std::chrono::duration<float, std::ratio<1, 60>>;
using Frames = std::chrono::duration<uint64_t, std::ratio<1, 60>>;


template<typename Clock = std::chrono::steady_clock>
[[nodiscard]] decltype(auto) Now() noexcept {
    return Clock::now();
}

std::chrono::nanoseconds GetCurrentTimeElapsed() noexcept {
    static auto initial_now = Now<std::chrono::steady_clock>();
    auto now = Now<std::chrono::steady_clock>();
    return (now - initial_now);
}

//...
} //end TimeUtils

static TimeUtils::FPSeconds previousFrameTime = TimeUtils::GetCurrentTimeElapsed();
TimeUtils::FPSeconds currentFrameTime = TimeUtils::GetCurrentTimeElapsed();
TimeUtils::FPSeconds deltaSeconds = (currentFrameTime - previousFrameTime);
previousFrameTime = currentFrameTime;

//...Prevents death-spiral when stepping through debugger
#ifdef DEBUG_BUILD
    deltaSeconds = (std::min)(TimeUtils::FPSeconds{TimeUtils::FPFrames{1}}, deltaSeconds);
#endif

//...

Update(deltaSeconds);

Now you can declare your deltaTime as TimeUtils::FPSeconds deltaTime in function arguments. This allows you to express it in any std::chrono::duration format you want as it will be converted automagically:

void Foo(TimeUtils::FPSeconds deltaSeconds);

Foo(TimeUtils::FPMilliseconds{10.0f}); //Automatically converted to 0.010f seconds