Discussion :

[Xander51]

Bonjour,

Après avoir passé quelques heures à chercher ce qui n'allait pas, je me permets de partager mon problème à vous, qui avez certainement plus d'expérience en la matière

Je développe une application sous Windows avec OpenGL. J'utilise WinAPI pour gérer la fenêtre, et DevIL pour charger les pixels d'une image.

Le problème est que dès que j'utilise la fonction glBindTexture avec un autre nom de texture que 0 (la texture par défaut), je n'ai plus aucune texture qui s'affiche (tout est blanc). D'ailleurs même si j'appelle la fonction glIsTexture, c'est terminé plus de texture non plus, même si elle renvoie GL_TRUE et que je bind ce nom de texture après

Si je ne fais appel ni à glGenTextures, ni à glBindTexture, c'est la dernière texture chargée qui est utilisée pour tout (je suppose que glTexImage2D charge dans la texture par défaut si on appelle pas glBindTexture).

Voici le code des deux fonctions utilisées :

--- Chargement de texture ---

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
bool Graphics::LoadTexture ( unsigned int * texId, const string & filename )
{
	assert( texId );
 
	// Create the texture
	ILuint ilTexId;
	ilGenImages( 1, &ilTexId );		// glGenTextures( 1, (GLuint *)texId );
	ilBindImage( ilTexId );			// glBindTexture( GL_TEXTURE_2D, (GLuint)*texId );
 
	// Load the image
	if ( ilLoadImage( filename.c_str() ) == IL_FALSE )
		return false;
 
	glGenTextures( 1, texId );
	glBindTexture( GL_TEXTURE_2D, *texId );
 
	glTexImage2D( GL_TEXTURE_2D, 0,
		ilGetInteger( IL_IMAGE_BPP ),		// Number of bytes per pixel
		ilGetInteger( IL_IMAGE_WIDTH ),		// Width of the texture
		ilGetInteger( IL_IMAGE_HEIGHT ),	// Height of the texture
		0, ilGetInteger( IL_IMAGE_FORMAT ),	// Image format
		GL_UNSIGNED_BYTE,
		(void*)ilGetData() );			// Pixel data
 
	// We can now delete the image variable
	ilDeleteImage( ilTexId );
 
	// Check for errors
	if ( glGetError() == GL_INVALID_VALUE )
		return false;
 
	return true;
}

--- Utilisation d'une texture ---

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
bool Graphics::EnableTexture ( unsigned int texId ) const
{
	// Enable texturing
	glEnable( GL_TEXTURE_2D );
 
	// Check if the texture name is correct
	if ( _DEBUG )
		if ( glIsTexture( texId ) == GL_FALSE )
			return false;
 
	// Set the current texture
	glBindTexture( GL_TEXTURE_2D, texId );
 
	return true;
}

La fonction qui charge est correctement appelée pour toutes les textures, les noms de texture sont corrects (de 1 à n), la fonction pour en utiliser une aussi, avant de dessiner l'objet auquel elle doit être appliquée. Là encore le nom de texture est correct (compris entre 1 et n à chaque fois), même glIsTexture me dit qu'il est bon.

Quand je dis que dès que j'appelle glBindTexture j'ai plus rien, c'est vraiment ça, même si je la rappelle après avec 0.

Je ne vois pas ce que je fais et qui ne va pas, et sinon d'où peut venir le problème ?...

[fearyourself]

Est-ce qu'on pourrait voir comment tu appelles ces fonctions et la définition des différents paramètres ?

Jc

[Xander51]

La fonction LoadTexture est appelée dans la fonction Init de World :

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
bool World::Init ( )
{
	// Initialise the graphics component
	if ( !GRAPHICS.Init() )
		return false;
 
	// Particle system
	unsigned tex;
 
	if ( !GRAPHICS.LoadTexture( &tex, "particle.tga" ) )
		return false;
 
	Entity * ps = new EntityParticleSystem;
	ps->Init( this, -1, tex );
	Emitter * em = new CircleEmitter;
	( (CircleEmitter*)em )->Init( 5, 4, Colour(0.8,0.8,0.8,1), Colour(0.4,0.4,0.4,0.4), 0.5f, 0.6f, 100, 100, 5, 6 );
	( (EntityParticleSystem*)ps )->SetEmitter( em );
	_entities.push_back( ps );
 
	// Skybox loading
	GRAPHICS.LoadSkybox( "left.bmp", "right.bmp", "front.bmp", "back.bmp", "top.bmp", "bottom.bmp" );
 
	// TODO: Load the animations into the world
 
	// TODO: Create the world entities
 
	// Play wind sound
	sndPlaySound( "desertwind.wav", SND_ASYNC | SND_LOOP );
 
	return true;
}

