[OpenGL, SDL]Blit de surface

Bon alors voilà, j'ai décidé d'utiliser OpenGL pour l'affichage de mes images plutôt que les fonctions de base de la SDL pour améliorer les performances. J'ai donc écrit une fonction de "blittage" de texture OpenGL sur l'écran pour faire mon jeu 2D.

Jusque là, tout fonctionne parfaitement, et j'obtiens une fonction qui fait exactement ce que je veux. Fier de moi et voulant améliorer toujours plus, je crée donc une classe Image qui stockera toutes les informations nécessaires à ce "blit" et surtout me facilitant grandement le traitement de plusieurs images à le fois. Et là, c'est la cata...

Voici le code:

Fichier affichage.h

#ifndef AFFICHAGE_H
#define AFFICHAGE_H
#include "define.h"
#include "moteur.h"
class Image {
private:
GLuint image;
int largeur;
int hauteur;
SDL_Surface* flipSurface(SDL_Surface*);
public:
Image(string,bool);
void Blit(SDL_Rect*, SDL_Rect*);
void setTexture(GLuint);
};
void DrawGL(void);
#endif

fichier affichage.cpp

#include "affichage.h"
extern Moteur moteur;
Image::Image(string filename, bool useMipMap)
{
GLuint glID;
SDL_Surface * picture_surface = NULL;
SDL_Surface *gl_surface = NULL;
SDL_Surface * gl_fliped_surface = NULL;
Uint32 rmask, gmask, bmask, amask;
picture_surface = IMG_Load(filename.c_str());
if (picture_surface == NULL)
die("Could not load image");
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
rmask = 0xff000000;
gmask = 0x00ff0000;
bmask = 0x0000ff00;
amask = 0x000000ff;
#else
rmask = 0x000000ff;
gmask = 0x0000ff00;
bmask = 0x00ff0000;
amask = 0xff000000;
#endif
SDL_PixelFormat format = *(picture_surface->format);
format.BitsPerPixel = 32;
format.BytesPerPixel = 4;
format.Rmask = rmask;
format.Gmask = gmask;
format.Bmask = bmask;
format.Amask = amask;
gl_surface = SDL_ConvertSurface(picture_surface,&format,SDL_SWSURFACE);
gl_fliped_surface = flipSurface(gl_surface);
glGenTextures(1, &glID);
glBindTexture(GL_TEXTURE_2D, glID);
if (useMipMap)
{
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, gl_fliped_surface->w,
gl_fliped_surface->h, GL_RGBA,GL_UNSIGNED_BYTE,
gl_fliped_surface->pixels);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR);
}
else
{
glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_fliped_surface->w,
gl_fliped_surface->h, 0, GL_RGBA,GL_UNSIGNED_BYTE,
gl_fliped_surface->pixels);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
largeur=gl_fliped_surface->w;
hauteur=gl_fliped_surface->h;
SDL_FreeSurface(gl_fliped_surface);
SDL_FreeSurface(gl_surface);
SDL_FreeSurface(picture_surface);
setTexture(glID);
}
SDL_Surface* Image::flipSurface(SDL_Surface * surface)
{
int current_line,pitch;
SDL_Surface * fliped_surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
surface->w,surface->h,
surface->format->BitsPerPixel,
surface->format->Rmask,
surface->format->Gmask,
surface->format->Bmask,
surface->format->Amask);
SDL_LockSurface(surface);
SDL_LockSurface(fliped_surface);
pitch = surface->pitch;
for (current_line = 0; current_line < surface->h; current_line ++)
{
memcpy(&((unsigned char* )fliped_surface->pixels)[current_line*pitch],
&((unsigned char* )surface->pixels)[(surface->h - 1 -
current_line)*pitch],
pitch);
}
SDL_UnlockSurface(fliped_surface);
SDL_UnlockSurface(surface);
return fliped_surface;
}
void DrawGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
moteur.affichage();
glFlush();
SDL_GL_SwapBuffers();
}
void Image::Blit(SDL_Rect* tmpsrc, SDL_Rect *tmpdest)
{
SDL_Rect dest;
float srcx,srcy,srcw,srch;
if(tmpdest==NULL)
{
dest.x=0;
dest.y=600;
dest.h=600;
dest.w=800;
} else
{
dest.x=tmpdest->x;
dest.y=600-tmpdest->y;
dest.w=tmpdest->w;
dest.h=tmpdest->h;
}
if(tmpsrc==NULL)
{
srcx=0;
srcy=1;
srch=1;
srcw=1;
} else
{
srcx=(float)tmpsrc->x/largeur;
srcy=1-((float)tmpsrc->y/hauteur);
srcw=(float)tmpsrc->w/largeur;
srch=(float)tmpsrc->h/hauteur;
}
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, image);
glBegin(GL_QUADS);
glTexCoord2f(srcx,srcy);
glVertex2d(dest.x,dest.y);
glTexCoord2f(srcx,srcy-srch);
glVertex2d(dest.x,dest.y-dest.h);
glTexCoord2f(srcx+srcw,srcy-srch);
glVertex2d(dest.x+dest.w,dest.y-dest.h);
glTexCoord2f(srcx+srcw,srcy);
glVertex2d(dest.x+dest.w,dest.y);
glEnd();
glDisable(GL_TEXTURE_2D);
}
void Image::setTexture(GLuint t)
{
image=t;
}

Quand je charge une image, pas de problème, le chargement se passe bien (je teste toujours le chargement de mes images). L'image est bien chargé, elle est bien converti en texture OpenGL, les dimensions de "blittage" que je fourni à ma fonction sont bien prises en compte mais surprise : il ne m'affiche pas l'image chargé mais une surface blanche, et ceux quelque soit l'image ou le format d'image que je charge.

Pour ce qui est des fonctions de chargement d'image, de conversion de SDL_Surface en texture OpenGL ainsi que la fonction qui permet de faire subir une rotation à ma surface, elle ne présente en théorie aucun problème. Elles ont été testé et approuvé étant donnée qu'elles proviennent directement du tuto de kayl sur OpenGL (section C des tutoriels). Je n'ai rien modifié dans ces fonctions!

Je ne vois vraiment pas d'où vient l'erreur, surtout que mon code fonctionnait à merveille avant le passage à une classe, et que pour faire ce changement, je n'ai vraiment pas modifié grand chose!

Merci d'avance si vous trouvez une solution à mon problème, qui peut venir de ma méthode ou d'une ligne de code pas clair. (Pour info : le compilo ne râle pas, pas même un warning)!

Autre information :
J'utilise mon objet de type image dans une classe nommée Menu. Je le fais comme ceci:
Membre de la classe Menu:

Image* bg;

Dans le constructeur de Menu:

bg=new Image("images/menu.jpg", true);

Dans le destructeur:

delete bg;

Et dans la fonction d'affichage du Menu (qui est elle-même appelé par la fonction affichage de la classe Moteur comme vous l'avez vu dans le fichier affichage.cpp) :

bg->Blit(NULL, NULL);

Vanger

18 novembre 2007 à 3:11:12

Pole

18 novembre 2007 à 12:03:59

Utilise la SFML qui utilise OpenGL.
http://sfml.sourceforge.net/index-fr.php
Il y a des tutos et est très facile d'utilisation.

18 novembre 2007 à 17:50:06

C'est pas vraiment ce que j'attendais. Je connais effectivement la librairie SFML et j'ai déjà programmé 2-3 trucs avec pour m'y essayer, mais mon but en fait est de mieux comprendre l'OpenGL directement, pas de passer par une librairie qui fera le travail pour moi.

J'y viendrai par la suite mais j'ai envie de voir plus le coeur du fonctionnement, c'est pour ça que j'essaye de developper cette fonction de blittage moi-même en OpenGL.

Par la suite, lorsque j'aurai bien tout compris, je n'hésiterais pas à passer à la SFML par contre!

18 novembre 2007 à 20:26:35

Tu as mis srcy à 1, ce qui est probablement faux.
Pareil pour dest.y que tu as mis à 600.

18 novembre 2007 à 21:05:36

Non c'est correct également. En OpenGL, le repère n'est pas

0---------------1

| |

1---------------1

mais :

Donc mes valeurs sont correctes! D'ailleurs l'image s'affiche bien au bon endroit, donc le problème ne vient pas de là. Même si je m'étais trompé dans ces valeurs, l'effet de cette erreur serait une image mal positionné, pas une image corrompu. Là ça se positionne bien, mais au lieu d'avoir mon image qui s'affiche, c'est du blanc (par dessus mon fond noir).

18 novembre 2007 à 23:03:36

Exact, c'est juste que j'ai l'habitude de commencer par 0,0 .
Essaye quand même d'afficher le rectangle en mettant les coordonnées dans le programme.
Sinon il doit y avoir un problème du côté du chargement.

toutes mes images sont blanches!

[OpenGL, SDL]Blit de surface

Supprimer

Modérer

Signaler le message aux modérateurs