c++ - 我的 SDL C++(2d 游戏)使用 opengl 很慢，怎么办？

Question

我自己做了一个游戏，就像Pong在c++下使用SDL和OpenGL一样:

#include "SDL.h"
#include "SDL_opengl.h"
#include <iostream>
int main(int argc, char* args[])
{
//initialize SDL
SDL_Init(SDL_INIT_EVERYTHING);

//OpenGL memory
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 8);
SDL_GL_SetAttribute( SDL_GL_BUFFER_SIZE, 32);
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1);

//caption of the window
SDL_WM_SetCaption( "Bine baaa", NULL );

//size
SDL_SetVideoMode(600,400,32, SDL_OPENGL);

//clearcolor
glClearColor(0,0,0,1); //RED,GREEN,BLUE,ALPHA

//portion of screen displayed
glViewport(0,0,600,400);

//for gradients
glShadeModel(GL_SMOOTH);

//2D rendering
glMatrixMode(GL_PROJECTION);
glLoadIdentity();//save

glDisable(GL_DEPTH_TEST);

bool isRunning = true;

SDL_Event event;

typedef struct player{

    float myX;
    float myY;
    float width=15;
    float height=60;
    bool up=false;
    bool down=false;
};
player player1,player2;

player1.myX=10;
player1.myY=160;
player2.myX=580;
player2.myY=160;

float ballX=300;
float ballY=200;
float vitezaX=0.5;
float vitezaY=0.5;
float latura =10;

//main loop
while(isRunning){
    //EVENTS
    while ( SDL_PollEvent(&event)){

        if( event.type == SDL_QUIT )
            isRunning=false;
        //escape button closes window
        if(event.type == SDL_KEYUP && event.key.keysym.sym == SDLK_ESCAPE)
            isRunning=false;
        if( event.type == SDL_KEYUP && event.key.keysym.sym == SDLK_r)
            glClearColor(1,0,0,1);
        if( event.type == SDL_KEYDOWN){
            if(event.key.keysym.sym==SDLK_UP)
                player2.up=true;
            if(event.key.keysym.sym==SDLK_DOWN)
                player2.down=true;
            if(event.key.keysym.sym==SDLK_w)
                player1.up=true;
            if(event.key.keysym.sym==SDLK_s)
                player1.down=true;
        }
        if( event.type == SDL_KEYUP){
            if(event.key.keysym.sym==SDLK_UP)
                player2.up=false;
            if(event.key.keysym.sym==SDLK_DOWN)
                player2.down=false;
            if(event.key.keysym.sym==SDLK_w)
                player1.up=false;
            if(event.key.keysym.sym==SDLK_s)
                player1.down=false;
        }
    }
    //LOGIC
    if(player1.up==true)
        player1.myY-=0.3;
    if(player1.down==true)
        player1.myY+=0.3;
    if(player2.up==true)
        player2.myY-=0.3;
    if(player2.down==true)
        player2.myY+=0.3;
    if(ballY<0)
        vitezaY=-vitezaY;
    if(ballY+latura>400)
        vitezaY=-vitezaY;
    if(ballX+latura>player2.myX && ballY+latura>player2.myY && ballY<player2.myY+player2.height){
        vitezaX=-vitezaX;
        if(ballX+latura-player2.myX>=1){
                if(vitezaY>0)
                    ballY=player2.myY-latura;
                else
                    ballY=player2.myY+player2.height;
            vitezaX=-vitezaX;
            vitezaY=-vitezaY;
        }
    }
    if(ballX<player1.myX+player1.width && ballY+latura>player1.myY && ballY<player1.myY+player1.height){
        vitezaX=-vitezaX;
        if((player1.myX+player1.width)-ballX>=1){
            if(vitezaY>0)
                ballY=player1.myY-latura;
            else
                ballY=player1.myY+player1.height;
            vitezaX=-vitezaX;
            vitezaY=-vitezaY;
        }
    }
    if(ballX<0 || ballX>600){
         ballX=300;
         ballY=200;
         SDL_Delay(500);
    }
    ballX+=vitezaX;
    ballY+=vitezaY;

    //RENDER
    glClear(GL_COLOR_BUFFER_BIT);

        glPushMatrix(); //Begin Render

        glColor4ub(255,255,255,255);
        glOrtho(0,600,400,0,-1,1);

        glBegin(GL_QUADS);//GL_LINES, GL_LINE_STRIP, GL_QUADS, GL_POLIGON,GL_TRIANGLES, GL_LINE_LOOP

        glVertex2f(player1.myX,player1.myY);
        glVertex2f(player1.myX+player1.width,player1.myY);
        glVertex2f(player1.myX+player1.width,player1.myY+player1.height);
        glVertex2f(player1.myX,player1.myY+player1.height);

        glEnd();//End Draw

         glBegin(GL_QUADS);//GL_LINES, GL_LINE_STRIP, GL_QUADS, GL_POLIGON,GL_TRIANGLES, GL_LINE_LOOP

        glVertex2f(player2.myX,player2.myY);
        glVertex2f(player2.myX+player2.width,player2.myY);
        glVertex2f(player2.myX+player2.width,player2.myY+player2.height);
        glVertex2f(player2.myX,player2.myY+player2.height);

        glEnd();//End Draw

        glBegin(GL_QUADS);//GL_LINES, GL_LINE_STRIP, GL_QUADS, GL_POLIGON,GL_TRIANGLES, GL_LINE_LOOP

        glVertex2f(ballX,ballY);
        glVertex2f(ballX+latura,ballY);
        glVertex2f(ballX+latura,ballY+latura);
        glVertex2f(ballX,ballY+latura);

        glEnd();//End Draw

        glPopMatrix(); //End Render


    SDL_GL_SwapBuffers();
    SDL_Delay(2);
}
SDL_Quit();

