L'Utility Toolkit: GLUT

INITIALISATION
ET OUVERTURE
FENÊTRE

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

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

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

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

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

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

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

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.

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

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.

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);
}

Programme GLUt

Exécutable GLUt

Gestion d'un processus en tâche de fond

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);
}

 

Programme GLUt

Exécutable GLUt

Gestion des redimensionnements fenêtre

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);
}

 

Programme GLUt

Exécutable GLUt

Gestion des événements clavier

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);
}

 

Programme GLUt

Exécutable GLUt

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);
}

 

Programme GLUt

Exécutable GLUt

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);
}

 

Programme GLUt

Exécutable GLUt

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.

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);
}

 

Programme GLUt

Exécutable GLUt

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

Fonctions génériques:

  • void glutWireObjet() ;

  • void glutSolidObjet() ;

 

Objet

Sphère
  Rayon
  Nombre sections
  Nombre coupes

glutWireSphere(double r,
               int ns,
               int nc);

glutSolidSphere(double r),
                int ns,
                int nc);

Cube
  Coté

glutWireCube(double c);

glutSolidCube(double c);

Tore
  Rayon intérieur
  Rayon extérieur
  Nombre côtés
  Nombre anneaux

glutWireTorus(double rint,
              double rext,
              int ns,
              int nr);

glutSolidTorus(double rint,
               double rext,
               int ns,
               int nr));

Cône
  Rayon
  Hauteur
  Nombre sections
  Nombre coupes

glutWireCone(double r,
             double h,
             int ns,
             int nc);

glutSolidCone(double r,
              double h,
              int ns,
              int nc);

Tétraèdre

4 faces

glutWireTetrahedron(void);

glutSolidTetrahedron(void);

Octaèdre

8 faces

glutWireOctahedron(void);

glutSolidOctahedron(void);

Icosaèdre

12 faces

glutWireIcosahedron(void);

glutSolidIcosahedron(void);

Dodécaèdre

20 faces

glutWireDodecahedron(void);

glutSolidDodecahedron(void);

Teapot
  Rayon

glutWireTeapot(double s) ;

glutSolidTeapot(double s) ;

 

 

 

 

 

Programme GLUt

Exécutable GLUt

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.

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

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

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.

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);
}

Programme GLUt

Exécutable GLUt

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

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

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

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

Dimensionne la fenêtre courante en plein écran.

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

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);
}

 

Programme GLUt

Exécutable GLUt

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

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.

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

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.

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);
}

Programme GLUt

Exécutable GLUt

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

  • ...

Autres exemples

Le fichier Glut.h