11/07/01 18:11

OpenGL      (Partie 1)

INTRODUCTION
Fonctionnalités
Syntaxe
Variables d'état
Bibliothèques

L'AUXILIARY
LIBRARY

L'UTILITY
TOOLKIT

INSTRUCTIONS
DE BASE
Effacement
de la fenêtre
Couleur de tracé
Terminaison
du tracé
Les parties cachées
Sommets, lignes
et polygones

EXEMPLES GLUt

VISUALISATION
EN OPENGL
Le processus
de visualisation
Les transformations
Exemples

LES LISTES
D'AFFICHAGE
Définition
Commandes

MODES DE
LISSAGE

LES LUMIÈRES
Configuration
Modèle d'illumination
Exemple

LES MATÉRIAUX
Configuration
Exemple

LES BITMAPS
Introduction
Commandes
Exemple

LE PLACAGE
DE TEXTURE
Introduction
Commandes

LES COURBES
ET SURFACES
LISSÉES
Introduction
Commandes
Les NURBS

LA SÉLECTION
D'OBJETS
Introduction
Mode opératoire
Commandes

RETOUR

Dernière modification
11/07/01 18:11:50

Définition

Exemple

#include <~~~~~~~~.h>
void main() {
...
glClearColor(0.0,0.0,0.0,0.0) ;
glClear(GL_COLOR_BUFFER_BIT) ;
glColor3f(1.0,1.0,1.0) ;
glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0) ;
glBegin(GL_POLYGON) ;
glVertex2f(-0.5,-0.5) ;
glVertex2f(-0.5,0.5) ;
glVertex2f(0.5,0.5) ;
glVertex2f(0.5,-0.5) ;
glEnd() ;
glFlush() ;
...
}

Ce programme dessine un carré blanc au centre d’une fenêtre de fond noir.

Syntaxe des instructions

Les fonctions OpenGL de base commencent par le préfixe gl.

Les constantes (#define ou enum) sont données en majuscule et commencent par le préfixe GL_.

Certaines instructions finissent par un suffixe.

Exemple: glVertex2f

Ce suffixe indique le nombre et le type des arguments de la fonction.

glVertex2i(1,3); <=> glVertex2f(1.0,3.0);

La lettre terminale v indique que la fonction prend comme paramètre un pointeur sur un tableau.

Variables d'état

OpenGL est une state-machine.

-> Des instructions existent pour placer le système dans certains états. Ceux-ci resteront actifs (utilisés à cette valeur) jusqu'à être changés (couleurs de tracé, matrices de transformation, activation du Z-Buffer, ...).

L'ensemble des ces "variables d'états" constitue l'"environnement".

Fonctions

• glEnable(GLenum pname)

activation de variables d'état

pname: variable d'état à activer

Par exemple glEnable(GL_LIGHTING) -> activation de la gestion des lumières et des matériaux

• glDisable(GLenum pname)

inhibition de variables d'état

pname: variable d'état à désactiver

• glGetBooleanv(GLenum pname,GLboolean *param)

• glGetIntegerv(GLenum pname,GLinteger *param)

• glGetFloatv(GLenum pname,GLfloat *param)

• glGetDoublev(GLenum pname,GLdouble *param)

consultation de variables d'états ou de paramètres de l'environnement OpenGL

pname: variable d'état consultée

param: résultat (de type tableau)

• GLboolean glIsEnabled(GLenum pname)

consultation de variables d'états booléennes

pname: variable d'état consultée

• glPushAttrib(GLbitfield mask)

sauvegarde de variables d'état par empilement dans une pile

mask: variables d'état à sauvegarder

• glPopAttrib()

restauration de variables d'état par dépilement

Exemple

glEnable(GL_DEPTH_TEST)

Active l'affichage avec élimination des parties cachées.

Bibliothèques d'OpenGL

(1) OpenGL Library (GL)

Librairie standard proposant les fonctions de base

Préfixe des fonctions: gl

(2) OpenGL Utility Library (GLU)

Commandes bas-niveau écrites en GL:

- transformations géométriques

- triangulation des polygones

- rendu des surfaces

-...

Préfixe des fonctions: glu

(3) OpenGL extension to X-Windows (GLX)

Utilisation d’OpenGL en association avec X Windows

Préfixe des fonctions: glX

(4) Auxiliary Library

Écrite pour rendre simple la programmation de petites applications dans le cadre d'interfaces graphiques interactives simples:

- gestion des fenêtres

- gestion de la souris

- gestion du clavier

- ...

Préfixe des fonctions: aux

(5) OpenGL Tk Library (GLTk)

Équivalent à Aux mais avec l'utilisation de TclTk pour l'interface graphique

Préfixe des fonctions: tk

(6) OpenGL Ut Library (GLUt)

Équivalent à Aux

Interface utilisateur programmable plus élaborée -> plus grande complexité

Préfixe des fonctions: glut

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

Programmation presque identique à celle réalisée au moyen de Aux.

Fonctionnalités supplémentaires:

• gestion des menus,

• gestion des environnements fenêtrés,

• existence de polices de caractères bitmap et vectorielles intégrées,

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

• ...

Autres exemples

Instructions de base d'OpenGL

Effacement de la fenêtre de dessin

Par effacement de la fenêtre de dessin, on entend effacement des zones de mémoire suivantes (définies dans OpenGL):

• le tampon couleur -> stockage de la couleur des pixels,

• le tampon profondeur -> stockage d'une information de profondeur pour l'élimination des parties cachées,

• le tampon accumulation -> accumulation d'images les une sur les autres,

• le tampon stencil.

L'effacement proprement dit est réalisé par

• void glClear(GLbitfield mask);

mask: choix du buffer à éffacer

Les valeurs de masque sont composables par ou.

Choix de la couleur d'éffacement

• void glClearColor(GLclampf r,GLclampf v,GLclampf b, GLclampf alpha) ;

r, v, b, alpha: couleurs de remplissage du tampon couleur

• void glClearDepth(GLclampf depth) ;

depth: profondeur de remplissage du tampon profondeur

Choix d'une couleur de tracé

• void glColor3{b s i f d ub us ui}(TYPE r,TYPE v,TYPE b);

• void glColor4{b s i f d ub us ui}(TYPE r,TYPE v,TYPE b,TYPE alpha);

r, v, b, alpha: couleurs de tracé

• void glColor3{b s i f d ub us ui}v(const TYPE *v);

• void glColor4{b s i f d ub us ui}v(const TYPE *v);

v: tableau contenant les couleurs de tracé

Un carré de couleur

La couleur choisie est active pour tous les objets définis après elle, jusqu'à nouvelle notification.

Utilisé pour forcer l'exécution entière du tracé d'une image (vidage d'un pipeline d'affichage sur une station graphique, exécution des ordres de tracé sur un réseau).

• void glFlush(void);

• void glFinish(void);

glFinish se met en attente d'une notification d'exécution de la part du dispositif graphique tandis que glFlush n'attend pas.

Élimination des parties cachées

L'affichage d'une scène correspond à l'exécution du programme suivant:

while(1) {
  definir_camera();
  glClear(GL_COLOR_BUFFER_BIT);
  dessiner_objet_3D_A() ;
  dessiner_objet_3D_B() ;
  dessiner_objet_3D_C() ;
  ...
}

-> L'élimination des parties cachées n'est pas réalisée car on utilise un algorithme du peintre.

-> Utilisation de la fonction glEnable pour valider l'élimination des parties cachées par Z-Buffer.

glEnable(GL_DEPTH_TEST);
while(1) {
  definir_camera();
  glClear(GL_COLOR_BUFFER_BIT|
          GL_DEPTH_BUFFER_BIT);
  dessiner_objet_3D_A() ;
  dessiner_objet_3D_B() ;
  dessiner_objet_3D_C() ;
  ...
}

Sans élimination des parties cachées

Avec élimination des parties cachées

Sommets, lignes et polygones

Un polygone OpenGL ne se recoupe pas, n'a pas de trou et est convexe.

Si on veut représenter un polygone ne vérifiant pas ces conditions, on devra le subdiviser (tessèlation) en un ensemble de polygones convenables.

Les polygones OpenGL ne doivent pas forcément être plans. Le résultat à l'affichage n'est pas garantit en cas de non planarité.

Déclaration d'un sommet

• glVertex{234}{sifd}[v](TYPE coords) ;

coords: coordonnées du sommet

Cette fonction sert uniquement à la déclaration ultérieure de lignes et de polygones: des primitives graphiques.

Déclaration d'une primitive graphique

Une primitive graphique est constituée d'un ensemble de sommets.

La primitive est délimitée au début et à la fin par

• void glBegin(GLenum mode) ;

mode: GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_POLYGON, GL_QUADS, GL_QUAD_STRIP, GL_TRIANGLES, GL_TRIANGLE_STRIP ou GL_TRIANGLE_FAN

et

• void glEnd(void) ;

Il existe plusieurs types de primitives graphiques (mode dans glBegin).

Exemple

glBegin(GL_POLYGON);
glVertex2f(0.0,0.0) ;
glVertex2f(2.0,1.0) ;
glVertex2f(1.0,3.0) ;
glVertex2f(5.0,0.5) ;
glVertex2f(-.5,2.0) ;
glVertex2f(1.5,2.5) ;
glEnd() ;

Une primitive peut contenir d'autres informations que ses seuls points. Celles-ci sont aussi données via des appels à des fonctions.

Parmi ces fonctions, les plus importantes sont:

• void glNormal3{bsidf}(TYPE x,TYPE y,TYPE z);

• void glNormal3{bsidf}v(const TYPE *v);

Configure la normale courante (utilisée pour les calculs d'éclairage) avec la valeur passée en paramètre. La valeur par défaut est (0,0,1).

Exemple

glBegin(GL_POLYGON);
glColor3f(1.0,0.0,0.0) ;
glVertex2f(0.0,0.0) ;
glNormal3f(-1.0,0.0,0.0) ;
glVertex2f(2.0,1.0) ;
glColor3f(0.0,1.0,0.0) ;
glVertex2f(1.0,3.0) ;
glEnd() ;

Donne la couleur rouge aux premier et deuxième sommets, et la couleur verte au troisième.

Donne la normale(-1.0,0.0,0.0) aux deuxième et troisième sommets.

Programme exemple

Déclaration d'un ensemble de facettes

Utilisation fréquente de surfaces polygonales (ensembles de facettes adjacentes) pour modéliser des objets complexes.

Recommandations

• Conserver constante l'orientation des polygones

• Eviter les facettes non triangulaires

• Trouver un bon équilibre entre le nombre de polygones et la vitesse et la qualité d'affichage

• Multiplier le nombre de polygones sur la silhouette des objets

• Éviter des intersections en T

Exemple

#define X .525731112119133606
#define Z .850650808352039932
static GLfloat vdata[12][3] = {
  {-X,0,Z},{X,0,Z},{-X,0,-Z},
  {X,0,-Z},{0,Z,X},{0,Z,-X},
  {0,-Z,X},{0,-Z,-X},{Z,X,0},
  {-Z,X,0},{Z,-X,0},{-Z,-X,0}} ;
static GLint t[20][3] = {
  {0,4,1},{0,9,4},{9,5,4},{4,5,8},
  {4,8,1},{8,10,1},{8,3,10},{5,3,8},
  {5,2,3},{2,7,3},{7,10,3},{7,6,10},
  {7,11,6},{9,2,5},{0,1,6},{6,1,10},
  {9,0,11},{9,11,2},{11,0,6},
  {7,2,11}};
for ( i = 0 ; i < 20 ; i++ ) {
  glBegin(GL_TRIANGLES) ;
    glNormal3fv(&vdata[t[i][0]][0]);
    glVertex3fv(&vdata[t[i][0]][0]);
    glNormal3fv(&vdata[t[i][1]][0]);
    glVertex3fv(&vdata[t[i][1]][0]);
    glNormal3fv(&vdata[t[i][2]][0]);
    glVertex3fv(&vdata[t[i][2]][0]);
  glEnd() ; }

Programme exemple

Fonction diverses

• void glPointSize(GLfloat size) ;

Configure la grandeur de tracé (par défaut 1) des points.

• void glLineWidth(GLfloat width) ;

Configure la largeur de tracé (par défaut 1) des segments de ligne.

• void glLineStipple(GLint facteur,GLushort motif) ;

Configure le motif de tracé des lignes. Le motif est une série de 16 bits (poids faible à poids fort) où les 1 représentent des pixels allumés et des 0 des pixels non modifiés. Le facteur (de 1 à 255) permet l'étirement du motif par multiplication (un 1 devient factor 1 consécutifs). L'utilisation des motifs pour les segments est subordonnée à autorisation via un glEnable(GL_LINE_STIPPLE).

• void glPolygoneMode(GLenum face,GLenum mode) ;

Configure le dessin des faces avant et arrières des polygones. face peut être GL_FRONT, GL_BACK ou GL_FRONT_AND_BACK. mode peut être GL_POINT, GL_LINE ou GL_FILL pour un dessin des sommets, en fil de fer ou avec remplissage.

• void glFrontFace(GLenum mode) ;

Contrôle comment la face frontale des polygones est déterminée. La valeur par défaut est GL_CCW. Elle peut être inversée par GL_CW.

• void glCullFace(GLenum mode) ;

Contrôle si les polygones doivent être éliminés avant leur passage en coordonnées écran. mode peut être GL_FRONT, GL_BACK ou GL_FRONT_AND_BACK. L'utilisation du culling est subordonnée à autorisation via un glEnable(GL_CULL_FACE).

• void glPolygoneStipple(GLubyte *mask) ;

Définit le motif de remplissage courant des polygones. mask est un pointeur sur une bitmap de 32x32 pixels interprétée comme un masque de bits (128 octets). Si un 1 est présent, le pixel est dessiné, sinon, il ne l'est pas. L'utilisation des motifs pour les polygones est subordonnée à autorisation via un glEnable(GL_POLYGONE_STIPPLE).

Programme exemple

Suite