Problème avec glBindTexture

Version imprimable

Bonjour :coucou:,

j'ai un problème qui en fait n'en est pas un :mouarf: !

En fait j'essaye d'utiliser OpenGL avec wxWidgets via un wxGLCanvas.
Je charge une image à l'aide de la classe wxImage, et j'essaye d'en faire une texture affichable à l'aide d'OpenGL.

Pour se faire j'ai donc utilisé le tutoriel trouvé sur le wiki de wxWidgets, que j'ai adapté un petit peu.

Le problème c'est que ça fonctionne parfaitement sur MacOSX, mais sur Windows XP quand j'essaye d'afficher j'ai une violente erreur et ça plante directement. J'ai réussi à isoler la ligne qui bloque le tout sur windows, du coup ça affiche une image blanche sans la texture donc.

J'ai isolé d'où viens le problème, c'est la ligne suivante :

Code:

glBindTexture(GL_TEXTURE_2D, image->getID()[0]);

J'ai bien vérifié dans la classe GLImage si l'image était bien chargée, et c'est le cas, la taille est bien prise etc. Donc je ne sais pas trop d'où viens le problème puisque ça s'affiche au poil sur OS X.

Voila le code :

Code:

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
#ifndef __GLImage
	#define __GLImage
#ifdef __WXMAC__
	#include "OpenGL/glu.h"
	#include "OpenGL/gl.h"
	#include "GLUT/glut.h"
#else
	#include <wx/glcanvas.h>
#endif
#include <wx/wx.h>
#include <wx/image.h>
#include <cmath>
 
namespace Graphics
{
	/**
         * GLImage contains an OpenGL representation of an image (i.e. a texture) wich
         * is dedicated to be rendered in an OpenGL scene. 
         * The asset of this class is to provide a convenient way to load image via wxImage
         * to an OpenGL representation wich can be directly rendered. 
         */
	class GLImage
	{
	private:
		GLuint* ID;
 
	public:
		int width,
			height,
			textureWidth,
			textureHeight;
		float textureCoordX,
		      textureCoordY;
 
		GLuint* getID();
		GLImage();
		GLImage(wxString path);
		~GLImage();
		int getWidth();
		void load(wxString path);
		GLuint* loadImage(wxString imagePath, int* imageWidth, int* imageHeight, int* textureWidth, int* textureHeight);
	};
}	
#endif

Code:

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
#include "GLImage.h"
#define HAS_ALPHA (img->HasAlpha() ?  4 : 3)
#define IS_RGBA (img->HasAlpha() ?  GL_RGBA : GL_RGB)
 
using Graphics::GLImage;
using namespace std;
 
/**
 * Default constructor.
 */
GLImage::GLImage()
{
}
 
/**
 * Constructor from the path to the image to load.
 * @param imagePath path to the image to load
 */
GLImage::GLImage(wxString imagePath)
{
    this->load(imagePath);
}
 
/**
 * Load an image.
 * @param imagePath path to the image to load
 */
void GLImage::load(wxString imagePath)
{
    ID = loadImage(imagePath, &width, &height, &textureWidth, &textureHeight);
 
    textureCoordX = width / (float)textureWidth;
    textureCoordY = height / (float)textureHeight;
}
 
/**
 * Get the OpenGL texture identifiant.
 * @return the OpenGL texture identifiant
 */
GLuint* GLImage::getID()
{
    return ID;
}
 
/**
 * Get the texture width.
 * @return the width of the texture
 */
int GLImage::getWidth()
{
    return width;
}
 
/**
 * Destructor
 */
GLImage::~GLImage()
{
    glDeleteTextures(1, ID);
}
 
/**
 * Load an image into it's OpenGL representation
 * @param imagePath the path to the image to load
 * @param imageWidth variable where the image's width is stored
 * @param imageHeight variable where the image's heigth is stored
 * @param textureWidth variable where the texture's width is stored
 * @param textureHeight variable where the texture's width is stored
 * @return the OpenGL texture representation of the image.
 */
