Come disegnare immagini 2D usando OpenGL, in SDL?

Dopo tutto, sono riuscito a trovare un semplice pezzo di codice che mostra come disegnare un'immagine 2D con openGL:

    #include "SDL/SDL.h"
    #include "SDL/SDL_opengl.h"
    #include "SDL/SDL_image.h"

    const int SCREEN_WIDTH = 640;
    const int SCREEN_HEIGHT = 480;
    const int SCREEN_BPP = 32;

    int tex;

    int loadTexture(char* fileName){
        SDL_Surface *image=IMG_Load(fileName);
        SDL_DisplayFormatAlpha(image);
        GLuint object;
        glGenTextures(1,&object);
        glBindTexture(GL_TEXTURE_2D,object);
        glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
        glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
        glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
        glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
        glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image->w,image ->h,0,GL_RGBA,GL_UNSIGNED_BYTE,image->pixels);
        SDL_FreeSurface(image);
        return object;
    }
    void init(){
        glClearColor(0.0,0.0,0.0,0.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(0.0,800,600,1.0,-1.0,1.0);
        glEnable(GL_BLEND);
        glEnable(GL_TEXTURE_2D);
        glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
        tex = loadTexture("hi.png");
    }
    void draw(){
        glClear(GL_COLOR_BUFFER_BIT);
        glBindTexture(GL_TEXTURE_2D,tex);
        glBegin(GL_QUADS);
            glTexCoord2f(0,0);
            glVertex2f(0,0);
            glTexCoord2f(1,0);
            glVertex2f(500,0);
            glTexCoord2f(1,1);
            glVertex2f(500,500);
            glTexCoord2f(0,1);
            glVertex2f(0,500);
        glEnd();
        glFlush();
    }
    int main(int argc,char** argv){
        SDL_Init(SDL_INIT_EVERYTHING);
        SDL_Surface* screen=SDL_SetVideoMode(800,600,32,SDL_SWSURFACE|SDL_OPENGL);
        bool running=true;
        Uint32 start;
        SDL_Event event;
        init();
        while(running){
            start=SDL_GetTicks();
            draw();
            while(SDL_PollEvent(&event)){
                switch(event.type){
                    case SDL_QUIT:
                        running=false;
                        break;
                }
            }
            SDL_GL_SwapBuffers();
            if(1000/60>(SDL_GetTicks()-start))
                SDL_Delay(1000/60-(SDL_GetTicks()-start));
        }
        SDL_Quit();
        return 0;
    }

Sono inesperto in 2D e circa una settimana fa ha iniziato a fare scherzi con SDL. Costruivo alcune strutture semplici per avere immagini, che sarebbero su livelli, in modo che potessi avere il mio ordine di disegno, quindi gli sprite sarebbero stati disegnati dopo lo sfondo, ecc., E poi avrebbero fatto un piccolo "motore di sprite". Ho avuto uno sprite Megaman che camminava a destra e a sinistra proprio come lo volevo, sopra una semplice immagine di sfondo di 900x900.

Il fatto è che la CPU ha quasi raggiunto il 20% sul mio i5 ... quindi ho pensato di usare la scheda grafica per fare il disegno! Ho abitato in OpenGL e oggi sono finalmente riuscito a far funzionare gl3w!

Quindi ora sto cercando un modo semplice per visualizzare i miei sprite / immagini, sulla finestra, usando OpenGL. Ho provato tutti i tipi di codice che ho incontrato, ma non riesco a visualizzare nulla, nonostante abbia fatto controlli di errore praticamente ovunque, e tutto sembra funzionare correttamente!

TL: DR; Stavo cercando un semplice codice di lavoro, usando SDL, su come disegnare immagini 2D (che, se non funziona, sicuramente ho qualcosa di sbagliato).

Grazie!

Ti consiglio di caricare i tuoi sprite usando il SUOLO e di renderli semplicemente disegnando quad strutturati. Se lo fai senza alcuna funzionalità obsoleta (usa shader) scoprirai che è molto veloce.

Ecco un punto di partenza piuttosto semplice ma ottimo per disegnare quads strutturati in OpenGL, da questo punto di partenza della funzione ho altre 7 funzioni che offrono funzionalità leggermente diverse, al disegno con colori colorati, al disegno di oggetti con valori alfa diversi e quindi abbiamo rotazione, ritaglio ecc. ecc. Ma questo dovrebbe aiutarti a iniziare :).

Modifica: codice aggiornato;

void Draw(int x, int y, Image* texture, bool blendFlag) {
//Bind Texture
glBindTexture(GL_TEXTURE_2D, texture->getData());

if (blendFlag)
{
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

GLfloat Vertices[] = {(float)x, (float)y, 0,
                    (float)x + texture->getWidth(), (float)y, 0,
                    (float)x + (float)texture->getWidth(), (float)y + (float)texture->getHeight(), 0,
                    (float)x, (float)y + (float)texture->getHeight(), 0};
GLfloat TexCoord[] = {0, 0,
    1, 0,
    1, 1,
    0, 1,
};
GLubyte indices[] = {0,1,2, // first triangle (bottom left - top left - top right)
                     0,2,3}; // second triangle (bottom left - top right - bottom right)

glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, Vertices);

glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, TexCoord);

glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices);

glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);

if (blendFlag) glDisable(GL_BLEND);
}

L'immagine è una struttura di base contenente i dati di trama (GLuint) e quindi due numeri interi per contenere larghezza e altezza.

SDL è necessario per te? SFML è un'alternativa a SDL che utilizza OpenGL per il rendering. Potrebbe anche essere più facile per i principianti, a causa dell'API orientata agli oggetti.