L'Utility Toolkit: GLUT

AFFICHAGE

TÂCHE DE FOND

AJUSTEMENT
TAILLE FENÊTRE

CLAVIER

SOURIS

DESSIN
D'OBJETS

MENUS

FENÊTRES
MULTIPLES

POLICES DE
CARACTÈRES

RETOUR

Facilite la programmation d'applications utilisant OpenGL au moyen d'un jeu de fonctions d'interfaçage vis à vis du système d'exploitation de l'ordinateur (Interface graphique).

Programmation événementielle: Une boucle infinie avec gestion par le dispositif GLUT d'une file d'attente d'événements et exécution de fonctions prédéfinies ou paramètrables par le programmeur en réaction à ces événements.

Fonctionnalités principales

Définition et ouverture d'une ou plusieurs fenêtres d'affichage.

Définition de fonctions devant s'exécuter en réaction à des événements du type:

• raffraichissement de l'image,
• modification de la taille de la fenêtre d'affichage,
• utilisation de la souris dans la zone d'affichage,
• utilisation du clavier,
• ...

Création de menus et définition de fonctions exécutées en association avec des entrées dans ces menus.

Initialisation et ouverture d’une fenêtre d'affichage

• void glutInit(int *argc,char **argv);

Initialise la bibliothèque GLUT. Traite les options de ligne de commande (celles reçues en entête de fonction main) (options non décrites ici).

• void glutInitDisplayMode(unsigned int b);

Définit le type de fenêtre d'affichage par composition des constantes suivantes:
- GLUT_RGBA ou GLUT_INDEX (vraies couleurs ou couleurs indexées),
- GLUT_SINGLE ou GLUT_DOUBLE (simple ou double buffer),
- GLUT_DEPTH, GLUT_STENCIL et GLUT_ACCUM (utilisation de tampons profondeur, stencil et/ou accumulation).

• void glutInitWindowPosition(int x,GLint y);

Définit la position de la fenêtre sur l'écran.

• void glutInitWindowSize(int larg,int haut);

Définit la taille de la fenêtre à l'écran.

• int glutCreateWindow(char *t);

Crée une fenêtre avec le titre t selon les paramètres définis lors de l'exécution des fonctions précédentes. La fenêtre n'est affichée qu'ultérieurement lors de l'exécution de glutMainLoop.
La fonction rend un handle entier désignant la fenêtre ouverte.

Affichage principal

• void glutDisplayFunc(void (*displayFunc)(void));

Définit la fonction exécutée automatiquement par GLUT quand un événement intervient entraînant le rafraîchissement de l'image affichée (création initiale de la fenêtre d'affichage, déplacement, agrandissement, réduction, réactivation en avant-plan, ordre par programme, ...).

La fonction display passée en paramètre ne doit assurer l'affichage que d'une seule image. Son prototype doit obligatoirement correspondre à
void (*display)(void).

• void glutMainLoop(void);

Fonction assurant la boucle principale d'affichage. La fonction glutMainLoop est bloquante. Elle gère les événements liés au fonctionnement du programme et exécute les fonctions associées par le programmeur à ces événements -> simili programmation événementielle.

• void glutPostRedisplay(void);

Fonction plaçant en file d'attente d'événements un ordre de rafraîchissement de la fenêtre d'affichage active.

• void glutPostWindowRedisplay(int handle);

Fonction plaçant en file d'attente d'événements un ordre de rafraîchissement de la fenêtre d'affichage désignée par le handle.

• void glutSwapBuffers(void);

Fonction assurant le swap entre les deux buffers d'affichage dans le cas où le double buffering est utilisé.

Squelette d'un programme

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme,   */
  /* appels de fonctions OpenGL     */
  /* réalisés une fois et une seule */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  glutMainLoop();
  return(0);
}

Gestion d'un processus en tâche de fond

• void glutIdleFunc(void (*fonct)(void));

Définit la fonction exécutée automatiquement par GLUT s'il n'y a pas d'événement en attente et donc si l'application est disponible pour la réalisation d'une tâche annexe
-> exécution d'actions en tâche de fond.ter par GLUT s'il n'y a pas d'événement en attente et donc que l'application est disponible pour la réalisation d'une tâche annexe -> exécution d'actions en tâche de fond.ter par GLUT s'il n'y a pas d'événement en attente et donc que l'application est disponible pour la réalisation d'une tâche annexe
-> exécution d'actions en tâche de fond.

Cette fonction est fréquemment utilisée pour programmer des animations. Dans ce cadre, elle est généralement dédiée à la modification de variables globales employées dans la fonction display et ne contient pas d'appel de fonction OpenGL.
Il lui est possible de demander l'affichage d'une nouvelle image via glutPostRedisplay ou glutPostWindowRedisplay générant ainsi l'animation car chaque idle entraine un display et idle est lancé de manière récurente quand rien d'autre n'est à réaliser.

Le prototype de la fonction en paramètre doit obligatoirement correspondre à void (*idle)(void).

Squelette d'une application avec gestion d'une tâche de fond

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme */
}

void idle(void)
{ /* Tâche de fond */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  glutIdleFunc(idle);
  glutMainLoop();
  return(0);
}

Gestion des redimensionnements fenêtre

• void glutReshapeFunc(void (*fonct)(int larg,int haut));

Définit la fonction exécutée automatiquement par GLUT avant le rafraîchissement (lui aussi automatique) d’une fenêtre dont la taille est modifiée.

Cette fonction "reshape" est habituellement employée pour configurer deux caractéristiques liées à la visualisation:
- la zone de la fenêtre d'affichage dans laquelle l'image est affichée,
- le mode de représentation (projection parallèle ou en perspective) et ses paramètres,
et éventuellement pour amorcer le dessin de la scène en fixant un point de vue. Elle doit obligatoirement avoir en entête deux paramètres de type entier qui représentent les tailles en x et en y de la fenêtre après changement de dimension.
Ces paramètres permettront éventuellement à la fonction reshape d'adapter son action aux nouvelles dimensions de la fenêtre.

Squelette d'une application avec gestion des modifications du fenêtrage

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme */
}

void myReshape(int w, int h)
{ /* opérations
     de rafraîchissement */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  glutReshapeFunc(myReshape);
  glutMainLoop();
  return(0);
}

Gestion des événements clavier

• void glutKeyboardFunc(void (*fonct)
  (unsigned char key,int x,int y))

Définit la fonction exécutée automatiquement par GLUT lorsqu'une touche ASCII du clavier est frappée. Au moment de son exécution, cette fonction recevra les paramètres key, x et y contenant respectivement le code ASCII de la touche de clavier et les positions instantanées en x et en y de la souris relativement à la fenêtre au moment de la frappe clavier.

Squelette d'une application avec gestion des touches ASCII du clavier

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme */
}

void key(unsigned char k,int x,int y)
{ /* opérations exécutées
     lors de la frappe
     d'une touche
     de clavier ASCII */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  glutKeyboardFunc(key)
  glutMainLoop();
  return(0);
}

• void glutSpecialFunc(void (*fonct)(int key,int x,int y))

Définit la fonction exécutée automatiquement par GLUT lorsqu'une touche de fonction ou une touche de curseur du clavier est frappée. Au moment de son exécution, cette fonction recevra les paramètres key, x et y contenant respectivement le code de la touche de clavier (GLUT_KEY_F1 à GLUT_KEY_F12, GLUT_KEY_LEFT, GLUT_KEY_RIGHT, GLUT_KEY_UP, GLUT_KEY_DOWN, GLUT_KEY_PAGE_DOWN, GLUT_KEY_PAGE_UP, GLUT_KEY_HOME, GLUT_KEY_END, GLUT_KEY_INSERT) et les positions instantanées en x et en y de la souris relativement à la fenêtre.

Squelette d'une application avec gestion des touches de fonction et de curseur du clavier

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme */
}

void special(int k,int x,int y)
{ /* opérations exécutées
     lors de la frappe
     d'une touche
     de fonction ou de curseur */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  glutSpecialFunc(special)
  glutMainLoop();
  return(0);
}

Gestion des événements souris

• void glutMouseFunc(void (*fonct)(int bouton,int etat,int x,int y));