GLuint* GLImage::loadImage(wxString imagePath, int* imageWidth, int* imageHeight, int* textureWidth, int* textureHeight)
{
	wxImage * img = new wxImage(imagePath);
 
	GLuint* ID = new GLuint[1];
	glGenTextures(1, ID);
 
	glBindTexture(GL_TEXTURE_2D, *ID);
 
	// init image handlers
	static bool firstRun = true;
	if ( firstRun )
	{
		wxInitAllImageHandlers();
		firstRun = false;
	}
 
	*imageWidth = img->GetWidth();
	*imageHeight = img->GetHeight();
 
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
	float correctWidth  = log((float)*imageWidth) / log(2.0);
	float correctHeight = log((float)*imageHeight) / log(2.0);
 
	// check if image dimensions are a power of two
	if ( (int)correctWidth == correctWidth && (int)correctHeight == correctHeight)
	{
		glTexImage2D(GL_TEXTURE_2D, 0, HAS_ALPHA, *imageWidth, *imageHeight, 0, IS_RGBA, GL_UNSIGNED_BYTE, img->GetData());
 
		*textureWidth  = *imageWidth;
		*textureHeight = *imageHeight;
 
	}
	else // resize the texture to match a power of 2
	{
		int newWidth = (int)pow(2.0, (int)ceil(correctWidth));
		int newHeight = (int)pow(2.0, (int)ceil(correctHeight));
 
		GLubyte	*bitmapData = img->GetData();
		GLubyte *alphaData  = img->GetAlpha();
		GLubyte	*imageData;
 
		int old_bytesPerPixel = 3;
		int bytesPerPixel     = HAS_ALPHA;
 
		int imageSize = newWidth * newHeight * bytesPerPixel;
		imageData     = (GLubyte *)malloc(imageSize);
 
		int rev_val = *imageHeight - 1;
 
		for (int y = 0; y < newHeight; ++y)
		{
			for (int x = 0; x < newWidth; ++x)
			{
 
				if ( x < *imageWidth && y < *imageHeight )
				{
					imageData[(x + y * newWidth) * bytesPerPixel] = 
						bitmapData[(x + (rev_val-y) * *imageWidth) * old_bytesPerPixel];
 
					imageData[(x+y*newWidth) * bytesPerPixel + 1] = 
						bitmapData[(x + (rev_val-y) * *imageWidth) * old_bytesPerPixel + 1];
 
					imageData[(x+y*newWidth) * bytesPerPixel + 2] = 
						bitmapData[(x + (rev_val-y) * *imageWidth) * old_bytesPerPixel + 2];
 
					if (bytesPerPixel == 4) 
						imageData[(x + y * newWidth) * bytesPerPixel + 3] = 
							alphaData[x + (rev_val-y) * *imageWidth];
				}
				else
				{
					imageData[(x + y * newWidth) * bytesPerPixel]  =  0;
					imageData[(x + y * newWidth) * bytesPerPixel + 1]  =  0;
					imageData[(x + y * newWidth) * bytesPerPixel + 2]  =  0;
					if (bytesPerPixel == 4) 
						imageData[(x + y * newWidth) * bytesPerPixel + 3]  =  0;
				}
			}
		}
 
		glTexImage2D(GL_TEXTURE_2D, 0, HAS_ALPHA, newWidth, newHeight, 0, IS_RGBA, GL_UNSIGNED_BYTE, imageData);
 
		*textureWidth  = newWidth;
		*textureHeight = newHeight;
 
		delete imageData;
	}
 
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0);//GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 0);//GL_CLAMP_TO_EDGE);
 
	wxMessageBox(wxString::Format(wxT("id : %d"), *ID));
	return ID;
}

Code:

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
#ifndef __GLSprite
	#define __GLSprite
#ifdef __WXMAC__
	#include "OpenGL/gl.h"
#else
	#include <wx/glcanvas.h>
#endif
#include "wx/wx.h"
#include "GLImage.h"
 
namespace Graphics
{
	class GLSprite
	{
		private:
		    GLImage* image;
		    int x, y, angle, hotSpotX, hotSpotY;
		    float xScale, yScale;
		    bool xFlip, yFlip;
 
