sp.cpp

// Démonstration du mécanisme de sélection et picking
// la souris (bouton gauche) permet de faire tourner toute la scène
//
// Clic droit sur un des points pour le sélectionner et l'afficher en jaune
// Echap pour quitter l'application

#include <iostream>
#include <stdlib.h>
#include <GL/glut.h>

using namespace std;

class Scene{
public:
  GLfloat spinG_x, spinG_y; //Rotation globale de la scène
  GLint selected;           //Nom du point sélectionné
  int mouse_x, mouse_y;     //Sauvegarde des coordonnées de la souris
  int mode_selection;       //Est-on en mode sélection ?
  GLfloat x0,y0,z0,x1,y1,z1;//Coordonnées de deux points P0 et P1

  Scene(){
    spinG_x = spinG_y = 0;
    selected = -1;
    x0 = y0 = z0 = -2;
    x1 = y1 = z1 = 2;
    mode_selection = false;
  }
  void Init(){
    //On épaissit les points
    glPointSize(10);
    //On épaissit les lignes
    glLineWidth(2.0);
  }
  void setProjection(){
    glOrtho(-5, 5, -5, 5, -5, 5);
  }
  void Draw(GLenum mode);

  ~Scene(){};
};


//Affiche la scène pour l'affichage ou pour le picking
void Scene::Draw(GLenum mode)
{ 
  glPushMatrix();
  {
    //On contrôle à la souris la rotation globale de la scène
    glRotatef(spinG_y, 1, 0, 0);
    glRotatef(spinG_x, 0, 1, 0);
    
    
    if (mode == GL_RENDER)
      {
        //Segment de droite blanc
        glColor3f(1, 1, 1);
        glBegin(GL_LINES);
        glVertex3f(x0, y0, z0);
        glVertex3f(x1, y1, z1);
        glEnd();
        
        //Deux points bleutés ou jaunes s'ils sont sélectionnés
        glBegin(GL_POINTS);
        if (selected == 1)
          glColor3f(1, 1, 0);  
        else
          glColor3f(0, 0, .8);  
        glVertex3f(x0, y0, z0);

        if (selected == 2)
          glColor3f(1, 1, 0);  
        else
          glColor3f(0, 0, .8);  
        glVertex3f(x1, y1, z1);
        glEnd();

        glColor3f(0, 0, .8);  
      }
    else //mode GL_SELECT
      {
        //ATTENTION, on ne peut pas mettre le glLoadName ENTRE glBegin et glEnd !

        //Deux points avec leurs noms
        glLoadName(1);
        glBegin(GL_POINTS);
        glVertex3f(x0, y0, z0);
        glEnd();

        glLoadName(2);
        glBegin(GL_POINTS);
        glVertex3f(x1, y1, z1);
        glEnd();
    }
  }
  glPopMatrix();

} //Draw()


Scene s;


//Pour redimensionner la fenêtre
void myReshapeFunc(int w,int h)
{
  glViewport(0,0,(GLint) w,(GLint) h);

  glMatrixMode( GL_PROJECTION );
  glLoadIdentity();
  
  s.setProjection();
  
  glMatrixMode( GL_MODELVIEW );
}//myReshapeFunc()
 

//Fonction d'affichage
void myDisplayFunc()
{
  // Nettoyage du "Tampon Chromatique" et du "Z buffer" 
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  //On dessine la scène
  s.Draw(GL_RENDER);
  
  // Permute les "back buffer" et "front buffer" (double-buffering).
  glutSwapBuffers();
  
}//myDisplayFunc()

 
//traitement du buffer de picking
void processHits (GLint hits, GLuint buffer[])
{
  GLuint i, nb_names, name, *ptr;
  GLdouble z1, z2;

  //on réinitialise la sélection
  s.selected = -1;

  //S'il y a plusieurs hits, il faudrait choisir le nom de l'objet le plus proche
  //  et non pas celui du dernier hit comme ici.
  printf ("hits = %d\n", hits);
  ptr = (GLuint *) buffer;
  for (i = 0; i < hits; i++) {  /*  for each hit  */
    nb_names = ptr[0];
    if (nb_names != 1) {
      cerr << "erreur, ce programme ne supporte qu'un seul nom dans la pile, et non pas " << nb_names << endl;
      exit(1);
    }
    
    z1 = (double) ptr[1]/0x7fffffff;
    z2 = (double) ptr[2]/0x7fffffff;
    cout << "zmin = " << z1 << ", zmax= " << z2 << endl;
    
    name = ptr[3];
    s.selected = name;
    cout << "selected = " << s.selected << endl;
  }
}

#define BUFSIZE 512

//Pour sélectionner un objet dans la scène
void myPick(int x, int y){
  GLuint selectBuf[BUFSIZE];
  GLint hits;
  GLint viewport[4];

  //on récupère le viewport courant
  glGetIntegerv(GL_VIEWPORT, viewport);
  
  glSelectBuffer(BUFSIZE, selectBuf);
  (void) glRenderMode(GL_SELECT);
  
  //Initialisation de la pile des noms
  glInitNames();
  glPushName(0);
  
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  /*  create 10x10 pixel picking region near cursor location    */
  gluPickMatrix((GLdouble) x, (GLdouble) (viewport[3] - y), 
                 10.0, 10.0, viewport);
  //On doit avoir la même projection en mode sélection qu'en mode rendu :
  s.setProjection();
  glMatrixMode(GL_MODELVIEW);

  //On calcule la scène pour le picking : elle n'est pas dessinée dans un tampon chromatique
  s.Draw(GL_SELECT);
  
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);

  //On s'assure que les ordre OpenGL sont exécutés
  glFlush();
  
  hits = glRenderMode(GL_RENDER);

  //On traite les sommets cliqués
  processHits (hits, selectBuf);

  glutPostRedisplay(); 
}

void myKeyboardFunc(unsigned char k,int x,int y)  
{ 
  switch(k)  
    { 
    case 27 : exit(0);break;
    default: break; 
    }  
  // actualisation de l'affichage  
  glutPostRedisplay();

}//myKeyboardFunc()

//myMouseFunc
void myMouseFunc(int button, int state, int x, int y) 
{
  if ((button == GLUT_RIGHT_BUTTON)
      && (state == GLUT_DOWN)){
    //On utilise le bouton de droite pour le picking des points
    s.mode_selection = true;
    
    cout << "Picking" <<endl;
    myPick(x, y); 
  }
  
  if ((button == GLUT_LEFT_BUTTON)
      && (state == GLUT_DOWN)){
    s.mode_selection = false;

    s.mouse_x = x;
    s.mouse_y = y;
    //    cout << "mouse_x = "<< s.mouse_x << endl;
    //    cout << "mouse_y = "<< s.mouse_y << endl;
  }    
  glutPostRedisplay(); 
}//myMouseFunc
  
void myMotionFunc(int x, int y){
  if (!s.mode_selection){
    s.spinG_x += (s.mouse_x - x);
    if (s.spinG_x > 360.0) s.spinG_x -= 360.0;
    if (s.spinG_x < -360.0) s.spinG_x += 360.0;
    
    s.spinG_y += (s.mouse_y - y);
    if (s.spinG_y > 360.0) s.spinG_y -= 360.0;
    if (s.spinG_y < -360.0) s.spinG_y += 360.0;
    
    s.mouse_x = x;
    s.mouse_y = y;
    //    cout << "mouse_x = "<< s.mouse_x << endl;
    //    cout << "mouse_y = "<< s.mouse_y << endl;
    
    glutPostRedisplay();
  }
}//myMotionFunc()


void init(int argc,char** argv)
{ 
  glutInit(&argc,argv);
  // Paramètres du contexte de rendu.
  glutInitDisplayMode( GLUT_DOUBLE |GLUT_DEPTH );
  // Dimensions de la fenêtre.
  glutInitWindowSize(500, 500);
  // Position du coin haut-gauche de la fenêtre.
  glutInitWindowPosition(50,50);
  // Creation de la fenêtre (titre en paramètre).
  glutCreateWindow("Selection et Picking");
  // Association des fonctions utilisateurs et des 
  // callbacks glut (appelées lors d'un événement).
  glutReshapeFunc(myReshapeFunc);
  glutDisplayFunc(myDisplayFunc);
  glutKeyboardFunc(myKeyboardFunc); 
  glutMouseFunc(myMouseFunc);
  glutMotionFunc(myMotionFunc);

  // Couleur du fond
  glClearColor(.5, 0, 0, 1);

  // Activation du test de profondeur
  glEnable(GL_DEPTH_TEST);
        
  //Initialisation de la scène
  s.Init();
        
}//init()

int main(int argc,char **argv)
{
  init(argc,argv);
  glutMainLoop();
  return 0;

}//main()

---