Textures : problème avec glBindTexture

Version imprimable

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 :D

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 :cfou:

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:

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:

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 ?... :arf:

22/05/2007, 10h34
fearyourself

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

Jc

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

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
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:

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:

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:

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:

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:

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:

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:

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...

j'ai comme un doute sur cette ligne la :

Code:

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 )...

23/05/2007, 10h31
Laurent Gomila

Citation:

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.
23/05/2007, 20h17
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:

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:

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 :roll:

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... :koi:

Voilà le résultat :

http://val51.neuf.fr/uni/tornado.png
23/05/2007, 21h33
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 ?

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

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
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:

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 :marteau:
Bref, c'est pas le problème du sujet)

23/05/2007, 22h20
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...)
23/05/2007, 22h55
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.
23/05/2007, 23h29
bafman

Citation:

Envoyé par Xander51

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 :aie:) ?
23/05/2007, 23h35
Xander51

C'est une nVidia Geforce Go 7400. J'arrive à faire tourner correctement des applications OpenGL qui utilisent des textures.
Sur les PC de l'université, équipés de cartes graphiques puissantes, ça donne pareil.

A première vue ta initilaliser tes textures avant d'activer ton context opengl
Code:

1 2 wglMakeCurrent( _dc, _rc );
tu es en train de les créer dans un autre context opengl (sous 98 ça devrait planter si tu fais ça, puisque apparament il n'a pas de context opengl d'activé par défaut comme sous XP). Ce qui expliquerait que quand tu vires les bind tu as la dernière textures de construite d'affichée. Car un bind active dans le context courant une texture, hors si tu le fais pas ta carte graphique va prendre la dernière bindée qui est celle que tu as crées dans le context opengl par défaut (je dis context "opengl par défaut" mais c'est pas totalement vrais car si on veut la version d'opengl faut quand même en créer un soit même).
Code:

1 2 3 4 5 6 7 8 9 10 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 );
Pourquoi tu fais deux Gen et deux Bind ?

Si ça peus t'aider voici comment j'initilise mes textures.
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 glGenTextures(1, &m_Texture);//on réserve un espace pour la texture glBindTexture(GL_TEXTURE_2D, m_Texture);//on l'active pour bosser dessus glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);//GL_REPLACE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, Repetition); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, Repetition); if(m_repeat)//mitmap { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);//ATI pas aimer //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 5); gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, this->m_Bitmap->GetWidth(), this->m_Bitmap->GetHeight(),GL_RGBA, GL_UNSIGNED_BYTE, TextureImage); } else { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, Smooth); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, Smooth); //c'est là qu'on charge la texture avec le data glTexImage2D(GL_TEXTURE_2D,0, GL_RGBA, this->m_Bitmap->GetWidth(), this->m_Bitmap->GetHeight(),0,GL_RGBA, GL_UNSIGNED_BYTE, TextureImage); } delete [] TextureImage;

Effectivement le problème venait de l'initialisation des textures au mauvais endroit !
J'ai rajouté ces lignes après le glBindTexture, comme dans ton code :
Code:

1 2 3 4 5 6 // 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 );
Voilà ça fonctionne maintenant, :merci:

Citation:

Envoyé par Suryavarman

Pourquoi tu fais deux Gen et deux Bind ?

J'ai besoin d'un ilGenImage et d'un ilBindImage pour charger les pixels de l'image avec DevIL, qui sont différents de glGenTexture et glBindTexture (c'était d'ailleurs un de mes premiers problèmes).

Tu es de l'IUT du Puy ? Je connais plusieurs étudiants ici, à Teesside, qui sont de l'IUT du Puy aussi ;)

24/05/2007, 02h52
Suryavarman

huhu Salut Florient Axel Charlie Marlène , Morfalou de la part de Pierre :king:
EDIT :
Et Capitaiiiinnnneee...CAaaaavernne...
:mrgreen: