Performances au ras des paquerettes pour l'affichage de quads

**AliceD** · 03/08/2006, 22h30

Bonsoir,

Je viens d'ecrire un programme qui affiche des quads textures en RGBA aux coordonnes completement aleatoires d'une frame a l'autre, juste pour tester les performances de ma carte 3D.

Je suis tombee de haut en me rendant compte que pour afficher un frame de 170 quads (avec une texture 32*32), mon ordi met quelque 1.05404 secondes.

Ce resultat me semble ridicule, comparé aux performances des DisplayLists.

Je pose donc la question : si des polygons prennent tous une trajectoire differentes, et qu'alors les displaylists sont inutilisables, quelle est la bonne methode pour rendre des quads plus rapidement ?

-------

Voici un bout du code que j'ai utilisé, si cela peut aider a comprendre pourquoi j'obtiens de perfs desastreuses.... A la vue des tutos disponibles sur la toile, ma methode ne me semblait pas abherante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
34
35
 
 
void OnDraw(){
	//**Bcl0:
	for (;;) {
		//Randomize
		LARGE_INTEGER Hi;
		QueryPerformanceCounter(&Hi);
		srand(Hi.QuadPart);
		//**Init scene
		glClearColor(.5,.5,.5,0); 
		glClear(GL_COLOR_BUFFER_BIT);
		glEnable(GL_ALPHA_TEST);
		glAlphaFunc(GL_LESS, 1.0f);
		glLoadIdentity(); 
		gluLookAt(0,0,100,0,0,0,0,1,0); 
		//Init chrono
		Chrono.StartChrono();
		//**Dessin de NbQuads quads (coor xy:[-100;100], Z fixe)
		glBegin(GL_QUADS);
		for (tDWord Bcl=0;Bcl<=NbQuads;Bcl++) {
			glTexCoord2d(0,0);	glVertex3d(Randez(),Randez(),0);
			glTexCoord2d(1,0);  glVertex3d(Randez(),Randez(),0);
			glTexCoord2d(1,1);	glVertex3d(Randez(),Randez(),0);
			glTexCoord2d(0,1);	glVertex3d(Randez(),Randez(),0);
		}
		glEnd();	
		float Ctn=Chrono.GetLapTime();
		printf ("NbQuads:%i ; Seconds : %f\n",NbQuads,Ctn);	
	//Fin rendu
	glDisable(GL_ALPHA_TEST);
	glutSwapBuffers();
	NbQuads+=10;
	}
}

Je sais que c'est un peu le bazar dans cette fonction. Je l'aivais ecrite pour voir jusqu'a combien de quads je pouvais aller pour avoir un temps de rendu inferieur a 0,0167 seconds. (D'apres mon test, je peux m'autoriser maxi 7 quads

)

J'ai beau chercher dans les tuto, les methodes de rendu illustrees ne parlent que de DisplayList (apparament impropres a l'affichage de nombreux polygons aux deplacement independants) ou de glbegin/glend...

**fearyourself** · 03/08/2006, 23h22

Au vue du programme tu utilises Glut... Il ne faut pas faire de boucle infinie dans la fonction d'affichage...

Pour ce genre de test, il serait plus intelligent d'utiliser la SDL qui te permet de mettre une boucle événementielle autour de la fonction de rendu (voir les tutoriels sur SDL http://jeux.developpez.com/tutoriels/#a_sdl).

Ensuite, il faudrait voir aussi ce qui se trouve dans la fonction Randez...

Enfin, cela dépend aussi de la carte 3D

Jc

**fearyourself** · 03/08/2006, 23h53

En passant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
		srand(Hi.QuadPart);

srand doit être appelé au début du programme (une seule fois c'est tout...)

Jc

**Ti-R** · 04/08/2006, 01h35

La fonction Randez() est optimisée ?

Si tu fais un rendu de 10 fois plus de quads, le temps de rendu change ?

Si oui -> problème
Si non -> problème de conception. (et il semble en avoir pas mal)

**AliceD** · 04/08/2006, 09h57

Ce code est une vraie honte, je sais...

J'ai modifié la fonction pour faire demarrer le chrono avant glBegin et l'arreter apres glend. et j'obtient ces resultats :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
...
NbQuads:101 ; Seconds : 0.000168
NbQuads:111 ; Seconds : 0.000173
NbQuads:121 ; Seconds : 0.000194
NbQuads:131 ; Seconds : 3.554757
NbQuads:141 ; Seconds : 3.565252
NbQuads:151 ; Seconds : 3.619532
NbQuads:161 ; Seconds : 3.628514
NbQuads:171 ; Seconds : 3.670949
NbQuads:181 ; Seconds : 3.605468
...

Tout de meme, le temps pour afficher X quads, est enorme a partir de 131 quads et je n'arrive pas a me l'expliquer.
La fonction Randez (qui renvoit un float dans l'interval [-100;100] ne semble pas en cause car en passant des coordonnes constantes a Vertex3d(), j'obtient des resultats similaires.

**fearyourself** · 04/08/2006, 10h20

Pourrait-on avoir un code minimal/compilable qui illustre ton problème ?

Jc

**Ti-R** · 04/08/2006, 10h35

Entre 121 et 131 il y a un big problème....

Ce n'est pas logique qu'il y est un "saut" de performance...

**AliceD** · 04/08/2006, 11h34

Merci pour votre aide.

Voici un lien vers l'archive de mon projet. (dispo jusqu'au 11/08/06)

http://www.yousendit.com/transfer.ph...383DE630AFD928

VOus me direz les performances que ca donne chez vous...

**fearyourself** · 04/08/2006, 12h08

Premièrement ton code est que pour Windows -> utilisant Glut c'est un peu ...

Deuxièment, en changeant pas mal de trucs j'ai remarqué que tu fais beaucoup de grands triangles... Normal qu'il va avoir du mal à un moment...

Ensuite, en faisant des quads de 2*2 sans textures, je suis bien monté dans le nombre de triangles...

Enfin, en virant ta boucle et mettant un glutPostRedisplay à la fin, le programme tournait encore plus vite...

Jc

**AliceD** · 04/08/2006, 22h21

Merci pour l'interet porte a mon probleme.

en fait, j'ai reussi a faire s'envoler les perf de ce programme rien qu'en mettant a jour les pilotes de ma carte. J'arrive enfin a plus de 5'000 quads en moins d'1/60 de second, meme avec monimplementation a l'arrache.

ps: merci pour les precisions du dernier post, je commence un peu mieux a comprendre comment marche cet API.
J'en profite pour demander par curiosite : Ca vous a pris combien de temps pour maitriser l'OpenGL ?