[Problème] Vertex Buffer Object

Version imprimable

:salut: ,

Je débute sous open-gl. Pour apprendre, j'essaye de faire un générateur de heightmap (tout simple pour l'instant).
Je rencontre donc un problème pour utiliser les VBO et afficher ma heightmap.
Le problème se trouve au niveau de l'utilisation de "GL_COLOR_ARRAY".

Voici ce que je (ne) fais (pas) dans mon programme :
- aucune optimisation pour l'affichage (plus tard).
- pas de calcul des normales (j'ai pas encore compris leur utilité, calcul des lumières?)

J'ai fait des tests de performances sur 2 PC différents :
PC1 : radeon x850, proc P-D805
PC2 : Accelerator Graphic Intel, proc Celeron 3,06Ghz

Pour une heightmap de 256*256 soit (sauf erreur) 130050 triangles sans utiliser "GL_COLOR_ARRAY".
PC 1 : 130 FPS (VBO)
PC 2 : 30 FPS (VBO)
PC 1 : 46 FPS (Vertex Buffer Array Non Compilé)
PC 2 : 25 FPS (VBANC)

Les résultats semblent à peu près cohérent.

Pour une heightmap de 256*256 soit (sauf erreur) 130050 triangles avec "GL_COLOR_ARRAY".
PC 1 : 19 FPS (VBO)
PC 2 : 21 FPS (VBO)
PC 1 : 29 FPS (VBANC)
PC 2 : 22 FPS (VBANC)

Là, je comprend pas...

Voici, mon code d'affichage

Ici, les déclaration des tableaux et du buffer dans mon .h
Code:

1 2 3 4 5 valarray <GLfloat> * Vertices; valarray <GLuint> * Indices; valarray <GLubyte> * Colours; GLuint BufferName[3];
Ici, c'est au moment de la création de la heightmap .cpp
Je passe la creation de la heightmap.
Code:

1 2 glGenBuffersARB(3,BufferName);
Ici, c'est le contenu de la fonction d'affichage pour la version 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 if(hasColor) { glEnableClientState ( GL_COLOR_ARRAY ); glBindBufferARB(GL_ARRAY_BUFFER_ARB, BufferName[2]); glBufferDataARB(GL_ARRAY_BUFFER_ARB, Size*Size*3*sizeof(GLubyte), &(*Colours)[0], GL_STATIC_DRAW_ARB); glColorPointer(3, GL_UNSIGNED_BYTE, 0, 0); } glBindBufferARB(GL_ARRAY_BUFFER_ARB, BufferName[1]); glBufferDataARB(GL_ARRAY_BUFFER_ARB, Size*Size*3*sizeof(GLfloat), &(*Vertices)[0], GL_STATIC_DRAW_ARB); glVertexPointer(3, GL_FLOAT, 0, 0); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, BufferName[0]); glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, (Size-1)*(Size-1)*6*sizeof(GLuint), &(*Indices)[0] , GL_STATIC_DRAW_ARB); glIndexPointer(GL_UNSIGNED_INT, 0, 0); // Activation des parametres glEnableClientState ( GL_VERTEX_ARRAY ); // Affichage des elements glDrawElements ( GL_TRIANGLES, (Size-1)*(Size-1)*6 , GL_UNSIGNED_INT, 0 ); // Desactivation des parametres glDisableClientState ( GL_COLOR_ARRAY ); glDisableClientState ( GL_VERTEX_ARRAY );
Si vous avez une idée sur mon problème, je suis vraiment preneur (je comprend pas ce qu'il se passe :( )

Merci.

Salut,

C'est une impression ou tu reconstruit ton VBO à chaque affichage (glBufferData()) ???

De plus :
- glIndexArray, ce n'est pas pour les indices mais pour les couleurs indexées.
- Par conséquent, pour que les indices fonctionnent, il faut juste binder le VBO des indices (GL_ELEMENT_ARRAY_BUFFER) juste avant l'appel de glDrawElements(), avec son pointeur vers NULL (et tu devrais normalement utiliser la macro BUFFER_OFFSET pour envoyer l'adresse 0).

Donc, pour l'affichage, ce code suffit théoriquement (à adapter) :
Code:

