如何使用 C 限制循环中的 FPS？

Question

我正在尝试使用带有计时和线程的 C++ 来限制执行交叉点检查的循环中的每秒帧数。

这是我的代码：

 std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
std::chrono::system_clock::time_point lastFrame = std::chrono::system_clock::now();

while (true)
{
    // Maintain designated frequency of 5 Hz (200 ms per frame)
    now = std::chrono::system_clock::now();
    std::chrono::duration<double, std::milli> delta = now - lastFrame;
    lastFrame = now;

    if (delta.count() < 200.0)
    {
        std::chrono::duration<double, std::milli> delta_ms(200.0 - delta.count());
        auto delta_ms_duration = std::chrono::duration_cast<std::chrono::milliseconds>(delta_ms);
        std::this_thread::sleep_for(std::chrono::milliseconds(delta_ms_duration.count()));
    }

    printf("Time: %f \n", delta.count());

    // Perform intersection test

}

我遇到的问题是 delta 的所有其他输出都显示微不足道的数量，而不是我的目标约为 200 毫秒/帧：

 Time: 199.253200
Time: 2.067700
Time: 199.420400
Time: 2.408100
Time: 199.494200
Time: 2.306200
Time: 199.586800
Time: 2.253400
Time: 199.864000
Time: 2.156500
Time: 199.293800
Time: 2.075500
Time: 201.787500
Time: 4.426600
Time: 197.304100
Time: 4.530500
Time: 198.457200
Time: 3.482000
Time: 198.365300
Time: 3.415400
Time: 198.467400
Time: 3.595000
Time: 199.730100
Time: 3.373400

关于为什么会发生这种情况的任何想法？

原文由 Irongrave 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

如果您考虑一下您的代码是如何工作的，您会发现它完全按照您编写的方式工作。由于代码中的逻辑错误，Delta 振荡。

这就是发生的事情：

• 我们从 delta == 0 开始。
• 因为 delta 小于 200 ，所以您的代码会休眠 200 - delta(0) == 200 毫秒。
• 现在，增量本身接近 200 （因为您已经测量了睡眠时间以及实际工作）并且您睡眠 200 - delta(200) == 0 ms。
• 之后循环重复。

要解决此问题，您无需测量睡眠时间。

这是可以做到的：

 #include <iostream>
#include <cstdio>
#include <chrono>
#include <thread>

std::chrono::system_clock::time_point a = std::chrono::system_clock::now();
std::chrono::system_clock::time_point b = std::chrono::system_clock::now();

int main()
{
    while (true)
    {
        // Maintain designated frequency of 5 Hz (200 ms per frame)
        a = std::chrono::system_clock::now();
        std::chrono::duration<double, std::milli> work_time = a - b;

        if (work_time.count() < 200.0)
        {
            std::chrono::duration<double, std::milli> delta_ms(200.0 - work_time.count());
            auto delta_ms_duration = std::chrono::duration_cast<std::chrono::milliseconds>(delta_ms);
            std::this_thread::sleep_for(std::chrono::milliseconds(delta_ms_duration.count()));
        }

        b = std::chrono::system_clock::now();
        std::chrono::duration<double, std::milli> sleep_time = b - a;

        // Your code here

        printf("Time: %f \n", (work_time + sleep_time).count());
    }
}

这段代码给了我一个稳定的增量序列：

 Time: 199.057206
Time: 199.053581
Time: 199.064718
Time: 199.053515
Time: 199.053307
Time: 199.053415
Time: 199.053164
Time: 199.053511
Time: 199.053280
Time: 199.053283

原文由 HolyBlackCat 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

交替的增量时间是由逻辑问题引起的：您根据前一帧的持续时间（根据帧持续时间的计算方式）为一帧添加延迟。这意味着在长帧（~200ms）之后，您不会应用延迟并获得短帧（几毫秒），然后会在下一帧触发延迟，从而产生长帧，依此类推。

原文由 Mike Dinsdale 发布，翻译遵循 CC BY-SA 3.0 许可协议