+ Répondre à la discussion Actualité déjà publiée
  1. #1
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 471
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 471
    Points : 6 241
    Points
    6 241

    Par défaut PGE, moteur graphique "simple" en Java/JOGL, articles/tutos

    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 !
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  2. #2
    Membre régulier
    Homme Profil pro
    Automaticien
    Inscrit en
    décembre 2008
    Messages
    146
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Automaticien
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 146
    Points : 73
    Points
    73

    Par défaut Torus et vecteur normal

    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?

  3. #3
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 471
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 471
    Points : 6 241
    Points
    6 241

    Par défaut

    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.
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  4. #4
    Membre régulier
    Homme Profil pro
    Automaticien
    Inscrit en
    décembre 2008
    Messages
    146
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Automaticien
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 146
    Points : 73
    Points
    73

    Par défaut

    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

  5. #5
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 471
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 471
    Points : 6 241
    Points
    6 241

    Par défaut

    Citation Envoyé par lio908 Voir le message
    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.
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  6. #6
    Membre régulier
    Homme Profil pro
    Automaticien
    Inscrit en
    décembre 2008
    Messages
    146
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Automaticien
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 146
    Points : 73
    Points
    73

    Par défaut

    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.

  7. #7
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 471
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 471
    Points : 6 241
    Points
    6 241

    Par défaut

    Citation Envoyé par lio908 Voir le message
    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.
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  8. #8
    Membre régulier
    Homme Profil pro
    Automaticien
    Inscrit en
    décembre 2008
    Messages
    146
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Automaticien
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2008
    Messages : 146
    Points : 73
    Points
    73

    Par défaut

    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)

  9. #9
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 471
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 471
    Points : 6 241
    Points
    6 241

    Par défaut

    Désolé, mais c'est impossible de répondre avec si peu d'information...
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

Discussions similaires

  1. Difference entre [Simple quote] & [Double quote]
    Par Invité dans le forum SQL
    Réponses: 3
    Dernier message: 24/07/2013, 12h24

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo