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]

D'aprés moi : les vao ne peux être utiliser car dans ma boucle j'utilise :

Code :

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

glUniformMatrix4fv(mamat,1,GL_FALSE,f);

Question : les vao enregistre plusieurs vbo mais enregiste t'il les index textures comme dans les list-display ?

[dragonjoker59]

Les VAO sont pour les VBO, IBO et attributs de sommets (glVertexAttribPointer). Aucun rapport avec les Uniforms ou les Textures (qui doivent toujours être bindés de manière traditionnelle)

EDIT:

En OpenGL 3.x, si tu crées un contexte forward compatible, tu n'auras pas d'autre choix que d'utiliser les VAO qui sont obligatoires.

[yann458]

A propos du normal-mapping :
si j'ai bien compris , le normal-mapping n'agirais pas sur la mesh , mais plutôt sur les valeurs couleur de texture et le light (lumière).

[dragonjoker59]

Le normal mapping te permet d'introduire des variations dans les normales de ton mesh, en utilisant une texture de normales (normal map).
Le calcul des lumières prenant en compte les normales des points à dessiner, le normal mapping modifie donc le comportement des lumières.

[yann458]

Je sais convertir une image-texture en image-texture normal mapping.
Ayant vu l'exemple tutoriel 15, je sais maitriser les UV , je pense pouvoir trouver les tangente et bi-tangente .
Mais comment je peux deviner les normals (x,y,z) qu'on passe ????
sachant que je veux dessiner un mur simple avec 2 meshs (2 triangles).

Merci.

[dragonjoker59]

Ben la normale est écrite dans la normal map. Tu dois donc l'échantillonner au niveau de ton shader, avec les UV de tes vertex

[LittleWhite]

Sinon, pour un mur plat (sans relief), on pourrait aussi simplement faire un cross product de deux côtés de chaque triangle.
Mais cette technique, pour des murs non plats est inadéquate .

[yann458]

