C++ SDL 帧率脉冲

Question

最近我一直在开发一些供我自己使用的 SDL 包装器，但我遇到了一个问题，自从我第一次开始使用 SDL 库以来就一直存在。

请看，像许多其他人一样，我一直在使用类似于http://lazyfoo.net/SDL_tutorials/lesson14/index.php 的计时器来调节我的帧速率，并且运动永远不会流畅。它看起来不像是双缓冲或垂直同步问题，而是运动是平滑的，但会周期性地跳跃和口吃（实际上它有一定的脉搏和节奏）。每当帧速率调节关闭时，脉冲就会消失 - 当然，一切都会变得不可用）所以我很确定它与它有关。

我已经组装了一个小应用程序，它只包含计时器和一个围绕它移动的红色方块。我会把代码放在这篇文章的最后。代码是垃圾，没有使用任何类型的精灵或任何东西：只要知道无论我给它施加多少压力（例如，添加更多移动的东西或只是更新屏幕的一部分），它都会出现相同的口吃。我尝试了不同的帧速率设置，并且总是出现脉冲（只是使用不同的“节奏”）。不用说，我已经在几台机器（Linux 机器，全部）上尝试过。

无论如何，我一直在阅读并看到其他人遇到此问题，但没有真正的答案。一方面，我有关于 delta 计时技术的知识，并且很乐意尝试它，但我的问题在于这个非常简单的应用程序中的计时器本身。为什么会结巴？。 SDL_GetTicks 的精度和准确性有问题吗？我可以做些什么来改进它？。

所以，这里是那些想要尝试的代码：

#include <SDL/SDL.h>

class fps_control
{
    private:

    bool apply;
    Uint32 ticks_frame_count;
    Uint32 ticks_frame_end;
    Uint32 ticks_frame_begin;
    Uint32 diff;
    unsigned int frame_count;   //Visible to the outside
    unsigned int frame_count_inner; //Keeps count until a second has passed, then overwrites former to give the elapsed frames in a second.
    unsigned int frame_length;
    unsigned int desired_framerate;

    private:

    void calculate_frame_length()
    {
        this->frame_length=1000 / this->desired_framerate;  
    }

    public:

    fps_control(unsigned int p_f=30):desired_framerate(p_f), apply(true), ticks_frame_count(0), ticks_frame_end(0), ticks_frame_begin(0), diff(0), frame_count(0), frame_count_inner(0), frame_length(0)
    {
        this->calculate_frame_length();
    }

    unsigned int get_frame_count() const {return this->frame_count;}
    unsigned int get_desired_framerate() const {return this->desired_framerate;}
    void framerate_increase(){this->set_framerate(this->desired_framerate+1);}
    void framerate_decrease(){this->set_framerate(this->desired_framerate+1);}
    void set_framerate(unsigned int p_param)
{
this->desired_framerate=p_param;
this->calculate_frame_length();
}
    void toggle_apply() {this->apply=!this->apply;}

    void init()
    {
        //Call this once before starting, to set the beginning frame count to the initial values.

        this->ticks_frame_count=SDL_GetTicks();
        this->ticks_frame_begin=this->ticks_frame_count;
        this->frame_count_inner=0;
        this->frame_count=0;
    }

    void turn()
    {
        //Call this when all drawing and logic is done.

        if(!this->apply) return;    //Only apply when asked for.

        //Ask for time before drawing and logic to calculate the difference. Add a frame.

        this->ticks_frame_end=SDL_GetTicks();
        this->frame_count_inner++;

        //Whenever a second has passed, update the visible frame count.
        if( (this->ticks_frame_end - this->ticks_frame_count) > 1000)
        {
            this->frame_count=this->frame_count_inner;
            this->frame_count_inner=0;
            this->ticks_frame_count=SDL_GetTicks();
        }

        //Calculate difference and apply delay when needed.

        this->diff=this->ticks_frame_end - this->ticks_frame_begin;

        if(this->diff < this->frame_length) SDL_Delay(this->frame_length-this->diff);


        //Get the beginning time and start again.
        this->ticks_frame_begin=SDL_GetTicks();
    }
};

class Box
{
    private:

    SDL_Rect position;
    int movement_x;
    int movement_y;

    public:

    Box():movement_x(4), movement_y(4)
    {
        this->position.x=100;
        this->position.y=100;
        this->position.w=30;
        this->position.h=30;
    }

    SDL_Rect get_position() {return this->position;}

    void move_around()
    {
        //Won't touch the edges, but doesn't really matter.

        if(this->position.x<=0 || this->position.x>=800-this->position.w) this->movement_x=-this->movement_x;
        if(this->position.y<=0 || this->position.y>=600-this->position.h) this->movement_y=-this->movement_y;

        this->position.x+=this->movement_x;
        this->position.y+=this->movement_y;
    }
};

bool init_sdl(){return SDL_Init( SDL_INIT_VIDEO ) >= 0;}
void quit_sdl(){SDL_Quit();}
void fill_screen(SDL_Surface * screen)
{
    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format,0,0,0));
}

