Discussion :

[flamme34]

Bonjour à tous.

je développe depuis peu un logiciel de CAO. Et donc je suis en train de mettre en place le système de sélection (c'est la première fois que j'utilise OpenGl) . Et là j'ai un petit problème j'ai du mal à comprendre en quel unité je dois passer mes variables dans la fonction gluPickMatrix dont le prototype est :

void WINAPI gluPickMatrix(
GLdouble x,
GLdouble y,
GLdouble height,
GLdouble width,
GLint viewport[4]
);

Dans la docs j'ai trouvé :

x -> The x window coordinate of a picking region.
y -> The y window coordinate of a picking region.
height ->The height of the picking region in window coordinates.
width ->The width of the picking region in window coordinates.
viewport -> The current viewport (as from a glGetIntegerv call).

"window coordinates" c'est a dire? en pixel sur la fenêtre ou dans le plan openGL ? personnellement j'aurais dis pixel mais vu les résultats qui ressortes de mes tests je préfère poser la question.


J'ai tenté pour mes tests de mettre 1.0 et 1.0 pour width et height si c'était vraiment en pixel je ne devrais avoir le nom que de ce que j'ai en dessous de la souris. or là il me sélectionne tout les objets à une distance d'environ 3 (unité dans le plan openGL) autour de là où j'ai cliqué...

Donc quelqu'un peut m'expliquer comment bien se servir de cette fonction? sachant que je dois pouvoir sélectionner avec un rectangle de sélection.

EDIT : En fait j'ai remarqué qu'il me renvoyait les nom de TOUS ce qui est présent dans le viewport.

[MilWolf]

x et y correspondent aux coordonnées de ton pointeur de souris et effectivement width et height doivent être de 1 pixel.

edit: donc pour ton rectangle de sélection il sera en pixels et là tu changeras le width et height en fonction de la taille de ton rectangle.

[flamme34]

J'ai fait quelque chose comme ça :

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
void GLWidget::Picking()
{
    rectangleSelection = rectangleSelection.normalized();
    QPoint Coin1 = GetCoordonneesEcran(rectangleSelection.topLeft());
    QPoint Coin2 = GetCoordonneesEcran(rectangleSelection.bottomRight());
    QPoint Centre = GetCoordonneesEcran(rectangleSelection.center());
 
    int x=Centre.x();
    int y=Centre.y();
    int l_width = MAX(2,abs((Coin1-Coin2).x()));
    int l_height = MAX(2,abs((Coin1-Coin2).y()));
 
    //Creation du Buffer
    const GLint BUFFERSIZE = 4194288;
    GLuint *  BUFFER = new GLuint[BUFFERSIZE];
 
    // on spécifi la zone mémoire pour le retour d'information de selection
    glSelectBuffer (BUFFERSIZE, BUFFER);
 
    // Entrer en mode Selection
    glRenderMode (GL_SELECT);
 
    // Initialisation de la pile de nom
    glInitNames();
    glPushName(0);
    {
        glPushMatrix ();
        {
            //on recupert le viewport
            GLint viewport[4];
            glGetIntegerv(GL_VIEWPORT,viewport);
 
            gluPickMatrix((GLdouble)x,(GLdouble)(viewport[3]-y),(GLdouble)l_width/2, (GLdouble)l_height/2,viewport);
            glMatrixMode( GL_PROJECTION );
            glLoadIdentity();
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            // On applique les transformation
 
 
            gluPerspective(20.0f, (GLdouble)width()/(GLdouble)height(), 0.000001, 10000000);
 
            glMatrixMode( GL_MODELVIEW );
            glLoadIdentity();
 
             //	Caméra
            gluLookAt(PositionCamera.x(), PositionCamera.y(), PositionCamera.z(), CibleCamera.x(), CibleCamera.y(), CibleCamera.z(), 0, 1,0);
 
 
            //On redessine la scene en mode picking
            QMap <unsigned int, CAO_ItemClone*> ListePick;
            glPushMatrix();
            {
                liste->PickingItem(ListePick);
            }glPopMatrix ();
 
 
            glFlush();
 
            //On repasse en mode RENDER *
            //et on recupère le nombre d'élement séléctionner
            int hits = glRenderMode(GL_RENDER);
 
            int sizeList = ListePick.size();
            QVector <CAO_ItemClone*> listeASelectionner;
            listeASelectionner.clear();
 
 
            GLuint names, *ptr;
            ptr = (GLuint *) BUFFER;
            for (unsigned int i = 0; i < hits; i++)
            {
                //On recupère le numbre de pick
                names = *ptr;
                ptr++;
 
                //coordonnée minimum
                ptr++;
 
                //coordonnée maximum
                ptr++;
 
                //et enfin on recupère tout les pickingID
                for (unsigned int j = 0; j < names; j++)
                {
                    printf ("%d ", *ptr);
                    if (ListePick.find(*ptr)!= ListePick.end())
                    {
                        listeASelectionner.push_back(ListePick[*ptr]);
                        qDebug() << "selection ID " << QString::number(*ptr);
                    }
                    else
                    {
                        qDebug() << "On a Selectionner un pickingID non existant ! ! !" << QString::number(*ptr);
                    }
                    ptr++;
                }
            }
 
            qDebug() << "taille de la liste" << QString::number(sizeList);
            liste->Selection(listeASelectionner);
 
            //on vide le buffer
            for (unsigned int i =0; i <BUFFERSIZE; i++)
                BUFFER = 0;
            delete BUFFER;
            BUFFER = NULL;
 
        }glPopMatrix ();
    }glPopName();
}