1 2 3 4 5 6 7 /* on s'occupe des données */ glBindBuffer(GL_ARRAY_BUFFER, ...); glVertexPointer(..., BUFFER_OFFSET(0)); // 0 pointe sur le vertex buffer actif /* puis le VBO des indices */ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ...); glDrawElements(..., BUFFER_OFFSET(0)); // 0 pointe sur l'index buffer actif
Et BUFFER_OFFSET, au cas où tu ne connaîtrais pas :

Code:

#define BUFFER_OFFSET(off) ( (char*)NULL + (off) )

A+

16/07/2007, 11h35
MatRem
Tu peux aussi utiliser glew, pour faciliter l'utilisation des fonctionnalités récentes d'OpenGL (j'ai l'impression que tu ne l'utilises pas parceque tu as des ARB partout ;) ).

Sinon j'ai une question à propos de BUFFER_OFFSET.
Est ce qu'il est correct, en c++, de le remplacer par ça :
Code:

1 2 3 4 inline GLubyte * BUFFER_OFFSET(int bytes) { return reinterpret_cast<GLubyte *>(bytes); }
16/07/2007, 11h46
Laurent Gomila

Citation:

Tu peux aussi utiliser glew, pour faciliter l'utilisation des fonctionnalités récentes d'OpenGL (j'ai l'impression que tu ne l'utilises pas parceque tu as des ARB partout ).

Les fonctions gardent leur suffixe ARB avec GLEW. Le retirer signifierait que tu utilises une version récente d'OpenGL qui intègre ces fonctions directement dans son core.

Citation:

Sinon j'ai une question à propos de BUFFER_OFFSET.
Est ce qu'il est correct, en c++, de le remplacer par ça :

En pratique oui, mais en théorie non. En l'occurence si GLubyte n'a pas une taille de 1, ça ne marchera pas.
16/07/2007, 12h39
MatRem

Citation:

Les fonctions gardent leur suffixe ARB avec GLEW. Le retirer signifierait que tu utilises une version récente d'OpenGL qui intègre ces fonctions directement dans son core.

A tient, je croyais que glew définissait les noms sans suffixes... autant pour moi. :oops:

D'ailleurs, maintenant que j'y regarde de plus près, ces fonctions sont déclarées dans mon glext.h.

Est ce bien portable d'utiliser les fonctions sans suffixes?

Citation:

En pratique oui, mais en théorie non. En l'occurence si GLubyte n'a pas une taille de 1, ça ne marchera pas.

Ha oui d'accord, mais le problème est le même avec le #define décrit plus haut non?

Sinon GLubyte n'a pas toujours une taille de 1 octet? C'est juste un typedef unsigned char?
Dans ce cas y a t il une solution qui fonctionne à tous les coups?
16/07/2007, 12h47
Laurent Gomila

Citation:

Est ce bien portable d'utiliser les fonctions sans suffixes?

Comme je l'ai dit plus haut, les versions sans suffixe sont celles qui sont intégrées au core. Par exemple avec des en-têtes OpenGL 1.1 tu devras utiliser glGenBuffersARB + glext.h car les VBO n'existaient pas encore ; avec des en-têtes OpenGL 1.5 tu pourras par contre utiliser glGenBuffers car les VBO sont intégrés directement au core.
En fait un suffixe signifie que tu vas chercher la fonction dans les extensions, pas de suffixe signifie que la fonction est disponible directement.
Ceci dit, lorsque tu utilises les extensions directement, c'est toi qui choisis le nom de la fonction, donc tu peux la nommer comme tu veux. Y compris glGenBuffers si ça te chante (mais c'est fortement déconseillé) ;)

Citation:

Ha oui d'accord, mais le problème est le même avec le #define décrit plus haut non?

