11/07/01 18:13

OpenGL      (Partie 2)

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 MATERIAUX
Configuration
Exemple

LES LUMIERES
Configuration
Modèle
d'illumination
Exemple

LES BITMAPS
Introduction
Commandes
Exemple

LE PLACAGE
DE TEXTURE
Introduction
Commandes

LES COURBES
ET SURFACES
LISSEES
Introduction
Commandes
Les NURBS

LA SELECTION
D'OBJETS
Introduction
Mode opératoire
Commandes

RETOUR

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

Visualisation en OpenGL

Processus de visualisation

Quatre transformations successives pour obtenir une image:

(1) Transformation de modélisation (Model)

Permet de créer la scène à afficher par création, placement et orientation des objets qui la composent.

(2) Transformation de visualisation (View)

Permet de fixer la position et l'orientation de la caméra de visualisation.

(3) Transformation de projection (Projection)

Permet de fixer les caractéristiques optiques de la caméra de visualisation (focale, mode de projection,...).

(4) Transformation d'affichage (Viewport)

Permet de fixer la taille et la position de l'image sur l'écran.

Les transformations de visualisation et de modélisation n'en forment qu'une pour OpenGL (transformation modelview). Cette transformation fait partie de l'environnement OpenGL.

La transformation de projection existe en tant que telle dans OpenGL, et fait elle aussi partie de l'environnement OpenGL.

Chacune de ces transformations peut être modifiée indépendamment de l'autre ce qui permet d'obtenir une indépendance des scènes modélisées vis à vis des caractéristiques de la "caméra" de visualisation.

Exemple

#include "windows.h"

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

#include <stdio.h>
#include <stdlib.h>

static float rotx = 0.0f ;
static float roty = 0.0f ;
static float rotz = 0.0f ;

void myinit(void) {
  glShadeModel(GL_FLAT);
}

void CALLBACK myReshape(int w, int h) {
  glViewport(0,0,w,h);            /*(4)*/
  glMatrixMode(GL_PROJECTION);    /*(3)*/
  glLoadIdentity();               /*(3)*/
  glFrustum(-1.,1.,
            -1.,1.,
            1.5,20.);             /*(3)*/
  glMatrixMode(GL_MODELVIEW);     /*(2-1)*/
}

void CALLBACK display(void) {
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0,1.0,1.0);
  glLoadIdentity();               /*(2)*/
  glTranslatef(0.0,0.0,-5.0);     /*(2)*/
  glRotatef(rotx,1.0f,0.0f,0.0f); /*(2)*/
  glRotatef(roty,0.0f,1.0f,0.0f); /*(2)*/
  glRotatef(rotz,0.0f,0.0f,1.0f); /*(2)*/
  glScalef(1.0,2.0,3.0);          /*(1)*/
  auxWireCube(1.0);               /*(1)*/
  glFlush();
}

void CALLBACK auxX(void) {
  rotx += 2 ;
}

void CALLBACK auxx(void) {
  rotx -= 2 ;
}

void CALLBACK auxY(void) {
  roty += 2 ;
}

void CALLBACK auxy(void) {
  roty -= 2 ;
}

void CALLBACK auxZ(void) {
  rotz += 2 ;
}

void CALLBACK auxz(void) {
  rotz -= 2 ;
}

void main() {
  auxInitDisplayMode(AUX_SINGLE|AUX_RGB);
  auxInitPosition(0,0,200,200);
  auxInitWindow("Visualisation");
  myinit();
  auxKeyFunc(AUX_X,auxX) ;
  auxKeyFunc(AUX_x,auxx) ;
  auxKeyFunc(AUX_Y,auxY) ;
  auxKeyFunc(AUX_y,auxy) ;
  auxKeyFunc(AUX_Z,auxZ) ;
  auxKeyFunc(AUX_z,auxz) ;
  auxReshapeFunc(myReshape);
  auxMainLoop(display);
}

Transformations

Transformations d'utilité générale

• void glMatrixMode(GLenum mode);

mode: matrice sur laquelle les transformations à venir vont être opérées (GL_MODELVIEW ou GL_PROJECTION).

glMatrixMode est généralement appelé une fois sur chacun de ces paramètres de manière à calculer les matrices modelview et projection. Ces appels sont habituellement réalisés au sein de la fonction reshape si la librairie Aux est utilisée.

• void glLoadIdentity(void);

Affecte la matrice courante avec la matrice identité.

• void glLoadMatrix{f d}(const TYPE *m);

Affecte la matrice courante avec la matrice m (16 valeurs).

• void glMultMatrix{f d}(const TYPE *m);

Multiplie la matrice courante par la matrice m (16 valeurs).

• void glTranslate{f d}(TYPE x,TYPE y,TYPE z);

Multiplie la matrice courante par la matrice de translation (x,y,z).

• void glRotate{f d}(TYPE a,TYPE dx,TYPE dy,TYPE dz);

Multiplie la matrice courante par la matrice de rotation d'angle a autour de l'axe (dx,dy,dz).

• void glScale{f d}(TYPE rx,TYPE ry,TYPE rz);

Multiplie la matrice courante par la matrice composition des affinités d'axe x, y et z et de rapports respectifs rx, ry et rz.

Transformation spécifique à la visualisation

• void gluLookAt(GLdouble ex, GLdouble ey, GLdouble ez, GLdouble cx, GLdouble cy, GLdouble cz, GLdouble upx, GLdouble upy, GLdouble upz);

Multiplie la matrice courante (genéralement MODELVIEW) par la matrice donnant un point de vue depuis (ex,ey,ez) avec une direction de visualisation passant par (cx,cy,cz). (upx,upy,upz) indique quelle est la direction vers le haut.

gluLookAt est une fonction de la bibliothèque GLU.

Transformations de projection

• void glFrustum(GLdouble g, GLdouble d, GLdouble b, GLdouble h, GLdouble cmin, GLdouble cmax);

Multiplie la matrice courante par la matrice de projection en perspective définie par la pyramide tronquée de plan supérieur défini par la diagonale (g,b,-cmin) (d,h,-cmin). cmin et cmax sont les distances entre le point de vue et les plans de clipping. Ils doivent être positifs.

• void gluPerspective(GLdouble foc, GLdouble ratio, GLdouble cmin, GLdouble cmax);

Multiplie la matrice courante par la matrice de projection en perspective définie par la focale foc (angle d'ouverture verticale), l'apect-ratio ratio (largeur/hauteur) et les plans de clipping -cmin et -cmax. cmin et cmax doivent avoir une valeur positive et respecter cmin < cmax car il s'agit de distances selon l'axe z.

• void glOrtho(GLdouble g, GLdouble d, GLdouble b, GLdouble h, GLdouble cmin, GLdouble cmax);

Multiplie la matrice courante par la matrice de projection orthographique définie par le parallélépipède (g,d,b,h,-cmin,-cmax). cmin et cmax peuvent être positifs ou négatifs.

Un programme de visualisation en projection parallèle
et projection en perspective

Transformation d'affichage

• void glViewport(GLint x,GLint y,GLsizei l,GLsizei h);

Définit le rectangle de pixels dans la fenêtre d'affichage dans lequel l'image calculée sera affichée.

Un programme de changement de viewport

Utilisation de toute la surface de la fenêtre d'affichage

Utilisation d'une partie seulement de la fenêtre d'affichage

Opérations diverses liées à la visualisation

• void glPushMatrix(void);

Empile la matrice courante dans la pile de matrices

• void glPopMatrix(void);

Dépile la matrice en haut de pile et remplace la matrice courante par celle-ci.

• void glClipPlane(GLenum plane,const GLdouble *equ);

Définit un plan de clipping (découpage).

equ: tableau de quatre coefficients (a,b,c,d) qui définissent l'équation ax+by+cz+d = 0 du plan de clipping.

plane: GL_CLIP_PLANEi avec i compris entre 0 et 5.

glClipPlane(plane,equ) est à utiliser en association avec glEnable(plane) et glDisable(plane) pour autoriser et interdire la gestion du plan de clipping plane.

Programme exemple

Problème

L'affichage des scènes fait appel à un repère virtuel associé au viewport de visualisation. Les dimensions fournies au moment de l'exécution de la fonction de projection définissent ce repère qui peut donc ne pas être homothétique au viewport.

Exemple: glFrustum(-1.,1.,-1.,1.,1.5,20.) associe le repère virtuel (-1,-1) - (1,1) au viewport d'affichage. Si celui-ci n'a pas des tailles en x et y identiques, les objets dessinés sont déformés.

Solution: Adapter aux dimensions du viewport les dimensions données pour la définition de projection.

Exemple: Pour un viewport défini par
glViewport(0,0,w,h)
on pourra utiliser
gluPerspective(65.,w/h,1.0,20.0)
ce qui revient à adapter le ratio de gluPerspective au ratio du viewport.

Programme avec reshape homothétique

Exemples

#include <GL/gl.h>
#include <GL/glu.h>
#include "glaux.h"

static int shoulder = 0, elbow = 0;

void elbowAdd(void) {
  elbow = (elbow + 5) % 360;
}

void elbowSubtract(void) {
  elbow = (elbow - 5) % 360;
}

void shoulderAdd(void) {
  shoulder = (shoulder + 5) % 360;
}

void shoulderSubtract(void) {
  shoulder = (shoulder - 5) % 360;
}

void display(void) {
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0,1.0,1.0);
  glPushMatrix();
  glTranslatef(-1.0,0.0,0.0);
  glRotatef((GLfloat) shoulder,
            0.0,0.0,1.0);
  glTranslatef(1.0,0.0,0.0);
  auxWireBox(2.0,0.4,1.0);
  glTranslatef(1.0,0.0,0.0);
  glRotatef((GLfloat)
            elbow,0.0,0.0,1.0);
  glTranslatef(1.0,0.0,0.0);
  auxWireBox(2.0,0.4,1.0);
  glPopMatrix();
  glFlush();
}

void myinit(void) {
  glShadeModel (GL_FLAT);
}

void myReshape(int w,int h) {
  glViewport(0,0,w,h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(65.,
                 (float)w/(float)h,
                 1.0,20.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef (0.0,0.0,-5.0);
}

int main(int argc,char** argv) {
  auxInitDisplayMode(AUX_SINGLE|
                     AUX_RGB|
                     AUX_DIRECT);
  auxInitPosition(0,0,400,400);
  auxInitWindow(argv[0]);
  myinit();
  auxKeyFunc(AUX_LEFT,
             shoulderSubtract);
  auxKeyFunc(AUX_RIGHT,shoulderAdd);
  auxKeyFunc(AUX_UP,elbowAdd);
  auxKeyFunc(AUX_DOWN,elbowSubtract);
  auxReshapeFunc(myReshape);
  auxMainLoop(display);
}

Le programme

#include <GL/gl.h>
#include <GL/glu.h>
#include "glaux.h"

static int year = 0, day = 0;

void dayAdd(void) {
  day = (day + 10) % 360;
}

void daySubtract(void) {
  day = (day - 10) % 360;
}

void yearAdd(void) {
  year = (year + 5) % 360;
}

void yearSubtract(void) {
  year = (year - 5) % 360;
}

void display(void) {
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0,1.0,1.0);
  glPushMatrix();
  auxWireSphere(1.0);
  glRotatef((GLfloat) year,
            0.0,1.0,0.0);
  glTranslatef(2.0,0.0,0.0);
  glRotatef((GLfloat) day,
            0.0,1.0,0.0);
  auxWireSphere(0.2);
  glPopMatrix();
  glFlush();
}

void myinit(void) {
  glShadeModel(GL_FLAT);
}

void myReshape(int w,int h) {
  glViewport(0,0,w,h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(60.0,
                 (float) w/(float) h,
                 1.0,20.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  glTranslatef(0.0,0.0,-5.0);
}

int main(int argc,char** argv) {
  auxInitDisplayMode(AUX_SINGLE|
                     AUX_RGB);
  auxInitPosition(0,0,500,500);
  auxInitWindow(argv[0]);
  myinit();
  auxKeyFunc(AUX_LEFT,yearSubtract);
  auxKeyFunc(AUX_RIGHT,yearAdd);
  auxKeyFunc(AUX_UP,dayAdd);
  auxKeyFunc(AUX_DOWN,daySubtract);
  auxReshapeFunc(myReshape);
  auxMainLoop(display);
}

Le programme

Les listes d'affichage

Définition

Une liste d'affichage est un ensemble de commandes OpenGL stocké pour une utilisation future.

Quand une liste d'affichage est invoquée, les commandes qu'elle contient sont exécutées dans l'ordre où elles ont été stockées.

Les commandes d'une liste d'affichage sont les mêmes que les commandes d'affichage immédiat.

Exemple

Dessin d'un polygone régulier de 100 sommets.

void cercle(){
  GLint i ;
  GLfloat cosinus,sinus ;
  glBegin(GL_POLYGON) ;
  for ( i = 0 ; i < 100 ; i++ ) {
    cosinus = cos(i*2*PI/100.0);
    sinus = sin(i*2*PI/100.0);
    glVertex2f(cosinus,sinus) ; }
  glEnd() ;
}

Cette méthode sans liste d'affichage est inefficace car tout appel à cercle() entraîne l'exécution des calculs de sinus et cosinus.

#define CERCLE 1
void cercle() {
  GLint i ;
  GLfloat cosinus,sinus ;
  glNewList(CERCLE,GL_COMPILE) ;
  glBegin(GL_POLYGON) ;
  for ( i = 0 ; i < 100 ; i++ ) {
    cosinus = cos(i*2*PI/100.0);
    sinus = sin(i*2*PI/100.0);
    glVertex2f(cosinus,sinus) ; }
  glEnd() ;
  glEndList() ;
}

glCallList(CERCLE) ;

Programme

Fonctionnalités

Les listes d'affichage optimisent les temps de calcul et d'affichage car elles permettent la suppression de calculs redondants sur:

• les opérations matricielles,

• les conversions de formats d'image bitmap,

• les calculs de lumière,

• les calculs de propriétés des matériaux de surface,

• les calculs de modèle d'éclairage,

• les textures,

• les motifs de tracé.

L'inconvénient principal des listes d'affichage est qu'elles peuvent occuper beaucoup de place mémoire.

Syntaxe des commandes

Commandes principales

• void glNewList(GLuint liste,GLenum mode);

Indique le début de la définition d'une liste d'affichage.

liste: entier positif unique qui identifiera la liste.

mode: GL_COMPILE ou GL_COMPILE_AND_EXECUTE suivant que l'on désire seulement stocker la liste ou la stocker et l'exécuter.

• void glEndList(void);

Indique la fin d'une liste d'affichage.

Toutes les commandes depuis le dernier glNewList ont été placées dans la liste d'affichage (quelques exceptions).

• void glCallList(GLuint liste);

Exécute la liste d'affichage référencée par liste.

Commandes auxiliaires

• GLuint glGenLists(GLsizei nb);

Alloue nb listes d'affichage contiguës, non allouées auparavant.

L'entier retourné est l'indice qui donne le début de la zone libre de références.

• GLboolean glIsList(GLuint liste);

Retourne vrai si liste est utilisé pour une liste d'affichage, faux sinon.

• void glDeleteLists(GLuint l,GLsizei nb);

Détruit les nb listes à partir de la liste l.

Exemple

#include <GL/gl.h>
#include <GL/glu.h>
#include "glaux.h"

GLuint listName = 1;

void myinit(void) {
  glNewList(listName,GL_COMPILE);
  glColor3f(1.0,0.0,0.0);
  glBegin(GL_TRIANGLES);
  glVertex2f(0.0,0.0);
  glVertex2f(1.0,0.0);
  glVertex2f(0.0,1.0);
  glEnd();
  glTranslatef(1.5,0.0,0.0);
  glEndList();
  glShadeModel(GL_FLAT);
}

void drawLine(void) {
  glBegin(GL_LINES);
  glVertex2f(0.0,0.5);
  glVertex2f(15.0,0.5);
  glEnd();
}

void display(void) {
  GLuint i;
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(0.0,1.0,0.0);
  for ( i = 0 ; i < 10 ; i++ )
    glCallList(listName);
  drawLine();
  glFlush();
}

void myReshape(int w,int h) {
  glViewport(0,0,w,h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  if ( w <= h )
    gluOrtho2D(0.,2.,
               -0.5*(float)h/(float)w,
               1.5*(float)h/(float)w);
    else
    gluOrtho2D(0.,
               2.*(float)w/(float)h,
               -.5,1.5);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

int main(int argc,char** argv) {
  auxInitDisplayMode(AUX_SINGLE|
                     AUX_RGB);
  auxInitPosition(0,0,400,50);
  auxInitWindow(argv[0]);
  myinit();
  auxReshapeFunc(myReshape);
  auxMainLoop(display);
}

Le programme

Mode de lissage

• void glShadeModel(GLenum mode)

mode: mode de lissage (GL_FLAT: uni, GL_SMOOTH: Gouraud)

Lissé (utilisé par défaut)

Non lissé

Les calculs d'illumination

#include <GL/gl.h>
#include <GL/glu.h>
#include "glaux.h"

void myinit(void) {
  GLfloat specular[] = { 1.0,1.0,
                         1.0,1.0 };
  GLfloat shinines[] = { 50.0 };
  GLfloat l_pos[] = { 1.0,1.0,
                      1.0,0.0 };
  glMaterialfv(GL_FRONT,GL_SPECULAR,
               specular);
  glMaterialfv(GL_FRONT,GL_SHININESS,
               shinines);
  glLightfv(GL_LIGHT0,GL_POSITION,
            l_pos);
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);
}

void display(void) {
  glClear(GL_COLOR_BUFFER_BIT|
          GL_DEPTH_BUFFER_BIT);
  auxSolidSphere(1.0);
  glFlush();
}

void myReshape(int w,int h) {
  glViewport(0,0,w,h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  if (w <= h)
    glOrtho(-1.5,1.5,
            -1.5*(float)h/(float)w,
            1.5*(float)h/(float)w,
            -10.,10.);
    else
    glOrtho(-1.5*(float)w/(float)h,
            1.5*(float)w/(float)h,
            -1.5,1.5,-10.,10.);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

int main(int argc,char** argv) {
  auxInitDisplayMode(AUX_SINGLE|
                     AUX_RGB|
                     AUX_DEPTH);
  auxInitPosition(0,0,500,500);
  auxInitWindow(argv[0]);
  myinit();
  auxReshapeFunc(myReshape);
  auxMainLoop(display);
}

Le programme