[Java3D] Clic sur un objet visuel (MouseListener ou autre) [Sources]

**loka** · 14/11/2007, 02h49

Bonjour,

J'ai un programme Java3D qui m'affiche des objets de type A.
Chacun de ces objets possède une caméra (une position de la caméra) qui lui est propre que je peux récupérer grâce à la fonction getCamera() appliquée à mon objet de type A.

Ce que j'aimerais, c'est que lorsque je clique sur un objet de type A dans ma fenêtre de visualisation 3D, c'est récupérer cet objet de type A afin de lui appliquer ma fonction getCamera().

Il me faudrait donc un fonctionnement similaire déjà au MouseListener pour détecter le clic sur l'objet. j'ai regardé un peu du coté de MouseBehavior mais je n'arrive pas à récupérer mon objet (cependant, j'arrive à le faire bouger, ce que je ne souhaite pas :p).

Voila, si vous savez comment faire, je suis preneur, je pense que j'ai du passer à coté de quelque chose ^^

Merci

**pan99** · 14/11/2007, 11h33

Bonjour.

Je possède la solution à votre problème.
Je l'utilise régulièrement, et elle fonctionne parfaitement.

La fonction retourne le nom de l'objet cliqué directement.

Amicalement.

**loka** · 14/11/2007, 17h36

Bonjour,

Quelle est cette solution ?

Ce n'est pas le nom de l'objet que je souhaite mais l'objet en lui même (mon instance).

Merci

**pan99** · 15/11/2007, 08h34

Bonjour.

Par le biais de cette méthode, il est possible de récupérer directement le 'UserData' de l'objet cliqué.

Tout d'abord, lors de la création de l'objet, il faut lui affecter un nom, comme suit (exemple), où 's' est une sphère ici:

s.setUserdata("objet 1");

La méthode utilisée lors d'un clic fait ensuite appel à la fonction 'getuserData' du noeud cliqué.

J'espère m'être fait bien comprendre.

Amicalement.

Voici la méthode complète à utiliser:
----------------------------------------

Classe écoutant les clics de souris, et retournant le nom de l'objet cliqué.

Tous les objets doivent se trouver dans des TransformGroup.
Ces TransformGroup doivent être initialisés comme suit:

Code :

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

1
2
3
 
 TransformGroup TG = new TransformGroup();
  initialiser (TG,true);

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
 
 
  // A inclure dans la classe principale.
  public TransformGroup initialiser (TransformGroup TG, boolean picquable)
   {
   TG.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
   TG.setCapability(TransformGroup.ALLOW_CHILDREN_WRITE);
   TG.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
   TG.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
   TG.setCapability(TransformGroup.ENABLE_PICK_REPORTING);
 
TG.setPickable(picquable);
 
   return TG;
   }

Nommer chaque noeud comme suit: noeud.setUserData(''nom'');

Classe ' PickMouseBehavior.java'
------------------------------------

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
 
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.util.Enumeration;
import javax.media.j3d.*;
 
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import java.math.*;
import com.sun.j3d.utils.picking.*;
import javax.swing.*;
 
public abstract class PickMouseBehavior extends Behavior
{
 
    protected PickCanvas pickCanvas;
    protected WakeupCriterion conditions[];
    protected WakeupOr wakeupCondition;
    protected boolean buttonPress;
    protected TransformGroup currGrp;
    protected static final boolean debug = false;
    protected MouseEvent mevent;
 
    public PickMouseBehavior(Canvas3D canvas3d, BranchGroup branchgroup, Bounds bounds)
    {
        buttonPress = false;
        currGrp = new TransformGroup();
        currGrp.setCapability(18);
        currGrp.setCapability(17);
        branchgroup.addChild(currGrp);
        pickCanvas = new PickCanvas(canvas3d, branchgroup);
    }
 
    public void setMode(int i)
    {
        pickCanvas.setMode(i);
    }
 
    public int getMode()
    {
        return pickCanvas.getMode();
    }
 
    public void setTolerance(float f)
    {
        pickCanvas.setTolerance(f);
    }
 
    public float getTolerance()
    {
        return pickCanvas.getTolerance();
    }
 
    public void initialize()
    {
        conditions = new WakeupCriterion[2];
        conditions[0] = new WakeupOnAWTEvent(503);
        conditions[1] = new WakeupOnAWTEvent(501);
        wakeupCondition = new WakeupOr(conditions);
        wakeupOn(wakeupCondition);
    }
 
