indexation des triangles composant une surface 3D

Bonjour, je fais une appli de modélisation 3D, avec la possibilité de loader des modeles 3D de différents formats.
Un objet 3D est un ensemble de faces composés par des triangles.
A l'heure actuelle, je dessine pour chaque face tous les triangles, qui sont placés dans une liste d'affichage.
         Debut Liste d'affichage
         Tant que toute les faces ne sont pas déssinées
              Tant que tous les triangles Ti d'une face n'ont pas été déssinés
                     Je dessine le triangle Ti
                           glBegin(GL_TRIANGLES)
                                   glNormal(au Sommet 1)
                                   glVertex(Sommet1)
                                   glNormal(au Sommet 2)
                                   glVertex(Sommet2)
                                   glNormal(au Sommet 3)
                                   glVertex(Sommet3)
                           glEnd();
               FinTantque
         FinTantque
         Fin Liste d'affichage

Dans cette configuration, j'affiche un nombre concidérable de fois les memes vertex, vu que les triangles sont collés les uns aux autres.
J'aimerais utiliser GL_TRIANGLE_STRIP et GL_TRIANGLE_FAN pour optimiser l'appel à glVertex, mais mes listes de triangles décrivant les faces ne sont pas ordonnées.
Comment trouvé le bon ordre des triangles permettant d'affiché en strip ou en fan ?
Si vous avez deja concocté un algo similaire, merci de me filer un ptit coup de main, je patauge !
Bonne continuation.

Jc.

La carte vidéo a du cache. Si tu dois afficher les triangles 1,2,3 et 2,3,4, la carte fera 4 projections au total pour les deux triangles car garde en mémoire le résultat de la transformation des vertex 2 et 3. Donc aucun avantage qui en vaille la peine niveau vitesse de calcul par rapport a un triangle strip 1,2,3,4. Le seul avantage d'un index buffer indexé en strip (ou fan) est sa taille plus réduite. Trouver la strip list qui minimise au mieux l'index buffer est très compliqué (gourmand en temps de calcul aussi) j'en avais fait un mais je ne l'utilise pas, si je le retrouve je te le file. Il réduit très sensiblement la taille de l'index buffer mais niveau vitesse d'execution.... pas de gain mesurable :(. Bref pour accélérer ta vitesse d'affichage il faut que tu regroupes les triangles de façon à ce que les vertex utilisés pour l'affichage d'un triangle aient été utilisé le plus récement possible pour l'affichage des triangles précedent...... en gros c'est une histoire de cache. J'utilise un script 3DSMax pour générer mes listes de vertex et d'index. Je n'ai pas vérifier mais à première vu il me semble que l'index buffer générer est assez optimisé par defaut.

Utiliser un TRIANGLE_STRIP réduit la quantité de données qui se balade sur le bus non ?

Sinon, le plus optimisé pour afficher un mesh, c'est d'utiliser les vertex array. Il me semble que tu peux pas faire plus rapide pour afficher une série de primitives. C'est pas très compliqué à utiliser, mais ca nécessite que tes données soient stockés de facon ordonnée.

Regarde du coté de :
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(...)

et donc:
glDrawArrays()
glDrawElements()
glMultiDrawArrays()
glMultiDrawElements()

Excuse-moi, quand je dis "index buffer", je suppose qu'il est chargé dans la mémoire vidéo. C'est vrai qu'avec cette méthode: glBegin(GL_TRIANGLES) glNormal(au Sommet 1) glVertex(Sommet1) glNormal(au Sommet 2) glVertex(Sommet2) glNormal(au Sommet 3) glVertex(Sommet3) glEnd(); Les données passent de la RAM à la Vidéo RAM via AGP et de plus la carte doit se taper à chaque fois le calcul des transformations des points car pas d'indexation. Ce que j'ai dit ne fonctionne que si tes données graphiques (ici vertex buffer et index buffer) ont été préalablement chargées dans la mémoire vidéo. Le bus AGP n'est pas infiniment rapide, il faut limiter au maximum la quantité de données qui y transite pendant les rendus. PS: je ne pensais pas (je n'arrivais pas à croire) que c'étaient des vrais lignes de codes, mais juste l'algorithme. Pour info, avec DX c'est DrawPrimitives()

Apparemment sous DX, l'utilisation du vertes array est plus simple que sous opengl, ou disons que c'est la méthode utilisée habituellement. Sous opengl, il existe des méthodes très simples, mais peu efficace comme l'appel à glBegin/End.