		public:
		    GLSprite(GLImage* img);
			~GLSprite();
		    /* des fonctions pour rotation etc... */
		    void setImage(GLImage* image);
		    GLImage* getImage();
		    void render();
	};
}	
#endif

Code:

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
71
72
73
74
75
#include "GLSprite.h"
using Graphics::GLSprite;
using Graphics::GLImage;
 
/**
 * This is a simple class built on top of OpenGL that manages drawing images in a higher-level and quicker way.
 */
GLSprite::GLSprite(GLImage* img)
{
    x = y = hotSpotX = hotSpotY = angle = 0;
    xScale = yScale = 1;
    xFlip = yFlip = false;
 
    if (img != NULL) 
		this->setImage(img);
    else 
		image = NULL;
}
 
GLSprite::~GLSprite()
{
	delete image;
}
 
void GLSprite::setImage(GLImage* image)
{
    this->image = image;
}
 
Graphics::GLImage* GLSprite::getImage()
{
	return this->image;
}
 
void GLSprite::render()
{
    if (image == NULL)
	{
		wxMessageBox(wxT("image vide"));
		exit(1);
	}
 
    glLoadIdentity();
    glTranslatef(x, y, 0);
 
    if (xScale != 1 || yScale != 1)
        glScalef(xScale, yScale, 1);
 
    if (angle)
        glRotatef(angle, 0,0,1);
 
    if (image->getID() == NULL)
	{
		wxMessageBox(wxT("ID vide"));
		exit(1);
	}
 
    glBindTexture(GL_TEXTURE_2D, image->getID()[0]);
 
    glBegin(GL_QUADS);
 
    glTexCoord2f(xFlip? image->textureCoordX : 0, yFlip? 0 : image->textureCoordY);
    glVertex2f(-hotSpotX, -hotSpotY);
 
    glTexCoord2f(xFlip? 0 : image->textureCoordX, yFlip? 0 : image->textureCoordY);
    glVertex2f(image->width - hotSpotX, -hotSpotY);
 
    glTexCoord2f(xFlip? 0 : image->textureCoordX, yFlip? image->textureCoordY : 0);
    glVertex2f(image->width - hotSpotX, image->height - hotSpotY);
 
    glTexCoord2f(xFlip? image->textureCoordX : 0, yFlip? image->textureCoordY : 0);
    glVertex2f(-hotSpotX, image->height - hotSpotY);
 
    glEnd();
}

Et finalement j'affiche l'image comme ceci :

Code:

1
2
Graphics::GLSPrite * sprite = new Graphics::GLSprite(new Graphics::GLImage("sprite.bmp"));
sprite->render();

J'ai fait une recherche mais je n'ai pas trouvé de réponse pour le moment, donc si vous pouviez m'aider ça serait très sympathique:king:

Merci d'avance !

09/10/2007, 17h13
smashy
L'erreur est ici :0

Code:

GLuint* ID = new GLuint[1];

tu redeclare une variable ID qui est locale a la methode . Comme cette variable a le meme nom que le membre de la classe image , le membre est masque !. Tu devrais ecrire quelque chose comme
Code:

1 2 ID = new GLuint[1]; /* qui est finalement equivalent a this->ID = ... */
Question: pourquoi ne pas directement utilise un membre ID de type uint plutot que pointeur sur uint (qui force une allocation memoire) ?
09/10/2007, 17h58
Flaie

Malheureusement ça ne change rien, et puis la fonction loadImage renvoyais le GLuint* crée qui était donc assigné à ID (le membre de la classe).

J'ai vraiment du mal à voir d'où peut venir l'erreur.
Car finalement, même en commentant la ligne que j'ai indiqué dans mon premier message, ça s'affiche correctement sous MacOSX ce qui est en fait logique puisque je n'affiche qu'une seule image pour le moment, donc je ne fais qu'un appel à glBindTextures, donc ça unbind pas si je puis dire l'ancienne texture bindé à GL_TEXTURE_2D.

En faisant ça sur Windows ça ne plante plus, par contre j'ai un rectangle blanc de la taille de l'image. Je peux donc supposer que l'image data n'est pas correctement lue ? Mais ça seulement sous Windows, ça me parait étrange :aie:. C'est un peu comme si l'appel à glGenTextures() n'avais pas d'effet. Bien sur je peux me tromper, je débute avec OpenGL, mais d'après le manuel j'ai à peu près compris comment s'enchainent les appels à ces fonctions.

Pour l'instant je suis toujours dans le flou :(.

Pour ta deuxième question, j'ai fait ça car ça me parait mieux pour gérer plusieurs Sprite qui partageraient une même texture (genre pour répéter l'affichage de cette texture par l'appel de plusieurs objets).

Si vous avez d'autres idées je suis preneur :mrgreen: !
10/10/2007, 14h32
lordheavy

De quelle taille est ta texture ?

Sous osx la carte supporte peut-être les textures n'étant pas d'une puissance de 2 ?
10/10/2007, 18h00
Flaie

Citation:

Envoyé par lordheavy

De quelle taille est ta texture ?

Sous osx la carte supporte peut-être les textures n'étant pas d'une puissance de 2 ?

La texture fais du 195x16 mais j'ai testé également avec une image de taille 256x256 ça ne change rien.

Le code donné dans mon premier message est censé créer une image de taille puissance de 2 en collant du noir pour remplir, donc ça devrais également charger l'image même si elle n'est pas de taille puissance de 2.

Je vais tenter avec auxDIBImageLoad pour voir si le problème arrive avec ça, ce qui voudrais dire que ça viens du traitement via wxImage, mais du coup je perds le gain d'utilisation de wxImage qui est de pouvoir charger tout un tas de format différent, notamment le png :).
10/10/2007, 18h37
deadalnix

Ca serait pas un probleme de big ou little indian lors du chargement des textures ?
10/10/2007, 19h05
Flaie

Citation:

Envoyé par deadalnix

Ca serait pas un probleme de big ou little indian lors du chargement des textures ?

Merci de ta réponse !

Mais ça serait quand même étonnant, puisque tout les exemples de chargement que d'image que j'ai trouvé ne tiennent pas compte de ça.
J'ai lu sur un site qu'il fallais activer GL_TEXTURE_2D avant de render, chose que j'ai faite via glEnable(GL_TEXTURE_2D) mais ça ne change rien.

J'ai également modifié la classe GLImage pour tenir compte du commentaire de smashy (on sait jamais) mais ça ne change rien.
La seule différence que je détecte entre l'exécution sur Win et sur OS X c'est l'affichage de la valeur d'ID (le GLuint identifiant ma texture nommée passe à glGenTextures) avant et après l'appel à glGenTextures. Sur OS X sa valeur est changée après l'appel, sous Win ... non :?. A noter que j'ai testé sur mon Linux et ça fonctionne aussi l'affichage de l'image.

Ça viens donc de Windows ? Ça me parait bizarre, les exemples pris sur NEHE fonctionnent au poil (mais ils utilisent win32 et pas wxWidgets).

Bref toujours dans le flou :mouarf:
10/10/2007, 20h48
Flaie

Bon ben voila j'ai fini par résoudre ce sale bug :mrgreen: !

Je vais quand même expliquer d'où viens le problème, si jamais ça sert à d'autres :mouarf:.

En gros j'ai une classe GLCanvas qui dérive de wxGLCanvas.
C'est dans le constructeur de cette classe que je créais mes instances de GLImage et GLSprite de cette image, jusque là tout va bien.

Le problème c'est que la création du sprite à partir de l'image fait appel (voir code source dans le premier post) aux fonctions glGenTextures et compagnie, or lors du constructeur de GLCanvas l'appel de SetCurrent() qui fixe le contexte OpenGL à ce canvas n'a pas encore été fait, donc ça pose problème pour l'appel des fonctions glXXX tout du moins sur Windows XP apparemment, sur OS X et Linux je n'ai pas eu ce soucis.

Solution : charger les images, c'est à dire créer les instances de GLSprite etc dans InitGL() après l'appel de SetCurrent().

Voila, ça a l'air un peu évident, mais j'aurais quand même perdu plusieurs heures pour trouver ce *`$£%^+ de bug.

Problème résolu :king: