Discussion :

[plegat]

Bonsoir,

Je viens vous présenter mes premiers articles en tant que rédacteur. Le sujet est la création de mon moteur graphique 3D, programmé en Java et utilisant JOGL. Celui-ci se veut "simple", donc ne vise pas à concurrencer les gros moteurs 3D (loin de moi cette prétention...). Par contre il se veut comme une introduction au monde OpenGL en Java. Ces articles sont donc plutôt orientés "débutants", et n'abordent pas le monde joyeux des VBO, shaders, et autres joyeusetés un peu techniques ! (plus tard, peut-être, mais déjà que j'ai mis trois ans pour sortir ces articles...)

Brève description des articles, et liens vers ceux-ci:

1e article: Introduction

Introduction, but de la série d'articles, où récupérer JOGL, la première fenêtre.

Lien: PGE (Plegat Graphic Engine) - Introduction


2e article: Définition des caméras et de leur manipulation

Définition des outils mathématiques (vecteur, matrice, quaternion)
Mise en place de la caméra, et interaction utilisateur avec celle-ci.

Lien: PGE (Plegat Graphic Engine) - Définition des caméras et de leur manipulation


3e article: Définition et affichage des objets

Description des objets qui seront affichés, définition des objets 3D, localisation et orientation, assemblage.

Lien: PGE (Plegat Graphic Engine) - Définition et affichage des objets



J'espère qu'ils seront utiles à ceux qui veulent se lancer dans la 3D en Java.

N'hésitez pas à me faire part de vos retours et de vos commentaires.


Au passage, j'en profite pour rappeler les liens vers deux articles de F. De Leo, qui datent un peu, mais qui méritent tout de même d'y jeter un oeil:
Les API 3D pour Java
Apprendre l'OpenGL avec Java : Introduction

Et pour finir, un grand merci à ceux qui ont participé à la création de ces articles de par leurs commentaires, leur assistance technique, ou leur relecture intransigeante !

[lio908]

J'essaie de faire un cube avec un maillage
Un cube c'est 8 points, 6 faces

Donc

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
PGE_Node[] nodesLocal = new PGE_Node[8];
PGE_Quad[] elements = new PGE_Quad[6];
 
nodesLocal[0] = new PGE_Node("Pt 1", this, x, y, z);
nodesLocal[1] = new PGE_Node("Pt 2", this, this.largeur, y, z);
nodesLocal[2] = new PGE_Node("Pt 3", this, this.largeur, -this.largeur, z);
nodesLocal[3] = new PGE_Node("Pt 4", this, x, -this.largeur, z);
nodesLocal[4] = new PGE_Node("Pt 5", this, x, y, this.largeur);
nodesLocal[5] = new PGE_Node("Pt 6", this, this.largeur, y, this.largeur);
nodesLocal[6] = new PGE_Node("Pt 7", this, this.largeur, -this.largeur, this.largeur);
nodesLocal[7] = new PGE_Node("Pt 8", this, x, -this.largeur, this.largeur);
this.addNode(nodesLocal);

et pour mes 6 faces je fait

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
		int[] nd = new int[4];
		nd[0] = 0;
		nd[1] = 1;
		nd[2] = 2;
		nd[3] = 3;
		elements[0] = new PGE_Quad("Face 1", this, nd);
		elements[0].setParent(this);
		elements[0].setColor(this.color[0], this.color[1], this.color[2]);
		elements[0].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[0].setNodeNormal(0, elements[0].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));

ou je pensais calculer 1 vecteur normal par face mais apparement c'est 1 vecteur par point, car à l'élément [4} ça plante.
Je me trompe ou j'ai pas compris.
Comment on calcule le vecteur normal d'un point. Je me fixe la face comme carré et donc les 4 vecteurs sont identiques?

[plegat]

Désolé, mais "ça plante" c'est trop peu comme info pour pouvoir dire ce qu'il se passe de travers...
Surtout si ca plante sur l'élément 4, et que le code présenté est pour l'élément 0...

