Discussion :

[LastSpear]

Bonjours à tous

Je suis nouveau sur le forum parce que je suis tout simplement nouveau dans le développement de jeux video ( perspicace le petit me diriez vous )

Pour ma part, j'ai choisi de développer un jeux de sous-marins, seulement, les belle rondeur de ceux ci gâché par des polygones, c'est dommage. je suis donc sur le développement d'une fonction intituler addSubSurf qui en faite calcule les vecteur normaux au point, connaissant ceux des faces. Seulement, mon souci et des lors la compilation, je me retrouve avec un sous-marin tout noir. tandis que lorsque cet fonction n'est pas appelé sur mon corps de sous-marin, j'ai belle est bien les lumière qui fonctionne dessus, mais toujours avec le souci des polygone bien entendu.

Je vous explique mon système ...

tout d'abord, je charge tout les objets contenu dans un fichier .3ds. Les calculs des normals au faces y sont notamment inclue.
mesh[0].load3DS ("models/sousMarinCorps.3ds");

Voici l'appel de la fonction qui devrai calculé tout les vecteur normaux pour chaque point. l'argument 0 signifie que j'applique cet fonction que sur l'objet n°0 contenu dans mon fichier 3DS à savoir : le corps de mon sous-marin.
mesh[0].addSubSurf (0) ;

Enfin, je compile une display liste pour optimisé le CPU lors des rendu des frams
mesh[0].compileDisplayListe(0);

Dans ma fonction charger de dessiné mes frams, je n'est plus qu'a :
mesh[0].draw (0);
pour dessiner mon corps de sous-marin.

Intéressons nous maintenant à la fonction addSubSurf dans ma class intitulée DS_OBJECT

Code :

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

1
2
3
4
 
void DS_OBJECT::addSubSurf (int MeshNum)
{
	obj_vertex allVertices[2000] ;

C'est un tableau permettant de stocké les float de x, y, z de mes futur cordonné de normals pour chaque points : une structure appelé obj_vertex.

Code :

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

1
2
3
4
 
	int id, i, j ;
 
	for ( i = 0 ; i < mesh[MeshNum].polygons_qty; i++ )

mesh[MeshNum].polygons_qty me retourne le nombre de triangle dans l'objet de numero MeshNum.
Triangle ?! Oui, parce que les .3ds ne sont fait que de triangles, un avantage pour le calcul des normals.

Code :

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

1
2
3
4
 
	{
 
		id = mesh[MeshNum].polygon[i].a ;

Donc, on va chercher le numéro du point A du poligone I
Pourquoi pas directement ces cordonné ? parce que 2 face ayant un point en commun, seront 2 face qui auron un même id pour ce point, et avec l'id du point, il nous reste plus qu'a aller chercher les x, y ,z de ce point dans un autre tableau. Cela économise de la mémoire lorsque 1 point peut avoir entre 8 et 20 faces en commune.

Code :

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

1
2
3
4
 
		allVertices[id].x += mesh[MeshNum].normals[i].x ;
		allVertices[id].y += mesh[MeshNum].normals[i].y ;
		allVertices[id].z += mesh[MeshNum].normals[i].z ;

et on ajout les composante à mon tableau de cordonné de normals par point. Qui di triangle, di 3 point, donc on fait exactement pareil pour les point B et C

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
		id = mesh[MeshNum].polygon[i].b ;
		allVertices[id].x += mesh[MeshNum].normals[i].x ;
		allVertices[id].y += mesh[MeshNum].normals[i].y ;
		allVertices[id].z += mesh[MeshNum].normals[i].z ;
 
		id = mesh[MeshNum].polygon[i].c ;
		allVertices[id].x += mesh[MeshNum].normals[i].x ;
		allVertices[id].y += mesh[MeshNum].normals[i].y ;
		allVertices[id].z += mesh[MeshNum].normals[i].z ;
	}

Enfin, une convention veux que les vecteur normals soit de normes 1.0f. donc pour tout les vertex de mon objet (mesh[MeshNum].vertices_qty) on fait un petit pythagore dans les 3 dimensions pour obtenir la norme, puis on divise les 3 composant x,y,z par la norme obtenu à fin d'avoir une norme de 1 ( le principe de a/a = 1 )

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
	for ( i = 0 ; i <= mesh[MeshNum].vertices_qty ; i++ ) 
	{
		float norme = sqrt ( (allVertices[i].x*allVertices[i].x) + (allVertices[i].y*allVertices[i].y) + (allVertices[i].z*allVertices[i].z)); 
		if ( norme > 0 ) { 
			norme = 1 /norme; 
			mesh[MeshNum].SubSurf[i].x *= norme; 
			mesh[MeshNum].SubSurf[i].y *= norme;
			mesh[MeshNum].SubSurf[i].z *= norme;
		}
 
	}

pour finir, il faut prevenir la fonction compileDisplayListe que l'objet à 1 normals par point.

Code :

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

1
2
3
 
	mesh[MeshNum].SubSurfActived = true ;
}

compileDisplayListe se contentera de précisé chaque normals contenu mesh[MeshNum].SubSurf pour chaque point de mon objet.

je praicise que j'ai bien mi glShadeModel(GL_SMOOTH); à l'initialisation d'openGL.

En l'espérance d'une réponse, je vous remercie de votre attention ainsi qu'a votre aide éventuel.

[Djakisback]

Salut,
je ne comprends pas comment tu calcules ta normale au sommet ? Normalement tu fais la moyenne des normales des faces adjacentes non ?
Ce qui te donne pour un point ayant 2 faces adjacentes :

Code :

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

Ns0 = ((Nf0 + Nf1) / 2) x (1 / ||(Nf0 + Nf1) / 2||)

Ns0 la normale au sommet 0
Nf0, Nf1 les normales des 2 faces adjacentes au sommet 0

or tu fais juste des additions ?

Code :

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

1
2
3
allVertices[id].x += mesh[MeshNum].normals[i].x ;
allVertices[id].y += mesh[MeshNum].normals[i].y ;
allVertices[id].z += mesh[MeshNum].normals[i].z ;

Tu peux aussi vérifier que tes normales pointent bien vers l'extérieur de ton objet et non vers l'intérieur.
Tu peux aussi les tracer, ça aide pour le debug.

[LastSpear]

Bonjours Djakisback

Tout d'abord, je vous remercie énormément de votre aide et me presse de vous répondre ci dessous.

Salut,
je ne comprends pas comment tu calcules ta normale au sommet ? Normalement tu fais la moyenne des normales des faces adjacentes non ?
Ce qui te donne pour un point ayant 2 faces adjacentes :

Code :

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

Ns0 = ((Nf0 + Nf1) / 2) x (1 / ||(Nf0 + Nf1) / 2||)

je fais une addition classique comme une moyenne, cependant, au lieu de devisé par le nombre de d'addition, je me content directement de remettre mon vecteur normal à une norme de 1 dans les 3 dimensions (d'ou le calcul avec pythagore sur les x, y et z). Je viens à l'instants d'essayer les moyennes par votre façon, seulement, elle ne fonctionne pas non plus. mon sous-marin est encore tout noir.

Pour ce qui est de la direction, je doute quelle puisse être vers l'intérieur, car lorsque cet fonction n'est pas appelé sur un mesh, les faces sont correctement éclairé. Néanmoin, il est tout de même possible que je me soit planté sur un detail.

comment puis - je tracé les vecteur normaux ?

UPDATE : j'ai enfin trouvé mon souci, c'est juste une faute d'inatention de part.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
for ( i = 0 ; i <= mesh[MeshNum].vertices_qty ; i++ ) 
	{
		float norme = sqrt ( (allVertices[i].x*allVertices[i].x) + (allVertices[i].y*allVertices[i].y) + (allVertices[i].z*allVertices[i].z)); 
		if ( norme > 0 ) { 
			norme = 1 /norme; 
			mesh[MeshNum].SubSurf[i].x *= norme; 
			mesh[MeshNum].SubSurf[i].y *= norme;
			mesh[MeshNum].SubSurf[i].z *= norme;
		}
 
	}

j'avais tout simplement oublier d'ajouté les coordonnés des vecteur dans ma structure "mesh[MeshNum].SubSurf[i]" pour que ma fonction d'affichage puisse les appliquer. Ce qui donne donc :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
for ( i = 0 ; i <= mesh[MeshNum].vertices_qty ; i++ ) 
	{
		float norme = sqrt ( (allVertices[i].x*allVertices[i].x) + (allVertices[i].y*allVertices[i].y) + (allVertices[i].z*allVertices[i].z)); 
		if ( norme > 0 ) { 
			norme = 1 /norme; 
			mesh[MeshNum].SubSurf[i].x = allVertices[i].x * norme; 
			mesh[MeshNum].SubSurf[i].y = allVertices[i].y * norme;
			mesh[MeshNum].SubSurf[i].z = allVertices[i].z * norme;
		}
 
	}