Discussion :

[Soznor]

,

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 :

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

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 :

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

1
2
 
glGenBuffersARB(3,BufferName);

Ici, c'est le contenu de la fonction d'affichage pour la version VBO

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

[Yno]

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 :

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

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 :

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

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

A+

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

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

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

[Laurent Gomila]

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.

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.

[MatRem]

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.

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?

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?

[Laurent Gomila]

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

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

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.

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.

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

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

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?

[Laurent Gomila]

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

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.

[MatRem]

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 :

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

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

[Laurent Gomila]

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.

[Soznor]

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

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

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

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.

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

[Soznor]

Yop,

Je suis trop content, maintenant c'est OK .

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 .
J'ai ensuite réessayer sur le PC2 avec son chips graphics intégré.
Et là, je flippe -> 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

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

[Yno]

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

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.

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

À priori si, cela permet de "désactiver" les VBOs.

[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

[Yno]

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 (TEXTURE_2D, 3D, etc...).

[MatRem]

Super!!!!
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 ...? ça vous le fait aussi?

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

[Soznor]

MatRem, comme ton problème semble être également résolu , je me permets de mettre le topic comme étant OK.

[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!


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!