Non, car additionner un entier N à un pointeur ne décale pas de N octets, mais de N éléments (d'où la différence si les éléments ne font pas 1 octet).

Citation:

Sinon GLubyte n'a pas toujours une taille de 1 octet? C'est juste un typedef unsigned char?

Il faut voir dans les spécifications quelles sont les contraintes sur GLubyte. A priori ce n'est pas une contrainte de taille fixe, sinon cela apparaîtrait dans le nom.

Citation:

Dans ce cas y a t il une solution qui fonctionne à tous les coups?

La première qui a été donnée, vu que le décalage doit être exprimé en octets et que char a toujours une taille de 1 selon la norme.
16/07/2007, 13h25
MatRem
En fait je ne comprends pas vraiment le problème de la fonction inline... Puisque il faut donner un décalage en octet, le fait de convertir un entier en n'importe quel type de pointeur donne bien un décalage en nombre d'octet non?

A la limite il pourrait y avoir un problème à l'utilisation du pointeur résultat... dans ce cas en remplaçant la fonction par ça:
Code:

1 2 3 4 inline void * BUFFER_OFFSET(long bytes) { return reinterpret_cast<void *>(bytes); }
je ne vois plus du tout de problème...

Pour les nom de fonctions non suffixé, je demandias si c'était portable dans le sens ou :
si je fournis à un client mon code qui utilise les fonctions non suffixées, et qu'il doit le recompiler alors qu'il n'a qu'une version d'header inférieure à 1.5, le code risque de ne pas compiler?
16/07/2007, 13h42
Laurent Gomila

Citation:

En fait je ne comprends pas vraiment le problème de la fonction inline... Puisque il faut donner un décalage en octet, le fait de convertir un entier en n'importe quel type de pointeur donne bien un décalage en nombre d'octet non?

En fait... j'ai dû parler un peu trop vite :mrgreen:
Effectivement là ça ne fait aucune différence ; je pense que la macro BUFFER_OFFSET est telle qu'elle est pour éviter un avertissement de conversion entier --> pointeur. Mais en C++ reinterpret_cast permet de faire la même chose sans obtenir d'avertissement, donc c'est ok.

Citation:

Pour les nom de fonctions non suffixé, je demandias si c'était portable dans le sens ou :
si je fournis à un client mon code qui utilise les fonctions non suffixées, et qu'il doit le recompiler alors qu'il n'a qu'une version d'header inférieure à 1.5, le code risque de ne pas compiler?

Tout à fait.

Ok merci :).
Sinon les versions suffixées sont définies tout le temps on dirait (peut être serait-ce un peu plus portable, mais moins pratique)?

---

Pour revenir plus dans le sujet, j'ai moi aussi un problème avec les VBO.
Je test sous linux (mandriva 2007) + gforce fx5200 + pilotes nvidia 100.14.11 (les derniers pour l'instant).

En fait le problème semble venir du tableau d'indices, en effet quand je n'utilise pas de VBO pour les indices tout fonctionne parfaitement, si j'utilise un VBO => erreur de segmentation.

initialisation (1 fois):

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
void Mesh::init() throw(GException)
{
	const int V_BUFF_SIZE = 3 * _nbVertex * sizeof(float);
	const int N_BUFF_SIZE = _normals ?(3 * _nbVertex * sizeof(float)) : 0;
	const int T_BUFF_SIZE = _texCoord?(2 * _nbVertex * sizeof(float)) : 0;
 
	const int A_BUFF_SIZE = V_BUFF_SIZE + N_BUFF_SIZE + T_BUFF_SIZE;
 
	const int EA_BUFF_SIZE = (_nbVertexPerFacet*_nbFacets)*sizeof(GLint);
 
	glGenBuffers(2, _vbos);
	if(_vbos[0]==0 || _vbos[1]==0) throw GException("No vertex buffer object available");
 
	glBindBuffer(GL_ARRAY_BUFFER, _vbos[0]);
 
	glBufferData(GL_ARRAY_BUFFER, A_BUFF_SIZE, 0, GL_STATIC_DRAW);
 
	              glBufferSubData(GL_ARRAY_BUFFER, 0          , V_BUFF_SIZE, _vertex);
	if(_normals)  glBufferSubData(GL_ARRAY_BUFFER, V_BUFF_SIZE, N_BUFF_SIZE, _normals);
	if(_texCoord) glBufferSubData(GL_ARRAY_BUFFER, V_BUFF_SIZE + (_normals ? N_BUFF_SIZE : 0), T_BUFF_SIZE, _texCoord);	
 
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbos[1]);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, EA_BUFF_SIZE, _indices, GL_STATIC_DRAW);
}

