OpenGL : l'input avec GLUT

Introduction

Jusqu'à maintenant, nous avons fait pas mal de trucs, tous toujours plus beaux les uns que les autres, mais nous n'avons jamais pu vraiment contrôler les objets. Ce que nous faisions de mieux c'était tourner autour plus ou moins vite et puis c'est tout. En plus la vitesse de rotation dépendait de la vitesse d'affichage, et vu que c'était prévu pour tourner de façon fluide en software, on distinguait plus grand chose avec une GeForce... Nous allons donc apprendre comment gérer les interactions utilisateurs : souris, clavier, et pourquoi pas tablette graphique. Il n'y aura pas de code OpenGL spécifique dans ce tutorial, mais vous pourrez l'utiliser pour modifier les exemples des tuts précédents.

 

1. Généralités

Bon, vous avez vraiment du bol que je fasse ça, parce que sous GLUT, c'est tellement simple que c'est presque inutile de faire un tutorial là-dessus. Mais bon puisque y'en a un sous Windows, autant faire le pendant pour GLUT.
Donc, si vous connaissez l'anglais et que vous avez pas envie de vous taper toute cette page, allez directement à la page de specs de GLUT, et vous trouverez tout de suite ce qu'il vous faut. En tout cas le principe n'est pas dur à comprendre : jusqu'ici, on utilisait par exemple glutDisplayFunc() pour dire à GLUT quelle fonction se chargeait de l'affichage, et ben c'est toujours pareil : on va dire à GLUT quelle fonction gèrera le clavier ou la souris, c'est pas plus dur que ça !

 

2. Le clavier

Les touches reçues par GLUT sont divisées en 2 parties : les touches simples, qui peuvent être traduites par un char, et les touches spéciales, qui correspondent à un code ASCII étendu (flèches, touches de fonction...). La gestion du clavier est donc séparée en 2 fonctions : celle qui gère les touches normales, et celle qui gère les touches spéciales :

 

1.1 glutKeyboardFunc()

Cette fonction sert à spécifier à GLUT quelle fonction s'occupe de la gestion des touches normales. Elle prend donc en paramètre le nom de la fonction. La fonction de gestion doit avoir 3 paramètres : le code ASCII de la touche, et la position x et y de la souris. Un petit exemple :

void GestionClavier(unsigned char key, int x, int y)
{
printf("vous avez appuyé sur %c ",key);
printf("position de la souris : ");
printf("%d,%d ",x,y);  
if (key==27) exit(0);  
}
int main()
{
// Initialisation de GLUT etc...
glutKeyboardFunc(GestionClavier);
glutMainLoop();
}

C'est aussi simple que ça : votre fonction peut s'appeler n'importe comment, mais elle doit forcément recevoir les paramètres (unsigned char, int, int), sinon GLUT n'est pas content. Ici la fonction ne fait qu'afficher les paramètres, et quitte le programme si l'utilisateur a appuyé sur Escape (dont le code ASCII est 27 comme chacun sait).

 

1.2 glutSpecialFunc()

Bon, je suppose que vous aurez compris à quoi sert cette fonction. La différence ici, c'est que la touche n'est plus un caractère ASCII, mais un int. Un petit exemple :

void GestionSpecial(int key, int x, int y)
{

printf("vous avez appuyé sur ")

switch (key)
{
case GLUT_KEY_F1 :
case GLUT_KEY_F2 :
case GLUT_KEY_F3 :
case GLUT_KEY_F4 :
case GLUT_KEY_F5 :
case GLUT_KEY_F6 :
case GLUT_KEY_F7 :
case GLUT_KEY_F8 :
case GLUT_KEY_F9 :
case GLUT_KEY_F10 :
case GLUT_KEY_F11 :
case GLUT_KEY_F12 :
case GLUT_KEY_LEFT :
case GLUT_KEY_UP :
case GLUT_KEY_RIGHT :
case GLUT_KEY_DOWN :
case GLUT_KEY_PAGE_UP :
case GLUT_KEY_PAGE_DOWN :
case GLUT_KEY_HOME :
case GLUT_KEY_END :
case GLUT_KEY_INSERT :

printf("F1 ");break;
printf("F2 ");break;
printf("F3 ");break;
printf("F4 ");break;
printf("F5 ");break;
printf("F6 ");break;
printf("F7 ");break;
printf("F8 ");break;
printf("F9 ");break;
printf("F10 ");break;
printf("F11 ");break;
printf("F12 ");break;
printf("Gauche ");break;
printf("Haut ");break;
printf("Droite ");break;
printf("Bas ");break;
printf("Page up ");break;
printf("Page down ");break;
printf("Home ");break;
printf("End ");break;
printf("Insert ");break;

}
printf("position de la souris : ");
printf("%d,%d ",x,y);
}
int main()
{
// Initialisation de GLUT etc...
glutSpecialFunc(GestionSpecial);
glutMainLoop();
}

Et voilà, grâce à cet exemple vous avez tout pigé, et en plus vous avez vu toutes les valeurs que pouvait prendre la touche.

 
Voilà pour ce qui est du clavier. La fonction glutGetModifiers() est aussi en relation avec le clavier, mais comme elle s'applique aussi à la souris, je n'en parlerais qu'à la fin.

 

3. La souris

Cette fois-ci, GLUT nous fournit un peu plus de fontions. En voici la liste :

  • glutMouseFunc() : définit la fonction à appeler lorsqu'un bouton de la souris est appuyé ou relâché. La fonction utilisateur doit avoir les paramètres (int button, int state, int x, int y), où button peu valoir GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, ou GLUT_RIGHT_BUTTON, state vaut GLUT_UP ou GLUT_DOWN, et x et y sont les coordonnées de la souris par rapport à le fenêtre.
  • glutPassiveMotionFunc() : définit la foncion à appeler lorsque la souris bouge. Les paramètres de la fonction utilisateur doivent être du type (int x, int y), où x et y sont les coordonnées du pointeur de la souris.
  • glutMotionFunc() : même chose que la précédente, sauf que la fonction utilisateur ne sera appelée que si la souris bouge et qu'un bouton est appuyé (comme dans un drag'n drop, par exemple)
  • glutEntryFunc() : c'est pas très utile, mais bon. Cette fonction sert à définir la fonction à appeler lorsque la souris sort ou rentre dans la fenêtre. La fonction utilisateur ne recoit qu'un paramètre, de type int, qui vaut GLUT_LEFT si la souris sort de la fenêtre, ou GLUT_ENTERED si la souris rentre dans la fenêtre.
 

4. Les autres

GLUT sait également gérer les tablettes graphiques et autres spaceballs, mais comme tout le monde ne s'en sert pas, je ne vais pas encombrer ce tutorial avec ça. Pour ceux que ca intéresse, ils n'auront qu'à aller voir eux-même dans les pages de références de GLUT.
Par contre il reste une fonction qui sert à la fois pour la souris et pour le clavier : la fonction glutGetModifiers(). Ce n'est pas une fonction de callback comme les précédentes, mais une fonction d'état : elle sert à savoir si les touches Ctrl, Alt ou Shift sont appuyées. Il ne faut l'appeler que dans un fonction de gestion du clavier ou de la souris. Elle ne prend aucun paramètre et renvoie un int qui peut valoir GLUT_ACTIVE_SHIFT, GLUT_ACTIVE_CTRL ou GLUT_ACTIVE_ALT.

Ben voilà c'est déjà terminé. Pas de source à télécharger aujourd'hui, puisqu'on a rien vu de particulier niveau OpenGL.

Antoche
 


← Les textures↑ Tutoriaux OpenGL ↑L'input avec Windows →