    private void processMouseEvent(MouseEvent mouseevent)
    {
        buttonPress = false;
        if((mouseevent.getID() == 501) | (mouseevent.getID() == 500))
        {
            buttonPress = true;
            return;
        } else
        {
            if(mouseevent.getID() != 503);
            return;
        }
    }
 
    public void processStimulus(Enumeration enumeration)
    {
        java.awt.AWTEvent aawtevent[] = null;
        int i = 0;
        int j = 0;
        do
        {
            if(!enumeration.hasMoreElements())
            {
                break;
            }
            WakeupCriterion wakeupcriterion = (WakeupCriterion)enumeration.nextElement();
            if(wakeupcriterion instanceof WakeupOnAWTEvent)
            {
                aawtevent = ((WakeupOnAWTEvent)wakeupcriterion).getAWTEvent();
            }
        } while(true);
        if(aawtevent[0] instanceof MouseEvent)
        {
            mevent = (MouseEvent)aawtevent[0];
            processMouseEvent((MouseEvent)aawtevent[0]);
            i = mevent.getPoint().x;
            j = mevent.getPoint().y;
        }
        if(buttonPress)
        {
            updateScene(i, j);
        }
        wakeupOn(wakeupCondition);
    }
 
    public abstract void updateScene(int i, int j);
}

Classe 'CustomPickTranslateBehavior.java'
----------------------------------------------

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
 
// Créé une seule fois pour l'ensemble de la scène.
 
import javax.media.j3d.*;
import com.sun.j3d.utils.picking.behaviors.*;
import com.sun.j3d.utils.picking.*;
import com.sun.j3d.utils.behaviors.mouse.*;
import javax.vecmath.*;
 
/**
 * A mouse behavior that allows user to pick and translate scene graph objects.
 * Common usage: 1. Create your scene graph. 2. Create this behavior with
 * the root and canvas. See PickRotateBehavior for more details.
 */
 
public class CustomPickTranslateBehavior extends PickMouseBehavior implements MouseBehaviorCallback {
  private CustomMouseTranslate translate;
  private PickingCallback callback = null;
  private TransformGroup currentTG;
 
  /**
   * Creates a pick/translate behavior that waits for user mouse events for
   * the scene graph.
   * @param root   Root of your scene graph.
   * @param canvas Java 3D drawing canvas.
   * @param bounds Bounds of your scene.
   **/
 
  public CustomPickTranslateBehavior(BranchGroup root, Canvas3D canvas, Bounds bounds){
    super(canvas, root, bounds);
    translate = new CustomMouseTranslate(MouseBehavior.MANUAL_WAKEUP);
 
    // 'currGrp' est un 'TransformGroup' défini dans 'PickMouseBehavior'.
    translate.setTransformGroup(currGrp);
 
    translate.setFactor(0.008);
    currGrp.addChild(translate);
    translate.setSchedulingBounds(bounds);
    this.setSchedulingBounds(bounds);
  }
 
  /**
   * Update the scene to manipulate any nodes. This is not meant to be
   * called by users. Behavior automatically calls this. You can call
   * this only if you know what you are doing.
   *
   * @param xpos Current mouse X pos.
   * @param ypos Current mouse Y pos.
   **/
  public void updateScene(int xpos, int ypos)
       {
         TransformGroup tg = null;
 
         if (!mevent.isAltDown() && !mevent.isMetaDown())
            {
            pickCanvas.setShapeLocation(xpos, ypos);
            PickResult pr = pickCanvas.pickClosest();
 
            if (pr != null)
           {
               tg=(TransformGroup) pr.getNode(PickResult.TRANSFORM_GROUP);
 
               if (tg == null)
                {}
                  else
                 {
               if (tg != null && (tg.getCapability(TransformGroup.ALLOW_TRANSFORM_READ)) && (tg.getCapability(TransformGroup.ALLOW_TRANSFORM_WRITE)))
                  {
                  // Fournit l'adresse interne de l'objet cliqué.
                  Node n=tg.getChild(0);
                  // System.out.println(tg.toString()+" "+tg.numChildren()+" "+n.toString());
                  System.out.println("Adresse interne de l'objet cliqué: "+n.toString());
                  System.out.println("Nom du noeud: "+(String) n.getUserData());
 
              translate.setTransformGroup(tg);
              translate.wakeup();
              currentTG = tg;
              //freePickResult(pr);
              }
             }
               }
                else
               if (callback!=null) callback.transformChanged (PickingCallback.NO_PICK, null);
            }
 
  }
 
