Concilier gestion avancée de vertices et API OpenGL

Bonjour,

Je me pose une petite question de design concernant la gestion de vertices.
Si en débutant, je n'utilisais que les classiques glVertex*, je me suis mis aux tableaux de vertices et aux VBO, qui sont nettement plus rapides.

Mais si les glVertex* sont lents, ils permettent de gérer sa propre classe de vertex, en appelant par exemple:

Code:

---

1 2	glVertex3f( monvertex.pos.x, monvertex.pos.y, monvertex.pos.z ) ;

---

Avec les vbo et autres tableaux, il faut utiliser des tableaux de variables, ce qui n'est pas vraiment conciliable avec une gestion de classe de Vertex, de Polygone, etc...

j'ai pensé deux solutions:
- 1, chaque objet dispose d'une méthode getVertexArray qui extrait les données nécessaires et renvoit un tableau prêt à être envoyé dans le VBO.
- 2, chaque modif des données donne lieu à une mise à jour aussi bien des données sous forme de classe que du tableau pour VBO.

Mais ces méthodes me paraissent lourdes et pas vraiment comme il faut.

Quelqu'un saurait-il comment concilier ces deux aspects (gestion par classe et VBOs) de gestion de vertices ?

Merci d'avance.

Je ne suis pas sur d'avoir bien compris ton problème ! normalement, tu n'as pas (rarement) à modifier les vertices directement, pour les transformations standards, on utilises les glRotate, glTranslate et glScale, donc, nbormalement, tes arrays ne vont pas varier, non ?

c'est tout simple, tu utilise le parametre "stride" (je croit que c'est son nom mais c'est a verifier) des VBO et autre vertex Array.
en gros tu a ta structure de vertex

Code:

---

1 2 3 4 5 6 7 8

struct Vertex { float x,y,z; float u,v; float nx,ny,nz; [ + plein de truc qui font plein de bits en memoire] }

---

et tu passe comme ceci a opengl

Code:

---

1 2 3 4

glVertexPointer(GL_FLOAT,3,sizeof(Vertex),&TableauDeVertex[0].x); glTexCoordPointer(GL_FLOAT,2,sizeof(Vertex),&TableauDeVertex[0].u); glNormalPointer(GL_FLOAT,3,sizeof(Vertex),&TableauDeVertex[0].nx);

---

(Attention, je n'ai pas ma doc sous la mains, il est donc fort probable que les parametres des fonction ne soit pas exactement pareil :wink: )

En gros le sizeof(Vertex) lui donne la taille d'un vertex en memoire, et le TableauDeVertex[0].x lui donne l'adresse memoire de la premiere coordonnée X de vertex. Ensuite, sachant le type de donnée (GL_FLOAT), le nombre de coordonnée (3), la taille de la structure, openGL n'a plus qu'a effectuer des decalages memoire pour retouver ses informations... le tour est joué :D

pour plus d'info regarde dans le red book la gestion des vertex array

Et cela fonctionne également quand les objets sont imbriqués ?

Exemple:

Code:

---

1 2 3 4 5 6 7 8

class vec3 { public: float x, y, z ;   // des fonctions, opérateurs... } ;

---

Code:

---

1 2 3 4 5 6 7 8 9 10

class Vertex { public: vec3 position ; vec3 tex1 ; col3 color ;   // [...] } ;

---

Code:

---

1 2 3 4 5 6 7 8

class Quad { public: Vertex[ 4 ] vertices ;   // [...] } ;

---

Parce que là, c'est un peu le boxon pour envoyer ce qu'il faut dans le VBO...

Je pense que tu as un problème de conception. En l'occurence tes diverses entités ne devraient pas avoir à faire des calculs compliqués pour dire à OpenGL où est la géometrie à afficher. Tu devrais plutôt créer des classes englobantes pour tes VBO, et les laisser ensuite se débrouiller. Tes entités quant à elles doivent se limiter à créer des buffers et les envoyer à OGL, pas plus. Modulariser et séparer les tâches est important.

De plus comme l'a fait remarquer Modjo ta géometrie ne devrait normalement pas varier une fois créée, et pour les buffers dynamique OpenGL offre des fonctions pour aller bidouiller en mémoire tes VBO.

Je ne sais pas si ça peut t'aider, mais je te renvoie à tout hasard à mes tutoriels.