[Vertex Array] Optimisation de l'affichage d'un maillage 3D triangulé

Bonjour,

Je realise un modeler 3D (primitives geometrics) / loader de differents formats 3D. J'en suis a l'optimisation de la méthode d'affichage OpenGl. pour mes maillages 3D. Lorsque je charge un objet, j'ai cette structure de données pour le maillage triangulé :

- le tableau de normale en float : ( normale1X, normale1Y, normale1Z, ...... ,normaleiX, normaleiY, normaleiZ, ..... )
- le tableau de vertex en float :  ( vertex1X, vertex1Y, vertexiZ, ...... ,vertexiX, vertexiY, vertexiZ, ......)
- le tableau d'index en uint : ( triangle1 :  indicNormale1 indicNormale2 indicNormale3 
                                                   indicVertex1 indicVertex2 indicVertex3,  ->les trois sommets du triangle 1 avec leurs trois normales
                                               ............ 
                                              trianglei :   indicNormale1 indicNormale2 indicNormale3 
                                                    indicVertex1 indicVertex2 indicVertex3,  ->les trois sommets du triangle i
                                              .............)

J'utilise un index separé pour les normales et les vertex, car pour un vertex donné, la normale n'est pas forcément unique, dans le cas de formes 3D anguleuses notamment (le carré par exemple) où le gouraud shading pose probleme (vertex situé sur un angle ou un arète). Donc indexé séparément les normales permet d'éviter les doublons de vertex et de normales dans leur tableau respectif.
A l'heure actuelle, j'affiche en utilisant les display listes :

           ->debut liste d'affichage
           -> parcours de l'index des triangles (indic de normales et de vertex)
           -> glBegin(GL_TRIANGLES)
                     glnormal()   glvertex(),  glnormal() glvertex(),  glnormal()   glvertex()
           ->glEnd()
            ->fin liste d'affichage

J'ai de trés bon résultats avec cette méthode des display list (maillage de plusieurs centaines milliers de triangles), mais je voudrais essayer d'optimiser encore en testant d'autres solutions d'affichage OpenGl, particulierement les "vertex array".
Cependant il apparait qu'avec ma structure de données, ce n'est pas possible de coder en "vertex array"... car j'ai deux index et les vertex array ne semble prendre qu'un seul index identique pour les normales et les vertex. Si je me trompe arrétez moi !

J'ai alors transformé ma structure de données pour ne garder qu'un seul index, je peux alors initialiser un "vertex array"
              ->...... glNormalPointer(......);  glVertexPointer(......); glDrawElements(); .......

Ca marche aussi sans souci, mais on revient alors au probleme des vertex d'angle, ce qui conduit à avoir des doublons de vertex et de normales dans les tableaux de float.... Pas tres optimal en mémoire... Et au final une appli qui tourne moins bien qu'avec les listes d'affichage.
Auriez vous des conseils ou des infos sur les "vertex array" qui me permetteraient de garder ma structure de données optimale ?
Existerait-il un autre moyen optimal d'afficher de tels maillages 3d triangulé ? (J'ai essayé aussi de faire un algo pour ordonner mes triangles en bandes de triangles, mais c pas au point (erreur dans certains cas), si l'un d'entre vous à un prog robuste qui stripe, ca peut m'interesser aussi) !!! ;o)
Merci pour votre interet pour ce petit probleme d'optimisation.
Bonne journée.

JcLoupGarou

Display list, vertex array, c'est dépassé ca !
Mais malheureusement, tous les tutoriels openGL nous apprennent un peu n'importe quoi.
Faut arreter d'utiliser ca.
"(maillage de plusieurs centaines milliers de triangles)" <= Moi j'ai pareil, mais tu remplaces plusieurs centaines de milliers par plusieurs dizaines de millions et encore!!! J'ai un pb que je n'arrive pas résoudre avec opengl. Normalement, on devrait atteindre plusieurs centaines de millions !! ce qui est atteint facilement en directx. Mais on s'appercoit que ya une perte énorme dans les drivers opengl à l'aide d'outils spécialisés.

Mais dans ton cas. Faut remplacer les vertex array par des vertex buffer (c'est directement stocké en mémoire video).
Tu parles de strip triangle ? mais tu peux simplement utiliser des triangles tout court mais en utilisant les index buffer.
Donc tu utilises un vertex buffer pour stocker tous les points, et un index buffer pour dire quel point utiliser pour tracer une primitive.
Et la, les perfs, ca cartonne ! :)