  /**
    * Callback method from MouseTranslate
    * This is used when the Picking callback is enabled
    */
  public void transformChanged (int type, Transform3D transform)
       {
         callback.transformChanged (PickingCallback.TRANSLATE, currentTG);
         }
 
  /**
    * Register the class @param callback to be called each
    * time the picked object moves
    */
  public void setupCallback (PickingCallback callback)
         {
         this.callback = callback;
 
         if (callback==null)
            translate.setupCallback (null);
               else
            translate.setupCallback (this);
  }
 
}

Classe 'CustomMouseTranslate.java'
---------------------------------------

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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.behaviors.mouse.*;
 
/**
 * MouseTranslate is a Java3D behavior object that lets users control the
 * translation (X, Y) of an object via a mouse drag motion with the third
 * mouse button (alt-click on PC). See MouseRotate for similar usage info.
 */
 
public class CustomMouseTranslate extends MouseBehavior {
 
    double x_factor = .02;
    double y_factor = .02;
    Vector3d translation = new Vector3d();
 
    private MouseBehaviorCallback callback = null;
 
    /**
     * Creates a mouse translate behavior given the transform group.
     * @param transformGroup The transformGroup to operate on.
     */
    public CustomMouseTranslate(TransformGroup transformGroup) {
    super(transformGroup);
    }
 
    /**
     * Creates a default translate behavior.
     */
    public CustomMouseTranslate(){
    super(0);
    }
 
    /**
     * Creates a translate behavior.
     * Note that this behavior still needs a transform
     * group to work on (use setTransformGroup(tg)) and
     * the transform group must add this behavior.
     * @param flags
     */
    public CustomMouseTranslate(int flags)
           {
           // Cette méthode est appelée    par 'CustomPickTranslateBehavior'.
           super(flags);
           }
 
    /**
     * Creates a translate behavior that uses AWT listeners and behavior
     * posts rather than WakeupOnAWTEvent.  The behavior is added to the
     * specified Component. A null component can be passed to specify
     * the behavior should use listeners.  Components can then be added
     * to the behavior with the addListener(Component c) method.
     * @param c The Component to add the MouseListener
     * and MouseMotionListener to.
     * @since Java 3D 1.2.1
     */
    public CustomMouseTranslate(Component c) {
    super(c, 0);
    }
 
    /**
     * Creates a translate behavior that uses AWT listeners and behavior
     * posts rather than WakeupOnAWTEvent.  The behaviors is added to
     * the specified Component and works on the given TransformGroup.
     * A null component can be passed to specify the behavior should use
     * listeners.  Components can then be added to the behavior with the
     * addListener(Component c) method.
     * @param c The Component to add the MouseListener and
     * MouseMotionListener to.
     * @param transformGroup The TransformGroup to operate on.
     * @since Java 3D 1.2.1
     */
    public CustomMouseTranslate(Component c, TransformGroup transformGroup) {
    super(c, transformGroup);
    }
 
    /**
     * Creates a translate behavior that uses AWT listeners and behavior
     * posts rather than WakeupOnAWTEvent.  The behavior is added to the
     * specified Component.  A null component can be passed to specify
     * the behavior should use listeners.  Components can then be added to
     * the behavior with the addListener(Component c) method.
     * Note that this behavior still needs a transform
     * group to work on (use setTransformGroup(tg)) and the transform
     * group must add this behavior.
     * @param flags interesting flags (wakeup conditions).
     * @since Java 3D 1.2.1
     */
    public CustomMouseTranslate(Component c, int flags) {
    super(c, flags);
    }
 
    public void initialize() {
    super.initialize();
    if ((flags & INVERT_INPUT) == INVERT_INPUT) {
        invert = true;
        x_factor *= -1;
        y_factor *= -1;
    }
    }
 
    /**
     * Return the x-axis movement multipler.
     **/
    public double getXFactor() {
    return x_factor;
    }
 
    /**
     * Return the y-axis movement multipler.
     **/
    public double getYFactor() {
    return y_factor;
    }
 
    /**
     * Set the x-axis amd y-axis movement multipler with factor.
     **/
    public void setFactor( double factor) {
    x_factor = y_factor = factor;
    }
 
