VBO et texture

Version imprimable

24/09/2008, 16h12
Naelhem

VBO et texture

bonjour à tous,

Pour un cube
le buffer d'indice [GL_ELEMENT_ARRAY_BUFFER] (6 par face, dessin à partir de triangles) ira chercher dans le buffer de données [GL_ARRAY_BUFFER] les "sous-données" de position de vertex et de coordonnées de texture.

Mais comment faire pour afficher une texture différente par face?

Merci d'avance.
24/09/2008, 16h26
ShevchenKik

Salut,

tu peux utiliser le multitexturing pour appliquer differentes textures a un meme objet.
Mais vu que dans ton cas tu ne veux pas superposer les textures mais en avoir une differente par face, pourquoi ne pas simplement considerer ton cube comme 6 faces independantes avec chacune sa texture?

Sinon en multitexturing tu peux jouer avec les coordonnees de texture, les textures elles-même et la méthode d'application pour qu'au final on ait l'impression qu'il n'y ait qu'une texture par face, mais ca me parait très très lourd...

j'espere que ca répond un peu à ta question...
24/09/2008, 16h34
shenron666

chaque couple "vertex + texcoord" doit être unique, donc là où un cube était composé de 8 vertex, je ne pense pas me tromper en disant qu'un cube texturé est composé de 24 couples
éventuellement tu peux essayer de réutiliser certains couples en tournant tes textures ou en les inversant, je sait pas si ça peux marche mais tu devrais descendre à 12 couples

Merci c'était tout bête mais je n'y avais pas pensé ;) mais la théorie n'est pas la pratique.

L'affichage du cube en indexant mes 36 sommets (6 par face pour draw avec GL_TRIANGLES) à partir d'un tableau de donnée stockant les positions des 24 sommet (4 par face) puis les coordonnées de textures.

Ma texture ne s'affiche pas, le cube prend une couleur gris clair (au lieu du blanc de base) sur toutes ses faces et seule la dernière face (right) est en partie (moins d'un quart de a surface de cette face, par deux triangles texturés) et incorrectement texturée (déformation de l'image de la texture).

EDIT : la couleur grise semble être un artefact d'application de la texture, puisque si je change de texture cette couleur devient maron (image 128x128 bois).

Ma métatexture fait 512x512 px, les texture utilisée sont 3 carrés différent de 128px de coté "empilées" les unes au dessus des autres à partit du point d'origine de la métatexture en bas à gauche.

mes données :

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
 
void CCube::InitArray()
{
 
  //    v7------v6                                                               
  //   /|         /|                                                                
  //  v3------v2|                                                                
  //  | |       | |                                                                
  //  | |v4---|-|v5                                                              
  //  |/        |/                                                                 
  //  v0------v1  
 
  // N_VERTS = 24;  P_SIZE = 3; T_SIZE = 2; N_FACE = 6;
 
	GLfloat pos[N_VERTS * P_SIZE] =   
    {
 
		// front face 		0, 1, 2, 2, 3, 0,
		-1.0f, -1.0f,  1.0f, //0_v0
		 1.0f, -1.0f,  1.0f, //1_v1
		 1.0f,  1.0f,  1.0f, //2_v2
		-1.0f,  1.0f,  1.0f, //3_v3
 
		// top face 		4, 5, 6, 6, 7, 4,
		-1.0f,  1.0f,  1.0f, //4_v3
		 1.0f,  1.0f,  1.0f, //5_v2
		 1.0f,  1.0f, -1.0f, //6_v6
		-1.0f,  1.0f, -1.0f, //7_v7
 
		// back face		8, 9, 10, 10, 11, 8,
		 1.0f, -1.0f, -1.0f, //8_v5
		-1.0f, -1.0f, -1.0f, //9_v4
		-1.0f,  1.0f, -1.0f, //10_v7
		 1.0f,  1.0f, -1.0f, //11_v6
 
		// left face		12, 13, 14, 14, 15, 12,
		-1.0f, -1.0f, -1.0f, //12_v4
		-1.0f, -1.0f,  1.0f, //13_v0
		-1.0f,  1.0f,  1.0f, //14_v3
		-1.0f,  1.0f, -1.0f, //15_v7
 
		// bottom face		16, 17, 18, 18, 19, 16,
		-1.0f, -1.0f, -1.0f, //16_v4
		 1.0f, -1.0f, -1.0f, //17_v5
		 1.0f, -1.0f,  1.0f, //18_v1
		-1.0f, -1.0f,  1.0f, //19_v0
 
		// right face		20, 21, 22, 22, 23, 20
		 1.0f, -1.0f,  1.0f, //20_v1
		 1.0f, -1.0f, -1.0f, //21_v5
		 1.0f,  1.0f, -1.0f, //22_v6
		 1.0f,  1.0f,  1.0f  //23_v2		
    }; 
 
	GLuint coordTexture[N_VERTS * T_SIZE] = { 
		// front face 		0, 1, 2, 2, 3, 0,
		0.00f, 	0.50f,
		0.25f,	0.50f,
		0.25f,	0.75f,
		0.00f,	0.75f,
 
		// top face 		3, 2, 6, 6, 7, 3,
		0.00f, 	0.00f,
		0.25f,	0.00f,
		0.25f,	0.25f,
		0.00f,	0.25f,
 
		// back face		5, 4, 7, 7, 6, 5,
		0.00f, 	0.50f,
		0.25f,	0.50f,
		0.25f,	0.75f,
		0.00f,	0.75f,
 
		// left face		4, 0, 3, 3, 7, 4,
		0.00f, 	0.25f,
		0.25f,	0.25f,
		0.25f,	0.50f,
		0.00f,	0.50f,
 
		// bottom face		4, 5, 1, 1, 0, 4,
		0.00f, 	0.00f,
		0.25f,	0.00f,
		0.25f,	0.25f,
		0.00f,	0.25f,
 
		// right face		1, 5, 6, 6, 2, 1
		0.00f, 	0.25f,
		0.25f,	0.25f,
		0.25f,	0.50f,
		0.00f,	0.50f           
	};  
 
	GLuint indice[N_FACE * 6] = {
 
		0, 1, 2, 2, 3, 0,		// front face 
		4, 5, 6, 6, 7, 4,		// top face 
		8, 9, 10, 10, 11, 8,	// back face
		12, 13, 14, 14, 15, 12,	// left face
		16, 17, 18, 18, 19, 16,	// bottom face	
		20, 21, 22, 22, 23, 20	// right face	
	}; 
 
	int max;
 
	if (N_VERTS * P_SIZE < N_FACE * 6) max = N_FACE * 6;
	else max = N_VERTS * P_SIZE;
 
	for (int i = 0; i < max; i++)
	{
		if (i < N_VERTS * P_SIZE)
		{
			CCube::VertexArray[i] = pos[i];
		}
		if (i < N_VERTS * T_SIZE)
		{
			CCube::CoordTextureArray[i] = coordTexture[i];
		}
		if (i < N_FACE * 6)
		{
			CCube::IndiceArray[i] = indice[i];
		}
	}
}

initialisation des VBO :

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
 
void CCube::InitVBO()
{
 
	// Génération des buffers
	glGenBuffers(1, &CCube::ArrayBuffer);
 
	// on bind le buffer                                                                 
	glBindBuffer(GL_ARRAY_BUFFER, CCube::ArrayBuffer);                                                    
 
	// on alloue un espace                                                               
	glBufferData(GL_ARRAY_BUFFER,								// target                            
				  (N_VERTS * P_SIZE * sizeof *CCube::VertexArray) +	// taille des positions              
				  (N_VERTS * T_SIZE * sizeof *CCube::CoordTextureArray), 
				  NULL,											// ...                              
				  GL_STREAM_DRAW);								// mode                              
 
	// on specifie les donnees                                                           
	glBufferSubData(GL_ARRAY_BUFFER,                                                       
				  0,											// emplacement des donnees dans le VBO 
				  (N_VERTS * P_SIZE * sizeof *CCube::VertexArray),		// taille des donnees                  
				  CCube::VertexArray);									// adresse des donnees                 
 
	glBufferSubData(GL_ARRAY_BUFFER,                                                       
				  (N_VERTS * P_SIZE * sizeof *CCube::VertexArray),			// emplacement                       
				  (N_VERTS * T_SIZE * sizeof *CCube::CoordTextureArray),	// taille                            
				  CCube::CoordTextureArray);								// donnees  
 
 
	glBindBuffer(GL_ARRAY_BUFFER, 0);
 
	// Buffer d'indices                                                                      
	glGenBuffers(1, &CCube::IndiceBuffer);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, CCube::IndiceBuffer);                                           
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(CCube::IndiceArray), IndiceArray, GL_STREAM_DRAW);
 
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
 
 
}

Affichage :

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
 
void CCube::Affiche(bool Picking)
{
 
	glPushMatrix();
 
	//glTranslatef(2.0, 0.0, 0.0);
 
 
	glFrontFace(GL_CCW);//glFrontFace(GL_CW);
	glCullFace(GL_BACK);
	glEnable(GL_CULL_FACE);
 
	// Si le cube n'est pas selectionne couleur blanche (pas d'interference avec texture)
	if(!Selected) glColor3f(1.0f, 1.0f, 1.0f);
	else glColor3f(1.0f, 1.0f, 0.0f);
 
 
 
	// Si on est en mode picking couleur de picking CObjetBase
	// on recupere la couleur de l'objet pour le mode picking par la methode CCube::GetColorObjet()
	if (Picking)
	{
		unsigned char * Color = CCube::GetColorObjet(); 
		glColor3f((float)Color[0]/255, (float)Color[1]/255, (float)Color[2]/255);
	}
	else
	{
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, CCube::Texture); // Appel de la Meta-texture
	}
	// Utilisation des données des buffers
	glBindBuffer(GL_ARRAY_BUFFER, CCube::ArrayBuffer);
	glVertexPointer(P_SIZE, GL_FLOAT, 0, BUFFER_OFFSET(0));
	if(!Picking)glTexCoordPointer(T_SIZE, GL_FLOAT, 0, BUFFER_OFFSET(N_VERTS * P_SIZE * sizeof *CCube::VertexArray));
 
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, CCube::IndiceBuffer);
 
	// Activation d'utilisation des tableaux
	glEnableClientState( GL_VERTEX_ARRAY );
	if(!Picking)glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 
	// Rendu de notre géométrie
	glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
 
 
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
	glDisableClientState( GL_TEXTURE_COORD_ARRAY );
	glDisableClientState( GL_VERTEX_ARRAY );
 
	glBindTexture(GL_TEXTURE_2D, 0);
 
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_CULL_FACE);
 
	glPopMatrix();
}

mon loader de texture utilisant la SDL_image :

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
 
GLuint loadTexture(const char *nomFichier ,bool useFont, 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(nomFichier);
    if (picture_surface == NULL)
    {
	   cerr << "Impossible de charger Fichier image! \n";
	   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;
 
    if (useFont) SDL_SetColorKey(picture_surface, SDL_SRCCOLORKEY, SDL_MapRGB(picture_surface->format, 0, 0, 0));
    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);
 
	cerr << "Load TEXTURES : OK, id :" << glID << "\n";
 
    return glID;
}

Merci d'avance pour votre aide. Parce que galérer juste pour un cube ça me déprime d'avance pour la suite ;)

25/09/2008, 21h30
Naelhem

Quelqu'un pourrait-il me montrer un code d'affichage par VBO d'un cube texturé. Cela fait déjà deux jours que je bloque sur le texturage sans comprendre pourquoi.

Merci d'avance
26/09/2008, 20h45
raptor70

Citation:

Envoyé par Naelhem

Quelqu'un pourrait-il me montrer un code d'affichage par VBO d'un cube texturé. Cela fait déjà deux jours que je bloque sur le texturage sans comprendre pourquoi.

Merci d'avance

Par là, tu as une explication de l'utilisation des VBO pour un cubbe coloré avec des couleurs différentes par vertex : http://raptor.developpez.com/tutorial/opengl/vbo/

Tu n'a qu'à remplacé la couleur par tes coordonnées de texture. Pour avoir une "texture" différente par face ... tu peux utiliser une texture unique en changeant tes coordonnées de textures sur tes faces.

oO 5 min pour réussir un cube parfaitement texturé, en regroupant coordonnées de texture et de vertex à la suite pour chaque sommet dans un seul tableau de données.

Mille merci Raptor, pourtant j'ai commencé les VBO en regardant ton tuto ;)

Donc voici mon code pour le buffer de données rempli par deux tableaux (1 pour sommet et 1 pour coordonnées texture) => cube texturé avec problèmes

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
 
static const GLsizei VertexSize = N_VERTS * P_SIZE * sizeof(GLfloat);
static const GLsizei CoordTextureSize = N_VERTS * T_SIZE * sizeof(GLfloat);
static const GLsizei IndiceSize = N_FACE * 6 * sizeof(GLuint);
 
glGenBuffers(1, &ArrayBuffer);
 
	// on bind le buffer                                                                 
	glBindBuffer(GL_ARRAY_BUFFER, ArrayBuffer);                                                    
 
	// on alloue un espace                                                               
 
	glBufferData(GL_ARRAY_BUFFER,								// target                            
				  VertexSize + CoordTextureSize,			// taille du tableau
				  NULL,											// ...                              
				  GL_STREAM_DRAW);								// mode                              
 
	// on specifie les donnees                                                           
	glBufferSubData(GL_ARRAY_BUFFER,                                                       
				  0,											// emplacement des donnees dans le VBO 
				  VertexSize,									// taille des donnees                  
				  VertexArray);									// adresse des donnees                 
 
	glBufferSubData(GL_ARRAY_BUFFER,                                                       
				  VertexSize,									// emplacement                       
				  CoordTextureSize,								// taille                            
				  CoordTextureArray);
 
        glBindBuffer(GL_ARRAY_BUFFER, 0);
 
	// Buffer d'indices                                                                      
	glGenBuffers(1, &IndiceBuffer);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndiceBuffer);                                           
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, IndiceSize, IndiceArray, GL_STREAM_DRAW);
 
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
// ***** puis ****
 
// Utilisation des données des buffers
	glBindBuffer(GL_ARRAY_BUFFER, ArrayBuffer);
	glVertexPointer(P_SIZE, GL_FLOAT, 0, BUFFER_OFFSET(0));
	glTexCoordPointer(T_SIZE,GL_FLOAT, 0, BUFFER_OFFSET(VertexSize));
 
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndiceBuffer);
 
	// Activation d'utilisation des tableaux
	if(!Picking)glEnableClientState( GL_TEXTURE_COORD_ARRAY );//
	glEnableClientState( GL_VERTEX_ARRAY );
 
	// Rendu de notre géométrie
	glDrawElements(GL_TRIANGLES, N_FACE * 6, GL_UNSIGNED_INT, BUFFER_OFFSET(0));

et celui code pour le buffer de donnée rempli par un seul tableau (coordonnées texture + sommet) => cube texturé sans problème

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
 
static const GLsizei CubeSize = N_VERTS * (P_SIZE + T_SIZE) * sizeof(GLfloat);
static const GLsizei IndiceSize = N_FACE * 6 * sizeof(GLuint);
 
// Génération des buffers
	glGenBuffers(1, &ArrayBuffer);
 
	// on bind le buffer                                                                 
	glBindBuffer(GL_ARRAY_BUFFER, ArrayBuffer);                                                    
 
	// on alloue un espace                                                               
	glBufferData(GL_ARRAY_BUFFER,								// target                            
				  CubeSize,			// taille du tableau
				  CubeArray,											// ...                              
				  GL_STREAM_DRAW);								// mode
 
        glBindBuffer(GL_ARRAY_BUFFER, 0);
 
	// Buffer d'indices                                                                      
	glGenBuffers(1, &IndiceBuffer);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndiceBuffer);                                           
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, IndiceSize, IndiceArray, GL_STREAM_DRAW);
 
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
 
// ***** puis ****
 
// Utilisation des données des buffers
	glBindBuffer(GL_ARRAY_BUFFER, ArrayBuffer);
	glVertexPointer(P_SIZE, GL_FLOAT, 5 * sizeof(float), BUFFER_OFFSET(2));
	glTexCoordPointer(T_SIZE,GL_FLOAT, 5 * sizeof(float), BUFFER_OFFSET(0));
 
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IndiceBuffer);
 
	// Activation d'utilisation des tableaux
	if(!Picking)glEnableClientState( GL_TEXTURE_COORD_ARRAY );//
	glEnableClientState( GL_VERTEX_ARRAY );
 
	// Rendu de notre géométrie
	glDrawElements(GL_TRIANGLES, N_FACE * 6, GL_UNSIGNED_INT, BUFFER_OFFSET(0));

Question = pourquoi ces deux code n'ont pas le même résultat ? Désolé d'insister mais j'aime bien comprendre mes erreurs.

27/09/2008, 12h17
raptor70

Juste en regardant, ça viens peut être de là :

Code:

BUFFER_OFFSET(VertexSize)

qui devrait être :

Code:

BUFFER_OFFSET(N_VERTS * P_SIZE)

(juste une idée en regardant ton code mais c'est pas sur :aie:)

Encore merci Raptor, tu as exactement pointé sur le problème.

Il faut ecrire ça :
Code:

1 2 3 4 5 6 7 glTexCoordPointer(T_SIZE,GL_FLOAT, 0, BUFFER_OFFSET(N_VERTS * P_SIZE)); // ou bien ça glTexCoordPointer(T_SIZE,GL_FLOAT, 0, (char*)NULL+VertexSize);
mais surtout pas ça :
Code:

1 2 3 glTexCoordPointer(T_SIZE,GL_FLOAT, 0, BUFFER_OFFSET(VertexSize));
puisque BUFFER_OFFSET est defini comme suit :
Code:

1 2 #define BUFFER_OFFSET(a) ((float*)NULL + (a))
Encore merci, je peux enfin continuer ;)