Fonction LoadSkybox dans Graphics :

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
bool Graphics::LoadSkybox ( const string & left, const string & right, const string & front, const string & back, const string & top, const string & bottom )
{
	unsigned int leftTex, rightTex, frontTex, backTex, topTex, bottomTex;
 
	LoadTexture( &leftTex, left );
	LoadTexture( &rightTex, right );
	LoadTexture( &frontTex, front );
	LoadTexture( &backTex, back );
	LoadTexture( &topTex, top );
	LoadTexture( &bottomTex, bottom );
 
	GfxEntity * skybox = new GfxEntitySkybox;
	( (GfxEntitySkybox*)skybox )->Init( leftTex, rightTex, frontTex, backTex, topTex, bottomTex );
	_gfxEntities.push_back( skybox );
	_skyboxId = _gfxEntities.size() - 1;
 
	return true;
}

La fonction World::Init() est appelée au lancement de l'application :

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
int Application::Run ( const string & xmlFileName )
{
	// Tell Windows to display the window
	ShowWindow( _hWnd, _nCmdShow );
	UpdateWindow( _hWnd );
 
	// Initialise the world
	if ( !( _world->Init() ) )
		return -1;
 
	// Message loop
	MSG msg;
	ZeroMemory( &msg, sizeof( msg ) );
 
	while ( msg.message != WM_QUIT )
	{
		if ( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
		{
			TranslateMessage( &msg );
			DispatchMessage( &msg );
		}
		else if ( _run ) // We are badly behaved as we don't wait for Windows to tell us to redraw
		{
			if ( !_world->Update() ) // Update and render our virtual world
				return -1;
 
			// Swap the buffers
			SwapBuffers( _dc );
 
			Sleep(0);
		}
		else
			Sleep(10); // Let's be generous and give time over to other applications
	}
 
	return (int)msg.wParam;
}

Pour ce qui est de la fonction EnableTexture, elle est appelée indirectement dans la méthode Update de World :

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
bool World::Update ( )
{
	// --- Declare the beginning of a new frame to the timer ---
	TIMER.NewFrame();
 
	// --- Update the entities if it is time to ---
	if ( TIMER.TimeToUpdate() )
		for ( vector<Entity *>::const_iterator currentEntity = _entities.begin(); currentEntity != _entities.end(); ++currentEntity )
			( *currentEntity )->Update();
 
	// --- TODO: Test for collisions ---
 
	// --- Start drawing ---
	if ( !GRAPHICS.StartRender() )
		return false;
 
	// Render the virtual world by rendering every entity
	for ( vector<Entity *>::const_iterator currentEntity = _entities.begin(); currentEntity != _entities.end(); ++currentEntity )
		( *currentEntity )->Render();
 
	// --- End drawing ---
	if ( !GRAPHICS.EndRender() )
		return false;
 
	return true;
}

J'appelle la fonction Render de toutes mes entités :

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
bool EntityParticleSystem::Render ( )
{
	// If the entity is textured...
	if ( _texId != -1 )
	{
		GRAPHICS.EnableTexture( _texId );
		if ( !GRAPHICS.RenderParticles( &_livingParticles, 5 ) )
			return false;
		GRAPHICS.DisableTexture();
	}
	else if ( !GRAPHICS.RenderParticles( &_livingParticles ) )
			return false;
 
	return true;
}

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
bool GfxEntitySkybox::Render ( ) const
{
	// Disable the depth buffer
	glDisable( GL_DEPTH_TEST );
 
	// Disable lighting
	glDisable( GL_LIGHTING );
 
	// Backup the model - view matrix
	glPushMatrix();
 
	// Modify the view matrix so it is centred
	Vector cameraPosition = GRAPHICS.GetCameraPosition();
	glTranslatef( cameraPosition[0], cameraPosition[1], cameraPosition[2] );
 
	// --- We can now render the skybox ---
	glColor4f( 1.f, 1.f, 1.f, 1.f );
 
	// Left side
	GRAPHICS.EnableTexture( _leftTexId );
	glBegin( GL_QUADS );
		glTexCoord2i( 0, 0 );		glVertex3i( -1, -1,  1 );
		glTexCoord2i( 1, 0 );		glVertex3i( -1, -1, -1 );
		glTexCoord2i( 1, 1 );		glVertex3i( -1,  1, -1 );
		glTexCoord2i( 0, 1 );		glVertex3i( -1,  1,  1 );
	glEnd();
 
	// Right side
	GRAPHICS.EnableTexture( _rightTexId );
	glBegin( GL_QUADS );
		glTexCoord2i( 0, 0 );		glVertex3i( 1, -1, -1 );
		glTexCoord2i( 1, 0 );		glVertex3i( 1, -1,  1 );
		glTexCoord2i( 1, 1 );		glVertex3i( 1,  1,  1 );
		glTexCoord2i( 0, 1 );		glVertex3i( 1,  1, -1 );
	glEnd();
 
	// Front side
	GRAPHICS.EnableTexture( _frontTexId );
	glBegin( GL_QUADS );
		glTexCoord2i( 0, 0 );		glVertex3i( -1, -1, -1 );
		glTexCoord2i( 1, 0 );		glVertex3i(  1, -1, -1 );
		glTexCoord2i( 1, 1 );		glVertex3i(  1,  1, -1 );
		glTexCoord2i( 0, 1 );		glVertex3i( -1,  1, -1 );
	glEnd();
 
	// Back side
	GRAPHICS.EnableTexture( _backTexId );
	glBegin( GL_QUADS );
		glTexCoord2i( 0, 0 );		glVertex3i(  1, -1, 1 );
		glTexCoord2i( 1, 0 );		glVertex3i( -1, -1, 1 );
		glTexCoord2i( 1, 1 );		glVertex3i( -1,  1, 1 );
		glTexCoord2i( 0, 1 );		glVertex3i(  1,  1, 1 );
	glEnd();
 
	// TODO: Top and bottom side
 
	// Restore the original model - view matrix
	glPopMatrix();
 
	// Restore the states
	GRAPHICS.DisableTexture();
	glEnable( GL_DEPTH_TEST );
	glEnable( GL_LIGHTING );
 
	return true;
}

La méthode Render de GfxEntitySkybox est appelée dans StartRender :

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
bool Graphics::StartRender ( )
{
	// Clear the image to the background colour and clear the depth buffer
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
	// Set the view transformation
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();
 
	// TODO: Set eye space lights
		static float position2[]  = { 0, 0, 1, 1 };
		static float direction2[]  = { 0, 0, -1 };
		static float intensity2[] = { 1, 1, 1, 1 };
		glLightfv( GL_LIGHT2, GL_POSITION, position2 );
		glLightfv( GL_LIGHT2, GL_SPOT_DIRECTION, direction2 );
		glLightf( GL_LIGHT2, GL_SPOT_CUTOFF, 45.f );
		glLightfv( GL_LIGHT2, GL_DIFFUSE, intensity2 );
 
	// Set the view transformation
	_camera->ViewTransform();
 
	// TODO: Set the world space lights
 
	// Render the skybox if there is one
	if ( _skyboxId > -1 )
		_gfxEntities[ _skyboxId ]->Render();
 
	return true;
}

Pour info, la méthode Graphics::Init() :

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
bool Graphics::Init ( )
{
	glEnable( GL_DEPTH_TEST );		// Enable the depth test
	glClearColor( 0, 0, 0.25f, 0 );		// Clear the colour buffer to a dark blue
 
	// Enable lighting
	glEnable( GL_LIGHTING );
	//glEnable( GL_LIGHT0 );
	glEnable( GL_LIGHT0+2 );
 
	// Initialise the camera
	_camera = new FirstPersonCamera;
	_camera->Init( Vector( 0, -4, 100 ) );
 
	// Set parameters for texturing
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
	glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
	glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
 
	// Define material properties of specular color and degree of shininess
	GLfloat specular [] = { 1.f, 1.f, 1.f, 1.f };
	GLfloat shininess [] = { 64.f };
	glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, specular );
	glMaterialfv( GL_FRONT_AND_BACK, GL_SHININESS, shininess );
 
	// Set the GL_AMBIENT_AND_DIFFUSE color state variable to be the
	// one referred to by all following calls to glColor
	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
	glEnable(GL_COLOR_MATERIAL);
	// Check DevIL version
	if ( ilGetInteger(  IL_VERSION_NUM ) < IL_VERSION )
		return false;
 
	// Initialise DevIL
	ilInit();
 
	// Enable blending
	glEnable( GL_BLEND );
	glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 
	return true;
}

Voilà, désolé si c'est pas bien clair...

Avec le debuggeur de Visual Studio, je vois bien que les appels à la méthode LoadTexture sont bien fait pour chaque texture à l'initialisation, que j'obtiens des noms valides d'OpenGL (de 1 à nbDeTextures), et que les appels à EnableTexture ont bien lieu avant de dessiner, avec là encore des noms de texture corrects.
Même glIsTexture me confirme qu'ils sont bons avant que je les bind.
Pourtant, tout est blanc...

[bafman]

j'ai comme un doute sur cette ligne la :

Code :

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

1
2
3
4
5
6
7
8
    glTexImage2D( GL_TEXTURE_2D, 0,
        ilGetInteger( IL_IMAGE_BPP ),        // Number of bytes per pixel
        ilGetInteger( IL_IMAGE_WIDTH ),        // Width of the texture
        ilGetInteger( IL_IMAGE_HEIGHT ),    // Height of the texture
        0, ilGetInteger( IL_IMAGE_FORMAT ),    // Image format
        GL_UNSIGNED_BYTE,
        (void*)ilGetData() );            // Pixel data

je ne connait pas devIl, mais tu est sure que ilGetInteger( IL_IMAGE_BPP ) retourne bien une valeure valide pour openGL du type GL_RGB ou GL_RGBA ? idem pour ilGetInteger( IL_IMAGE_FORMAT )...

