Discussion :

[venomelektro]

Bonjour,

je suis en train de m interesser au normal mapping et en regardant des sources sur le net j ai trouvé souvent deux vecteurs definit pour chaque vertex :

Code :

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

1
2
3
 
 
Vector3 sTangent, tTangent;

qui pourrait m expliquer a quoi il correpondent et comment les calculer (je dispose deja des normales par vertex)

merci

[Steki-kun]

vu leurs noms et sans même savoir de quoi ca parle, j'imagine que ce sont deux vecteurs qui définissent le plan tangent à la surface considérée au point considéré ; en particulier la normale est perpendiculaire à ce plan.

pr les calculer, ca se fait par différenciation entre la normale au point considéré et celles aux points auxquels il est connecté.
bon en vrai, il n'a pas de réelle existence mathématique ce plan, pas plus que la soi-disant "normale" qu'on calcule en chaque point mais ca marche bien, à part dans les 'coins', si ton point est au milieu d'une seule arête par exemple.

[sebh]

En fait, c'est deux vecteur sont plus connu sous le non de tangente et binormal qui complète la normal du triangle pour former une base représentant le repere des normals dans la texture de normal pour le dot3.
En effet, le normal de la texture sont très très souvent exprimer dans le repere de la surface et non dans le repere globale : tu doit donc transformer ta lumière dans ce repere pour pourvoir faire des calcul de dot3 qui te donneront le résultat que tu attend(éclairage dans le bon sens).

Le calcul de ces deux vecteur n'est pas très compliqué(j'y avait presque réussit tout seul : il me manquait juste un produit vectoriel pour orienté correctement les vecteur). Je ne sais plus ou on peut trouvé ce calcul.(cherche avec google). En tout cas, tu a besoin des inforamation des 3 vertex du triangle de ton triangle et des coordonnée de texture des 3 vertex de ton triangle. De plus, les coordonnée de texture ne doivent pas être egal ou égal 2 à 2 pour deux vertex d'un même triangle sinon, tu va avoir des vecteur infinie(division par 0 avec ds ou dt).

En espérant que sa t'a aidé....

NB : si tu trouve pas je pourrait te passé le calcul...

[Bourriko]

Salut,

Je te conseille ceci (en anglais) :

http://www.paulsprojects.net/tutoria...implebump.html

http://www.terathon.com/code/tangent.html.
Le livre "Mathematics for 3D Game Programming & Computer Graphics" du même auteur est excellent !

[Steki-kun]

celui ci est excellent aussi, même s'il commence à dater. l'auteur est une référence internationale dans ce domaine (et il est français !!)

http://www.amazon.com/exec/obidos/tg/detail/-/0262061589/103-3070270-1977461?v=glance

[venomelektro]

merci a tous pour vos réponses


je jette un oeil a tout ca ce soir et vous tien au courant si je galere

a+

[venomelektro]

Salut,

Je te conseille ceci (en anglais) :

http://www.paulsprojects.net/tutoria...implebump.html

http://www.terathon.com/code/tangent.html.
Le livre "Mathematics for 3D Game Programming & Computer Graphics" du même auteur est excellent !

Vu le resultat mediocre que j obtiens j ai du faire une connerie dans le calcul des stangent et ttangent

donc sebh si tu passes par la je veux bien voir ton code

je me suis basé sur le code de paul project pour ce qui est init d extension et rendu et j ai adapté le code de terathon pour le calcul des stangent et ttangent et j ai du faire une connerie a ce niveau...

les données dans mon format de modele sont stockés dans trois tableaux de float vertex_data,text_data,et norm_data a la base

et je construit a partir de ca une struct qui contient position,normal , s,t, stan,ttan et tangentSpaceLight( ?)

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
 
		data = new VMR_VERTEX[numVertices];
 
		Vector3 *tan1 = new Vector3[numVertices * 2];
		Vector3 *tan2 = tan1 + numVertices;
 
	    for (int i=0,j=0,k=0; i < Size_Vertex,j<Size_Texture ; i+=9,j+=6)	
 
	        {
 
					data[k  ].position =  &vertex_data[i];
					data[k  ].normal   =  &norm_data[i];
					data[k  ].s        =  text_data[j];
					data[k  ].t        =  text_data[j+1];
 
					data[k+1].position =  &vertex_data[i+3];
					data[k+1].normal   =  &norm_data[i+3];
					data[k+1].s        =  text_data[j+2];
					data[k+1].t        =  text_data[j+3];
 
					data[k+2].position =  &vertex_data[i+6];
					data[k+2].normal   =  &norm_data[i+6];
					data[k+2].s        =  text_data[j+4];
					data[k+2].t        =  text_data[j+5];
 
					Vector3 v1,v2,v3;
					Vector2 w1,w2,w3;
 
					v1 = data[k].position;
					v2 = data[k+1].position;
					v2 = data[k+2].position;
 
					w1 = Vector2(data[k].s     , data[k].t);
					w2 = Vector2(data[k+1].s   , data[k+1].t);
					w3 = Vector2(data[k+2].s   , data[k+2].t);
 
					float x1 = v2.x - v1.x;
					float x2 = v3.x - v1.x;
					float y1 = v2.y - v1.y;
					float y2 = v3.y - v1.y;
					float z1 = v2.z - v1.z;
					float z2 = v3.z - v1.z;
 
					float s1 = w2.x - w1.x;
					float s2 = w3.x - w1.x;
					float t1 = w2.y - w1.y;
					float t2 = w3.y - w1.y;
 
					float r = 1.0f / (s1 * t2 - s2 * t1);
 
					Vector3 sdir((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r,
							(t2 * z1 - t1 * z2) * r);
					Vector3 tdir((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r,
							(s1 * z2 - s2 * z1) * r);
 
					tan1[k  ] += sdir;
					tan1[k+1] += sdir;
					tan1[k+2] += sdir;
 
					tan2[k  ] += tdir;
					tan2[k+1] += tdir;
					tan2[k+2] += tdir;
 
					k = k + 3;
 
			}
 
 
			long count = numVertices;
 
			for (long a = 0; a < count; a++)
			{
				const Vector3 & n = data[a].normal; 
				const Vector3 & t = tan1[a];
 
				// Gram-Schmidt orthogonalize
 
				Vector3 tmp = t - n * (n.DotProduct(t) );
 
				data[a].sTangent = tmp.GetNormalized();
 
				// Calculate handedness
				data[a].tTangent = ((n.CrossProduct(t)).DotProduct(tan2[a]) < 0.0f) ? -1.0f : 1.0f;
			}
 
			delete[] tan1;

[sebh]

Donc, si j'y pense je t'amene sa demain sinon faudra attendre lundi(pas internet chez oim).

En attendant, Si tu peut poster un screen de ce que tu obtient sa serait bien. Affiche aussi tes normal,tangente et binormal pour voir s'il n'y en a pas qui sont a l'infinie.
question conne : A tu déjà simplement réussit à afficher un simple quad avec du dot3 dessus en essayant n'importe quel vecteur de lumière ?

[bafman]

j'atait deja tombé sur cet algo pour calculer la tengante et la binormale et apparament il est faux, j'avait des vecteurs qui s'inverssaient durant l'animation sans raisons...

[venomelektro]

http://schafik.free.fr/img/bump_vm.jpg


c pas evident sur une seule image mais y a aucun relief sur le perso , sur le torus de paul proect par contre tout est bon

pour le code d affichage j utilise le code de paul proj

et c le mm pour le torus et le mesh , sauf que pour le torus les stangent et tt sont bonnes .. et pas sur mon mesh

aussi par rapport a ce que dit bafman des fois les vecteurs (donc la texture) bougent d un coup et bizarrement

[Bourriko]

j'atait deja tombé sur cet algo pour calculer la tengante et la binormale et apparament il est faux, j'avait des vecteurs qui s'inverssaient durant l'animation sans raisons...

Le code de Eric lengyel (terathon) ?
Pour le moment c'est celui qui fait reference sur www.opengl.org.
Je l'ai adapté pour faire du dot3 bumpmapping avec fichiers ms3d (milkshape ) et j'ai jamais eu de problème.

[venomelektro]

j'atait deja tombé sur cet algo pour calculer la tengante et la binormale et apparament il est faux, j'avait des vecteurs qui s'inverssaient durant l'animation sans raisons...

Le code de Eric lengyel (terathon) ?
Pour le moment c'est celui qui fait reference sur www.opengl.org.
Je l'ai adapté pour faire du dot3 bumpmapping avec fichiers ms3d (milkshape ) et j'ai jamais eu de problème.

sans doute son code marche , mais le truc c de l adapter correctement

Code :

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

1
2
3
4
 
tan1[i1] += sdir;
tan1[i2] += sdir;
tan1[i3] += sdir;

deja si y a ca , c surement parce que sa geometrie est indexé dans son code, pas la mienne (le += sert a quoi sinon .? )

est ce cela qui fait que la rendu obtenu n est pas du tout correct ?

sinon a part ca j ai pas changé grand chose , a part convertir ces "Vector3D" en "Vector3"

puisque tu as adapté ce code sur des modeles milkshape peut etre tu pourras me dire si tu vois un connerie dans le code que j ai posté plus haut qui te saute aux yeux..

l erreur ne vient pas de mes données de position , tex, et normales en tout cas , l affichage a ce niveau est correct, c bien le calcul de stangent et ttangent qui est faux

[sebh]

a+=b équivaut à a = a + b.

Sinon se qui devait arriver arriva : j'ai oublier le code... Lundi j'y pense sur... vraiment désolé.... En attendant quelqu'un t'aura peut être fournit le bon code.

REM : Si tu utilise le même code pour les 2 models c'est bizarre que sa marche pour l'un et pas pour l'autre...

[damienlann]

a+=b équivaut à a = a + b.

pas certain...
au final oui, mais pour ce qui est du temps de calcul... ca reste a voir...
a mon avis a+=b est plus rapide car à la compilation 'a' est à la fois source et destination... on ajoute 'b' directementt dans la données 'a' alors que pour a=a+b on charge 'a' et 'b' dans des registre de données on les additione et on met le resultat dans a.

[Bourriko]

Désolé, j'utilise aussi des modèles indexés. Le += permets de prendre la contribution des tous les triangles autour du point.
Essaye sans le +=. Tu risques de perdre en "smoothing".

Attention, je ne suis pas un spécialiste opengl et encore moins des mathématiques .

[venomelektro]

a+=b équivaut à a = a + b.

lol , oui ca je le savais quand meme je suis quand meme pas nul a ce point

Sinon se qui devait arriver arriva : j'ai oublier le code... Lundi j'y pense sur... vraiment désolé.... En attendant quelqu'un t'aura peut être fournit le bon code.

Pas de souci la patience est une vertu et je suis pas super pressé

Merci d avance

REM : Si tu utilise le même code pour les 2 models c'est bizarre que sa marche pour l'un et pas pour l'autre...

non c pas le meme code c le meme code d affichage mais le torus est un objet calculé par une formule ( code de paul project) donc le calcul des stangent et ttangent ne s adapte pas a mon cas de mesh

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
for(int i=0; i<torusPrecision+1; i++)
	{
		vertices[i].position=Vector3(1.5f, 0.0f, 0.0f).GetRotatedZ(i*360.0f/torusPrecision)+
									Vector3(4.0f, 0.0f, 0.0f);
 
		vertices[i].s=0.0f;
		vertices[i].t=(float)i*4/torusPrecision;
 
		vertices[i].sTangent = Vector3(0.0f, 0.0f, -1.0f);
		vertices[i].tTangent=Vector3(0.0f, -1.0f, 0.0f).GetRotatedZ(i*360.0f/torusPrecision);
		vertices[i].normal=vertices[i].tTangent.
							CrossProduct(vertices[i].sTangent);
	}

Désolé, j'utilise aussi des modèles indexés. Le += permets de prendre la contribution des tous les triangles autour du point.
Essaye sans le +=. Tu risques de perdre en "smoothing".

yes , j avais bien compris ca , avec des index la boucle for risque de passer plusieurs fois sur le meme vertex d'ou le += , mais chez moi vu qu il y a pas d index un simple = ferais l affaire

mais j ai l impression qu il me manque plus qu un smooth ..

en fait j ai corrigé une petite erreur de ma part et j en suis la

http://schafik.free.fr/img/bump_vm2.jpg

en fait sur une face le modele est presque noir et l autre assez clair et l effet de bump n est pas du tout flagrant , contrairement au torus

:

[sebh]

Salut,

désolé pour le a+=b, je voualit pas te prendre pour un nul.

Sa m'a l'air d'assez bien marcher maintenant : tu est sur que ta normal map a bien des normal assez accentuer?

sinon, voici mon code pour calculer les TBN par triangle : ensuite, je fait la moyen équipondéré des TBN d'un vertex à partir des TBN de tout les triangle auquel il appartient. Sa marche pour tout les modeles qui on de bonne coordonnée de texture(tu a déjà du lire sa pour les TBN).

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
 
 
	//calcul de la tangente et binormal par triangle
	float v01x,v01y,v01z,v02x,v02y,v02z;
	float du01,dv01,du02,dv02;
	float st[2][2];
	float pq[2][3];
	float fx,fy,fz;
	for(i=0;i<nbTriangle;i++)
	{
		//calcul du vecteur allant du vertex 0 au vertex 1
		v01x = vertex[triangleIndex[i*3+1]*4  ] - vertex[triangleIndex[i*3+0]*4];
		v01y = vertex[triangleIndex[i*3+1]*4+1] - vertex[triangleIndex[i*3+0]*4+1];
		v01z = vertex[triangleIndex[i*3+1]*4+2] - vertex[triangleIndex[i*3+0]*4+2];
 
		//calcul du vecteur allant du vertex 0 au vertex 2
		v02x = vertex[triangleIndex[i*3+2]*4  ] - vertex[triangleIndex[i*3+0]*4];
		v02y = vertex[triangleIndex[i*3+2]*4+1] - vertex[triangleIndex[i*3+0]*4+1];
		v02z = vertex[triangleIndex[i*3+2]*4+2] - vertex[triangleIndex[i*3+0]*4+2];
 
		//calcul du vecteur des coordonnée de texture allant du vertex 0 au vertex 1
		du01 = texCoord[triangleIndex[i*3+1]*2  ] - texCoord[triangleIndex[i*3+0]*2  ];
		dv01 = texCoord[triangleIndex[i*3+1]*2+1] - texCoord[triangleIndex[i*3+0]*2+1];
 
		//calcul du vecteur des coordonnée de texture allant du vertex 0 au vertex 2
		du02 = texCoord[triangleIndex[i*3+2]*2  ] - texCoord[triangleIndex[i*3+0]*2  ];
		dv02 = texCoord[triangleIndex[i*3+2]*2+1] - texCoord[triangleIndex[i*3+0]*2+1];
 
		//calcul de 1/(u*v' - u'*v)
		float s = 1 / ((du01 * dv02) - (du02 * dv01));
 
		st[0][0] = dv02;
		st[0][1] = -dv01;
		st[1][0] = -du02;
		st[1][1] = du01;
 
		pq[0][0] = v01x;
		pq[0][1] = v01y;
		pq[0][2] = v01z;
		pq[1][0] = v02x;
		pq[1][1] = v02y;
		pq[1][2] = v02z;
 
		//la tangente, c'est l'ajout des deux edge en proportionellement à la longeur de uv qui leur corespondent
		fx = s * (st[0][0]*pq[0][0] + st[0][1]*pq[1][0]);
		fy = s * (st[0][0]*pq[0][1] + st[0][1]*pq[1][1]);
		fz = s * (st[0][0]*pq[0][2] + st[0][1]*pq[1][2]);
		l = sqrt(fx*fx + fy*fy + fz*fz);
		fx/=l;
		fy/=l;
		fz/=l;
		tangenteTris[triangleIndex[i*3+0]*3   ]  = fx;
		tangenteTris[triangleIndex[i*3+0]*3 +1]  = fy;
		tangenteTris[triangleIndex[i*3+0]*3 +2]  = fz;
		tangenteTris[triangleIndex[i*3+1]*3   ]  = fx;
		tangenteTris[triangleIndex[i*3+1]*3 +1]  = fy;
		tangenteTris[triangleIndex[i*3+1]*3 +2]  = fz;
		tangenteTris[triangleIndex[i*3+2]*3   ]  = fx;
		tangenteTris[triangleIndex[i*3+2]*3 +1]  = fy;
		tangenteTris[triangleIndex[i*3+2]*3 +2]  = fz;
 
		//idem que tangente...
		fx = s * (st[1][0]*pq[0][0] + st[1][1]*pq[1][0]);
		fy = s * (st[1][0]*pq[0][1] + st[1][1]*pq[1][1]);
		fz = s * (st[1][0]*pq[0][2] + st[1][1]*pq[1][2]);
		l = sqrt(fx*fx + fy*fy + fz*fz);
		fx/=l;
		fy/=l;
		fz/=l;
		binormalTris[triangleIndex[i*3]*3   ]  = fx;
		binormalTris[triangleIndex[i*3]*3 +1]  = fy;
		binormalTris[triangleIndex[i*3]*3 +2]  = fz;
		binormalTris[triangleIndex[i*3+1]*3   ]  = fx;
		binormalTris[triangleIndex[i*3+1]*3 +1]  = fy;
		binormalTris[triangleIndex[i*3+1]*3 +2]  = fz;
		binormalTris[triangleIndex[i*3+2]*3   ]  = fx;
		binormalTris[triangleIndex[i*3+2]*3 +1]  = fy;
		binormalTris[triangleIndex[i*3+2]*3 +2]  = fz;
	}

voilà. Chez moi sa marche super bien.

[venomelektro]

merci pour ce code , je vais etudier ca des ce soir