Comment dessiner des images 2D en utilisant OpenGL, en SDL?

Après tout, j'ai réussi à trouver un simple morceau de code qui montre comment dessiner une image 2D avec 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;
    }

Je n'ai pas d'expérience en 2D et il y a environ une semaine, j'ai commencé à jouer avec SDL. Construit des structures simples pour avoir des images, qui seraient sur des calques, afin que je puisse avoir mon propre ordre de dessin, afin que les sprites soient dessinés après l'arrière-plan, etc., puis fait un petit "moteur de sprite". J'ai eu un sprite Megaman marchant à gauche et à droite comme je le voulais, au-dessus d'une simple image d'arrière-plan 900x900ish.

Le truc, c'est que le CPU a presque atteint 20% sur mon i5 ... alors j'ai pensé à utiliser la carte graphique pour faire le dessin! Abit fouillé dans OpenGL et aujourd'hui, a finalement réussi à faire fonctionner gl3w!

Alors maintenant, je cherche un moyen simple d'afficher mes sprites / images, sur la fenêtre, en utilisant OpenGL. J'ai essayé toutes sortes de codes que j'ai rencontrés, mais je ne peux rien afficher, malgré le fait que j'ai fait des vérifications d'erreurs pratiquement partout, et tout semble vérifier que tout va bien!

TL: DR; Je cherchais un code de travail simple, en utilisant SDL, sur la façon de dessiner des images 2D (qui, si cela ne fonctionne pas, c'est sûr que j'ai quelque chose de mal).

Merci!

Je recommande de charger vos sprites en utilisant SOIL , puis de les rendre en dessinant simplement des quads texturés. Si vous le faites sans aucune fonctionnalité obsolète (utilisez des shaders), vous constaterez que c'est très rapide.

Voici un point de départ plutôt basique mais excellent pour dessiner des quads texturés dans OpenGL, à partir de ce point de départ de la fonction, j'ai 7 autres fonctions qui fournissent des fonctionnalités légèrement différentes, au dessin avec des couleurs teintées, au dessin d'éléments avec des valeurs alpha différentes et puis nous avons la rotation, écrêtage etc. etc. Mais cela devrait vous aider à démarrer :).

Edit: Code mis à jour;

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'image est une structure de base contenant les données de texture (GLuint), puis deux entiers pour contenir la largeur et la hauteur.

SDL est-il nécessaire pour vous? SFML est une alternative à SDL qui utilise OpenGL pour le rendu. Cela peut également être plus facile pour les débutants, en raison de l'API orientée objet.