[Laurent Gomila]

je ne connait pas devIl, mais tu est sure que ilGetInteger( IL_IMAGE_BPP ) retourne bien une valeure valide pour openGL du type GL_RGB ou GL_RGBA ? idem pour ilGetInteger( IL_IMAGE_FORMAT )...

Le troisième paramètre de glTexImage2D accepte aussi un nombre de composantes, ce que renvoie ilGetInteger(IL_IMAGE_BPP). Quant aux formats renvoyés par ilGetInteger(IL_IMAGE_FORMAT), selon la doc leurs valeurs coïncident avec celles des formats OpenGL. Donc a priori tout devrait être OK, cependant vérifier que toutes les valeurs sont correctes est quand même une bonne idée.

Il faut aussi vérifier les erreurs après chaque appel OpenGL (glGetError()), ça peut aider.

[Xander51]

Les valeurs retournées par ilGetInteger( IL_IMAGE_BPP ) sont 3 pour les textures sans canal alpha et 4 pour la texture avec.

Les valeurs retournées par ilGetInteger( IL_IMAGE_FORMAT ) sont 32992 (soit 80E0 en hexa) pour les textures sans canal alpha et 32993 (soit 80E1 en hexa) pour la texture avec. Cela correspond à :

Code :

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

1
2
3
/* EXT_bgra */
#define GL_BGR_EXT                        0x80E0
#define GL_BGRA_EXT                       0x80E1

J'ai essayé de placer en dur GL_BGR_EXT ou même GL_RGB : ça n'a rien changé.

J'ai placé, après chaque appel de fonction OpenGL dans les méthodes LoadTexture et EnableTexture, la chose suivante :

Code :

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

1
2
3
// Check for errors
if ( glGetError() == GL_INVALID_ENUM || glGetError() == GL_INVALID_VALUE || glGetError() == GL_INVALID_OPERATION )
	return false;

Il n'y a jamais d'erreur. On dirait que d'après OpenGL, tout fonctionne parfaitement

Pourtant j'ai recompilé et testé mon projet sur un autre ordinateur, et j'ai obtenu le même résultat : il doit donc y avoir un problème quelque part dans mon code...

Voilà le résultat :

[bafman]

j'ai regardé rapidement ton code, et je ne trouve pas ton appel à World::Init ... j'ai comme un doute la, il est bien fait après la creation de la fenetre ?

[Xander51]

