C++ C++；帧率脉冲

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

看，像其他许多人一样，我一直在使用一个类似于这个的计时器来调节我的帧速率，运动从来都不是平稳的。这看起来不像是双缓冲或vsync问题，而是运动平稳，但周期性地跳跃和口吃（实际上它有一定的脉搏和节奏）。每当帧速率调节被关闭时，脉冲就会消失——当然，一切都变得不可用了），所以我确信这与此有关

我已经组装了一个小应用程序，它只包含计时器和一个围绕它移动的红方块。我将把代码放在这篇文章的末尾。代码是垃圾，不使用任何类型的精灵或任何东西：只要知道无论我对它施加了多少压力（比如，添加更多移动的东西或只是更新屏幕的一部分），它的口吃都是一样的。我尝试了不同的帧速率设置，脉冲总是出现（只是以不同的“节奏”）。不用说，我已经在好几台机器（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();
    }
}

#包括
类fps_控制
{
私人：
布尔应用；
Uint32滴答声帧计数；
Uint32勾号(帧)结束;；
Uint32信号帧开始；
Uint32差异；
unsigned int frame_count；//外部可见
unsigned int frame_count_inner；//保持计数直到一秒钟过去，然后覆盖前者以在一秒钟内给出经过的帧。
无符号整数帧长度；
无符号整数所需的\u帧率；
私人：
void计算框架长度（）
{
此->帧长度=1000/此->所需的帧速率；
}
公众：
fps_控件（无符号整数p_f=30）：所需的_帧速率（p_f）、应用（true）、滴答帧计数（0）、滴答帧结束（0）、滴答帧开始（0）、差异（0）、帧计数（0）、帧内计数（0）、帧长（0）
{
此->计算帧长度（）；
}
无符号int get_frame_count（）常量{返回此->frame_count；}
unsigned int get_desired_framerate（）常量{返回此->desired_framerate；}
void framerate_increase（）{this->set_framerate（this->desired_framerate+1）；}
void framerate_decrease（）{this->set_framerate（this->desired_framerate+1）；}
void set_帧率（无符号int p_参数）
{
此->所需的帧速率=p_参数；
此->计算帧长度（）；
}
void toggle_apply（）{this->apply=！this->apply；}
void init（）
{
//在开始之前调用此函数一次，将开始帧计数设置为初始值。
这->勾选帧计数=SDL\u GetTicks（）；
this->ticks\u frame\u begin=this->ticks\u frame\u count；
此->帧计数内部=0；
此->帧计数=0；
}
无效回合（）
{
//完成所有绘图和逻辑后调用此函数。
如果（！this->apply）返回；//仅在请求时应用。
//在绘图和逻辑计算差异之前要求时间。添加一个框架。
此->勾选\u帧\u结束=SDL\u GetTicks（）；
此->帧\计数\内部++；
//只要经过一秒钟，就更新可见帧数。
如果（（此->滴答声\u帧\u结束-此->滴答声\u帧\u计数）>1000）
{
此->帧计数=此->帧计数内部；
此->帧计数内部=0；
这->勾选帧计数=SDL\u GetTicks（）；
}
//计算差异并在需要时应用延迟。
this->diff=this->ticks\u frame\u end-this->ticks\u frame\u begin；
如果（this->diffframe\u length）SDL\u延迟（this->frame\u length-this->diff）；
//获取开始时间并重新开始。
此->勾选\u frame\u begin=SDL\u GetTicks（）；
}
};
类框
{
私人：
垂直位置；
int-movement_x；
国际运动协会；
公众：
框（）：移动x（4），移动y（4）
{
此->位置x=100；
该->位置y=100；
该->位置w=30；
该->位置h=30；
}
SDL_Rect get_position（）{返回此->位置；}
无效移动_周围（）
{
//不会触及边缘，但并不重要。
如果（this->position.xposition.x>=800 this->position.w）this->movement\ux=-this->movement\ux；
如果（this->position.yposition.y>=600 this->position.h）this->movement\u y=-this->movement\u y；
此->位置.x+=此->移动\u x；
此->位置.y+=此->移动\u y；
}
};
bool init_sdl（）{return sdl_init（sdl_init_VIDEO）>=0；}
void quit_sdl（）{sdl_quit（）；}
空隙填充筛网（SDL筛网）
{
SDL_FillRect（屏幕，空，SDL_映射RGB（屏幕->格式，0,0,0））；
}
无效更新屏幕（SDL曲面*屏幕、方框和方框）
{
SDL_Rect b=box.get_position（）；
SDL_FillRect（屏幕和b、SDL_映射RGB（屏幕->格式，200、20、20））；
SDL_翻转（屏幕）；
}
int get_input（）
{
SDL_事件；
while（SDL_事件和事件））
{   
if（event.type==SDL_QUIT）返回1；
else if（event.type==SDL\u KEYDOWN）
{
开关（event.key.keysym.sym）
{
案例SDLK_逃逸：返回1；中断；
case-SDLK_空间：返回2；中断；
案例SDLK_UP：返回3；中断；
案例SDLK_故障：返回4；中断；
默认：中断；
}
}
}
返回0；
}
int main（int argc，字符**argv）
{
如果（！init_sdl（））
{
返回1；
}
其他的
{
//一些事情。。。
//SDL_表面*屏幕=SDL_设置视频模式（800、600、16、SDL_双BUF | SDL_表面）；/*SDL_表面| SDL_任意信息
void framerate_decrease(){this->set_framerate(this->desired_framerate+1);}

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

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

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

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);
    }
}