affichage (à chaque raffraichissement):

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
void Mesh::draw() const
{
	const int V_BUFF_SIZE = (3*_nbVertex)*sizeof(float);
	const int N_BUFF_SIZE = (3*_nbVertex)*sizeof(float);
 
	              glEnableClientState(GL_VERTEX_ARRAY);
	if(_normals)  glEnableClientState(GL_NORMAL_ARRAY);
	if(_texCoord) glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
	glBindBuffer(GL_ARRAY_BUFFER, _vbos[0]);
 
	              glVertexPointer  (3, GL_FLOAT, 0, BUFFER_OFFSET(0));
	if(_normals)  glNormalPointer  (   GL_FLOAT, 0, BUFFER_OFFSET(V_BUFF_SIZE));
	if(_texCoord) glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(V_BUFF_SIZE + (_normals ? N_BUFF_SIZE : 0)));
 
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbos[1]);
 
	if(_nbVertexPerFacet==3) glDrawElements(GL_TRIANGLES, _nbVertexPerFacet*_nbFacets, GL_INT, BUFFER_OFFSET(0));
	if(_nbVertexPerFacet==4) glDrawElements(GL_QUADS,     _nbVertexPerFacet*_nbFacets, GL_INT, BUFFER_OFFSET(0));
 
	if(_texCoord) glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	if(_normals)  glDisableClientState(GL_NORMAL_ARRAY);
	              glDisableClientState(GL_VERTEX_ARRAY);
}