Elle est appelée quand je lance l'application :

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
int Application::Run ( const string & xmlFileName )
{
	// Tell Windows to display the window
	ShowWindow( _hWnd, _nCmdShow );
	UpdateWindow( _hWnd );
 
	// Initialise the world
	if ( !( _world->Init() ) )
		return -1;
 
	// Message loop
	MSG msg;
	ZeroMemory( &msg, sizeof( msg ) );
 
	while ( msg.message != WM_QUIT )
	{
		if ( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
		{
			TranslateMessage( &msg );
			DispatchMessage( &msg );
		}
		else if ( _run ) // We are badly behaved as we don't wait for Windows to tell us to redraw
		{
			if ( !_world->Update() ) // Update and render our virtual world
				return -1;
 
			// Swap the buffers
			SwapBuffers( _dc );
 
			Sleep(0);
		}
		else
			Sleep(10); // Let's be generous and give time over to other applications
	}
 
	return (int)msg.wParam;
}

Quant à la création de la fenêtre, elle est faite dans le constructeur de Application :

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
71
72
73
74
Application::Application ( HINSTANCE hInstance, int nCmdShow ) throw (std::runtime_error) : _hWnd(NULL), _hInstance(hInstance), _nCmdShow(nCmdShow), _run(true)
{
	// Create a window "class"
	WNDCLASSEX wcex;
 
	wcex.cbSize        = sizeof( WNDCLASSEX );			// Size of the structure
	wcex.style         = CS_HREDRAW | CS_VREDRAW;		// Style
	wcex.lpfnWndProc   = (WNDPROC)WndProc;				// Event handler
	wcex.cbClsExtra    = 0;								// Extra bytes for the structure
	wcex.cbWndExtra    = 0;								// Extra bytes for the instance
	wcex.hInstance     = _hInstance;					// Instance
	wcex.hIcon         = 0;								// 32x32 icon
	wcex.hCursor       = LoadCursor( NULL, IDC_ARROW );	// Default mouse cursor
	wcex.hbrBackground = (HBRUSH)( COLOR_WINDOW + 1 );	// Colour of the window background
	wcex.lpszMenuName  = 0;								// Menu
	wcex.lpszClassName = "VISICA";						// Name of the class
	wcex.hIconSm       = 0;								// 16x16 icon
 
	// Register it with Windows
	if ( RegisterClassEx( &wcex ) == 0 )
		throw std::runtime_error( "Class registering failed!\n" );
 
	// Create it
	_hWnd = CreateWindow( "VISICA",		// Class name of the window
		"VISICA © Val",					// Title of the window
		WS_OVERLAPPEDWINDOW,			// Style of the window
		CW_USEDEFAULT, CW_USEDEFAULT,	// Position of the top left
		CW_USEDEFAULT, CW_USEDEFAULT,	// Width and height
		NULL, NULL, _hInstance, NULL );
 
	if ( !_hWnd )
		throw std::runtime_error( "Window creation failed!\n" );
 
	// Store a pointer to this object in the window
	SetWindowLong( _hWnd, GWL_USERDATA, (LONG)this );
 
	// --- The following is specific to OpenGL ---
	// Get the device context for your window
	_dc = GetDC( _hWnd );
 
	// Select the pixel format for OpenGL
	PIXELFORMATDESCRIPTOR pfd = {
		sizeof( PIXELFORMATDESCRIPTOR ),	// Size of this PFD
		1,									// Version number
		PFD_DRAW_TO_WINDOW |				// Support window
		PFD_SUPPORT_OPENGL |				// Support OpenGL
		PFD_DOUBLEBUFFER,					// Double buffered
		PFD_TYPE_RGBA,						// RGBA type
		24,									// 24-bit color depth
		0, 0, 0, 0, 0, 0,					// Colour bits ignored
		0,									// No alpha buffer
		0,									// Shift bit ignored 
		0,									// No accumulation buffer
		0, 0, 0, 0,							// Accum bits ignored
		24,									// 24-bit depth buffer
		0,									// No stencil buffer
		0,									// No auxiliary buffer
		PFD_MAIN_PLANE,						// Main layer
		0,									// Reserved
		0, 0, 0 };							// Layer masks ignored
 
	// Get the best available match of pixel format you're wanting
	int iPixelFormat = ChoosePixelFormat( _dc, &pfd ); 
 
	// Make that the pixel format of the window
	SetPixelFormat( _dc, iPixelFormat, &pfd ); 
 
	// Create an OpenGL context
	_rc = wglCreateContext( _dc );
	wglMakeCurrent( _dc, _rc );
 
	// Create the world
	_world = new World;
}

(Au passage, sous Windows Vista, la fonction ChoosePixelFormat s'est mise à me lancer une erreur d'accès mémoire illégal d'une compilation à l'autre ; depuis je ne peux plus compilé ce projet sous Vista
Bref, c'est pas le problème du sujet)

[bafman]

est ce que tu peut effetuer les deux tests suivants :
- enregistrer l'image chargé par devIl pour voir si il n'envoi pas du blanc à la carte graphique
- prendre tout tes appels à glBindTexture et mettre l'Id à 1 (pour voir si ce n'est pas un problème d'Id mal passé en paramètre ou autre...)

[Xander51]

J'ai enregistré une copie de toutes les images chargées par DevIL via DevIL : elles sont bonnes. Je les ai même enregistrées via ma propre fonction de sauvegarde de TGA pour être sûr : le pointeur sur les données de l'image est correct.

Si je mets tous les appels à glBindTexture à 1 : toujours pas de texture. Si je les mets tous à zéro (ou que je les supprime), c'est la dernière texture chargée qui texture tout.

[bafman]

Si je les mets tous à zéro (ou que je les supprime), c'est la dernière texture chargée qui texture tout.

ca, c'est pas normal. normalement, 0 est un ID reservé qui indique "pas de texture", donc c'est la que tu devrait avoir une texture blanche...
Tu utilise quoi comme carte ATI (ou peut être une intel ) ?