Discussion :

[yann458]

Bonjour,

J'ai tester un projet qui contient 6 méga de primitives ,
je m'explique , je travaille sur des murs deformer , pour cela j'ai besoin plus de primitives,
j'ai fait un projet MAQUETTE qui dessine des réseaux de murs deformer .
J'ai tester sur une machine un peu ancienne avec 30fps et taux uc 50% sur un poste biprocesseur ,
j'ai tester sur une machine plus récente avec 50fps et taux uc 5%.
Est ce normal ?

Sur les jeux commerciaux openGL , combien de fps ?

Merci.

[dragonjoker59]

Euh... Il est difficile de répondre sans connaitre ton workflow.
Tu utilises OpenGL 3.x? 4.x?
Tes murs déformés, tu as regardé ce que ça donnait avec du normal mapping, plutôt qu'en les déformant au niveau mesh?
6 méga de primitives, 6 000 000 ?
Tu demandes quoi au CPU pendant ton rendu?
Tu utilises des VBO?
...

[yann458]

Euh... Il est difficile de répondre sans connaitre ton workflow.
Tu utilises OpenGL 3.x? 4.x?
Tes murs déformés, tu as regardé ce que ça donnait avec du normal mapping, plutôt qu'en les déformant au niveau mesh?


Tu utilises des VBO?
Ben oui.
...

Je n'ai pas encore utiliser le normal mapping.
Je pense utiliser openGl 3.x
Je dessine 6 000 0000 de primitives avec 5*5 (25) vbo en utilisant glbindbuffer et gldrawelement (non gldrawarrays),
bien entendue j'utilise les VBO.
Tout cela sur une maquette d'essaie.

[dragonjoker59]

Peut-on voir ta boucle de rendu?

[yann458]

Peut-on voir ta boucle de rendu?

Je joint un extrait de mon code et ca fonctionne.
RC=5 ou 7

Pour le normal-mapping , j'ai jeter un oeil , ce n'est pas simple. Je regarderai plus tard en détail.

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
glm::mat4 Projection = glm::perspective(60.0f, 1.0f, 0.05f, 960.f); 
 
				glm::mat4 Model;
 
 
 
				//glm::mat4 View = glm::rotate(mat4(1.0f), ang, glm::vec3(0.0f, 1.0f, 0.0f)); 
					glm::mat4 View = glm::rotate(mat4(1.0f), ang, glm::vec3(0.0f, 1.0f, 0.0f)); 
				glm::mat4 ViewTranslate = glm::translate(View, glm::vec3(xp, haut, yp)); 
				//glm::mat4 ViewTranslate = glm::translate(View, glm::vec3(xp, haut, yp)); 
				glm::mat4 MVPint = ViewTranslate * Model;
int naelt=0;
			for (int rcx=0;rcx<rc;rcx++)
			{
				for (int rcy=0;rcy<rc;rcy++)
				{
								int ps=rcx+(rcy*rc);
								glm::mat4 MVP = Projection * ViewTranslate * Model; 
 
								//bug ????
								MVP=glm::translate(MVP,glm::vec3(rcx*8,0,rcy*8));
								////////////
								GLfloat *f=glm::value_ptr(MVP); 
								glActiveTexture(GL_TEXTURE+0);
								glBindTexture(GL_TEXTURE_2D,mur);
 
								glUniformMatrix4fv(mamat,1,GL_FALSE,f);
								glUniform4f(mafogcolor,0.0,0.0,0.0,0.0);
								glUniform1f(mamlt_fp,1.0); //echelle texture
								glUniform1f(mafogdensity,0.02);
 
 
 
								// Utilisation des données des buffers
								int err;
								glEnable(GL_TEXTURE_2D);
 
								glBindBuffer(GL_ARRAY_BUFFER, alesvertex[ps]);
 
								glVertexPointer( 3, GL_FLOAT, 5 * sizeof(float),( 0 ));
 
 
 
								glTexCoordPointer(2, GL_FLOAT, 5 * sizeof(float),(GLvoid*)( 3*sizeof(GLfloat)));
 
 
 
								glEnableClientState( GL_VERTEX_ARRAY );
 
 
								int ns=ne/5.0;
 
 
								glEnableClientState( GL_TEXTURE_COORD_ARRAY );
								if (iselement)
								{
									glDrawElements(GL_TRIANGLES,numberelement[ps],GL_UNSIGNED_INT,0);
 
									naelt+=numberelement[ps];
								}
								else
								{
									glBindBuffer(GL_ARRAY_BUFFER, alesid[ps]);
									glDrawArrays(GL_TRIANGLES,0,numbervertex[ps]);
								}
 
								glDisableClientState( GL_TEXTURE_COORD_ARRAY );
								glDisableClientState( GL_VERTEX_ARRAY );
				}
 
			}
 
 
 
 
			//DrawPanneau(1.5,0);
 
 
			SwapBuffers( hDC );
 
			static int nufps=0;
			static int ds=GetTickCount();
			nufps++;
			if ((GetTickCount()-ds)>1000)
			{
				char tmp[64];
				sprintf(tmp,"%d fps %d",nufps,naelt);
				SetWindowText(hStatic,tmp);
				nufps=0;
 
				ds=GetTickCount();
			}
			//theta += 1.0f;
 
		}
	}

[dragonjoker59]

Déjà, je te conseille de sortir de tes boucles le maximum de choses:
- calcul initial de ta MVP si tant est que ta Model ne varie pas, sinon uniquement le calcul de VP
- binding de la texture 0
- glEnable( GL_TEXTURE_2D )
- binding de tes uniforms avec mafogcolor, mamlt_fp, mafogdensity
...

En gros tout ce que tes boucles ne font pas varier.

Ensuite, privilégie l'utilisation des VAO (je te laisse te documenter là dessus), qui te permettront de ne pas avoir les multiples appels à glBindBuffer, glTexCoordPointer, glVertexPointer.
A propos de glTexCoordPointer, glVertexPointer, il serait temps de passer glVertexAttribPointer, car les 2 autres sont dépréciées en OpenGL 3.0.
Après, il est conseillé de mesurer les temps en millisecondes plutôt que les FPS (quelques liens pour appuyer: https://www.mvps.org/directx/article...frame_time.htm, http://www.neogaf.com/forum/showthread.php?t=512976, ...)

[yann458]

Bonjour,

Je suis sur un jeux de labyrinthe 3d opengl utilisant les VBO.
Pour information : En moyenne j'appelle 1000 fois par seconde la fonctions gldrawarray car je le fais pour chaque texture,bref et il y a 64 VBO (8x8) à afficher.
J'affiche un taux fps de 33 quand tout va bien. c'est 33 au lieu de 60 car j'utilise le timer de Windows,bref ....
Le soucis c'est qu'il y a certains endroit de mon labyrinthe ou le fps atteint 21 et j'observe dans le gestionnaire de tache le taux uc à 40% et ce phénoméne se produit quand la fenêtre openGL prend tout mon écran de 21".
Ce qui est étrange , si je tourne par exemple mon pion (caméra) de 90° , le taux uc passe à 0 1% avec un fps de 32 33, le code ne change pas quelque soit l'angle du pion (caméra).
J'ai essayer de reduire la taille des textures , là le taux uc passe à 0 1% avec un fps de 33 quelque soit l'angle du pion (caméra).

Est ce que c'est mon code qui bug ?
Encore pour information : Je travaille dans un environnement VirtualBox , il faudrait que je teste directement sur une machine.

Merci.

[LittleWhite]

Bonjour,

Essayez de réduire les drawcall, si possible.
Utilisez vous la technique du frustrum culling ?
Pouvez-vous utiliser un compteur de FPS externe ?

[dragonjoker59]

Salut!

Peux-tu montrer ta boucle de rendu?
Tu peux voir du côté des Occlusion tree, ou des BSP tree, qui te permettront de partitionner ton labyrinthe, et donc de réduire les zones à afficher (et donc les draw calls)

[yann458]

Bonjour,

Essayez de réduire les drawcall, si possible.
Utilisez vous la technique du frustrum culling ?
Pouvez-vous utiliser un compteur de FPS externe ?

Non je n'utilise pas de frustrum culling et
il n'y à pas sur ce site de tutoriel en français sur le frustum culling.
Sinon J'utilise un compteur FPS.

[LittleWhite]

En effet... mais bon, le principe est assez "simple" : http://jeux.developpez.com/faq/3d/?p...ULLING_frustum

[yann458]

Bonjour,

Essayez de réduire les drawcall, si possible.
Utilisez vous la technique du frustrum culling ?
Pouvez-vous utiliser un compteur de FPS externe ?

J'ai essayer avec le frustum culling , ca réduit les drawcall (evidemment), mais toujours même vitesse, ca ne va pas plus vite.

[LittleWhite]

Comme ça, sans plus d'indication, je ne saurais dire. L'idée générique étant de prendre un profiler GPU et de profiler pour voir ce qui rame.

[yann458]

Bonjour,

Pour l'affichage de labyrinthe ,
est ce que je dois tous afficher les primitives de mon labyrinthe ou appliquer le frustum culling ou est ce que je dois afficher que les primitives visible à l'endroit ou je suis selon l'angle ???
Par exemple est ce qu'il est dans OpenGL correcte de dessiner un mur qui est cacher de la vision par un autre (selon l'endroit ou je suis) ?

Si je dois dessiner les primitives seulement visible selon l'angle du pion , j'ai une méthode mais je ne sais pas si c'est bien adapter :
J'ai du mal à m'expliquer

Déclarer tous les primitives invisible (non drawable).
Parcourir les angles visible 'lambda' selon l'orientation du pion (par pas de 5° par exemple) , et projeter une ligne imaginaire tourner de l'angle 'lamba' et déclarer drawable le primitive intersecter (à la ligne imaginaire) seulement celui qui est le plus proche du pion,
celles qui sont plus loin , ne seront pas déclarer drawable pour l'angle parcourut car primitives subseptible d'être cacher par une autre primitives plus proche du point de vision.

voilà est ce une bonne méthode qui convient pour un labyrinthe avec qu'un seul niveau et mur avec hauteur fixe.

Merci.