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 | |
