Discussion :

[Luch_le_chti]

Boujour, je débute en Java3D et programme un rubicube
j'aimerais pouvoir lancer une animation sur une partie la scene de mon Canvas3D à partir de ma méthode

rotate ( RotationEvent event)

qui ai appelé à chaque fois que mon algo du rubicube affectue une rotation

Pourriez-vos m'aider SVP, d'avance merci.

Voici donc ma classe ' RubiKubG3D '

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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 class RubiKubG3D
    extends Panel
    implements RotationListener {  // mon listener pour lancer une rotation
 
  RubiKub monRubicube;                    // mon rubicube 
 
  float taille = 0.26f;            // taille d'un mini-cube
  float espace = 0.03f;            // espace entre les mini-cubes 
                        // 14 mini-cube seront dessiner pour fomer le rubicube     
 
  RubiKubG3D(RubiKub monRubicube) {
    try {
      this.monRubicube = monRubicube;
      monRubicube.setListener(this);
      jbInit();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  public void rotate(RotationEvent e) { //code appel a chauqe fois
    try {                             // qu'il y a une rotation par monRubicube
      System.out.print(e.toString());
 
      switch (e.getRotation()) {
        case RotationEvent.ROTATION_A: {
 
          // parties encore à coder
 
        }
 
        case RotationEvent.ROTATION_P:
 
        case RotationEvent.ROTATION_G:
 
        case RotationEvent.ROTATION_D:
 
        case RotationEvent.ROTATION_B:
 
        case RotationEvent.ROTATION_H:
 
        case RotationEvent.ROTATION_A_prime:
 
        case RotationEvent.ROTATION_P_prime:
 
        case RotationEvent.ROTATION_G_prime:
 
        case RotationEvent.ROTATION_D_prime:
 
        case RotationEvent.ROTATION_B_prime:
 
        case RotationEvent.ROTATION_H_prime:
 
        case RotationEvent.ROTATION_A_carre:
 
        case RotationEvent.ROTATION_P_carre:
 
        case RotationEvent.ROTATION_G_carre:
 
        case RotationEvent.ROTATION_D_carre:
 
        case RotationEvent.ROTATION_B_carre:
 
        case RotationEvent.ROTATION_H_carre:
 
      }
    }
    catch (Exception exc) {
      exc.printStackTrace();
    }
  }
 
  private void jbInit() throws Exception {
    // Création d'un composant de classe Canvas3D permettant de visualiser une scène 3D
    Canvas3D canvas = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
    setLayout(new BorderLayout());
    add(canvas, BorderLayout.CENTER);
    // Création de la scène 3D à visualiser
    BranchGroup scene = createSceneGraph();
    // on les compile pour optimiser les calculs
    scene.compile();
    // Création d'un univers 3D rattaché au composant 3D
    SimpleUniverse universe = new SimpleUniverse(canvas);
    // Rattachement de la scène 3D à l'univers
    universe.addBranchGraph(scene);
    // Positionnement pour avoir une vue correcte sur la scène 3D
    // (permet de voir une scène 3D contenue dans un cube d'1 unité
    // de côté et centré sur le centre du repère).
    universe.getViewingPlatform().setNominalViewingTransform();
  }
 
  public BranchGroup createSceneGraph() {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup();
 
    // Création d'une rotation de PI / 6 autour de l'axe X
    // puis d'une rotation de -PI / 4 autour de l'axe Y
    Transform3D rotationCubeDepart = rotateCubePositionDepart();
    TransformGroup rotationXYAxisGroup = new TransformGroup(rotationCubeDepart);
 
    // Création du groupe de transformation sur lequel vont s'appliquer les
    // comportements de la souris
    TransformGroup mouseTransform = new TransformGroup();
    // Le groupe de transformation sera modifie par le comportement de la
    // souris
    mouseTransform.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
    mouseTransform.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
    // Création comportement rotation à la souris
    CustomMouseRotate rotate = new CustomMouseRotate(mouseTransform);
    rotate.setSchedulingBounds(new BoundingSphere());
 
    // Création du groupe de transformation sur lequel vont s'appliquer les
    // rotations
    TransformGroup rotationTransform = new TransformGroup();
 
    // Le groupe de transformation sera modifié
    rotationTransform.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
    rotationTransform.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
 
    //------- début de ajout de l'interaction (rotation avec le clavier) -----------
    Behavior2 behav2 = new Behavior2(rotationTransform);
    behav2.setSchedulingBounds(new BoundingSphere());
    root.addChild(behav2);
    //------- fin de ajout de l'interaction --------------------
 
    // animation début (rotation du rubicube)
    Alpha alpha = new Alpha(3, Alpha.DECREASING_ENABLE, 0, 0, 0, 0, 0,
                            4 * 1000, 0, 0); // Un tour en 4 s
    RotationInterpolator rotator = new RotationInterpolator(alpha,
        rotationTransform);
    rotator.setSchedulingBounds(new BoundingSphere());
 
    // Création du rubicube
    Group cubeGroup = createRubicube();
 
    // Ajout du rubicube à la racine de l'arbre
    // Construction de la  branche de l'arbre de la scène
    rotationTransform.addChild(cubeGroup);
    rotationXYAxisGroup.addChild(rotationTransform);  // rotation clavier
    root.addChild(rotate);          // rotation 
    root.addChild(mouseTransform);  // à la souris
    root.addChild(rotator); //animation
    mouseTransform.addChild(rotationXYAxisGroup);
    return root;
  }
 
  // Crée le rubicube (14 mini-cubes colorés)
  public Group createRubicube() {
    Group cubeGroup = new Group();
    // Boucle de création des cubes
    for (int j = -1; j < 2; j++) {
      for (int i = -1; i < 2; i++) {
        for (int k = -1; k < 2; k++) {
          if (! (i == 0 && j == 0 && k == 0)) {
            // Création du translation pour positionner le cube
            Transform3D translation = new Transform3D();
            translation.setTranslation(new Vector3f(
                (taille + espace) * j,
                - (taille + espace) * i,
                - (taille + espace) * k));
            TransformGroup translationGroup = new TransformGroup(translation);
 
            // Création d'un mini-cube coloré (14 au total)
            MonColorCube cube = new MonColorCube(taille,
                       monRubicube.getCube(i + 1, j + 1,k + 1).getColor('A'),
                       monRubicube.getCube(i + 1, j + 1,k + 1).getColor('P'),
                       monRubicube.getCube(i + 1, j + 1,k + 1).getColor('G'),
                       monRubicube.getCube(i + 1, j + 1,k + 1).getColor('D'),
                       monRubicube.getCube(i + 1, j + 1, k + 1).getColor('H'),
                       monRubicube.getCube(i + 1, j + 1, k + 1).getColor('B'));
 
           // mise en place du mini-cube
            translationGroup.addChild(cube);    
            //Ajout d'une  branche à la racine de l'arbre
            cubeGroup.addChild(translationGroup);
          }
        }
      }
    }
    return cubeGroup;
  }
 
  private Transform3D rotateCubePositionDepart() {
    Transform3D rotate1 = new Transform3D();
    Transform3D rotate2 = new Transform3D();
    rotate1.rotX(Math.PI / 6);
    rotate2.rotY( -Math.PI / 4);
    rotate1.mul(rotate2);
    return rotate1;
  }
 
} // FIN

[leyee]

merci de mettre des balises codes pour les personnes qui souhaitent t'aider, là le code est difficilement lisible

[Luch_le_chti]

merci leyee pour l'info
le code est vraiment plus lisible comme ça.
(c'était mon 1er post mais je m'en souviendrais pour les prochains)
à +

[leyee]

je suis interessé par une eventuelle reponse : je n'ai jamais eu l'occasion de me mettre à JAVA3D, je me lancerai bien si j'avais un peu de temps

[Luch_le_chti]

En fait peut-etre devrais essayer de créer une classe qui étendrait la classe Behavior (comme la classe MouseRotate du tuto Java3D chap. interaction)

Mais je ne sais pas sur quel transfomGroup agir ?
.. le cube entier et on délimite la zone d'animation
.. chaque mini-cube


Si quelqu'un à une idée sur la question

Pour info, l'abre de la scene est représenté dans le fichier Word ci-joint