11/07/01 18:14

L'Utility Toolkit:
GLUT

AFFICHAGE

TACHE DE FOND

MODIFICATION
FENÊTRE

CLAVIER

SOURIS

DESSIN
D'OBJETS

MENUS

FENÊTRES
MULTIPLES

POLICES DE
CARACTÈRES

RETOUR

Dernière modification
11/07/01 18:14:24

Programmation presque identique à celle réalisée au moyen de l'Auxiliary library.

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

• void glutInitDisplayMode(unsigned int b);

Définit le type de fenêtre:
- GLUT_RGBA ou GLUT_INDEX (vraies couleurs ou couleurs indexées);
- GLUT_SINGLE ou GLUT_DOUBLE (simple ou double buffer);
- GLUT_DEPTH, GLUT_STENCIL ou GLUT_ACCUM (utilisation de tampons profondeur, stencil 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 *title);

Ouvre une fenêtre de titre title selon les paramètres définis au moyen des fonctions précédentes. La fenêtre n'est affichée que lors de l'exécution de glutMainLoop.

Affichage principal

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

Définit la fonction à exécuter quand la fenêtre d'affichage est créée, déplacée, agrandie, réduite ou réactivée ou si un autre événement intervient entraînant un rafraîchissement.

La fonction display passée en paramètre ne doit assurer l'affichage que d'une seule image.

• 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énement un ordre de rafraîchissement de la fenêtre d'affichage (fréquemment utilisée dans les fonctions d'animation Idle).

• void glutSwapBuffers(void);

Fonction assurant le swap entre les deux buffers d'affichage dans le cas du double buffering.

Squelette d'un programme

#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 */
}

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

Exemple

Gestion d'un processus en tâche de fond

• void glutIdleFunc(void *func(void));

Définit la fonction à exécuter 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
-> exécution d'actions en tâche de fond.

Cette fonction est fréquemment utilisée pour programmer des animations. Elle est généralement dédiée à la modification de variables employées dans la fonction display et ne contient donc habituellement pas d'appel de fonction OpenGL.

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

#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 idle(void)
{ /* Tâche de fond */
}

int main(int argc,char** argv) {
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);
}

Exemple

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

Définit la fonction exécutée automatiquement avant le rafraîchissement d’une fenêtre dont la taille est modifiée.

Cette fonction "Reshape" est habituellement employée pour signifier la zone de la fenêtre dans laquelle l'image est affichée, pour définir le mode de représentation (projection parallèle ou en perspective) et ses paramètres, et pour amorcer le dessin de la scène. Elle doit obligatoirement avoir en entête deux paramètres de type entier qui permettront de récupérer les tailles en x et en y de la fenêtre après changement de dimensions.

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

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

Exemple

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

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

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

#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 key(unsigned int 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);
}

Exemple

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

Définit la fonction exécutée automatiquement 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 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 <stdlib.h>
#include <GL/glut.h>

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

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

void special(unsigned 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);
}

Exemple

• 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 des fonctions -> fonctions à exécuter quand les boutons de la souris sont utilisés.
bouton: GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON ou GLUT_RIGHT_BUTTON
mode: 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);
}

Exemple

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

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

Définit la liaison entre les déplacements de la souris et des fonctions -> fonctions à exécuter quand la souris se déplace devant la fenêtre avec un bouton appuyé ou non.
x,y: position de la souris dans la fenêtre

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 mouseMotion(int x,int y)
{ /* opérations exécutées
     lors du deplacement de la souris
     bouton appuye */
}

void mousePassMotion(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(mouseMotion);
  glutPassiveMotionFunc(mousePassMotion);
  glutMainLoop();
  return(0);
}

Exemple

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

• void glutWireObjet() ;

• void glutSolidObjet() ;

Programme de visualisation de ces objets

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 <stdlib.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 sousMenu = glutCreateMenu(select2);
  glutAddMenuEntry("Sous-Option 1",0);
  glutAddMenuEntry("Sous-Option 2",1);
  int mainMenu = glutCreateMenu(select);
  glutAddMenuEntry("Option 1",0);
  glutAddMenuEntry("Option 2",1);
  glutAddMenuEntry("Sous-menu",sousMenu);
  glutAddMenuEntry("Quitter",2);
  glutAttachMenu(GLUT_LEFT_BUTTON);
  glutMainLoop();
  return(0);
}

Exemple

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 glutIdleFunc, glutReshapeFunc, glutDisplayFunc, glutMouseFunc, glutMotionFunc, glutKeyboardFunc, ...

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 <stdlib.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 = glutCreateWindow("Main");
  glutDisplayFunc(displayMain);
  int f2 = glutCreateWindow("Fille");
  glutDisplayFunc(displayFille);
  myinit();
  glutMainLoop();
  return(0);
}

Exemple

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 <stdlib.h>
#include <GL/glut.h>

void display(void)
{ glLineWidth(3.0);
  glStrokeCharacter(GLUT_STROKE_ROMAN,'a');
  glTranslatef(1.0F,0.0F,0.0F);
  glBitmapCharacter(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);
}

Exemple

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

• ...

Autres exemples

Le fichier Glut.h