void update_screen(SDL_Surface * screen, Box& box)
{
    SDL_Rect b=box.get_position();
    SDL_FillRect(screen, &b, SDL_MapRGB(screen->format, 200, 20, 20));
    SDL_Flip(screen);
}

int get_input()
{
    SDL_Event event;

    while(SDL_PollEvent(&event))
    {   
        if(event.type==SDL_QUIT) return 1;
        else if(event.type==SDL_KEYDOWN)
        {
            switch(event.key.keysym.sym)
            {
                case SDLK_ESCAPE: return 1; break;
                case SDLK_SPACE: return 2; break;
                case SDLK_UP: return 3; break;
                case SDLK_DOWN: return 4; break;
                default: break;
            }
        }
    }

    return 0;
}

int main(int argc, char **argv)
{
    if(!init_sdl())
    {
        return 1;
    }
    else
    {
        //Init things...

//      SDL_Surface * screen=SDL_SetVideoMode(800, 600, 16, SDL_DOUBLEBUF | SDL_HWSURFACE); /*SDL_SWSURFACE | SDL_ANYFORMAT);*/
        SDL_Surface * screen=SDL_SetVideoMode(800, 600, 16, SDL_SWSURFACE | SDL_ANYFORMAT);
        Box box=Box();
        fps_control fps=fps_control(60);    //Framerate is set to 60.
        bool run=true;
        int input=0;

        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format,255,0,0));

        //Main loop

        fps.init();

        while(run)
        {
            input=get_input();

            switch(input)
            {
                case 1: run=false; break;   
                case 2: fps.toggle_apply(); break;
                case 3: fps.framerate_increase(); break;
                case 4: fps.framerate_decrease(); break;
                default: break;
            }

            box.move_around();
            fill_screen(screen);
            update_screen(screen, box);
            fps.turn();
        }

        quit_sdl();
    }
}

它是自包含的（同样是纯垃圾），因此只需将其与 SDL 链接并尝试一下...您在这里看到任何口吃的脉冲吗？

我会尝试应用增量时间来查看问题是否消失。我只想知道为什么在如此简单的应用程序中会发生这种情况。非常感谢。

编辑：最后一件事，我知道我可能根本不应该使用 SDL_Delay （关于系统睡眠 至少 要求的值），但我真的对这种行为感到困惑看似强大的机器。

编辑：对“set_framerate”进行了一些修正，感谢 Yno 提供的 cmets。

编辑 2：由于我将所有代码更改为使用增量时间值而不是设定的帧速率，所以一切都变得更好了。我仍然会遇到一些周期性的减速（这次是每四十秒一次），但我可以将这些归咎于系统，因为帧速率和减速因我使用的 Linux 桌面而异（比如 Gnome、Unity、Gnome2d ......）。

Answer 1

您的类 fps_control 根本无法完成这项工作，它完全是错误的。 framerate_decrease() 函数错误：

void framerate_decrease(){this->set_framerate(this->desired_framerate+1);}

这里应该是-1。 calculate_frame_length() 应在每次更改所需的 FPS 时调用，即更改为 set_framerate()：

void set_framerate (unsigned int p_param) {
    desired_framerate = p_param;
    calculate_frame_length ();
}

还要小心你在calculcate_frame_length() 中的除法，你可能会被零除：

void framerate_decrease() {
    if (desired_framerate > 1)
        set_framerate (desired_framerate - 1);
}

除了这些问题之外，您的课程看起来毫无用处的复杂。如果你想限制你的帧率，你必须了解它是如何计算的。通常的方法是使用SDL_GetTicks() 计算帧所需的时间量：

int t;
while (run) {
    t = SDL_GetTicks ();
    // ...
    t = SDL_GetTicks () - t;
}

在循环结束时，t 是您的帧完成所需的毫秒数。 1000 / t 因此是您的每秒帧数。如果您的帧率太高（即 t 太小），您必须通过调用 SDL_Delay() 来填补当前帧时间和所需帧时间之间的差距。假设 FPS 是您的 FPS 限制，每帧应该花费的时间是 1000 / FPS。

int t;
while (run) {
    t = SDL_GetTicks ();
    // ...
    t = SDL_GetTicks () - t;

    // if the framerate is too high
    if (t < 1000 / FPS) {
        // compute the difference to have a total frame time of 1000 / FPS
        SDL_Delay ((1000 / FPS) - t);
    }
}

希望这会有所帮助。

Answer 2

我不知道您的 SDL 代码是怎么回事，但如果它有任何用处，我刚刚编写了一个使用 GLFW 的 FpsManager 类，该类限制为高端值并提供时间增量以保持运动一致，无论帧率。原理是相同的。

这不是有史以来最好的代码，但在通过按键更改目标 FPS +/- 时，它的记录非常清晰，并且在 10fps 和 1000fps 之间完全平滑。

如果它对您有用，您可以在以下位置找到它： FpsManager - A C++ helper class for framerate independent movement