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.