A priori (mais je ne suis plus sur que c'est exactement le même code), ça fonctionne avec une gForce 7600 , et j'avais le même soucis avec plusieurs ATI. Jamais testé sous windows par contre...

16/07/2007, 14h23
Laurent Gomila

Citation:

Sinon les versions suffixées sont définies tout le temps on dirait (peut être serait-ce un peu plus portable, mais moins pratique)?

Elles sont définies (ou plutôt leur prototype) si tu as une version suffisamment à jour de glext.h.

Relu,

Pour glew, je ne connaissais pas donc pourquoi pas surtout que Yno a fait un super tutorial que je m'empresserais de lire une fois mon problème résolu.
Puis actuellement, mon intégration des extensions est moche de chez moche (à l'arrache, no control)

Aussi Yno, :king: bravo pour ton tutorial sur les VBO et le reste (Display List et Vertex Array). Il est super bien écrit et construit.
Je l'ai lu en croisé mais je prendrai le temps de le lire attentivement.

Alors sinon pour ce qui est de mon problème. J'ai essayé d'adapter mon code à ce que tu as fait dans le tutorial.
Je reconstruisais le VBO à chaque affichage comme tu l'as souligné. C'est parce que j'ai suivi sans visiblement réfléchir un tutorial :aie: . Et aussi parce que je n'avais pas trop capté le fonctionnement des VBO, ca reste flou encore.

Donc pour la création de la heightmap, j'ai cela maintenant :
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 // Construction de 3 GLuint glGenBuffersARB(3,BufferName); // Creation du VBO pour les sommets glBindBufferARB(GL_ARRAY_BUFFER_ARB, BufferName[BUFFER_VERTEX]); glBufferDataARB(GL_ARRAY_BUFFER_ARB, Size*Size*3*sizeof(GLfloat), 0, GL_STREAM_DRAW_ARB); glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, Size*Size*3*sizeof(GLfloat), &(*Vertices)[0]); // Creation du VBO pour les couleurs glBindBufferARB(GL_ARRAY_BUFFER_ARB, BufferName[BUFFER_COLOR]); glBufferDataARB(GL_ARRAY_BUFFER_ARB, Size*Size*3*sizeof(GLubyte), 0, GL_STREAM_DRAW_ARB); glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, Size*Size*3*sizeof(GLubyte), &(*Colours)[0]); // Creation des GL_ARRAY_BUFFER terminées glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); // Creation de l'index glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,BufferName[BUFFER_INDEX]); glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, (Size-1)*(Size-1)*6*sizeof(GLuint), 0, GL_STREAM_DRAW_ARB); glBufferSubDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0, (Size-1)*(Size-1)*6*sizeof(GLuint), &(*Index)[0]); // Creation des GL_ELEMENT_ARRAY_BUFFER terminées glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
Est ce que mes appels à
- glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
- glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
sont correctement utilisés?

Pour l'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 /* specification du buffer des positions de sommet */ glBindBufferARB(GL_ARRAY_BUFFER_ARB, BufferName[BUFFER_VERTEX]); glVertexPointer(3, GL_FLOAT, 0, BUFFER_OFFSET(0)); /* specification du buffer des couleurs de sommet */ glBindBufferARB(GL_ARRAY_BUFFER_ARB, BufferName[BUFFER_COLOR]); glColorPointer(3, GL_UNSIGNED_BYTE, 0, BUFFER_OFFSET(0)); // Remise du pointeur de buffer sur NULL glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); // Activation des parametres glEnableClientState ( GL_VERTEX_ARRAY ); glEnableClientState ( GL_COLOR_ARRAY ); glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, BufferName[BUFFER_INDEX]); glDrawElements(GL_TRIANGLES, (Size-1)*(Size-1)*6, GL_UNSIGNED_INT, BUFFER_OFFSET(0)); // Remise du pointeur de buffer sur NULL glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); // Desactivation des parametres glDisableClientState ( GL_COLOR_ARRAY ); glDisableClientState ( GL_VERTEX_ARRAY );
Cela fonctionne.
J'ai pas refait de test approfondi.
Pour le PC1 sans couleur, je suis passé à 230 fps ( c'est quand même mieux )
Par contre avec couleur, j'ai encore un effondrement des performances, je ne comprend pas, cela donne 24 fps :cry: .

Merci pour vos réponses, ca me fait plaisir et ca me fait progresser.
Si vous avez des idées pour le problème de couleur, je suis preneur.
En attendant, je vais essayer de tester sur un autre PC avec une carte graphique (et pas un chips graphics intégré -_- comme le PC2).
Peut être un problème de drivers mais à priori, mes drivers sont à jour.

16/07/2007, 15h26
MatRem

Le glBufferSubData est intéressant quand tu écris plusieurs fois dans ton ton VBO (comme dans mon exemple, ou je met les vertex, normal, et texcoord dans le même vbo).
Sinon tu peux directement envoyer les données avec glBufferData (en ne passant pas 0, mais le pointeur vers tes données).

A priori tes
glBindBufferARB(..., 0);
ne servent à rien...
16/07/2007, 16h01
Soznor

Yop,

Je suis trop content, maintenant c'est OK :yaisse2: .

MatRem, je me doutais que l'appel à glBufferSubData était dans mon cas, pas très bien indiqué mais c'était pour être sûr de faire un truc correct.

Alors, voilà l'explication.
J'ai d'abord installé les derniers drivers radeons. Mais cela eut été trop simple comme solution. Cela n'a pas solutionné mon problème.
J'ai donc pu essayer sur un autre PC avec une radeon 9700 (portable).
Et là, 5 fps :mouarf: .
J'ai ensuite réessayer sur le PC2 avec son chips graphics intégré.
Et là, je flippe :aie: -> il met la misère à ma x850xt et à la radeon 9700.
36 fps de moyenne contre 24 (x850xt) et 5 (9700).

Je me dis que c'est pas cool (et ouais je pense par moment).

Et l'éclair de génie (à mon niveau lol, c'est relatif) m'est venu grâce à Yno enfin en lisant ces tutoriaux (notamment sur les vertex array).
Il récapitule l'utilisation des fonctions comme "glNormalPointer", "glVertexPointer"...

C'est en voyant "glColorPointer", notamment sur le size conseillé. C'est indiqué (3 ou 4). Et visiblement ma carte graphique et probablement beaucoup d'autres n'aiment pas traiter des couleurs RGB sans la transparence associée.

J'ai donc redéfini les couleurs en RGBA (size de 4 donc) et là, puff les 220 fps tant attendu sont là avec les couleurs.

Merci merci Yno :hola:

Je laisse le topic comme non-résolu vu que MatRem attend une solution à son problème. Je le cloturerai quand ce sera OK, ou si cela m'est demandé.

Merci à vous, j'ai pas fini de vous embéter ahahahah
16/07/2007, 18h24
Yno

Heureux de constater que j'ai pu t'être utile :D

Citation:

J'ai donc redéfini les couleurs en RGBA (size de 4 donc) et là, puff les 220 fps tant attendu sont là avec les couleurs.

Oui, car les couleurs RGBA sont codés sur 32 bits, contrairement au mode RGB, qui lui est en 24 bits, donc pas adapté à l'architecture de la pluparts des processeurs.
Idem pour les textures, il vaut mieux préférer un mode "cool", et non un truc bizarre codé sur X bits.

Citation:

Envoyé par MatRem

A priori tes
glBindBufferARB(..., 0);
ne servent à rien...

À priori si, cela permet de "désactiver" les VBOs.
16/07/2007, 20h43
MatRem

On peut avoir un VBO array et un VBO element, actif en même temps?
Le fait de faire :
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ...);
ne désactive pas le buffer précédement utilisé?

Ha oui sinon j'ai l'impression d'avoir gagné carrément en performance avec la desactivation de VBO quand je m'en sers plus (50FPS => 80FPS),
merci du conseil ;)
16/07/2007, 20h48
Yno

Citation:

Envoyé par MatRem

Le fait de faire :
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ...);
ne désactive pas le buffer précédement utilisé?

Oui, mais que celui du même target (je pense). Enfin c'est à voir, perso je désactive toujours tout à la fin (GL_ARRAY et GL_ELEMENT_ARRAY), faudra que je test en n'en désactivant qu'un, pour voir si glBindBuffer a une influence sur tous les types de target.
Du coup faudra aussi voir ce que ça donne pour les textures :aie: (TEXTURE_2D, 3D, etc...).
16/07/2007, 20h54
MatRem

Super!!!! :king:
Le fait de désactiver le element array buffer avant de quitter la boucle d'afichage m'enlève mon erreur de segmentation.

Un grand merci à toi.
C'est peut être une spécialité linux :aie: ...? ça vous le fait aussi?
16/07/2007, 21h11
MatRem

Bon en fait pour le gain de performances je me suis peut être un peu enflammé :), mais je gagne un peu quand même on dirait.
16/07/2007, 22h37
Soznor

MatRem, comme ton problème semble être également résolu :D , je me permets de mettre le topic comme étant OK.
18/07/2007, 16h30
michael84

est ce que vous pourriez me faire passez votre code pour m'aider a comprendre le fonctionnement de ces VBO,PBO,FBO....tout en O quoi!:yaisse2:

etant sou linux j'aimerai bien celui de MatRem (si ta un example d'un VBO tout bete qui affiche trois point sa me va tres bien)

enfin contacte moi en message privée si sa te derange pas et je te passe mon mail! merciii!!!

PS:g une nvidia!

Je n'ai testé que les VBOS pour l'instant, voilà l'exemple complet qui fonctionne (je travaille en c++, mais il n'y a pas grande différence avec le C, ici) :

Déclarations :

Code:

1
2
3
4
5
6
7
8
9
10
 
float *  _vertex;           // Tableau de sommets.
float *  _normals;          // Tableau de normales.
GLuint * _indices;          // Tableau de faces (indices de sommets).
float *  _texCoord;         // Tableau de coordonnees de textures.
GLint    _nbVertex;         // Nombre de sommets.
long     _nbFacets;         // Nombre de faces.
int      _nbVertexPerFacet; // Nombre de vertex par faces (3 ou 4 dans mon cas).
GLuint   _vbos[2];          // Identifiants des 2 vbos 1 array buffer pour vertex  + normals + texCoord et 1 element array buffer pour les indices)
int      _nbTex;       //Nombre d'unités de texture à utiliser.

Initialisations (avant 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
const int V_BUFF_SIZE = 3 * _nbVertex * sizeof(float); //Taille de la partie vertex dans le 1er VBO
const int N_BUFF_SIZE = _normals ?(3 * _nbVertex * sizeof(float)) : 0;  //Taille de la partie normals dans le 1er VBO
const int T_BUFF_SIZE = _texCoord?(2 * _nbVertex * sizeof(float)) : 0;  //Taille de la partie texCoord dans le 1er VBO
		
const int A_BUFF_SIZE = V_BUFF_SIZE + N_BUFF_SIZE + T_BUFF_SIZE; //Taille du premier VBO (Array buffer)
		
const int EA_BUFF_SIZE = (_nbVertexPerFacet*_nbFacets)*sizeof(GLint); //Taille du 2ème VBO (Element Array Buffer) pour les indices

_vbos[0] = 0;
_vbos[1] = 0;

// Allocation dynamique des tableaux (_vertex, _normals, ...)
// + remplissages des tableaux et initialisation des variables (_nbVertex. _nbFacets, ...).

// J'ai du code opérationnels pour charger des OFF, et des heighmap de terrain si tu veux, mais c'est un peu long à poster.

// Création des VBO et envoi des données RAM => MEM GPU.

glGenBuffers(2, _vbos);
if(_vbos[0]==0 || _vbos[1]==0) throw GException("No vertex buffer object available");
		
glBindBuffer(GL_ARRAY_BUFFER, _vbos[0]); //Activation du VBO 0
		
glBufferData(GL_ARRAY_BUFFER, A_BUFF_SIZE, 0, GL_STATIC_DRAW);
		
              glBufferSubData(GL_ARRAY_BUFFER, 0          , V_BUFF_SIZE, _vertex);
if(_normals)  glBufferSubData(GL_ARRAY_BUFFER, V_BUFF_SIZE, N_BUFF_SIZE, _normals);
if(_texCoord) glBufferSubData(GL_ARRAY_BUFFER, V_BUFF_SIZE + (_normals ? N_BUFF_SIZE : 0), T_BUFF_SIZE, _texCoord);	
		
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbos[1]); //Activation du VBO 1
glBufferData(GL_ELEMENT_ARRAY_BUFFER, EA_BUFF_SIZE, _indices, GL_STATIC_DRAW);

//Je comprends pas, je n'ai pas de coloration :(

Affichage (je gère les cas ou il n'y a pas de normales ou de coordonnées de textures, ainsi que le multitexturing, donc ça complique un peu... ) :

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
const int V_BUFF_SIZE = (3*_nbVertex)*sizeof(float);
const int N_BUFF_SIZE = (3*_nbVertex)*sizeof(float);
 
              glEnableClientState(GL_VERTEX_ARRAY);
if(_normals)  glEnableClientState(GL_NORMAL_ARRAY);
 
glBindBuffer(GL_ARRAY_BUFFER, _vbos[0]); //Activation du VBO 0
 
              glVertexPointer  (3, GL_FLOAT, 0, BUFFER_OFFSET(0));
if(_normals)  glNormalPointer  (   GL_FLOAT, 0, BUFFER_OFFSET(V_BUFF_SIZE));
 
 
/** Gestion du multitexturing, dans mon cas, toute les unités de textures utilisent les mêmes coordonnées de textures( donc le même VBO.  */
if(_texCoord)
{
	for(int i=1; i<_nbTex; i++)
	{
		glClientActiveTexture(GL_TEXTURE0 + i);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(V_BUFF_SIZE + (_normals ? N_BUFF_SIZE : 0)));
	}
	glClientActiveTexture(GL_TEXTURE0);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(V_BUFF_SIZE + (_normals ? N_BUFF_SIZE : 0)));
}
 
glBindBuffer(GL_ARRAY_BUFFER, 0); //Desactivation du VBO 0
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbos[1]); //Activation du VBO 1
 
if(_nbVertexPerFacet==3) glDrawElements(GL_TRIANGLES, _nbVertexPerFacet*_nbFacets, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
if(_nbVertexPerFacet==4) glDrawElements(GL_QUADS,     _nbVertexPerFacet*_nbFacets, GL_UNSIGNED_INT, BUFFER_OFFSET(0));
 
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); //Desactivation du VBO 1, ultra important !  (sous linux en tout cas :) )
 
if(_texCoord)
{
	for(int i=1; i<_nbTex; i++)
	{
		glClientActiveTexture(GL_TEXTURE0 + i);
		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	}
	glClientActiveTexture(GL_TEXTURE0);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
 
if(_normals)  glDisableClientState(GL_NORMAL_ARRAY);
              glDisableClientState(GL_VERTEX_ARRAY);

Nettoyage :

Code:

1
2
3
4
5
6
 
if(_vertex)   delete[] _vertex;
if(_indices)  delete[] _indices;
if(_normals)  delete[] _normals;
if(_texCoord) delete[] _texCoord;
if(_vbos[0])  glDeleteBuffers(2, _vbos);

//BUFFER_OFFSET est définie de cette façon:

Code:

1
2
3
4
inline void * BUFFER_OFFSET(int bytes)
{
	return reinterpret_cast<void *>(bytes);
}

ps: si tu as des problèmes ou des questions, n'hésites pas, le forum est là pour ça.
Je t'invites aussi à lire le tuto dont le lien est sur dans le post, et d'autres tutos sur les vbos.