Bon j'ai développer un mini-projet en prenant model sur le tutoriel , j'ai pu produire l'image normal_mapping et specular.
J'ai mis les normales-vertex (x,y,z) à 1 car je n'ai pas les informations.
Quand je trace les vertex et UV (ce qui n'est pas correct), la lumière s'affiche dans OpenGL mais étant mal positionner.
Quand je trace à la fois les vertex ,UV , normal (ce qui n'est pas encore correcte), là je ne vois plus de lumiére.
Même problème constater si je trace vertex,UV,normal,tangent,bitangent (ce qui est correcte par rapport au shader).

Demain ou aprés-demain je vais soumettre sur ce thread mon mini-projet zippé qui ne marche pas bien.

voilà ;
Pour information : je travaille dans l'environnement VirtualBox.

[dragonjoker59]

Déterminer les normales d'une face n'est pas compliqué, LittleWhite t'a donné la méthode.
Je ne comprends pas ce que tu cherches à faire.
Pour le normal mapping, il te faut:
- Tes vertex (avec au moins les UV et les positions)
- Une normal map (qui contient les normales)
- De quoi calculer l'espace tangent (faisable avec UV + Normales)
- Une texture de couleurs (optionnel, mais ça rend plus joli avec)

Qu'est-ce qu'il te manque, parmi ces informations?
Tu peux consulter le tutoriel d'OGLdev sur le normal mapping: http://ogldev.atspace.co.uk/www/tuto...utorial26.html

[yann458]

Déterminer les normales d'une face n'est pas compliqué, LittleWhite t'a donné la méthode.
Je ne comprends pas ce que tu cherches à faire.
Pour le normal mapping, il te faut:
- Tes vertex (avec au moins les UV et les positions)
- Une normal map (qui contient les normales)
- De quoi calculer l'espace tangent (faisable avec UV + Normales)
- Une texture de couleurs (optionnel, mais ça rend plus joli avec)

Qu'est-ce qu'il te manque, parmi ces informations?
Tu peux consulter le tutoriel d'OGLdev sur le normal mapping: http://ogldev.atspace.co.uk/www/tuto...utorial26.html

Pour calculer une normale je procede :

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
for (unsigned int i=0; i<v_hv.size(); i+=3 )
							{
glm::vec3 & v0 = glm::vec3(v_hv[i+0]->x,v_hv[i+0]->y,v_hv[i+0]->z);
									glm::vec3 & v1 =  glm::vec3(v_hv[i+1]->x,v_hv[i+1]->y,v_hv[i+1]->z);
									glm::vec3 & v2 =  glm::vec3(v_hv[i+2]->x,v_hv[i+2]->y,v_hv[i+2]->z);
 
									//on va calculer la normal
									glm::vec3 sanormal=glm::normalize(glm::cross(v2-v0,v1-v0));
									for (char cb=0;cb<3;cb++)
									{
										v_hv[i+cb]->xnormal=sanormal[0];
										v_hv[i+cb]->ynormal=sanormal[1];
										v_hv[i+cb]->znormal=sanormal[2];
									}
}

Ca ne marche pas trés bien , j'observe qu'une partie du mur seulement éclairée sous forme d'un triangle.
Comprend rien !
L'image joint :
http://fr.tinypic.com/view.php?pic=2yopbb8&s=9

La fonction qui calcule la normal tangente bitangente :

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
 
{
							std::vector <glm::vec3>tangents;
							std::vector <glm::vec3>bitangents;
							for (unsigned int i=0; i<v_hv.size(); i+=3 )
							{
 
									// Shortcuts for vertices
									glm::vec3 & v0 = glm::vec3(v_hv[i+0]->x,v_hv[i+0]->y,v_hv[i+0]->z);
									glm::vec3 & v1 =  glm::vec3(v_hv[i+1]->x,v_hv[i+1]->y,v_hv[i+1]->z);
									glm::vec3 & v2 =  glm::vec3(v_hv[i+2]->x,v_hv[i+2]->y,v_hv[i+2]->z);
 
									//on va calculer la normal
									glm::vec3 sanormal=glm::normalize(glm::cross(v2-v0,v1-v0));
									for (char cb=0;cb<3;cb++)
									{
										v_hv[i+cb]->xnormal=sanormal[0];
										v_hv[i+cb]->ynormal=sanormal[1];
										v_hv[i+cb]->znormal=sanormal[2];
									}
 
									// Shortcuts for UVs
									glm::vec2 & uv0 = glm::vec2(v_hv[i+0]->u,v_hv[i+0]->v);;
									glm::vec2 & uv1 =  glm::vec2(v_hv[i+1]->u,v_hv[i+1]->v);;
									glm::vec2 & uv2 =  glm::vec2(v_hv[i+2]->u,v_hv[i+2]->v);;
 
									// Edges of the triangle : postion delta
									glm::vec3 deltaPos1 = v1-v0;
									glm::vec3 deltaPos2 = v2-v0;
 
									// UV delta
									glm::vec2 deltaUV1 = uv1-uv0;
									glm::vec2 deltaUV2 = uv2-uv0;
 
									float r = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV1.y * deltaUV2.x);
									glm::vec3 tangent = (deltaPos1 * deltaUV2.y   - deltaPos2 * deltaUV1.y)*r;
									glm::vec3 bitangent = (deltaPos2 * deltaUV1.x   - deltaPos1 * deltaUV2.x)*r;
 
									// Set the same tangent for all three vertices of the triangle.
									// They will be merged later, in vboindexer.cpp
									tangents.push_back(tangent);
									tangents.push_back(tangent);
									tangents.push_back(tangent);
 
									// Same thing for binormals
									bitangents.push_back(bitangent);
									bitangents.push_back(bitangent);
									bitangents.push_back(bitangent);
 
								}
 
								// See "Going Further"
 
								for (unsigned int i=0; i<v_hv.size(); i+=1 )
								{
									glm::vec3  &n = glm::vec3(v_hv[i]->xnormal,v_hv[i]->ynormal,v_hv[i]->znormal);
									glm::vec3  &t = tangents[i];
									glm::vec3  &b = bitangents[i];
 
									// Gram-Schmidt orthogonalize
									t = glm::normalize(t - n * glm::dot(n, t));
 
									// Calculate handedness
									if (glm::dot(glm::cross(n, t), b) < 0.0f){
										t = t * -1.0f;
									}
									//tangents[i]=t;
								}
								for (int i = 0 ; i<v_hv.size();i++)
								{
									v_hv[i]->tangent[0]=tangents[i].x;
									v_hv[i]->tangent[1]=tangents[i].y;
									v_hv[i]->tangent[2]=tangents[i].z;
									v_hv[i]->bitangent[0]=bitangents[i].x;
									v_hv[i]->bitangent[1]=bitangents[i].y;
									v_hv[i]->bitangent[2]=bitangents[i].z;
									//i++;
								}
 
						}

Pour information : c'est le tout sur un VBO mais j'utilise 5 fois la fonction glvertexattribpointer.

Code :

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

1
2
3
4
5
6
7
 
int ss=(3+2+3+3+3)*sizeof(GLfloat); //vertex+uv+normal+bitangent+tangent
									::glVertexAttribPointer(0,3, GL_FLOAT,GL_FALSE,ss,0 );
									::glVertexAttribPointer(1,2, GL_FLOAT,GL_FALSE,ss,(BYTE*)NULL+(3*sizeof(GLfloat) ));
									::glVertexAttribPointer(2,3, GL_FLOAT,GL_FALSE,ss,(BYTE*)NULL+(5*sizeof(GLfloat) ));
									::glVertexAttribPointer(3,3, GL_FLOAT,GL_FALSE,ss,(BYTE*)NULL+(8*sizeof(GLfloat) ));
									::glVertexAttribPointer(4,3, GL_FLOAT,GL_FALSE,ss,(BYTE*)NULL+(11*sizeof(GLfloat) ));

Aussi j'ai un soucis avec l'éclairage , en faites dans mon projet j'affiche des buffers vbo (3*3) qui contient chacune 4 mur arrondits,bref,
j'ai remarque que chaque VBO était éclairer et j'utilise la variable LightId pour positionner la lumiére.
Chaque VBO fait 8x8.

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
 
//ang est l'angle du pion
double aa=ang/180.0; 
aa*=3.141;
								glm::vec3 direction(
		cos(aa),0,sin(aa)
		);
glm::vec3 position(xp,haut,yp); //translate
glm::mat4 ViewMatrix       = glm::lookAt(
								position,           // Camera is here
								position+direction, // and looks here : at the same position, plus "direction"
								glm::vec3(0,1,0)                  // Head is up (set to 0,-1,0 to look upside-down)
						   ); //semble bon
 
 
	glm::mat4 bidouille=ViewMatrix;
 
 
 
 
int naelt=0;
			for (int rcx=0;rcx<rc;rcx++)
			{
				for (int rcy=0;rcy<rc;rcy++)
				{
								int ps=rcx+(rcy*rc);
								//glm::vec3 lightPos = glm::vec3(xp+(rcx*8),0.5,yp+(rcy*8));
								DWORD xcpion=xp/1;
								DWORD ycpion=yp/1;
								int x8=xcpion>>3;
								int y8=ycpion>>3;
								int mx8=x8<<3;
								int my8=y8<<3;
								double glxpos=(xp/1.0);
								double glzpos=(yp/1.0);
								glxpos=glxpos-mx8;
								glzpos=glzpos-my8;
								glm::vec3 lightPos = glm::vec3(glxpos,0,glxpos);
								glUniform3f(LightID, lightPos.x, lightPos.y, lightPos.z); //je ne sais pas si c'est bon
 
								glm::mat4 modelmatrix=glm::mat4(1.0);
								//glm::mat4 ViewMatrix =
								//glm::mat4 ViewMatrix = MVP;
								glm::mat4 ViewMatrix = bidouille;; //LIGNE CODE A L'AIR BON
								glm::mat4 ModelViewMatrix = ViewMatrix * modelmatrix;
								glm::mat3 ModelView3x3Matrix = glm::mat3(ModelViewMatrix);
								glm::mat4 MVP = Projection * ViewMatrix * Model;  //LIGNE DE CODE BON !
								//bug ????
								MVP=glm::translate(MVP,glm::vec3(rcx*8,0,rcy*8));
								////////////
								//MVP=ProjectionMatrix * ViewMatrix * ModelMatrix;
 
								GLfloat *f=glm::value_ptr(MVP); 
 
 
								glUniformMatrix4fv(mamat,1,GL_FALSE,f);
 
 
								// Send our transformation to the currently bound shader, 
									// in the "MVP" uniform
									//glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);
									glUniformMatrix4fv(ModelMatrixID, 1, GL_FALSE, &modelmatrix[0][0]);
 
									glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &ViewMatrix[0][0]);
									glUniformMatrix3fv(ModelView3x3MatrixID, 1, GL_FALSE, &ModelView3x3Matrix[0][0]); //on lui passe mat3
 
 
...
...
...
}
}

Merci

[LittleWhite]

De mémoire, ce calcul de normal est dépendant de l'ordre des points du triangle. Cela veut dire que les deux triangles doivent avoir leur points allant dans le même sens (sens horaire, ou anti horaire). Ici, pour avoir ce genre de problème, vous devez avoir un triangle avec le sens horaire et un second triangle avec le sens anti horaire.
Pour confirmer cela, vous pouvez activer le backface culling (suppression des faces arrières) et vous verrez qu'il vous manque la moitié du plan.

[yann458]

De mémoire, ce calcul de normal est dépendant de l'ordre des points du triangle. Cela veut dire que les deux triangles doivent avoir leur points allant dans le même sens (sens horaire, ou anti horaire). Ici, pour avoir ce genre de problème, vous devez avoir un triangle avec le sens horaire et un second triangle avec le sens anti horaire.
Pour confirmer cela, vous pouvez activer le backface culling (suppression des faces arrières) et vous verrez qu'il vous manque la moitié du plan.

C'est bon , tous le mur est éclairer, mais pour le light (lumiére), je ne sais pas comment le corriger.

[dragonjoker59]

On peut voir le code du shader?

[Matt_Houston]

Ecris aussi un morceau de code pour afficher des vecteurs (en primitives GL_LINES). Il te sera très utile pour afficher tout ce qui est pivots, normales et autres. Tu verras immédiatement si les vecteurs ressemblent à ce qu'il sont sensés être plutôt que d'être témoin d'un résultat indirect (l'éclairage en l'occurrence).