Rapidité différente suivant les PC

[Colloc]

Bonjour,

Je développe une appli très simple utilisant OpenGL avec BCB6. J'affiche une objet issue d'un WaveFront puis réalise des tranches avec glOrtho que je récupère sous forme d'image ensuite pour le besoin d'une application particulière.

Ces calculs sont "rapides" sur le PC de développement (avec une CG de base à chipset Intel !) mais très lente dès que je passe sur d'autres PC normalement plus puissant.

La différence qd je regarde avec OpenGL Extension Viewer est que mon pc de base est en OpenGL 1.1, les autres en OpenGL 2.x avec des cartes graphiques plus puissantes. Comment optimiser ces calculs ?

[LittleWhite]

Bonjour,

Rapidité différente, oui parce que les cartes graphiques ne sont pas les mêmes.
Après, les différences peuvent sembler incohérentes, mais cela dépend de l'architecture des GPU et de vos programmes.
En effet, il semble que vous utilisez du OpenGL 1.x (appel à glBegin() / glEnd()), qui maintenant, sont devenu obsolète. De plus, si vous tentez des opérations précises (lectures des buffers, accès textures ou je ne sais quoi), sur certaines cartes, de part leur conception, ces appels peuvent être rapides, mais sur d'autres, non.
Finalement, ce que vous pouvez essayer de faire, pour amélioré la situation, c'est d'utiliser des techniques un peu plus évoluer (je suis parti du principe que vous étiez avec des glBegin() / glEnd()), du genre Vertex Buffer Object, les shaders et si besoin, des FrameBufferObject.

[Colloc]

En fait mon code est le suivant :

Code :

1
2
3
4
5
6
7
8
9
10
11
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
glEnable(GL_LINE_SMOOTH);
glLineWidth(1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-100,100,-100,100,200+hauteur-amplitude/(Max),200+hauteur+amplitude/(Max));
gluLookAt(0,200,0,0,0,0,0,0,1);
glMatrixMode(GL_MODELVIEW);
 
DrawScene(false);

L'idée ici est de faire des tranches de l'objet, hauteur étant un GLFloat qui évolue dans le thread en boucle, Max le nombre de tranche, et amplitude... l'amplitude !

Avec DrawScene qui est la suivante :

Code :

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
DrawScene(bool Couleur)
{
 
 
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        glMatrixMode(GL_MODELVIEW);
        glEnable(GL_CLIP_PLANE0);
        glLoadIdentity();
        glPushMatrix();
                glTranslated(0,0,0);
                glRotatef(g_rotation,0,1,0);
		glRotatef(h_rotation,1,0,0);
 
 
        if (Couleur)
                               Draw(objet,GLM_SMOOTH+GLM_MATERIAL+GLM_TEXTURE+GLM_COLOR);
        else
                Draw(objet, GLM_SMOOTH+GLM_MATERIAL+GLM_TEXTURE);
 
	glPopMatrix();
 
 
         if (Couleur)
                SwapBuffers(ghDC);

Ensuite, je fais un glReadPixels pour récupérer ces données dans une image OpenCV pour lui faire subir des traitements spécifiques.

Comment puis-je rendre ceci plus rapide sur d'autres machines ?

[ShevchenKik]

Bonjour,

quelques questions / idées pour optimiser votre code:

1) la partie suivante, vous l'appelez à chaque dessin?

Code :

1
2
3
4
5
6
7
8
9
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 
glEnable(GL_LINE_SMOOTH);
glLineWidth(1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-100,100,-100,100,200+hauteur-amplitude/(Max),200+hauteur+amplitude/(Max));
gluLookAt(0,200,0,0,0,0,0,0,1);
glMatrixMode(GL_MODELVIEW);

=> normalement les opérations de cadrage ne sont nécessaires que lors d'un redimensionnement de votre fenêtre, càd dans la fonction Resize (ou équivalente) de votre fenêtre

2) Dans votre Draw(), vous commencez par un:

Code :

glMatrixMode(GL_MODELVIEW);

=> c'est ici redondant car c'est déjà appelé dans votre fonction de cadrage. Là vous rechargez la matrice modelview à chaque dessin, alors que ce mode est déjà activé. C'est plus que redondant, ca fait perdre du temps de calcul...
(openGL ne verifie pas quels états sont déjà activés quand un changement d'état est demandé et l'effectue "bêtement")

3) De même dans votre dessin, vous avez la ligne suivante:

Code :

glEnable(GL_CLIP_PLANE0);

=> à moins que vous ayez besoin de le désactiver ailleurs, cet état devrait être activé une fois pour toute lors de l'initialisation et rester à ON tout le long

Voilà, ca ne résoudra probablement pas tous vos problèmes mais vous pouvez déjà commencer par ces optimisations et voir si vous observez toujours d'aussi grandes différences entre les systèmes de test.

Bonne chance!

[screetch]

ca doit représenter peanuts ca, par rapport a la méthode ReadPixels.

Questions:
* c'est quoi, une différence de vitesse? c'est quoi la vitesse sur intel et sur nvidia (en millisecondes de préférence?
* est-ce que tu vérifies tes appels a OpenGL? en faisant un glGetError() après chaque appel tu pourrais vérifier
* est ce que tu as essayé un debugger comme gDEBugger?
* est ce que tu as essayé un renderer software (on peut choisir ca dans SetPixelFormat)

[ShevchenKik]

ca doit représenter peanuts ca, par rapport a la méthode ReadPixels.

Oui je suis tout à fait de ton avis mais bon, tant qu'on a pas de mesure de ce qui bloque ou pas, autant optimiser ce qu'on peut, c'était pensé dans ce sens.

Après oui, il faut mesurer les temps d'exécution des différents appels OpenGL et voir ce qui varie de manière significative d'un système à l'autre.

Ah, et sinon des trucs tout bêtes mais sait-on jamais:
- Rebooter les 2 systemes avant de tester: il m'est déjà arrivé qu'à force de debugs suivis de crashs ou exits répétés, le ressources de la carte graphique ne soient pas libérées proprement, du coup ca plante ou donne des résultats au mieux bizarres. J'en ai (re) fait l'expérience pas plus tard que la semaine dernière donc au cas où...
- Et bien sûr vérifier que les bons drivers sont installés et à jour

[LittleWhite]

Sinon, comme là nous n'avons pas vraiment le code de dessin, pouvez vous donner le contenu des fonctions Draw:

Code :

1
2
3
4
if (Couleur)
                               Draw(objet,GLM_SMOOTH+GLM_MATERIAL+GLM_TEXTURE+GLM_COLOR);
        else
                Draw(objet, GLM_SMOOTH+GLM_MATERIAL+GLM_TEXTURE);

Est ce que vous dessinez des objets statiques ou dynamique ?

[screetch]

Envoyé par ShevchenKik

Oui je suis tout à fait de ton avis mais bon, tant qu'on a pas de mesure de ce qui bloque ou pas, autant optimiser ce qu'on peut, c'était pensé dans ce sens.

ah pardon c'était surtout pour l'auteur du post, qui donne du code qui (probablement) n'est pas le code qui prend du temps, pas pour toi

[Colloc]

Merci pour toutes ces réponses,

La différence est de 1 pour 4, j'ai sur mon PC de base 32 image/s contre 4 sur l'autre !

Mais je viens de trouver la différence !!! En fait, c'est un accès disque, donc rien à voir avec OpenGL... qui se faisait en local puis en réseau !

Merci de tous vos conseils, cela m'a permis de nettoyer quand même un peu mon code !!!