1.1 Понятия, связанные с беглостью речи Частота обновления и частота кадров Частота обновления: количество замечательных обновлений экрана, частота обновления элементов мобильного телефона составляет 60 Гц. Частота кадров: частота кадров, с которой графический процессор рисует за одну секунду.

рвать vs пропущенные кадры разрушить: Поскольку процесс обновления экрана происходит сверху вниз и слева направо, если Частота кадров>частота обновление, когда на экране не обновились данные n-1 кадров, Начинают формироваться данные n-го кадра, охватывающие n-1-й кадр сверху вниз. Если вы обновите экран в это время, Произойдёт такое явление, что верхняя половина изображения будет n-м кадром, а нижняя половина — n-м кадром. CPU/GPU постоянно выполняет рендеринг. пропущенные кадры: система Android отправляет сигнал VSYNC каждые 16 мс, запуская графический процессор для выполнения рендеринга пользовательского интерфейса. Если одна из ваших операций занимает 24 мс, система не готова к получению сигнала VSYNC. Невозможно обновить какой-либо контент, поэтому пользователь увидит один и тот же кадр в течение 32 мс (феномен заикания), то есть потеря кадра.

одиночный буфер vs VSYNC vs Двойная буферизация vs тройной кэш одиночный буфер (CSync не введен): Графический процессор записывает данные в кеш, а экран считывает данные из буфера и отображает их после обновления. Частота обновления и частота кадров не всегда совпадают, Это может вызвать явление разрушения. Решить одиночный проблема с разрывом экрана буфера, появилась Двойная буферизацияиVSYCNC VSYCNCи Двойная буферизация： Двойная буферизация используется для двух кэш-ходов: Назад Buffer、Frame Buffer При записи следующего кадра графический процессор сначала заполнит Back В буфере, Когда экран обновляется, экран меняется с Frame Buffer Чтение данных в VSYNC в основном завершает копирование кадра и рендеринг следующего кадра. Тройной кэш: Недостатком двойного кэширования является то, что при CPU/GPU Рисование кадра занимает больше времени, чем 16 ms когда, будет производить Джанк. Что еще страшнее, производить Jank Во время отображения этого кадра графический процессор/процессор Они все бездействуют.

Принцип ФПС FPS — это аббревиатура кадра в секунду, то есть количества кадров в секунду. Этот термин широко используется в компьютерной графике, захвате видео, играх и т. д.

Здесь мы в основном представляем частоту кадров в видеоиграх. Частота кадров в первом шутере от первого лица составляла всего около 6 кадров в секунду, но она все равно была очень успешной. Однако с улучшением аппаратного оборудования, особенно производительности видеокарт, частота кадров в играх теперь обычно составляет от 30 до 100 кадров в секунду. Поскольку время, затрачиваемое на каждый кадр изображения, разное, частота кадров постоянно меняется, поэтому в каждой игре будет установлена ​​максимальная частота кадров, чтобы обеспечить плавное переключение.

  // Timing...
        static QTime time;
        static int frames = 0;
        static bool started = false;
 
        if (!started || time.elapsed() > 1000) {
            qreal fps = frames * 1000. / time.elapsed();
            if (fps == 0)
                m_current_fps = "counting fps...";
            else
                m_current_fps = QString::fromLatin1("%3 FPS").arg((int) qRound(fps));
 
            time.start();
            started = true;
            frames = 0;
 
        } else {
            ++frames;
 
            p.setOpacity(1);
            p.setFont(QFont("times", 30));
            p.fillRect(5, height() - 40, 250, 40, Qt::white);
            p.drawText(10, height() - 8, m_current_fps);
        }
    }

Поскольку в большинстве игр реального времени есть таймер, который постоянно обновляет экран, вывод каждого кадра завершается с помощью PaintEvent. Поместите приведенный выше код в PaintEvent, чтобы рассчитать частоту кадров в секунду.

Так как же контролировать максимальную частоту кадров?

На самом деле это очень просто делается установкой интервала таймера. Учитывая, что частота отображения текущего монитора обычно 60Гц, то вообще лучше ставить интервал 1000/60мс, то есть 60FPS. теоретическая максимальная частота кадров.

Краткое изложение шести методов расчета частоты кадров (FPS): 1. Метод фиксированных сроков Формула расчета частоты кадров:

fps = FrameNum / ElapsedTime; Если вы записываете количество кадров в течение фиксированного периода времени, вы можете рассчитать скорость синхронизации. Этот метод используется чаще.

int fps()
{
    static int fps = 0;
    static int lastTime = getTime(); // ms
    static int frameCount = 0;
    ++frameCount;
    int curTime = getTime();
    if (curTime - lastTime > 1000) // Возьмите фиксированный интервал времени в 1 секунду.
    {
        fps = frameCount;
        frameCount = 0;
        lastTime = curTime;
    }
    return fps;
}

Есть еще один способ написать:

int fps(int deltaTime)
{
    static int fps = 0;
    static int timeLeft = 1000; // Возьмите фиксированный интервал времени в 1 секунду.
    static int frameCount = 0;

    ++frameCount;
    timeLeft -= deltaTime;
    if (timeLeft < 0)
    {
        fps = frameCount;
        frameCount = 0;
        timeLeft = 1000;
    }
    return fps;
}

2. Метод фиксированного номера кадра по времени. Формула расчета частоты кадров: fps = FrameNum / ElapsedTime; Если вы подсчитаете время, необходимое для расчета количества кадров для каждого фиксированного количества кадров, вы также сможете найти частоту кадров. Этот метод используется реже.

int fps()
{
    static int fps = 0;
    static int frameCount = 0;
    static int lastTime = getTime(); // ms
    ++frameCount;
    if (frameCount >= 100) // Возьмите фиксированное количество кадров за 100 кадров.
    {
        int curTime = getTime();
        fps = frameCount / (curTime - lastTime) * 1000;
        lastTime = curTime;
        frameCount = 0;
    }
    return fps;
}

3. Метод расчета в реальном времени. Метод расчета в реальном времени напрямую использует для расчета временной интервал предыдущего кадра, и результат получается в реальном времени, но плавность не очень хорошая.

int fps(int deltaTime) // ms
{
    int fps = static_cast<int>(1.f / deltaTime * 1000); // Не забудьте сначала преобразовать в плавающую точку, иначе будет потеря точности.
    return fps;
}

4. Метод общего среднего Метод общего среднего использует глобальный номер кадра, разделенный на глобальное время, чтобы найти частоту кадров.

int beginTime = getTime();
int fps()
{
    static int frameCount = 0;
    ++frameCount;
    int deltaTime = getTime() - beginTime();
    return static_cast<int>(frameCount * 1.f / deltaTime * 1000); // Не забудьте сначала преобразовать в плавающую точку, иначе будет потеря точности.
}

5. Точный метод отбора проб Метод точной выборки отбирает первые N кадров, а затем вычисляет среднее значение. Этот метод требует дополнительного места в памяти, поэтому он широко не используется.

int fps(int deltaTime) // ms
{
    static std::queue<int> q;
    static int sumDuration = 0; // ms
    int fps = 0;
    if (q.size() < 100) // Количество образцов установлено на 100.
    {
        sumDuration += deltaTime;
        q.push(deltaTime);
        fps = static_cast<int>(q.size() * 1.f / sumDuration * 1000.f); // Не забудьте преобразовать в плавающую точку, иначе будет потеря точности.
    }
    else
    {
        sumDuration -= q.front();
        sumDuration += deltaTime;
        sumDuration.pop();
        sumDuration.push(deltaTime);
        fps = static_cast<int>(100.f / sumDuration * 1000.f); // Не забудьте преобразовать в плавающую точку, иначе будет потеря точности.
    }
    return fps;
}

6. Метод средней выборки Метод средней выборки использует последние статистические результаты, чтобы преодолеть недостатки точного метода выборки, который требует дополнительного места. Этот метод используется чаще.

int fps(int deltaTime) // ms
{
    static float avgDuration = 0.f;
    static alpha = 1.f / 100.f; // Количество образцов установлено на 100.
    static int frameCount = 0;
    ++frameCount;
    int fps = 0;
    if (1 == frameCount)
    {
        avgDuration = static_cast<float>(deltaTime);
    }
    else
    {
        avgDuration = avgDuration * (1 - alpha) + deltaTime * alpha; 
    }
    fps = static_cast<int>(1.f / avgDuration * 1000);
    return fps;
}