Как ограничить FPS в цикле с помощью С++?

Ответ 1

Если вы думаете о том, как работает ваш код, вы обнаружите, что он работает именно так, как вы его написали. Дельта колеблется из-за логической ошибки в коде.

Вот что происходит:

• Начнем с delta == 0.
• Так как дельта меньше, чем 200, код присваивается 200 - delta(0) == 200 ms.
• Теперь сама дельта становится близкой к 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    

Ответ 2

Это очень похоже на ответ Galik, но он сохраняет синтаксис вопроса OP и не попадает в C API. Кроме того, он создает настраиваемую единицу для продолжительности кадра, которая, по моему мнению, важна для читаемости:

#include <chrono>
#include <cstdint>
#include <iostream>
#include <thread>

int
main()
{
    using namespace std;
    using namespace std::chrono;

    using frames = duration<int64_t, ratio<1, 5>>;  // 5Hz
    auto nextFrame = system_clock::now();
    auto lastFrame = nextFrame - frames{1};;

    while (true)
    {
        // Perform intersection test

        this_thread::sleep_until(nextFrame);
        cout << "Time: "  // just for monitoring purposes
             << duration_cast<milliseconds>(system_clock::now() - lastFrame).count()
             << "ms\n";
        lastFrame = nextFrame;
        nextFrame += frames{1};
    }
}

Это выводит для меня:

Time: 200ms
Time: 205ms
Time: 205ms
Time: 203ms
Time: 205ms
Time: 205ms
Time: 200ms
Time: 200ms
Time: 200ms
...

Ключевые моменты:

• Краткий способ документирования 5 Гц: using frames = duration<int64_t, ratio<1, 5>>;
• Использование sleep_until вместо sleep_for, которое заботится о неизвестности того, сколько времени потребуется, чтобы выполнить настоящую работу.
• Не использовать .count() за исключением ввода-вывода и здесь библиотека, чтобы избавиться от этого.
• Нет ручного преобразования единиц (например, / 1000).
• Нет единиц с плавающей запятой, а не что-то не так.
• Минимальная необходимость указывать или зависеть от явных единиц.

С добавлением длительности библиотеки ввода-вывода, вот как будет изменен приведенный выше код:

#include "chrono_io.h"
#include <chrono>
#include <cstdint>
#include <iostream>
#include <thread>

int
main()
{
    using namespace date;
    using namespace std;
    using namespace std::chrono;

    using frames = duration<int64_t, ratio<1, 5>>;  // 5Hz
    auto nextFrame = system_clock::now();
    auto lastFrame = nextFrame - frames{1};;

    while (true)
    {
        // Perform intersection test

        this_thread::sleep_until(nextFrame);
        // just for monitoring purposes
        cout << "Time: " << system_clock::now() - lastFrame << '\n';
        lastFrame = nextFrame;
        nextFrame += frames{1};
    }
}

Выход будет отличаться в зависимости от платформы (в зависимости от "основной продолжительности" system_clock). На моей платформе это выглядит так:

Time: 200042µs
Time: 205105µs
Time: 205107µs
Time: 200044µs
Time: 205105µs
Time: 200120µs
Time: 204307µs
Time: 205136µs
Time: 201978µs
...

Ответ 3

Параллельные времена дельта возникают из-за логической проблемы: вы добавляете задержку на один кадр в зависимости от продолжительности кадра (с точки зрения того, как отсчитываются длительности кадров). Это означает, что после длинного кадра (~ 200 мс) вы не применяете задержку и получаете короткий кадр (несколько мс), который затем вызывает задержку на следующем кадре с длинным кадром и т.д.

Ответ 4

Обычно я делаю что-то вроде этого:

#include <chrono>
#include <iostream>

int main()
{
    using clock = std::chrono::steady_clock;

    auto next_frame = clock::now();

    while(true)
    {
        next_frame += std::chrono::milliseconds(1000 / 5); // 5Hz

        // do stuff
        std::cout << std::time(0) << '\n'; // 5 for each second

        // wait for end of frame
        std::this_thread::sleep_until(next_frame);
    }
}

Выход: (по пять для каждого второго значения)

1470173964
1470173964
1470173964
1470173964
1470173964
1470173965
1470173965
1470173965
1470173965
1470173965
1470173966
1470173966
1470173966
1470173966
1470173966