Définit la liaison entre les clics de boutons de la souris et une fonction -> fonction exécutée automatiquement par GLUT quand les boutons de la souris sont utilisés.
Cette fonction est exécutée avec un jeu de paramètres fonction de l'utilisation réalisée de la souris:
bouton: GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON ou GLUT_RIGHT_BUTTON
etat: GLUT_UP ou GLUT_DOWN
x,y: position de la souris dans la fenêtre au moment de l'événement

Squelette d'une application avec gestion des clics de souris

#include <GL/gl.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <GL/glut.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme */
}

void mouse(int bouton,int etat,
           int x,int y)
{ /* opérations exécutées
     lors de l'arrivee
     d'un clic de souris */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  glutMouseFunc(mouse);
  glutMainLoop();
  return(0);
}

• void glutMotionFunc(void (*fonct)(int x,int y));

Définit la fonction exécutée automatiquement par GLUT quand la souris se déplace devant la fenêtre avec un bouton appuyé.
x et y sont les positions de la souris dans la fenêtre au moment de l'appel de la fonction.

• void glutPassiveMotionFunc(void (*fonct)(int x,int y));

Définit la fonction exécutée automatiquement par GLUT quand la souris se déplace devant la fenêtre sans bouton appuyé.
x et y sont les positions de la souris dans la fenêtre au moment de l'appel de la fonction.

Squelette d'une application avec gestion des déplacements de la souris

#include <GL/gl.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <GL/glut.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme */
}

void mMotion(int x,int y)
{ /* opérations exécutées
     lors du deplacement
     de la souris
     bouton appuye */
}

void mPMotion(int x,int y)
{ /* opérations exécutées
     lors du deplacement
     de la souris
     bouton relache */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  glutMotionFunc(mMotion);
  glutPassiveMotionFunc(mPMotion);
  glutMainLoop();
  return(0);
}

Dessin d’objets 3D en fil de fer ou en volumique

Fonctions génériques:

• void glutWireObjet() ;

• void glutSolidObjet() ;

Les objets sont facettetisés.

Fonctionnalités supplémentaires par rapport à Aux

Gestion des menus

GLUT permet la gestion de menus pop-up en cascade au sein des fenêtres d'affichage.

• int glutCreateMenu(void (*fonct)(int v));

Crée un nouveau menu pop-up et rend un identificateur entier pour ce menu. La fonction passée en paramètre est la fonction de traitement des items du menu. Le "menu courant" devient le menu créé.

• void glutAttachMenu(int bouton);

Attache le menu courant à la fenêtre courante et l'associe à un clic du bouton de souris spécifié (GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON ou GLUT_RIGHT_BUTTON).

• void glutAddMenuEntry(char *name,int value);

Ajoute un item supplémentaire à la fin du menu courant. Le paramètre name définit la chaîne de caractères d'affichage de l'item. Le paramètre value définit la valeur passée à la fonction de traitement exécutée lors de l'activation de l'item.

• int glutAddSubMenu(char *nom,int menu);

Ajoute un sous-menu à la fin du menu courant. Le paramètre name définit la chaîne de caractères d'affichage de l'item. Le paramètre menu est l'identificateur du sous-menu ajouté.

Squelette d'une application avec un menu et un sous-menu

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void display(void)
{ /* dessin de la scène */
}

void myinit(void)
{ /* initialisation du programme */
}

void select(int selection)
{ /* opérations réalisées
     en fonction
     de l'item sélectionné */
}

void select2(int selection)
{ /* opérations réalisées
     en fonction
     de l'item sélectionné */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow(argv[0]);
  glutDisplayFunc(display);
  myinit();
  int sMenu;
  sMenu = glutCreateMenu(select2);
  glutAddMenuEntry("S-Option 1",0);
  glutAddMenuEntry("S-Option 2",1);
  int mainMenu;
  menu = glutCreateMenu(select);
  glutAddMenuEntry("Option 1",0);
  glutAddMenuEntry("Option 2",1);
  glutAddSubMenu("Sous-menu",
                 sMenu);
  glutAddMenuEntry("Quitter",2);
  glutAttachMenu(GLUT_LEFT_BUTTON);
  glutMainLoop();
  return(0);
}

Gestion des environnements multi-fenêtrés

GLUT permet la gestion de plusieurs fenêtres d'affichage 3D au sein d'un même programme.

La fonction glutCreateWindow peut être appelée plusieurs fois pour créer plusieurs fenêtres munies individuellement d'un environnement d'affichage paramètrable au moyen des fonctions classiques glutReshapeFunc, glutDisplayFunc, glutMouseFunc, glutMotionFunc, glutKeyboardFunc, ... Attention, contrairement aux autres fonctions de gestion des événements, il n'existe qu'une seule fonction idle paramétrable par glutIdleFunc pour l'ensemble des fenêtres.

Autres fonctions de gestion des fenêtres

• void glutDestroyWindow(int fenetre);

Détruit la fenêtre spécifiée.

• void glutPositionWindow(int x,int y);

Déplace la fenêtre courante aux coordonnées (x,y).

• void glutReshapeWindow(int larg,int haut);

Dimensionne la fenêtre courante avec pour nouvelle taille (larg,haut).

• void glutFullScreen(void);

Dimensionne la fenêtre courante en plein écran.

• void glutPushWindow(void);

• void glutPopWindow(void);

Change la place de la fenêtre courante dans l'ordre d'empilement des fenêtres.

• int glutShowWindow(void);

• int glutHideWindow(void);

• int glutIconifyWindow(void);

Activation, désactivation et icônification de la fenêtre courante.

Squelette d'une application avec deux fenêtres d'affichage 3D

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void displayMain(void)
{ /* dessin de la scène
     de la fenêtre principale */
}

void displayFille(void)
{ /* dessin de la scène
     de la fenêtre fille */
}

void myinit(void)
{ /* initialisation du programme */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  int f1;
  f1 = glutCreateWindow("Main");
  glutDisplayFunc(displayMain);
  int f2;
  f2 = glutCreateWindow("Fille");
  glutDisplayFunc(displayFille);
  myinit();
  glutMainLoop();
  return(0);
}

Polices de caractères bitmap et vectorielle

GLUT gère les polices de caractères bitmap et vectorielle. L'avantage des polices bitmap est une grande rapidité d'affichage, tandis que les polices vectorielles supportent les fonctions GL classiques telles que glTranslatef, glScalef, glRotatef, glLineWidth, ...

• void glutBitmapCharacter(void *font,int c);

Affiche un caractère en bitmap. c est le caractère à afficher. font est la police de caractères bitmap utilisée:
  GLUT_BITMAP_9_BY_15,
  GLUT_BITMAP_8_BY_13,
  GLUT_BITMAP_TIMES_ROMAN_10,
  GLUT_BITMAP_TIMES_ROMAN_24,
  GLUT_BITMAP_HELVETICA_10,
  GLUT_BITMAP_HELVETICA_12,
  GLUT_BITMAP_HELVETICA_18.

• int glutBitmapWidth(void *font,int c);

Retourne la largeur du caractère c dans la police de caractères bitmap font.

• void glutStrokeCharacter(void *font,int c);

Affiche un caractère en vectoriel (par segments de droites). c est le caractère à afficher. font est la police de caractères vectorielle utilisée:
  GLUT_STROKE_ROMAN,
  GLUT_STROKE_MONO_ROMAN.

• int glutStrokeWidth(void *font,int c);

Retourne la largeur du caractère c dans la police de caractères vectorielle font.

Squelette d'une application avec deux fenêtres d'affichage 3D

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void display(void)
{ glLineWidth(3.0);
  glutStrokeCharacter
    (GLUT_STROKE_ROMAN,'a');
  glTranslatef(1.0F,0.0F,0.0F);
  glutBitmapCharacter
    (GLUT_BITMAP_8_BY_13,'b');
}

void myinit(void)
{ /* initialisation du programme */
}

int main(int argc,char** argv) {
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_SINGLE|
                      GLUT_RGB);
  glutInitWindowPosition(10,10)
  glutInitWindowSize(500,500);
  glutCreateWindow("Polices");
  glutDisplayFunc(display);
  myinit();
  glutMainLoop();
  return(0);
}

• Gestion de périphériques d'entrée supplémentaires

• ...

Autres exemples

Le fichier Glut.h