En ce qui concerne la normale, il s'agit effectivement de la normale au noeud. Rien d'extraordinaire là-dedans, ça peut être là normale de la face (pour un rendu facettisé) ou une normale moyennée sur les faces adjacentes (pour un rendu laissé), ou autre chose.

[lio908]

Bonsoir, après test, j'ai trouvé pourquoi ça plante...
Évidement, pour mes 6 faces des mon cube, de 0 à 5 cela plantait à 4 car la fonction

Code :

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

1
2
 
		elements[4].setNodeNormal(0, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));

renseigne le vecteur normal, index 4, qui n'existe pas, car sur un Quad avec 4 nodes, je crée 4 vecteurs normaux, avec le constructeur de Face, donc de 0 à 3.

Donc, pour un Quad, qui représente un carré dans mon Cube, j'ai 4 node,et si je crée 4 vecteurnormaux avec

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
		nd[0] = Pt1;
		nd[1] = Pt4;
		nd[2] = Pt8;
		nd[3] = Pt5;
		elements[4] = new PGE_Quad("Face 5", this, nd);
		elements[4].setParent(this);
		elements[4].setColor(this.color[0], this.color[1], this.color[2]);
		elements[4].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[4].setNodeNormal(0, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[4].setNodeNormal(1, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[4].setNodeNormal(2, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[4].setNodeNormal(3, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));

ça plante plus.

Pour autant je n'ai qu'une face qui se dessine sur les 6

Dans le main principal

Code :

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

1
2
3
4
5
6
7
8
 
		//UN CUBE
		PGE_Cubem Cube_1= new PGE_Cubem(null,1);
		Cube_1.setId("CUBE_1");
		Cube_1.setPositionActuelle(P3D.POS_INIT(0, 0, 0));
		Cube_1.setColor(Color.green);
		Cube_1.setColorDiffuse(Color.yellow);
		Cube_1.initMesh();//Reconstruit avec les couleurs

Classe Cubem

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
package object;
 
import java.awt.Color;
 
import mesh.PGE_Maillage;
import mesh.PGE_Node;
import mesh.PGE_Quad;
 
public class PGE_Cubem extends PGE_Maillage {
 
	private double largeur;
 
	public PGE_Cubem(IPGE_Object parent, double size) {
		this.largeur = size;
		this.initColor();
		this.initMesh();
	}
 
	/**
         * Initialisation des couleurs d'affichage en mode "fil de fer" et "solide"
         */
	private void initColor() {
		this.setColor(Color.WHITE);
		this.setColorDiffuse(Color.white);
	}
 
	public void initMesh() {
 
		// UN CUBE c'est 8 pts
		// Le cube est composé de 6 faces avec 6 vecteurs Normaux et 6 nodes
		// contenant chacun un quad
 
		// 6 faces
		PGE_Node[] nodesLocal = new PGE_Node[8];
		PGE_Quad[] elements = new PGE_Quad[6];
 
		// Definition des 6 nodes, cad les 8 faces avec leur position x,y,z
		double x = this.getPositionActuelle().getX();
		double y = this.getPositionActuelle().getY();
		double z = this.getPositionActuelle().getZ();
		x = 0;
		y = 0;
		z = 0;
 
		nodesLocal[0] = new PGE_Node("Pt 1", this, x, y, z);
		nodesLocal[1] = new PGE_Node("Pt 2", this, this.largeur, y, z);
		nodesLocal[2] = new PGE_Node("Pt 3", this, this.largeur, -this.largeur, z);
		nodesLocal[3] = new PGE_Node("Pt 4", this, x, -this.largeur, z);
 
		nodesLocal[4] = new PGE_Node("Pt 5", this, x, y, this.largeur);
		nodesLocal[5] = new PGE_Node("Pt 6", this, this.largeur, y, this.largeur);
		nodesLocal[6] = new PGE_Node("Pt 7", this, this.largeur, -this.largeur, this.largeur);
		nodesLocal[7] = new PGE_Node("Pt 8", this, x, -this.largeur, this.largeur);
		this.addNode(nodesLocal);
 
		int Pt1 = 0;
		int Pt2 = 1;
		int Pt3 = 2;
		int Pt4 = 3;
		int Pt5 = 4;
		int Pt6 = 5;
		int Pt7 = 6;
		int Pt8 = 7;
 
		int[] nd = new int[4];
		nd[0] = Pt1;
		nd[1] = Pt2;
		nd[2] = Pt3;
		nd[3] = Pt4;
		elements[0] = new PGE_Quad("Face 1", this, nd);
		elements[0].setParent(this);
		elements[0].setColor(this.color[0], this.color[1], this.color[2]);
		elements[0].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[0].setNodeNormal(0, elements[0].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[0].setNodeNormal(1, elements[0].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[0].setNodeNormal(2, elements[0].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[0].setNodeNormal(3, elements[0].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
 
		nd[0] = Pt1;
		nd[1] = Pt2;
		nd[2] = Pt6;
		nd[3] = Pt5;
		elements[1] = new PGE_Quad("Face 2", this, nd);
		elements[1].setParent(this);
		elements[1].setColor(this.color[0], this.color[1], this.color[2]);
		elements[1].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[1].setNodeNormal(0, elements[1].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[1].setNodeNormal(1, elements[1].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[1].setNodeNormal(2, elements[1].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[1].setNodeNormal(3, elements[1].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
 
		nd[0] = Pt2;
		nd[1] = Pt3;
		nd[2] = Pt7;
		nd[3] = Pt6;
		elements[2] = new PGE_Quad("Face 3", this, nd);
		elements[2].setParent(this);
		elements[2].setColor(this.color[0], this.color[1], this.color[2]);
		elements[2].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[2].setNodeNormal(0, elements[2].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[2].setNodeNormal(1, elements[2].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[2].setNodeNormal(2, elements[2].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[2].setNodeNormal(3, elements[2].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
 
		nd[0] = Pt3;
		nd[1] = Pt7;
		nd[2] = Pt8;
		nd[3] = Pt4;
		elements[3] = new PGE_Quad("Face 4", this, nd);
		elements[3].setParent(this);
		elements[3].setColor(this.color[0], this.color[1], this.color[2]);
		elements[3].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[3].setNodeNormal(0, elements[3].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[3].setNodeNormal(1, elements[3].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[3].setNodeNormal(2, elements[3].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[3].setNodeNormal(3, elements[3].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
 
		nd[0] = Pt1;
		nd[1] = Pt4;
		nd[2] = Pt8;
		nd[3] = Pt5;
		elements[4] = new PGE_Quad("Face 5", this, nd);
		elements[4].setParent(this);
		elements[4].setColor(this.color[0], this.color[1], this.color[2]);
		elements[4].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[4].setNodeNormal(0, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[4].setNodeNormal(1, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[4].setNodeNormal(2, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[4].setNodeNormal(3, elements[4].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
 
		nd[0] = Pt5;
		nd[1] = Pt6;
		nd[2] = Pt7;
		nd[3] = Pt8;
		elements[5] = new PGE_Quad("Face 6", this, nd);
		elements[5].setParent(this);
		elements[5].setColor(this.color[0], this.color[1], this.color[2]);
		elements[5].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		elements[5].setNodeNormal(0, elements[5].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[5].setNodeNormal(1, elements[5].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[5].setNodeNormal(2, elements[5].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
		elements[5].setNodeNormal(3, elements[5].GetNormale(nodesLocal[nd[0]], nodesLocal[nd[1]], nodesLocal[nd[2]]));
 
		this.addObject(elements);
 
	}
 
}

et j'ai ajouté le GetNormale dans la classe PGE_Quad

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
 
public Vector_3d GetNormale(PGE_Node n1, PGE_Node n2, PGE_Node n3) {
		double x1, y1, z1;
		double x2, y2, z2;
		double x3, y3, z3;
		x1 = n1.getX();
		y1 = n1.getY();
		z1 = n1.getZ();
		x2 = n2.getX();
		y2 = n2.getY();
		z2 = n2.getZ();
		x3 = n3.getX();
		y3 = n3.getY();
		z3 = n3.getZ();
		double x = 0, y = 0, z = 0;
		x = (y2 - y1) * (z3 - z1) - (z2 - z1) * (y3 - y1);
		y = (z2 - z1) * (x3 - x1) - (x2 - x1) * (z3 - z1);
		z = (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1);
		double norm = Math.sqrt(x * x + y * y + z * z);
		double X = (x / norm), Y = (y / norm), Z = (z / norm);
 
		return new Vector_3d(X,Y,Z);
	}

Si vous pourriez jeter un œil...
Merci d'avance

[plegat]

Pour autant je n'ai qu'une face qui se dessine sur les 6

Toutes tes faces référencent le même tableau d'indice de noeud, nd (même si tu modifies son contenu à chaque face)... donc normalement elles y sont toutes les 6, mais toutes dessinées avec les noeuds de la sixième face! (à la normale près...)

Regarde le code de la classe PGETorus, le tableau nd est déclaré à chaque boucle, donc à chaque élément, ce qui fait que chaque face pointe certes vers une variable qui porte le même nom, mais pas vers le même objet/emplacement mémoire.

Le plus simple pour un cube serait d'utiliser un tableau nd[6][4], et de faire passer nd[i] pour la face n°i.

[lio908]

Bonjour
Effectivement, j'ai remis ça comme il faut je pense.
Dans Cunem,
Je crée 8 PGE_Node

Code :

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

1
2
3
4
5
6
7
8
9
10
 
		N[0] = new PGE_Node("Pt 0", this, x, y, z);
		N[1] = new PGE_Node("Pt 1", this, this.largeur, y, z);
		N[2] = new PGE_Node("Pt 2", this, this.largeur, this.largeur, z);
		N[3] = new PGE_Node("Pt 3", this, x, this.largeur, z);
 
		N[4] = new PGE_Node("Pt 4", this, x, this.largeur, this.largeur);
		N[5] = new PGE_Node("Pt 5", this, x, y, this.largeur);
		N[6] = new PGE_Node("Pt 6", this, this.largeur, y, this.largeur);
		N[7] = new PGE_Node("Pt 7", this, this.largeur, this.largeur, this.largeur);

Puis 24 vecteurs Normaux

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
 
// face 0, du dessous, plan XY, vude de Z-
		//pt 0123
		normal[0] = this.GetNormale(N[0], N[1], N[2]);
		normal[1] = this.GetNormale(N[1], N[2], N[3]);
		normal[2] = this.GetNormale(N[2], N[3], N[0]);
		normal[3] = this.GetNormale(N[3], N[0], N[1]);
 
		// Face 2, plan YZ, vue de Y+
		// pt 3274
		normal[4] = this.GetNormale(N[3], N[2], N[7]);
		normal[5] = this.GetNormale(N[2], N[7], N[4]);
		normal[6] = this.GetNormale(N[7], N[4], N[3]);
		normal[7] = this.GetNormale(N[4], N[3], N[2]);
 
		// Face 3,plan YZ vue de X+
		// pt 1276
		normal[8] = this.GetNormale(N[1], N[2], N[7]);
		normal[9] = this.GetNormale(N[2], N[7], N[6]);
		normal[10] = this.GetNormale(N[7], N[6], N[1]);
		normal[11] = this.GetNormale(N[6], N[1], N[2]);
 
		// Face 4, plan XZ, vue de Y-
		// pt 1650
		normal[12] = this.GetNormale(N[1], N[6], N[5]);
		normal[13] = this.GetNormale(N[6], N[5], N[0]);
		normal[14] = this.GetNormale(N[5], N[0], N[1]);
		normal[15] = this.GetNormale(N[0], N[1], N[6]);
 
		// Face 5, plan YZ, vue de W-
		// pt 0345
		normal[16] = this.GetNormale(N[0], N[3], N[4]);
		normal[17] = this.GetNormale(N[3], N[4], N[5]);
		normal[18] = this.GetNormale(N[4], N[5], N[0]);
		normal[19] = this.GetNormale(N[5], N[0], N[3]);
 
		// Face 6, vu de dessus, plan XY vue de Z+
		//pt 5674
		normal[20] = this.GetNormale(N[5], N[6], N[7]);
		normal[21] = this.GetNormale(N[6], N[7], N[4]);
		normal[22] = this.GetNormale(N[7], N[4], N[5]);
		normal[23] = this.GetNormale(N[4], N[5], N[6]);

et pour les faces, je fais cela

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
		int[] nd = new int[4];
		nd[0] = Pt0;
		nd[1] = Pt1;
		nd[2] = Pt2;
		nd[3] = Pt3;
 
		F[0] = new PGE_Quad("Face CUBE du dessous", this, nd);
		F[0].setParent(this);
		F[0].setColor(this.color[0], this.color[1], this.color[2]);
		F[0].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		int i = 0;
		for (i = 0; i < 4; i++) {
			F[0].setNodeNormal(i, normal[i]);//0 1 2 3
		}
 
		nd[0] = Pt3;
		nd[1] = Pt2;
		nd[2] = Pt7;
		nd[3] = Pt4;
		F[1] = new PGE_Quad("Face CUBE 2", this, nd);
		F[1].setParent(this);
		F[1].setColor(this.color[0], this.color[1], this.color[2]);
		F[1].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		for (i = 0; i < 4; i++) {
			F[1].setNodeNormal(i, normal[4 + i]);//4 5 6 7
		}
 
		nd[0] = Pt1;
		nd[1] = Pt2;
		nd[2] = Pt7;
		nd[3] = Pt6;
		F[2] = new PGE_Quad("Face CUBE 3", this, nd);//
		F[2].setParent(this);
		F[2].setColor(this.color[0], this.color[1], this.color[2]);
		F[2].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		for (i = 0; i < 4; i++) {
			F[2].setNodeNormal(i, normal[8 + i]);//8 9 10 11
		}
 
		nd[0] = Pt1;
		nd[1] = Pt6;
		nd[2] = Pt5;
		nd[3] = Pt0;
		F[3] = new PGE_Quad("Face CUBE 4", this, nd);
		F[3].setParent(this);
		F[3].setColor(this.color[0], this.color[1], this.color[2]);
		F[3].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		for (i = 0; i < 4; i++) {
			F[3].setNodeNormal(i, normal[12 + i]);// 12 13 14 15
		}
 
		nd[0] = Pt0;
		nd[1] = Pt3;
		nd[2] = Pt4;
		nd[3] = Pt5;
		F[4] = new PGE_Quad("Face CUBE 5", this, nd);
		F[4].setParent(this);
		F[4].setColor(this.color[0], this.color[1], this.color[2]);
		F[4].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		for (i = 0; i < 4; i++) {
			F[4].setNodeNormal(i, normal[16 + i]);//16 17 18 19
		}
 
		nd[0] = Pt5;
		nd[1] = Pt6;
		nd[2] = Pt7;
		nd[3] = Pt4;
		F[5] = new PGE_Quad("Face CUBE 6 du dessus", this, nd);
		F[5].setParent(this);
		F[5].setColor(this.color[0], this.color[1], this.color[2]);
		F[5].setColorDiffuse(this.color_DIFFUSE[0], this.color_DIFFUSE[1], this.color_DIFFUSE[2]);
		for (i = 0; i < 4; i++) {
			F[5].setNodeNormal(i, normal[20 + i]);//20 21 22 23
		}

Quand je fait des test sur les Quad qui sont crée, les nodes affecté dand le int[] sont OK

Code :

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

1
2
3
4
5
6
7
8
9
 
	public PGE_Quad(String id, IPGE_Object parent, int[] nodes) {
		super(id, parent, nodes);
		System.out.println("Quad " + id);
		System.out.println("Nodes du Quad  " + nodes[0]);
		System.out.println("Nodes du Quad  " + nodes[1]);
		System.out.println("Nodes du Quad  " + nodes[2]);
		System.out.println("Nodes du Quad  " + nodes[3]);
	}

qui me donne
Quad Face CUBE du dessous
Nodes du Quad 0
Nodes du Quad 1
Nodes du Quad 2
Nodes du Quad 3

pour la première FACE
et
Quad Face CUBE 2
Nodes du Quad 3
Nodes du Quad 2
Nodes du Quad 7
Nodes du Quad 4

pour la Face 2, etc

Les vecteurs normaux sont différents.
Tout le monde a bien ces petit.

Mais dés que je regarde en mode debug ici

Code :

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

1
2
 
this.addObject(F);

les Quad ont le bon id mais tj les Nodes 5,6,7 et 4!

Comprend pas, pour id c'est OK, pour les nodes donc int [] de 4 élements, à la création ils ont OK, quand j'envoie avec le addObjct(F), ils ont changé de valeur.

Merci d'avance.

[plegat]

Comprend pas, pour id c'est OK, pour les nodes donc int [] de 4 élements, à la création ils ont OK, quand j'envoie avec le addObjct(F), ils ont changé de valeur.

Tu n'as rien modifié à ta façon de définir tes faces, donc le message n'est pas passé...

Je vais ré-expliquer en imageant...

Ce que tu fais actuellement, c'est de définir des faces en leur disant d'aller chercher les noeuds dans le tableau nd.
Que ce soit la première, ou la dernière, elle va chercher ses noeuds dans le tableau nd. Un seul et unique tableau nd.

C'est comme si le matin, tu allais chercher tes chaussettes dans le premier tiroir du dressing.
Le dimanche, tu choisis ce que tu vas mettre pour la semaine qui arrive:

• le lundi, ça sera les bleues, donc tu mets les bleues dans le tiroir.
• le mardi, ça sera les rouges, donc tu vires les bleues, et tu mets les rouges à la place.
• le mercredi, ça sera les vertes, tu vires les rouges, et tu mets les vertes dans le tiroir.
• le jeudi, ça sera les orange, tu vires les vertes, et tu mets les oranges dans le tiroir.
• le vendredi, ça sera les roses, tu vires les oranges, et tu mets les roses dans le tiroir.
• le samedi, c'est repos, donc tongs, pas de chaussettes!

Tu arrives au lundi, tu vas pour prendre tes chaussettes bleues, et manque de bol... elles ne sont pas bleues dans le tiroir, elles sont roses!

C'est quoi la solution?
Soit tu fais 5 compartiments dans ton tiroir, et tu affectes chaque compartiment à un jour de la semaine...
Soit tu utilises 5 tiroirs.

Pour tes faces, c'est la même chose.
Là, tu ne déclares qu'un seul et unique tableau nd.
Soit tu fais un tableau à deux dimensions...
Soit tu déclares un nouveau tableau pour chaque face...
Ou soit tu modifies la classe PGEQuad pour qu'elle se fasse une copie des valeurs des noeuds, et non pas qu'elle garde la référence sur le tableau de noeud.

Penche-toi sur le passage d'arguments dans les appels de méthode en Java.
Java utilise du passage de référence par valeur, c'est-à-dire que quand tu appelles:

Code :

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

1
2
new PGEQuad("Face CUBE 1", this, nd);

nd n'est pas passé directement, mais c'est sa référence qui est passé (par valeur, histoire de compliquer...).
Du coup dans la classe PGEQuad (ou plutôt PGEFace), l'objet this.nodes a la même référence que ton tableau nd.
Et pareil pour tous tes appels au constructeur de PGEQuad tels que tu les fais.
Tes six faces vont pointer vers l'unique référence que tu as défini pour ton unique tableau nd... qui donc contient les 4 derniers points que tu y as mis.

Si vraiment tu n'y arrives pas, écrit un nouveau constructeur pour PGEQuad, où tu passes les quatres noeuds en arguments, avec création et affectation du tableau this.nodes à partir de ces quatre points.

[lio908]

Bonjour et merci, effectivement ça marche mieux.
j'ai crée un nd pour chaque chaque face.

Maintenant j'ai un autre pb,
Entre file de fer et solid

si je mets
gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE);
j'ai pas d'affichage fil de fer, tout semble ecrasédans un même plan

si je met
gl.glColorMaterial(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE);
la permutation file de fer/solid marche trés bien avec la teapot.

mais tjs pas avec torus ou cube (car je présume q'avec mon cube je devrais voir que les cotés)

[plegat]

Désolé, mais c'est impossible de répondre avec si peu d'information...