    /**
     * Set the x-axis amd y-axis movement multipler with xFactor and yFactor
     * respectively.
     **/
    public void setFactor( double xFactor, double yFactor) {
    x_factor = xFactor;
    y_factor = yFactor;
    }
 
    public void processStimulus (Enumeration criteria) {
    WakeupCriterion wakeup;
    AWTEvent[] events;
     MouseEvent evt;
//     int id;
//     int dx, dy;
 
    while (criteria.hasMoreElements()) {
        wakeup = (WakeupCriterion) criteria.nextElement();
 
        if (wakeup instanceof WakeupOnAWTEvent) {
        events = ((WakeupOnAWTEvent)wakeup).getAWTEvent();
        if (events.length > 0) {
            evt = (MouseEvent) events[events.length-1];
            doProcess(evt);
        }
        }
 
        else if (wakeup instanceof WakeupOnBehaviorPost) {
        while (true) {
            // access to the queue must be synchronized
            synchronized (mouseq) {
            if (mouseq.isEmpty()) break;
            evt = (MouseEvent)mouseq.remove(0);
            // consolodate MOUSE_DRAG events
            while ((evt.getID() == MouseEvent.MOUSE_DRAGGED) &&
                   !mouseq.isEmpty() &&
                   (((MouseEvent)mouseq.get(0)).getID() ==
                MouseEvent.MOUSE_DRAGGED)) {
                evt = (MouseEvent)mouseq.remove(0);
            }
            }
            doProcess(evt);
        }
        }
 
    }
     wakeupOn(mouseCriterion);
    }
 
 void doProcess(MouseEvent evt) {
    int id;
    int dx, dy;
 
    processMouseEvent(evt);
 
    if (((buttonPress)&&((flags & MANUAL_WAKEUP) == 0)) ||
        ((wakeUp)&&((flags & MANUAL_WAKEUP) != 0))){
        id = evt.getID();
        if ((id == MouseEvent.MOUSE_DRAGGED) &&
        !evt.isAltDown() && !evt.isMetaDown()) {
 
        x = evt.getX();
        y = evt.getY();
 
        dx = x - x_last;
        dy = y - y_last;
 
        if ((!reset) && ((Math.abs(dy) < 50) && (Math.abs(dx) < 50))) {
            //System.out.println("dx " + dx + " dy " + dy);
            transformGroup.getTransform(currXform);
 
            translation.x = dx*x_factor;
            translation.y = -dy*y_factor;
 
            transformX.set(translation);
 
            if (invert) {
            currXform.mul(currXform, transformX);
            } else {
            currXform.mul(transformX, currXform);
            }
 
                                   // Ligne suivante désactivée: l'objet cliqué ne sera pas déplacé.
                                   // Car on ne veut traiter que les clics de souris.
            // transformGroup.setTransform(currXform);
 
            transformChanged (currXform);
 
            if (callback!=null) callback.transformChanged (MouseBehaviorCallback.TRANSLATE, currXform );
 
        }
        else {
            reset = false;
        }
        x_last = x;
        y_last = y;
        }
        else if (id == MouseEvent.MOUSE_PRESSED) {
        x_last = evt.getX();
        y_last = evt.getY();
        }
    }
    }
 
    /**
     * Users can overload this method  which is called every time
     * the Behavior updates the transform
     *
     * Default implementation does nothing
     */
    public void transformChanged (Transform3D transform) 
           {
           // Ici on peut réaliser des actions chaque fois que la scène est modifiée.    
           // System.out.println("*");    
           }
 
    /**
     * The transformChanged method in the callback class will
     * be called every time the transform is updated
     */
    public void setupCallback( MouseBehaviorCallback callback ) {
    this.callback = callback;
    }
}

**loka** · 15/11/2007, 21h13

Merci pour la réponse, je vais essayer

**loka** · 18/11/2007, 18h19

Merci, j'ai pu faire ce que je voulais

Je passe mon objet A dans le setUserData.
J'ai créé une classe SimplePickBehaviour car je n'ai pas besoin de tout ce que tu as dedans et dans la partie traitement une fois l'objet "pické", je passe ma camera.

Si ça intéresse certains, qu'ils postent à la suite

[Java3D] Clic sur un objet visuel (MouseListener ou autre) [Sources]

3D Java

Vue hybride

Discussions similaires

Partager

Partager