Discussion :

[KevinduC]

Bonsoir, je suis entrain de créer un projet en SDL2 et j'ai l'habitude de travailler en SDL1, et les premiers problèmes commencent : Rien que pour charger une texture, le programme plante en me renvoyant 3 comme code d'erreur. Pour effectuer le chargement, j'utilise cette fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
GLuint loadTexture(const char * filename,int 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);
    if (picture_surface == NULL)
        return 0;
 
    #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);
 
    SDL_FreeSurface(gl_fliped_surface);
    SDL_FreeSurface(gl_surface);
    SDL_FreeSurface(picture_surface);
 
    return glID;
}

Pour remédier à cela, j'ai décidé de récupérer le code donné dans le tuto sur OpenGL 3.3, et j'ai modifié un peu la fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
GLuint loadTexture(const char * filename,int useMipMap,int versionSDL)
{
    GLuint glID;
    SDL_Surface * picture_surface = NULL;
    SDL_Surface *gl_surface = NULL;
    SDL_Surface * gl_fliped_surface = NULL;
    Uint32 rmask, gmask, bmask, amask;
    GLenum formatInterne,format;
 
    picture_surface = IMG_Load(filename);
    if (picture_surface == NULL)
        return 0;
 
    if(versionSDL==1)
    {
        //Même code qu'au-dessus
    }
 
    else
    if(versionSDL==2)
    {
        glGenTextures(1,&glID);
 
        glBindTexture(GL_TEXTURE_2D,glID);
 
        if(picture_surface->format->BytesPerPixel==3)
        {
            formatInterne=GL_RGB;
 
            if(picture_surface->format->Rmask==0xff)
                format=GL_RGB;
            else
                format=GL_BGR;
        }
 
        else
        if(picture_surface->format->BytesPerPixel==4)
        {
            formatInterne=GL_RGBA;
 
            if(picture_surface->format->Rmask==0xff)
                format=GL_RGBA;
            else
                format=GL_BGRA;
        }
 
        printf("%x %x\n",formatInterne,format);
    }
 
    return glID;
}

Le code n'est pas encore achevé et j'ai déjà des problèmes : Les valeurs de "formatInterne" et "format" sont erronées, cela vient apparemment du paramètre "BytesPerPixel" qui étrangement ne vaut ni 3 ni 4 mais 8, c'est pourtant une copie du cod. Pour info l'image utilisée est au format TGA 24 bits donc logiquement "BytesPerPixel" devrait valoir 3. En attendant de trouver une solution, j'ai ajouté cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

glTexImage2D(GL_TEXTURE_2D,0,4,picture_surface->w,picture_surface->h,0,GL_RGBA,GL_UNSIGNED_BYTE,picture_surface->pixels);

Et là crac, le programme plante avec 3 comme code d'erreur.

Bref, je suis un peu coincé pour charger les textures en SDL2, auriez-vous une solution svp ?

[KevinduC]

Re, j'essaie finalement de tout coder à la main et pour l'instant j'en suis là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
glGenTextures(1,&glID);
 
glBindTexture(GL_TEXTURE_2D,glID);
 
glTexImage2D(GL_TEXTURE_2D,0,4,picture_surface->w,picture_surface->h,0,GL_BGR,GL_UNSIGNED_BYTE,picture_surface->pixels);
 
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

Le résultat n'est pas fameux : Une fois sur deux, la texture apparaît noire. Si je remplace "GL_BGR" par "GL_RGBA" (Si jamais je veux une texture opaque) alors le programme plante. Lorsque ça fonctionne, l'image apparaît retournée, j'ai donc codé une fonction pour la retourner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
SDL_Surface *flipSurface2(SDL_Surface *surface)
{
    SDL_Surface *fliped_surface=SDL_CreateRGBSurface(0,surface->w,surface->h,32,0,0,0,0);
 
    const int nbBytesPerRow=fliped_surface->pitch;
    const int nbRows=fliped_surface->h;
    int counter1=0,counter2=nbRows*nbBytesPerRow-nbBytesPerRow;
 
    SDL_LockSurface(surface);
    SDL_LockSurface(fliped_surface);
 
    while(1)
    {
        memcpy(fliped_surface->pixels+counter1,surface->pixels+counter2,nbBytesPerRow);
 
        counter1+=nbBytesPerRow;
        counter2-=nbBytesPerRow;
 
        if(counter2<0)
            break;
    }
 
    SDL_UnlockSurface(surface);
    SDL_UnlockSurface(fliped_surface);
 
    return fliped_surface;
}

