[jogl]Déplacement d'une scène à la souris

Version imprimable

Bonjour

J'ai mis au point un système de mouse pan avec la souris. En gros, tant que je clique, ma caméra se déplace sur les X et les Y de ma scène.
Voici un extrait de code:

Code:

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
 
public void display(GLAutoDrawable arg0) {
        final GL gl = arg0.getGL();
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
//other stuff
        if (firstDraw) {
            this.mustCenter = true;
            this.firstDraw = false;
        } else if (mustCenter) {
            setWrap();
            wrap.setCenter();
            qX = startX - wrap.centerX;
            qY = startY - wrap.centerY;
            x_f = y_f = 0;
            mustCenter = false;
            last_x = qX + x_f;
            last_y = qY + y_f;
        } else {
//travelling with mouse
            if(travelling){
                if(this.movePoint!=null){
                    lastx = this.movePoint.getX();
                    lasty = this.movePoint.getY();
                    double[]wcoord = Utils.convertIntoGL(gl, lastx, lasty);
                    last_x = (float)wcoord[0];
                    last_y = (float)-wcoord[1];
                }
            }
//travelling with keyboard
            else{
                last_x+=x_f;
                last_y+=y_f;
                x_f = y_f = 0;
            }
        }
 
        gl.glTranslatef(last_x, last_y, 0);
 
//drawing a marvellous scene
}
 
    public void mouseDragged(MouseEvent arg0) {
        if (picking) {
            if (arg0.getButton() == 0) {
                this.point = arg0.getPoint();
                this.mouse_state = this.PICKED;
            }
        } else if (travelling) {
            movePoint = arg0.getPoint();
        }
    }

Or, mon problème est que si je déplace une fois avec la souris, OK, tout va bien. Mais je reclique, je me rend à nouveau au centre de ma scène.
Comment résoudre ce problème ?
Merci d'avance de votre aide.

@++

Salut,

il faut que tu resettes last_x et last_y quand tu NE FAIS PAS de mouvement. Si tu ne le fais pas ton prochain clic utilisera les "vieilles" valeurs encore sauvegardées.

Par exemple chez moi ca ressemble à ca (désolé je ne fais pas de jogl mais tu devrais t'y retrouver) (HandleMouse est appelée à chaque fois que la souris bouge)

Code:

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
 
public bool HandleMouse(Point pt)
   {
            // If the "Control" key is pressed, we are in 'movement mode' in our OpenGL 
            // window
            if (m_key_CTRL)
            {                
                // Right mouse button triggers the scene's translation
                // ---------------------------------------------------
                else if (m_mouseButtons[2])
                {
                    if (m_mousePos[0] != -1)
                    {
                        axAxGL_EmptyWin1.IncrementTranslation(0, (pt.X - m_mousePos[0])*0.15f);
                        axAxGL_EmptyWin1.IncrementTranslation(1, -(pt.Y - m_mousePos[1])*0.15f);
                    }
                    m_mousePos[0] = pt.X;
                    m_mousePos[1] = pt.Y;
                    return true;
                }                
                // If no mouse button was pressed, reset the mouse position
                else
                    m_mousePos[0] = m_mousePos[1] = - 1;
            }
            // If the "Control" key wasn't pressed, reset the mouse position
            else
                m_mousePos[0] = m_mousePos[1] = -1;
 
            return false;
        }

Bonjour ShevchenKik

Je te remercie de ta réponse mais je reconnais être un peu perdu.
J'ai une méthode implémentée pour le release de la souris:
Code:

1 2 3 4 5 6 7 8 9 10 11 public void mouseReleased(MouseEvent arg0) { this.point = null; this.mouse_state = this.RELEASED; this.selected = -1; this.node_modified = false; this.rebuildList = true; this.i_neighbors = null; this.lastMovePoint = arg0.getPoint(); this.movePoint = null; }
Mais, le problème est toujours là. De même, si dans cette méthode je met last_x et last_y à 0, ma scène revient au départ bien évidemment :?
Bref, je ne vois pas comment je peux m'en sortir.

@++

29/05/2008, 15h48
shenron666

logiquement, ta scène est centrée sur un certain point qu'on appellera C(x,y)

lorsque tu actives le mode pan, tu dois ajouter à Cx et Cy les mouvements P(x,y) de ton clavier ou de ta souris

lorsque tu désactives le mode pan, ta coordonnée C n'est plus la même que le C avant le mode pan

si tu réactives le mode pan, tu dois repartir de ces mêmes valeurs modifiées
et non pas repartir des valeurs initiales

si j'ai le temps, je regarderai ton code pour être plus concret à ce sujet
mais de la façon dont je le ferai n'est peut-etre pas commune à celle que tu as utilisé :aie:
29/05/2008, 15h53
GLDavid

Merci Shenron de ta réponse.
Je vais tenter de mon côté également.
Peut être qu'à deux la solution viendra :)
Encore merci de ta proposition.

@++

Ok, d'après ce que j'ai compris, tu as MovePoint qui contient les coordonées actuelles de ta souris, et lastMovePoint celles à l'instant précédent.

essaie de remplacer

Code:

1
2
3
4
5
6
7
8
9
if(travelling){
                if(this.movePoint!=null){
                    lastx = this.movePoint.getX();
                    lasty = this.movePoint.getY();
                    double[]wcoord = Utils.convertIntoGL(gl, lastx, lasty);
                    last_x = (float)wcoord[0];
                    last_y = (float)-wcoord[1];
                }
            }

par

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
if(travelling)
{
    if(this.lastMovePoint.getX()!=-1)
   {
       deltaX =  this.movePoint.getX() - lastMovePoint.getX();
       deltaY =  this.movePoint.getY() - lastMovePoint.getY();
 
       double[]wcoord = Utils.convertIntoGL(gl, deltaX , deltaY );
       last_x = (float)wcoord[0];
       last_y = (float)-wcoord[1];
    }
    lastMovePoint.SetX(movePoint.getX());
    lastMovePoint.SetY(movePoint.getY());
}
else
{
lastMovePoint.SetX(-1);
    lastMovePoint.SetY(-1);
 
}

Salut ShevchenKik

J'essaie d'adapter ton code, mais je pense que c'est incomplet ou alors, j'ai mal compris:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
if(travelling){
                if(this.movePoint!=null && lastMovePoint==null){
                    lastx = this.movePoint.getX();
                    lasty = this.movePoint.getY();
                    double[]wcoord = Utils.convertIntoGL(gl, lastx, lasty);
                    last_x = (float)wcoord[0];
                    last_y = (float)-wcoord[1];
                }
                else if(this.movePoint!=null && lastMovePoint!=null){
                   double deltaX =  this.movePoint.getX() - lastMovePoint.getX();
                   double deltaY =  this.movePoint.getY() - lastMovePoint.getY();
                   double[]wcoord = Utils.convertIntoGL(gl, deltaX , deltaY );
                   last_x = (float)wcoord[0];
                   last_y = (float)-wcoord[1];
                   lastMovePoint = movePoint;
                }
            }

Le résultat est pas fameux. Au release de la souris ma scène est à l'origine (en 0, 0) !
J'ai pas dû comprendre quelque chose :koi:
Merci encore de ta réponse.
Autre chose, dans ma version précédente lastMovePoint n'était initialisé qu'au release de la souris.

@++

30/05/2008, 09h13
ShevchenKik

Salut,

je dois t'avouer être un peu perdu moi aussi.....;)

1 - tout d'abord, tu effectues tes calculs de déplacement de la souris dans ta fonction display. Je ne sais pas si c'est spécifique à Jogl, mais que ce soit en Win32, GLUT ou autres, je n'ai jamais vu ca: normalement il y a une fonction "callback" appelée à chaque fois que ta souris bouge. Le problème de ton approche, c'est par exemple que si ta souris a eu le temps de faire un aller-retour entre deux frames, tu ne verras pas de mouvement. Mais bon comme dit c'est peut être spécifique à Jogl et dans ce cas je n'ai rien dit

2 - l'exemple que je donnais hier c'est justement cette fonction, j'avais pas fait gaffe que tu faisais tes calculs dans ton display, donc le code n'est pas adapté....

Essaie de voir si en Jogl tu as moyen d'utiliser une callback pour ta souris. Si oui ca devrait aider pas mal ;)
30/05/2008, 10h27
shenron666

ta variable traveling, c'est elle qui indique si tu es en mode pan ?
comment est-elle modifiée ?

dans ma logique, il y a des initialisations et des modifications à prendre en compte lorsque tu entres en mode pan et également lorsque tu en sors
30/05/2008, 15h05
plegat

Citation:

Envoyé par ShevchenKik

1 - tout d'abord, tu effectues tes calculs de déplacement de la souris dans ta fonction display. Je ne sais pas si c'est spécifique à Jogl, mais que ce soit en Win32, GLUT ou autres, je n'ai jamais vu ca: normalement il y a une fonction "callback" appelée à chaque fois que ta souris bouge. Le problème de ton approche, c'est par exemple que si ta souris a eu le temps de faire un aller-retour entre deux frames, tu ne verras pas de mouvement. Mais bon comme dit c'est peut être spécifique à Jogl et dans ce cas je n'ai rien dit

Ce n'est pas spécifique Jogl...
D'après ce dont je me souviens de mes virées en C++, la fonction Callback sert à traiter les évènements (genre fermeture de la fenêtre, clic souris, clavier, etc). Et bien on peut faire la même chose en Java (et pas spécifiquement en Jogl donc), et traiter les évènements à part. C'est ce que fait GLDavid d'ailleurs, il gère les mouseDragged et mouseReleased, donc c'est bon. Seul soucis, c'est qu'il continue à faire du traitement dans la fonction Display, alors que je laisserais plutôt celle-ci gérer uniquement l'affichage, et donc je finaliserais plutôt tous les traitements dans la gestion des évènements.
Tout ça pour dire que vu que c'est séparé là, je ne comprends pas tout ce qui est fait au niveau traitement des évènements et gestion des coordonnées et tout et tout...

Sinon même remarque que shenron666, où et comment est modifiée la variable travelling?
Tu devrais essayer de tracer ton programme pour savoir où il passe quand tu fais ton drag...

Bonjour à tous

D'ores et déjà, un grand merci pour vos réponses et suggestions, cela fait toujours plaisir.
Maintenant, les choses sérieuses.
Je vais vous montrer des snippets de mon code. Déjà, travelling est un boolean modifié via un menu (un JMenuCheckboxItem pour les Javaistes).
Voici la callback lors du drag de la souris (mouvement de souris avec clic enfoncé)

Code:

1
2
3
4
5
6
7
8
9
10
11
 
public void mouseDragged(MouseEvent arg0) {
        if (picking) {
            if (arg0.getButton() == 0) {
                this.point = arg0.getPoint();
                this.mouse_state = this.PICKED;
            }
        } else if (travelling) {
            movePoint = arg0.getPoint();
        }
    }

mouseReleased, call back invoquée quand je relâche le clic.

Code:

1
2
3
4
5
6
7
8
9
10
11
 
public void mouseReleased(MouseEvent arg0) {
        this.point = null;
        this.mouse_state = this.RELEASED;
        this.selected = -1;
        this.node_modified = false;
        this.rebuildList = true;
        this.i_neighbors = null;
        this.lastMovePoint = this.movePoint;
        this.movePoint = null;
    }

La méthode display au complet:

Code:

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
 
public void display(GLAutoDrawable arg0) {
        final GL gl = arg0.getGL();
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
 
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        gl.glOrtho(-2.5f * this.mw.getWidth() / this.mw.getHeight(), 2.5f * this.mw.getWidth() / this.mw.getHeight(), -2.5f, 2.5f, -5f, 5f);
        gl.glScalef((float)zoom, (float)zoom, 1);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
 
        if (firstDraw) {
            this.mustCenter = true;
            this.firstDraw = false;
        } else if (mustCenter) {
            setWrap();
            wrap.setCenter();
            qX = startX - wrap.centerX;
            qY = startY - wrap.centerY;
            x_f = y_f = 0;
            mustCenter = false;
            last_x = qX + x_f;
            last_y = qY + y_f;
            /*Xcenter = last_x;
            Ycenter = last_y;*/
            //gl.glTranslatef(last_x, last_y, 0);
        } else {
            if(travelling){
                if (this.movePoint != null) {
                    if(lastMovePoint==null){
                    double[] wcoord = Utils.convertIntoGL(gl, this.movePoint.getX(), this.movePoint.getY());
                    double deltaX = wcoord[0];
                    double deltaY = wcoord[1];
                    last_x = (float)(deltaX/zoom);
                    last_y = -(float)(deltaY/zoom);
                    }
                    else{
                        double[] wcoord = Utils.convertIntoGL(gl, this.movePoint.getX()-lastMovePoint.getX(), this.movePoint.getY()-lastMovePoint.getY());
                    double deltaX = wcoord[0];
                    double deltaY = wcoord[1];
                    last_x = (float)(deltaX/zoom);
                    last_y = -(float)(deltaY/zoom);
                    }
                }
            }
            else if (keyPressed) {
                last_x += x_f;
                last_y += y_f;
                x_f = y_f = 0;
                /*Xcenter = last_x;
                Ycenter = last_y;*/
                //gl.glTranslatef(last_x, last_y, 0);
            }
        }
 
        gl.glTranslatef(last_x, last_y, 0);
        Xcenter = last_x;
        Ycenter = last_y;
        //System.out.println(Xcenter+"\t"+Ycenter);
 
        if (this.point != null) {
            //picking
            pickPoint(gl);
            drawWorld(gl, GL.GL_RENDER_MODE, true);
            node_modified=true;
        }
        else{
            if(node_modified){
                //picking and moving
                drawWorld(gl, GL.GL_RENDER_MODE, true);
            }
            else{
                //Default mode
                if(rebuildList){
                    gl.glDeleteLists(list, 1);
                    createList(gl);
                    rebuildList=false;
                }
                gl.glCallList(list);
            }
        }
 
        fps.draw();
 
        gl.glFlush();
    }

J'espère que cela est suffisant pour m'aider.
Encore une fois, merci encore de votre soutien.

@++

30/05/2008, 18h35
plegat

Citation:

Envoyé par GLDavid

J'espère que cela est suffisant pour m'aider.

Pas pour moi... je suis paumé complet...

D'après ce que je crois comprendre de ton code, la première fois que tu cliques, ta scène doit se centrer sur le point où tu as cliqué, puis se déplacer suivant les mouvements de la souris. Puis si tu relaches la souris, et que tu recliques, ça doit partir en vrille. C'est bien ça qu'il se passe?
Essaye de ré-expliquer les symptomes, si ça a un peu changé par rapport à ton premier post, vu que ton code a été modifié entre-temps.

Pourrais-tu aussi expliquer à quoi sert la variable lastMovePoint?

Pourquoi mémoriser les positions relatives à l'écran (lastMovePoint) et pas directement modifier les déplacements relatifs openGL (last_x et last_y)? Alors que par le clavier, last_x et last_y sont directement modifiées...

C'est juste des questions pour éclaircir, parce que je ne comprends pas la manip de la boucle else du traveling dans ton code...
30/05/2008, 22h31
shenron666
je suis désolé mais je vais encore te demander moi aussi quelques explications :aie:

lorsque le booléen traveling est à true c'est pour déplacer la scène ?

et le booléen picking, il sert à quoi ?

dans la callback mouseDragged, si tu fais arg0.getPoint() tu récupères la position de la souris ou les coordonnées x et y du déplacement relatif de la souris par rapport au dernier appel de la callback ?

avec le clavier, ça fonctionne bien ?
c'est ce bout de code là ? :
Code:

1 2 3 4 5 6 7 8 else if (keyPressed) { last_x += x_f; last_y += y_f; x_f = y_f = 0; /*Xcenter = last_x; Ycenter = last_y;*/ //gl.glTranslatef(last_x, last_y, 0); }
03/06/2008, 09h36
GLDavid

Bonjour

Pardon du retard dans ma réponse.
Puisque tout le monde semble perdu (moi inclus :aie:), je vais retravailler ce code. D'abord, cela permettra d'avoir du code plus aéré et peut être plus juste.
Mon prochain post contiendra ainsi ce nouveau code.
Néanmoins, je remercie encore les participants de ce thread pour leurs idées et suggestions. Ca me permet aussi de faire du code review, étant seul à travailler sur ce sujet.

@++ et merci encore.

Bonjour

Comme promis, j'ai repensé le code et l'ai simplifié. Ce nettoyage combiné à vos conseils fait quelque chose de plus joli et agréable. De plus, mes tests semblent être bon.
Pour mémoire, travelling est un booléen activé via un JMenu pour dire si je suis en mode panning.

Code:

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
 
private float last_x,  last_y;
private int x0,  y0,  x1, y1;
private BufferedImage bi;
private GLAutoDrawable drawable;
private boolean picking,  travelling;
 
public void mouseReleased(MouseEvent arg0) {
        this.point = null;
        this.mouse_state = this.RELEASED;
        this.selected = -1;
        this.node_modified = false;
        this.rebuildList = true;
        this.i_neighbors = null;
        this.movePoint = null;
        save = true;
    }
 
public void mouseDragged(MouseEvent arg0) {
        if (picking) {
            if (arg0.getButton() == 0) {
                this.point = arg0.getPoint();
                this.mouse_state = this.PICKED;
            }
        } else if (travelling) {
            x1 = arg0.getPoint().x;
            y1 = arg0.getPoint().y;
        }
        save = false;
    }
 
public void display(GLAutoDrawable arg0) {
        final GL gl = arg0.getGL();
 
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
 
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        gl.glOrtho(-2.5f * this.mw.getWidth() / this.mw.getHeight(), 2.5f * this.mw.getWidth() / this.mw.getHeight(), -2.5f, 2.5f, -5f, 5f);
        gl.glScalef((float) zoom, (float) zoom, 1);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
 
        if (firstDraw) {
            this.mustCenter = true;
            this.firstDraw = false;
        } else if (mustCenter) {
            setWrap();
            wrap.setCenter();
            qX = startX - wrap.centerX;
            qY = startY - wrap.centerY;
            x_f = y_f = 0;
            mustCenter = false;
            last_x = qX + x_f;
            last_y = qY + y_f;
        } else {
            if (travelling) {
                if(x1!=0 && y1 != 0){
                /*shift_x = x1 - x0;
                shift_y = y1 - y0;*/
                double[] wcoord = Utils.convertIntoGL(gl, x1, y1);
                last_x += (float)(wcoord[0]/(zoom*10));
                last_y -= (float)(wcoord[1]/(zoom*10));
                wcoord[0] = wcoord[1] = 0;
                x0 = x1;
                y0 = y1;
                x1 = y1 = 0;
                //shift_x = shift_y = 0;
                if(x0<0 || x0>this.mw.getWidth())
                    x0 = this.mw.getWidth()-x0;
                if(y0<0 || y0>this.mw.getHeight())
                    y0 = this.mw.getHeight()-y0;
                }
            } else if (keyPressed) {
                last_x += x_f;
                last_y += y_f;
                x_f = y_f = 0;
            }
        }
 
        gl.glTranslatef(last_x, last_y, 0);
 
        if (this.point != null) {
            //picking
            pickPoint(gl);
            drawWorld(gl, GL.GL_RENDER_MODE, true);
            node_modified = true;
            fps.draw();
        } else {
            if (node_modified) {
                //picking and moving
                drawWorld(gl, GL.GL_RENDER_MODE, true);
                fps.draw();
            } else {
                //Default mode
                if (rebuildList) {
                    gl.glDeleteLists(list, 1);
                    createList(gl);
                    rebuildList = false;
                    fps.draw();
                }
                gl.glCallList(list);
                fps.draw();
                if (bi == null || save) {
                    this.drawable = arg0;
                    makeImage(gl);
                    save = false;
                }
            }
        }
 
        gl.glFlush();
    }

Je laisse ce code encore pour commentaires futurs.

Merci d'avance.

@++