Mais le problème c'est que à chaque fois ça me retourne tout les ID des objets qui sont apparent. Tout ce que je ne vois pas n'est pas sélectionné mais ce qui est visible est sélectionné.

J'ai essayé de mettre 1 à la place de width et height mais c'est pareil.

[MilWolf]

Bonsoir,

change d'abord tes valeurs near/far dans gluPerspective (0.1, 5000 par exemple)
Regarde la doc à cette page: https://www.opengl.org/sdk/docs/man2...PickMatrix.xml et surtout les exemples en bas.

[flamme34]

change d'abord tes valeurs near/far dans gluPerspective (0.1, 5000 par exemple)

J'ai changé les valeur near far dans gluPerspective par celle que tu as proposé.

J'ai réussi a produire un code qui fonctionne
Pour ceux qui ont le même problème je le poste :

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
//Creation du Buffer
    const GLint BUFFERSIZE = 4194288;
    GLuint *  BUFFER = new GLuint[BUFFERSIZE];
    GLint view[4];
 
    //Selection du Buffer
    glSelectBuffer(BUFFERSIZE, BUFFER);
 
    //Récupération des info à propos de la fenetre
    glGetIntegerv(GL_VIEWPORT, view);
 
    //Passage en mode selection
    glRenderMode(GL_SELECT);
 
 
    // Effacage de la pile des noms
    //Cette pile contient toute les information sur les items
    glInitNames();
 
    //On initialise la pile avec un element ( pour le glLoad)
    glPushName(0);
    {
        QMap <unsigned int, CAO_ItemClone*> ListePick;
 
        //  Maintenant on modifi le volume de visualisation afin de
        // restreindre la zone de selection autours du curseur
        glPushMatrix();
        {
            glMatrixMode(GL_PROJECTION);
            glLoadIdentity();
 
 
            //on limite le tri à une zone autour du curseur
            gluPickMatrix(x, view[3]-y, l_width, l_height, view);
            gluPerspective(20.0f, (GLdouble)width()/(GLdouble)height(), 0.1, 5000);
 
             gluLookAt(PositionCamera.x(), PositionCamera.y(), PositionCamera.z(), CibleCamera.x(), CibleCamera.y(), CibleCamera.z(), 0, 1,0);
 
            // on Dessine les objets sur l'écran
            glMatrixMode(GL_MODELVIEW);
           glLoadIdentity();
 
 
            //On redessine la scene en mode picking
 
            liste->PickingItem(ListePick);
 
            //*On repasse en materice pojection
            glMatrixMode(GL_PROJECTION);
        }glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
 
 
        //On repasse en mode RENDER *
        //et on recupère le nombre d'élement séléctionner
        int hits = glRenderMode(GL_RENDER);
 
        int sizeList = ListePick.size();
        QVector <CAO_ItemClone*> listeASelectionner;
        listeASelectionner.clear();
 
 
        GLuint names, *ptr;
        ptr = (GLuint *) BUFFER;
        for (unsigned int i = 0; i < hits; i++)
        {
            //On recupère le numbre de pick
            names = *ptr;
            ptr++;
 
            //coordonnée minimum
            ptr++;
 
            //coordonnée maximum
            ptr++;
 
            //et enfin on recupère tout les pickingID
            for (unsigned int j = 0; j < names; j++)
            {
                printf ("%d ", *ptr);
                if (ListePick.find(*ptr)!= ListePick.end())
                {
                    listeASelectionner.push_back(ListePick[*ptr]);
                    qDebug() << "selection ID " << QString::number(*ptr);
                }
                else
                {
                    qDebug() << "On a Selectionner un pickingID non existant ! ! !" << QString::number(*ptr);
                }
                ptr++;
            }
        }
 
        qDebug() << "taille de la liste" << QString::number(sizeList);
        liste->Selection(listeASelectionner);
 
        //on vide le buffer
        for (unsigned int i =0; i <BUFFERSIZE; i++)
            BUFFER = 0;
        delete BUFFER;
        BUFFER = NULL;
 
    }glPopName();

et surtout ne pas oublier de mettre ceci dans la fonction d'affichage pour bien tout réinitialisé :

Code :

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

1
2
3
4
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(20.0f, (GLdouble)width()/(GLdouble)height(), 0.1, 5000);
    glMatrixMode(GL_MODELVIEW);

En tout cas merci pour ton aide MilWolf

[infernalbuild]

Pourquoi ne pas utiliser un framebuffer
Tu affiche un par un tes objets dans un framebuffer puis avec un shader glsl tu test si ta souris est au dessus du depth buffer de ton objet et tu sauvegarde le depth a ce point et après tu teste le 2 objet si ta valeur que tu as récupérer sur le depth est inférieur alors tu sais que c est la forme a sélectionner. Et tu teste pour tout tes objets. L objet avec la valeur la plus petite seras celui a sélectionner.