Le résultat fait plutôt peur :



Bref à ce stade ça dépasse mes compétences, je ne comprends pas pourquoi aucun code ne fonctionne, ni celui de SDL1 ni celui ne SDL2 donné dans le tuto sur OpenGL 3.3.

Edit : J'ai un peu avancé : Le problème de la surface qui disparaît n'avait rien à voir : C'était un problème d'initialisation de la caméra. Pour le résultat moche ci-dessus, c'est en fait le paramètre "pitch" qui étrangement vaut 1024, alors qu'il devrait être égal à 768 (J'ai une largeur de 256 pixels et 3 octets par pixel, confirmé par un éditeur hexadécimal). Lorsque je triche en mettant "nbBytesPerRow" à 768, ça fonctionne correctement, mais j'aimerais comprendre pourquoi j'ai 1024 au lieu de 768. Si je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const int nbBytesPerPixel=surface->pitch

alors le programme plante.

[Kannagi]

Edit : J'ai un peu avancé : Le problème de la surface qui disparaît n'avait rien à voir : C'était un problème d'initialisation de la caméra. Pour le résultat moche ci-dessus, c'est en fait le paramètre "pitch" qui étrangement vaut 1024, alors qu'il devrait être égal à 768 (J'ai une largeur de 256 pixels et 3 octets par pixel, confirmé par un éditeur hexadécimal). Lorsque je triche en mettant "nbBytesPerRow" à 768, ça fonctionne correctement, mais j'aimerais comprendre pourquoi j'ai 1024 au lieu de 768. Si je fais :

Normal , il y a un alignement pour les données , en préfère en général avoir 32 bits que 24 bits
J'ai très peu fait de la SDL2 donc je pourrais pas t'aider , pour la SDL1 s'il faut juste retourner l'image le mieux c'est juste de modifier les vt.
(J'ai lu vite fait mais ta fonction ne me semble pas du tout être une fonction qui fait un quelconque flip sur une image)

[KevinduC]

Je sais pourquoi j'ai 1024, ça vient de moi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

fliped_surface=SDL_CreateRGBSurface(0,surface->w,surface->h,32,0,0,0,0);

L'idéal est de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

nbBytesPerRow=surface->pitch;

Mais une fois sur deux, ça donne une valeur telle que 7537408 au lieu de 768. J'aimerais vraiment comprendre pourquoi ...
Quand j'ai 768 tout fonctionne.

J'ai lu vite fait mais ta fonction ne me semble pas du tout être une fonction qui fait un quelconque flip sur une image

C'est pas vraiment la question pour le moment mais pourtant l'image est bien à l'endroit lorsque je force le pitch à 768.

[KevinduC]

J'ai examiné un peu le code utilisé en SDL1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#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);

Apparemment, le format est fixé à 32 bits par pixel et pour forcer le "pitch" à la bonne valeur, c'est la fonction SDL_ConvertSurface() qui est utilisée. Mais lorsque j'utilise à mon tour cette fonction, ça plante une fois de plus. Voici mon code, c'est du copier-coller :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
if(versionSDL==2)
{
	#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,0);
 
	//gl_fliped_surface=flipSurface2(picture_surface);		//On verra après la question du retournement
 
	glGenTextures(1,&glID);
 
	glBindTexture(GL_TEXTURE_2D,glID);
 
	glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,gl_surface->w,gl_surface->h,0,GL_BGR,GL_UNSIGNED_BYTE,gl_surface->pixels);
 
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
 
	SDL_FreeSurface(gl_surface);
 
	glBindTexture(GL_TEXTURE_2D,0);
}

Pourquoi SDL_ConvertSurface() buggue ? C'est une fonction propre à SDL, là ça défie toute logique.

[KevinduC]

Bon finalement je me suis débrouillé en codant une fonction qui va lire en binaire dans le fichier le nombre d'octets par pixel. Ça fonctionne sauf lorsque je charge plusieurs textures de suite, je pense que c'est parce que je ne libère pas la SDL_Surface chargée avec IMG_Load(), c'est volontaire de ma part car lorsque j'appelle SDL_FreeSurface() ça bug une fois de plus ... Bref je ne peux plus faire grand-chose là à part retourner en SDL1, là au moins ça fonctionne.

Pour bien rendre compte du problème, même si je me contente de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
GLuint loadTexture(const char * filename,int useMipMap,int versionSDL)
{
    GLuint glID;
    SDL_Surface * picture_surface = NULL;
 
    picture_surface = IMG_Load(filename);
    if (picture_surface == NULL)
        return 0;
 
    SDL_FreeSurface(picture_surface);
 
    return glID;
}

Ça bug quand même, alors qu'il ne se passe rien entre le chargement de la surface et sa libération, et on sait que le chargement n'a pas échoué sinon la fonction ne serait pas allé plus loin !!! Pour éviter le bug il faut que je mette l'appel vers SDL_FreeSurface() en commentaire. A moins d'être magicien je ne vois pas d'explication ...

[KevinduC]

News : Je pense que l'erreur vient du fait que je charge ma surface avec IMG_Load() version SDL1, ce qui crée des incompatibilités lorsque j'utilise la surface avec SDL_ConvertSurface() ou SDL_FreeSurface(). J'ai donc téléchargé SDL2_image et au bout de nombreuses heures je suis parvenu à compiler, je teste donc en faisant un simple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
SDL_Surface *aa=IMG_Load("");
If(aa!=NULL)
    SDL_FreeSurface(aa);

Mais je me retrouve maintenant avec le message suivant à l'exécution :

"Le point d'entrée de procédure SDL_LoadFile_RW est introuvable dans la bibliothèque de liens dynamiques", ça veut dire qu'il manque une dll ??? J'ai pourtant copié toutes les dll, et j'ai beau les mettre dans le répertoire de l'exécutable ça ne change rien, j'ai cherché le fichier "SDL_LoadFile_RW.dll" sur Google mais en vain. Bref j'y suis presque (Du moins je l'espère), j'ai juste besoin d'un coup de pouce.

[LittleWhite]

Bonjour,

Peut être un problème avec les DLL de la SDL et non pas avec SDL_image. Peut être que depuis le début, vous utilisez les DLL de la version 1, ce qui expliquerai les nombreux crash "bizarres", mais je doute qu'un tel cas puisse arriver.
Aussi, si jamais vous avez mis les DLL dans un dossier de Windows (comme system32) alors, il faudra les retirer car c'est plus qu'une mauvaise pratique.

[KevinduC]

Le problème apparaît uniquement si j'utilise "IMG_Load()", donc je pense que c'est lié à la DLL de SDL2_image. Il y un fichier "SDL2_image.dll" fourni avec la lib et lorsque je le supprime, le programme annonce qu'il ne le trouve pas, donc c'est qu'il utilise bien ce fichier. Idem si je supprime "SDL2.dll"

[KevinduC]

J'ai téléchargé le fichier "SDL2_image.dll" de la version antérieure (2.0.3 au lieu de 2.0.4) mais aucun changement.

Edit : Je suis remonté jusqu'à la version 2.0.1 et le message a changé : "Le point d'entrée de procédure SDL_free est introuvable ..."

Si je ne parviens pas à résoudre ce problème je devrai renoncer à SDL2 et ses avantages (Multi-fenêtrage, gestion écrans tactiles, boîtes de dialogue ...). Alors s'il y a quelqu'un tombe sur cette conversation et parvient à utiliser SDL2_image svp dites-moi comment vous faites.

[LittleWhite]

Moi, j'utilise un des templates ici : https://jeux.developpez.com/telechar.../709/Templates
J'ai l'impression que quelque chose est vraiment parti en live dans votre installation, mais je ne saurai dire quoi.

[KevinduC]

Merci beaucoup, j'ai téléchargé le projet SDL 2.0.4 et ça fonctionne parfaitement ! J'étais entrain d'essayer de carrément recoder la fonction "loadTexture()" ainsi qu'une fonction à la place de "IMG_load()" qui charge les fichiers .tga lorsque j'ai vu votre message. Bref mon code ne fonctionnait pas de toute façon, ma texture apparaissait blanche. Par curiosité est-ce que vous pourriez (Si vous avez le temps, je suppose que vous avez un réveillon à préparer ^^) jeter un oeil au code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
GLuint loadTexture(const char * filename,int useMipMap)
{
    GLuint glID;
    char extension[4];
    char *adressePoint=strrchr(filename,'.');
    unsigned char *pixels=NULL;
    int nbBytesPerPixel,width,height;
    bool returnLoad;
 
    memcpy(extension,adressePoint+1,4);		//Récupération extension fichier
 
    if(strcmp(extension,"tga")==0)
    {
        returnLoad=TGA_load(filename,pixels,&nbBytesPerPixel,&width,&height);		//Chargement image (A la place de IMG_load())
        if(!returnLoad)
            return 0;
    }
    else
        return 0;
 
    glGenTextures(1,&glID);		//Initialisation objet OpenGL
 
    glBindTexture(GL_TEXTURE_2D,glID);		//Verrouillage
 
    if(nbBytesPerPixel==3)
        glTexImage2D(GL_TEXTURE_2D,0,GL_BGR,width,height,0,GL_RGB,GL_UNSIGNED_BYTE,pixels);
 
    else
    if(nbBytesPerPixel==4)
        glTexImage2D(GL_TEXTURE_2D,0,GL_BGRA,width,height,0,GL_RGBA,GL_UNSIGNED_BYTE,pixels);
	//Chargement en mémoire vidéo
 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
	//Filtres
 
    glBindTexture(GL_TEXTURE_2D,0);		//Déverrouillage
 
    if(pixels!=NULL)		//Libération mémoire
        free(pixels);
 
    return glID;
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
bool TGA_load(const char *filename,unsigned char *pixels,int *nbBytesPerPixel,int *w,int *h)
{
    unsigned char octet1,octet2,octet3,octet4;
    unsigned char caractereLu;
 
    FILE *file=fopen(filename,"rb");		//Ouverture fichier
    if(file==NULL)
        return false;
 
    fseek(file,12,SEEK_SET);
 
    caractereLu=fgetc(file);			//Lecture largeur image
    octet3=caractereLu/16;
    octet4=caractereLu%16;
 
    caractereLu=fgetc(file);
    octet1=caractereLu/16;
    octet2=caractereLu%16;
 
    *w=pow(16,3)*octet1+pow(16,2)*octet2+16*octet3+octet4;
 
    /////////////////////////////////////////////////////////////////////
 
    caractereLu=fgetc(file);			//Lecture hauteur image
    octet3=caractereLu/16;
    octet4=caractereLu%16;
 
    caractereLu=fgetc(file);
    octet1=caractereLu/16;
    octet2=caractereLu%16;
 
    *h=pow(16,3)*octet1+pow(16,2)*octet2+16*octet3+octet4;
 
    /////////////////////////////////////////////////////////////////////
 
    *nbBytesPerPixel=fgetc(file)/8;		//Lecture profondeur pixels
 
    /////////////////////////////////////////////////////////////////////
 
    pixels=(unsigned char*)malloc((*w)*(*h)*(*nbBytesPerPixel));	//Allocation mémoire
 
    /////////////////////////////////////////////////////////////////////
 
    fseek(file,18,SEEK_SET);
 
    fread(pixels,1,(*w)*(*h)*(*nbBytesPerPixel),file);		//Lecture des pixels
 
    /////////////////////////////////////////////////////////////////////
 
    fclose(file);		//Fermeture fichier
 
    return true;
}

Bon réveillon !

[LittleWhite]

Bonjour et bonne année,

Je crois avoir remarqué que le tableau de pixels ne sera jamais correctement renvoyé. Dans le cas d'un passage en paramètre d'un pointeur et d'une allocation de la mémoire dans la fonction, il faut passer un pointeur de pointeur, sans quoi, la mémoire allouée ne peut être retournée (à cause du processus du copie de la variable lors d'un appel de fonction).