return 0;}

注意:“latura”是矩形的宽度或高度，“viteza”是速度。

问题是当我在其他机器上测试游戏时，在我的 PC 上游戏运行非常慢，尽管我可以说我的 PC 还不错......(2GB RAM、8600GT nvidia 和四核英特尔)，在其他机器上游戏运行得更快，无论代码是否设置为相同的速度。我似乎找不到这个问题下的逻辑。我想知道如何让这个游戏在不同的机器上以相同的速度运行(我一直在寻找诸如时间相关动画之类的东西......我不知道taht会有多大帮助;我也找到了一些关于软件/硬件渲染的主题，这可能是问题所在吗？在我的 PC 上，游戏使用软件渲染，而在其他机器上是基于硬件的？)。

Answer 1

我看到的主要问题是在您的游戏循环中。为什么要使用 2 毫秒的静态延迟？那就是你的瓶颈。您正在尝试在可能没有硬件加速 OpenGL 驱动程序的机器上以 500 FPS 渲染您的游戏。

首先，将您的游戏延迟到 50 到 100Hz，而不是您在这里使用的 500。从游戏循环一开始的时间保持变量开始。

Uint32 time = SDL_GetTicks();

现在我们一直跳到最后以获取更多代码...

if(20>(SDL_GetTicks()-time))
{
    SDL_Delay(20-(SDL_GetTicks()-time)); //SDL_Delay pauses the execution.
}

对于不熟悉 SDL 的人来说，这可能看起来有点令人困惑，但它的作用是将代码延迟一个确切的时间量，无论程序通过它的循环的速度有多快。

为了更好地解释它，假设游戏循环从开始到结束需要 4 毫秒(仅出于争论的目的，循环实际上可能要快得多)。您已经在其上添加了 2 毫秒，因此总延迟为 6 毫秒，或约 130 FPS。大多数现代计算机显示器的刷新率只有大约 60Hz，即每秒 60 帧。

通过尽可能快地进行游戏循环，您的游戏可以渲染超过两倍的帧，甚至无需显示大部分帧。想想就很浪费，不过还是看看上面常见的解决方法吧。

SDL_GetTicks() 是一个函数，它告诉您自初始化以来的当前运行时间。您在循环的最开始拍摄这个时间的快照以获得您的开始时间。然后您会在末尾再次看到 SDL_GetTicks() 并使用它与您的起始值进行比较。

假设开始时间为 15，结束时 SDL_GetTicks() 返回的时间为 22。该等式首先比较 22 减去 15，即 7，然后比较该数字是否小于 20，结果为 20。然后它暂停系统 20 减 7 毫秒，13。

这很有用，因为帧率不会剧烈波动，如果游戏循环速度超过 20 毫秒才能到达终点，它根本不会延迟，这意味着您永远不会浪费宝贵的处理能力或用它进行帧渲染。

除了 20，您还可以将其替换为 (1000/FPS)，其中 FPS 是……好吧……您希望游戏运行的 FPS。这使得无需先拿出计算器就可以轻松完成 60 FPS 之类的操作。简单的除法，仅此而已。

最终结果:

int main(int argc, char *argv[])
{
    int FPS = 50 //Framerate
    //Setup stuff
    while(GAME_RUNNING)
    {
        Uint32 start_time = SDL_GetTicks();

        //Event handling

        //Logic stuff

        //Rendering things

        if((1000/FPS)>(SDL_GetTicks()-start_time))
        {
            SDL_Delay((1000/FPS)-(SDL_GetTicks()-start_time)) //Yay stable framerate!
        }
    }

这几乎是控制游戏渲染的最简单方法。附带说明一下，我使用了一种更复杂的方法，我创建了一个单独的线程以 60Hz 的频率进行屏幕渲染，同时以 100 的频率运行游戏循环。没有浪费的处理能力，我可以在游戏中使用一个漂亮的整数计算。查找 SDL_CreateThread() 函数，它对此非常简单。

您可能遇到的唯一问题是在屏幕上渲染动态数量的对象，但是所有这些都可以用静态 vector 解决，但我离题了。我希望这能解决您的大部分问题，但由于这篇文章已经发布 3 个月了，它可能对其他偶然发现它并提出相同问题的人更有用。