我的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"是速度.

问题是当我在其他机器上测试游戏时,在我的电脑上游戏移动速度非常慢,即使我可以说我的电脑不是那么糟糕...(2GB RAM,8600GT nvidia和四核英特尔),在其他机器上游戏移动得更快,无论代码是否以相同的速度设置.我似乎无法在这个问题上找到逻辑.我想知道如何让这个游戏在不同的机器上以相同的速度工作(我已经找了一些像时间相关的动画......我不知道有多少会帮助;我也发现了一些关于软件/硬件渲染的话题,这可能是问题吗？在我的电脑上游戏是使用软件渲染而在其他机器上是硬件基础？).

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减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()函数,它使这非常简单.

您可能遇到的唯一问题是向屏幕呈现动态数量的对象,但是所有这些都可以通过静态向量来解决,但我离题了.我希望这可以解决你的大多数问题,但由于这篇文章是3个月之后,对于其他任何磕磕绊绊提出同样问题的人来说,它可能更有用.