Introduction

Les mécanismes de sélection et de picking permettent l'interaction de l'utilisateur avec la scène 3-D :

• Sélection d'un ou plusieurs objets à l'écran
• On donne un nom à chaque objet, le mécanisme de sélection renvoie la liste des noms
• Il est facile de gérer des hiérarchies d'objets

Le mécanisme de feedback permet de récupérer des informations sur ce qui doit être dessiné sur l'écran

Sélection

1. On dessine d'abord la scène dans le framebuffer.
2. On entre en mode sélection et on redessine la scène.
3. Quand on sort du mode sélection, on reçoit la liste les primitives qui intersectent le volume de visualisation (défini par la modelview, la projection, et les plans de clipping)
4. Chaque primitive génère un hit, chaque hit contient un tableau de noms (qui sont en fait des entiers).

Sélection : les étapes

1. Spécifier la zone mémoire pour le retour des informations de sélection par glSelectBuffer().
2. Entrer en mode sélection en passant GL_SELCT à glRenderMode().
3. Initialiser la pile de noms avec glInitNames() et glPushName().
4. Définir le volume à utiliser pour la sélection. Penser à sauvegarder l'ancien volume par les glPushMatrix() et glPopMatrix() appropriés.
5. Redessiner la scène, et faire des appels aux fonctions de manipulation de la pile de noms
6. Sortir du mode sélection, et examiner les données retournées (une liste de hits).

Sélection : gestion de la pile de noms

glInitNames();
glPushName(-1);

glPushMatrix();   /* save the current transformation state */

    /* create your desired viewing volume here */

    glLoadName(1);
    drawSomeObject();
    glLoadName(2);
    drawAnotherObject();
    glLoadName(3);
    drawYetAnotherObject();
    drawJustOneMoreObject();

glPopMatrix ();   /* restore the previous transformation state*/

Sélection : exemple

select.c

> ./select 
hits = 2
 number of names for hit = 1
  z1 is 3.05176e-05; z2 is 3.05176e-05
   the name is 1 
 number of names for hit = 1
  z1 is 3.05176e-05; z2 is 3.05176e-05
   the name is 3 

Le picking : un cas particulier de la sélection

On utilise gluPickMatrix() pour effectuer la sélection sur une petite zone de l'affichage

On multiplie la matrice de projection par la matrice suivante :

Utilisation

      glMatrixMode (GL_PROJECTION);
      glPushMatrix ();
      glLoadIdentity ();
      gluPickMatrix (...);
      gluPerspective, glOrtho, gluOrtho2D, or glFrustum
         /* ... draw scene for picking ; perform picking ... */
      glPopMatrix();

Picking : exemple

picksquare.c

> ./picksquare 
hits = 1
 number of names for this hit = 2
  z1 is 3.05176e-05; z2 is 3.05176e-05
   names are 1 1 
hits = 1
 number of names for this hit = 2
  z1 is 3.05176e-05; z2 is 3.05176e-05
   names are 2 1 
hits = 4
 number of names for this hit = 2
  z1 is 3.05176e-05; z2 is 3.05176e-05
   names are 1 0 
 number of names for this hit = 2
  z1 is 3.05176e-05; z2 is 3.05176e-05
   names are 1 1 
 number of names for this hit = 2
  z1 is 3.05176e-05; z2 is 3.05176e-05
   names are 2 0 
 number of names for this hit = 2
  z1 is 3.05176e-05; z2 is 3.05176e-05
   names are 2 1 

Picking : gestion d'une hiérarchie d'objets

On utilise des noms multiples, qui reflètent la hiérarchie d'objets :

Création de noms multiples

draw_wheel_and_bolts()
{
    long i;

    draw_wheel_body();
    for (i = 0; i < 5; i++) {
        glPushMatrix();
            glRotate(72.0*i, 0.0, 0.0, 1.0);
            glTranslatef(3.0, 0.0, 0.0);
            glPushName(i);
                draw_bolt_body();
            glPopName();
        glPopMatrix();
    }
 }

draw_body_and_wheel_and_bolts()
{
    draw_car_body();
    glPushMatrix();
        glTranslate(40, 0, 20);  /* first wheel position*/
        glPushName(1);           /* name of wheel number 1 */
            draw_wheel_and_bolts();
        glPopName();
    glPopMatrix();
    glPushMatrix();
        glTranslate(40, 0, -20); /* second wheel position */
        glPushName(2);           /* name of wheel number 2 */
            draw_wheel_and_bolts();
        glPopName();
    glPopMatrix();

    /* draw last two wheels similarly */
 }

Utilisation des noms multiples

draw_three_cars()
{
    glInitNames();
    glPushMatrix();
        translate_to_first_car_position();
        glPushName(1);
            draw_body_and_wheel_and_bolts();
        glPopName();
    glPopMatrix();

    glPushMatrix();
        translate_to_second_car_position();
        glPushName(2);
            draw_body_and_wheel_and_bolts();
        glPopName();
    glPopMatrix();

    glPushMatrix();
        translate_to_third_car_position();
        glPushName(3);
            draw_body_and_wheel_and_bolts();
        glPopName();
    glPopMatrix();
}

Exemples de résultats

d1 et d2 sont les valeurs de profondeur min et max du pick

• vide: pick en dehors de toutes les voitures
• 2 d1d2 2 1: voiture 2, roue 1
• 1 d1d2 3: corps de la voiture 3
• 3 d1d2 1 1 0: écrou 0 sur roue 1 sur voiture 1

Picking et profondeur

Les valeurs de profondeur retournées permettent éventuellement de distinguer les objets par leur profondeur, si deux objets ont le même nom.

Exemple

pickdepth.c

> ./pickdepth 
hits = 1
 number of names for hit = 1
  z1 is 0.833333; z2 is 0.833333
   the name is 3 
hits = 2
 number of names for hit = 1
  z1 is 0.166667; z2 is 0.166667
   the name is 1 
 number of names for hit = 1
  z1 is 0.5; z2 is 0.5
   the name is 2 
hits = 3
 number of names for hit = 1
  z1 is 0.166667; z2 is 0.166667
   the name is 1 
 number of names for hit = 1
  z1 is 0.5; z2 is 0.5
   the name is 2 
 number of names for hit = 1
  z1 is 0.833333; z2 is 0.833333
   the name is 3 

Avantages de la sélection OpenGL

• Utilisation efficace du pipeline de rendu OpenGL : il suffit d'ajouter les noms aux fonctions de rendu
• Gère l'instanciation et les hiérarchies
• Retourne tous les objets du volume de visualisation

Limitations de la sélection OpenGL

• Ne considère pas la largeur des traits ou - plus grave - la taille des images raster
• Pas de culling, pas de test de visibilité
• Lent si la géométrie de la scène est complexe
• Lent si on veut sélectionner pendant le déplacement du curseur (highlighting)
• Pas forcément efficace pour de la sélection dans une scène 2D

Solutions

• Utiliser une représentation alternative pour la sélection : plus simple (bounding box), ou plus réaliste (rectangles pour un trait large).
• Considérer des méthodes plus directe, n'utilisant pas OpenGL
• Si on n'a besoin que de l'objet le plus proche, utiliser plutôt le marquage coloré
• Si on n'a besoin que de la profondeur de la zone pointée, utiliser glReadPixels() sur le depth buffer. Ça permet aussi de calculer la normale de la surface en lisant une zone de 3x3 pixels.

Picking par marquage coloré

• On redessine la scène dans le back-buffer, en utilisant une couleur par objet
• Utiliser glColor3ub(), en encodant le nom de l'objet ou la hiérarchie d'objets dans la couleur
• Attention aux possibilité hardware, notamment profondeur des buffers (8 bits par couleur = 24 bits par identifiant)
• "Partitionner" les bits pour gérer la hiérarchie
• Désactiver texturing, blending, dithering, lighting et smooth shading
• On lit l'identifiant sous le curseur par glReadPixels()
• Attention aux manipulations sur les front- et back-buffers.

Avantages

• Un seul identifiant par point : l'objet le plus proche
• Rapide

Surbrillance

• Combine le picking et le dessin en surimpression :
  • Retour visuel sur le processus de sélection
  • Évite de redessiner la scène entière
• Nécessite :
  • Un picking rapide
  • Un dessin en surimpression qui détruise au minimum l'image (on n'a pas le droit au back-buffer !)

Surbrillance : mode d'emploi

Picking rapide

• Utiliser le marquage coloré, le buffer pouvant être réutilisé d'un pick à l'autre
• Effectuer l'affichage de la surbrillance dans le front buffer
• Pour accélérer, utiliser une géométrie dégradée (bounding boxes), surtout si on n'utilise pas le marquage coloré

Surbrillance

• Utiliser les overlay planes s'ils sont disponibles, mais attention :
  • Pas toujours (rarement ?) supportés par le matériel
  • Pas de depth buffer
• XOR sur le bit le plus significatif des composantes de chaque couleur glEnable(GL_COLOR_LOGIC_OP), glLogicOp(GL_XOR)
• Redessiner l'objet avec glDepthFunc(GL_EQUAL)

Feedback

Retourne des informations sur ce qui doit être dessiné.

Exemple d'utilisation : Export vers un format de fichier 3D, impression

Les étapes du mode feedback :

1. Appeler glFeedbackBuffer() pour spécifier le tableau devant recevoir les données sur les objets dessinés.
2. Appeler glRenderMode(GL_FEEDBACK). Apres cet appel, les primitives ne sont plus rasterisées, à la place le feedback buffer est rempli.
3. Dessiner. Éventuellement, faire des appels à glPassThrough() pour insérer des marqueurs dans le feedback buffer
4. Appeler glRenderMode(GL_RENDER), qui renvoie le nombre de valeurs stockées dans le feedback buffer.
5. Parser le feedback buffer

Exemple

feedback.c

> ./feedback 
GL_LINE_RESET_TOKEN
  30.00 30.00 0.00 0.84 0.84 0.84 1.00 
  50.00 60.00 0.00 0.84 0.84 0.84 1.00 
GL_LINE_TOKEN
  50.00 60.00 0.00 0.84 0.84 0.84 1.00 
  70.00 40.00 0.00 0.84 0.84 0.84 1.00 
GL_PASS_THROUGH_TOKEN
  1.00
GL_PASS_THROUGH_TOKEN
  2.00
GL_POINT_TOKEN
  50.00 50.00 0.00 0.84 0.84 0.84 1.00 

Références

• http://reality.sgi.com/blythe/sig99/advanced99/overview.html
  : Advanced Graphics Programming Techniques using OpenGL
• http://ask.ii.uib.no/ebt-bin/nph-dweb/dynaweb/SGI_Developer/OpenGL_PG/
  ou
  http://fly.srk.fer.hr/~unreal/theredbook/
  : OpenGL programming guide