Optimiser la vitesse d affichage

Bonjour,

J'ai une fonction de dessin que j appelle dans mon DrawGLScene(),
elle lis un tableau de 11 elements d'une classe layer, et dans chaque element jâi un tableau de quads corespondant au polygon que je veux dessiner sur chacune des couches. J'ai des parametres sur ces couches comme "visible" (que je peux changer en live sur mon programme pour chaque layer independamenet)

seulement j'ai un des truc que je dois dessiner qui contient plus de 300 000 polygons! et ca saccade pas mal lorsque je veut le deplacer ou tourner avec ma souris! J'utilise le glutess car certain de ces polygons sont concaves!
L'element "bottom" est un tableau des points des sommet de mes polygons comme suit : {x1,y1,x2,y2,x3,y3,..}

bref, ma question est simple, y a t il un moyen d'optimiser au maximum ceci pour que ca s affiche plus vite!?

avant d avoir mes polygon concave, j'utilisais glArray, mais maintenant que j'ai le gluTess que puis je faire?
Est ce possible de faire 11 gllist ( par exemple glGenList(11) ) et dans chaque list  y mettre tous les polygon correspondant? dans ce cas il ne me restera dans mon DrawQuads() qu'un boucle de test sur la visibilité de la couche pour la dessiner ou pas!
Ca rendrai le "dessinage" plus rapide a votre avis?

Merci pour votre aide!


void DrawQuads()
{
    nombrequads=0;

    if(SaveLayers)    
    {
        for(int i=0; i<11; i++)
        {
            if(LLayer[i].visible==true)
            {
                for(int q=0; q<LLayer[i].num_quads; q++)
                {

               
                    
                    glColor4f(LLayer[i].color.r,LLayer[i].color.g,LLayer[i].color.b, LLayer[i].color.a);
                    
                    int num_pts = LLayer[i].quad[q].num_pts;
                    
                    GLdouble pt_bottom[250][3];
                        
                    for(int p=0; p<num_pts; p++)
                    {
                        pt_bottom[p][0]=LLayer[i].quad[q].bottom[p*2];
                        pt_bottom[p][1]=LLayer[i].zstart;
                        pt_bottom[p][2]=LLayer[i].quad[q].bottom[p*2+1];
                    }
                         // ON DESSINE LA FACE DU BAS

                    GLdouble pt_top[250][3];
                            
                    for(p=0; p<num_pts; p++)
                    {
                        pt_top[p][0]=LLayer[i].quad[q].bottom[p*2];
                        pt_top[p][1]=LLayer[i].zstart + LLayer[i].h;
                        pt_top[p][2]=LLayer[i].quad[q].bottom[p*2+1];
                    }

                        GLUtesselator *tobj;
                            
                        tobj = gluNewTess();
                        gluTessCallback(tobj, GLU_TESS_VERTEX, (GLvoid (CALLBACK*) ()) &glVertex3dv);
                        gluTessCallback(tobj, GLU_TESS_BEGIN, (GLvoid (CALLBACK*) ())
                        &beginCallback);
                        gluTessCallback(tobj, GLU_TESS_END, (GLvoid (CALLBACK*) ())
                        &endCallback);
                        gluTessCallback(tobj, GLU_TESS_ERROR, (GLvoid (CALLBACK*) ())
                        &errorCallback);
                        glShadeModel(GL_FLAT);
                        gluTessBeginPolygon(tobj, NULL);
                            gluTessBeginContour(tobj);
                                for(int u=0; u<num_pts; u++)
                                    gluTessVertex(tobj, pt_bottom[u], pt_bottom[u]);
                            gluTessEndContour(tobj);
                        gluTessEndPolygon(tobj);
                        gluDeleteTess(tobj);
                            
                            
                        tobj = gluNewTess();
                        gluTessCallback(tobj, GLU_TESS_VERTEX, (GLvoid (CALLBACK*) ()) &glVertex3dv);
                        gluTessCallback(tobj, GLU_TESS_BEGIN, (GLvoid (CALLBACK*) ())
                        &beginCallback);
                        gluTessCallback(tobj, GLU_TESS_END, (GLvoid (CALLBACK*) ())
                        &endCallback);
                        gluTessCallback(tobj, GLU_TESS_ERROR, (GLvoid (CALLBACK*) ())
                        &errorCallback);
                        glShadeModel(GL_FLAT);
                        gluTessBeginPolygon(tobj, NULL);
                            gluTessBeginContour(tobj);
                                for(u=0; u<num_pts; u++)
                                    gluTessVertex(tobj, pt_top[u], pt_top[u]);
                            gluTessEndContour(tobj);
                        gluTessEndPolygon(tobj);
                        gluDeleteTess(tobj);

                        for(int ee=0; ee<num_pts;ee++)
                        {
                            //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                            int ee2 = ee+1;
                            if(ee2 == num_pts)
                                ee2 = 0;
                            glColor4f(LLayer[i].color.r,LLayer[i].color.g,LLayer[i].color.b, LLayer[i].color.a);
                            glBegin(GL_POLYGON);
                                glVertex3f(pt_bottom[ee][0],pt_bottom[ee][1],pt_bottom[ee][2]);
                                glVertex3f(pt_bottom[ee2][0],pt_bottom[ee2][1],pt_bottom[ee2][2]);
                                glVertex3f(pt_top[ee2][0],pt_top[ee2][1],pt_top[ee2][2]);
                                glVertex3f(pt_top[ee][0],pt_top[ee][1],pt_top[ee][2]);
                            glEnd();
                            // ON DESSINE TOUTES LES ARRETES

                                glColor4f(0.0,0.0,0.0, 1.0);
                                
                                glBegin(GL_LINES);

                                glVertex3f(pt_bottom[ee][0],pt_bottom[ee][1],pt_bottom[ee][2]);
                                glVertex3f(pt_bottom[ee2][0],pt_bottom[ee2][1],pt_bottom[ee2][2]);

                                glVertex3f(pt_bottom[ee2][0],pt_bottom[ee2][1],pt_bottom[ee2][2]);
                                glVertex3f(pt_top[ee2][0],pt_top[ee2][1],pt_top[ee2][2]);

                                glVertex3f(pt_top[ee2][0],pt_top[ee2][1],pt_top[ee2][2]);
                                glVertex3f(pt_top[ee][0],pt_top[ee][1],pt_top[ee][2]);

                                glVertex3f(pt_top[ee][0],pt_top[ee][1],pt_top[ee][2]);
                                glVertex3f(pt_bottom[ee][0],pt_bottom[ee][1],pt_bottom[ee][2]);

                                glEnd();
                            }
                        }
            }
        }                    
    }    
}

Le plus efficace serait d'éviter les polygones concaves. Mais tu es obligés d'appeler glu a chaque affichage, tu peux le faire une seul fois ?

Pour le rendu, INTERDIT d'utiliser glBegin/End. Tu utilises une list ou un vbo, et ton rendu sera 100x plus rapide.

je ne peux malheureusement pas faire autrement pour les polygones concaves!
Par contre j'ai pas tout compris a ce que tu ma dis apres :
a propos de l appel du glu  a chaque affichage,
et concernant le rendu "INTERDIT d'utiliser glBegin/End" ? comment utiliser une list ou vbo (c'est quoi ca? ) dans mon cas?

merci beaucoup pour ton aide!

l'utilisation de glBegin et glEnd est une facilité offerte par openGL ( et pas par DirectX, d'ailleurs ) pour afficher des polys de manière simple, mais lente. Les listes marchent bien. les vbos encore mieux, mais c'est récent et donc pas forcément supporté par toutes les cartes.

_______________________

donc j'ai meilleur temps d'initialiser mes listes une fois et ensuite de les appeler dans mon DrawQuads()?
genre comme ca:

GLuint startList;

startList = glGenLists(10);

for(int i=0; i<11; i++)
        {

glNewList(startList + i, GL_COMPILE);

                for(int q=0; q<LLayer[i].num_quads; q++)
                {

               
                    
                    glColor4f(LLayer[i].color.r,LLayer[i].color.g,LLayer[i].color.b, LLayer[i].color.a);
                    
                    int num_pts = LLayer[i].quad[q].num_pts;
                    
                    GLdouble pt_bottom[250][3];
                        
                    for(int p=0; p<num_pts; p++)
                    {
                        pt_bottom[p][0]=LLayer[i].quad[q].bottom[p*2];
                        pt_bottom[p][1]=LLayer[i].zstart;
                        pt_bottom[p][2]=LLayer[i].quad[q].bottom[p*2+1];
                    }
                        // ON DESSINE LA FACE DU BAS

                    GLdouble pt_top[250][3];
                            
                    for(p=0; p<num_pts; p++)
                    {
                        pt_top[p][0]=LLayer[i].quad[q].bottom[p*2];
                        pt_top[p][1]=LLayer[i].zstart + LLayer[i].h;
                        pt_top[p][2]=LLayer[i].quad[q].bottom[p*2+1];
                    }

                        GLUtesselator *tobj;
                            
                        tobj = gluNewTess();
                        gluTessCallback(tobj, GLU_TESS_VERTEX, (GLvoid (CALLBACK*) ()) &glVertex3dv);
                        gluTessCallback(tobj, GLU_TESS_BEGIN, (GLvoid (CALLBACK*) ())
                        &beginCallback);
                        gluTessCallback(tobj, GLU_TESS_END, (GLvoid (CALLBACK*) ())
                        &endCallback);
                        gluTessCallback(tobj, GLU_TESS_ERROR, (GLvoid (CALLBACK*) ())
                        &errorCallback);
                        glShadeModel(GL_FLAT);
                        gluTessBeginPolygon(tobj, NULL);
                            gluTessBeginContour(tobj);
                                for(int u=0; u<num_pts; u++)
                                    gluTessVertex(tobj, pt_bottom[u], pt_bottom[u]);
                            gluTessEndContour(tobj);
                        gluTessEndPolygon(tobj);
                        gluDeleteTess(tobj);
                            
                            
                        tobj = gluNewTess();
                        gluTessCallback(tobj, GLU_TESS_VERTEX, (GLvoid (CALLBACK*) ()) &glVertex3dv);
                        gluTessCallback(tobj, GLU_TESS_BEGIN, (GLvoid (CALLBACK*) ())
                        &beginCallback);
                        gluTessCallback(tobj, GLU_TESS_END, (GLvoid (CALLBACK*) ())
                        &endCallback);
                        gluTessCallback(tobj, GLU_TESS_ERROR, (GLvoid (CALLBACK*) ())
                        &errorCallback);
                        glShadeModel(GL_FLAT);
                        gluTessBeginPolygon(tobj, NULL);
                            gluTessBeginContour(tobj);
                                for(u=0; u<num_pts; u++)
                                    gluTessVertex(tobj, pt_top[u], pt_top[u]);
                            gluTessEndContour(tobj);
                        gluTessEndPolygon(tobj);
                        gluDeleteTess(tobj);

                        for(int ee=0; ee<num_pts;ee++)
                        {
                            //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                            int ee2 = ee+1;
                            if(ee2 == num_pts)
                                ee2 = 0;
                            glColor4f(LLayer[i].color.r,LLayer[i].color.g,LLayer[i].color.b, LLayer[i].color.a);
                            glBegin(GL_POLYGON);
                                glVertex3f(pt_bottom[ee][0],pt_bottom[ee][1],pt_bottom[ee][2]);
                                glVertex3f(pt_bottom[ee2][0],pt_bottom[ee2][1],pt_bottom[ee2][2]);
                                glVertex3f(pt_top[ee2][0],pt_top[ee2][1],pt_top[ee2][2]);
                                glVertex3f(pt_top[ee][0],pt_top[ee][1],pt_top[ee][2]);
                            glEnd();
                            // ON DESSINE TOUTES LES ARRETES

                                glColor4f(0.0,0.0,0.0, 1.0);
                                
                                glBegin(GL_LINES);

                                glVertex3f(pt_bottom[ee][0],pt_bottom[ee][1],pt_bottom[ee][2]);
                                glVertex3f(pt_bottom[ee2][0],pt_bottom[ee2][1],pt_bottom[ee2][2]);

                                glVertex3f(pt_bottom[ee2][0],pt_bottom[ee2][1],pt_bottom[ee2][2]);
                                glVertex3f(pt_top[ee2][0],pt_top[ee2][1],pt_top[ee2][2]);

                                glVertex3f(pt_top[ee2][0],pt_top[ee2][1],pt_top[ee2][2]);
                                glVertex3f(pt_top[ee][0],pt_top[ee][1],pt_top[ee][2]);

                                glVertex3f(pt_top[ee][0],pt_top[ee][1],pt_top[ee][2]);
                                glVertex3f(pt_bottom[ee][0],pt_bottom[ee][1],pt_bottom[ee][2]);

                                glEnd();
                            }
                        }
glEndList();
            }

Et apres dans mon DrawQuads()

je fais :

void DrawQuads()
{
    nombrequads=0;

    if(SaveLayers)    
    {
        for(int i=0; i<11; i++)
        {
             if(LLayer[i].visible)
                   glCallList(startList + i);      
        }

    }

}

Ca marcherai ca? J'oublie quelque chose?

heuu je me trompe ou ça se fait pas comme ça les listes ? théoriquement tu remplis un buffer avec toutes des données, et tu passes ce buffer à oGL.
Enfin je peux me tromper, je n'ai plus fait ça depuis longtemps .

_______________________

Il me semble que tu peux les faire comme ca. J'utilise jamais les listes, mais tu auras les perfs maximales avec. Au lieu de faire 10 listes, tu aurais pu en faire une seule.

Pk tu demandes si ca marche ? test le d'abord.

Merci, j'etait en train de regler un autre probleme en meme temps :P
Je vais essayer maintenant ... je vous donnerai des nouvelles je pense demain pour dire si ca marche ou pas!

Je doit faire 10 listes, car je dois pouvoir ne pas en afficher une ou meme plusieur d entre elle!

Pour ceux que ca interesse (Arnaud16022 par exemple), [ Lien ] c'est pour la tesselation de polygone concave... et justement aussi la gestion des listes ogl des listes! Donc la facon que j'ai montré avant est normalement correcte...
Plus d'info demain apres mes tests!

Merci

++

Jojo

Hello!

Alors bah voila, ca marche! Par contre ca met un de ces temps a charger!!! une idée de comment accélérer ca?
Cependant j'aurai deux questions a vous posez, la premiere, mon programme utilise beaucoup de ressource, vous avez des astuces ou des idées de ou je dois regarder pour essyer de faire en sorte que mon logiciel face moins rammer mon ordi?

deuxieme question en OpenGL cette fois...
De loin mes differentes couches se "supperposent" et les couleurs du dessous se melent au couleur du dessus... vous allez comprendre en regardant ces images ci dessous: la premiere est la vu de loin, et la deuxieme la vu de pret... vous remarquerez que le vert est en dessous du blanc, qui est lui meme en dessous du rouge, qui est en dessous du noir, pis en qui lui est en dessous du bleu...
donc par exemple en bas, on devrai pas voir le vert dans les rectangle rouge! partout ou y a du blanc, on est pas sensé voir de vert par dessus!

bref, une idée de ou ca peu venir!

vu de loin:


2eme vu de loin ou l on voit bien que le blanc "deborde" sur les couche qui sont par dessus!

vu de pret :



Merci pour votre aide!


Jojo

aille en faite un un tit probleme avec les glLists... ca marche mais en fait comme vous le voyez sur mes images j'ai une fenetre de controles des couches, qui me permet de modifier la couleur et la transparence meme la hauteur de mes couches ... ca marchais tres bien avant... bah maintenant, si j'ai initialisé tous mes polygons dans une list et que je dessiner en appelant cette liste, je ne peux plus agir dessus?!? non? Vous connaissez une solutions a ce probleme?

merci encore