OpenGl

C'est une librairie graphique.

Permet de construire des objets à partir de primitives, les positionner, calculer les ombrages, la rastérisation (transformation de la scène en pixels à l'écran).

Etapes d'initialisation

En 4 parties:

1. Initialisation de la zone affectée au graphique :
   

   glViewPort(0,0,600,600)
   

2. Initialisation des matrices:
   

   OpenGL utilise des piles de matrices donc il faut faire les appels avec :
   

   glMatrixMode(GL_projection) /*Passage en mode matrice*/
   glLoadIdentity();/*Initialisation de la	 matrice à l'identité*/
   
   glMatrixMode(GL_projection)
   glLoadIdentity();
   

3. Effacement de la fenêtre
   

   void glClearColor(Glfloat rouge, Glfloat vert, Glfloat bleu, Glfloat alpha);
   

   Cette fonction permet de choisir la couleur du fond.
   Ex:
   

   glClearColor(0.0,0.0,0.0,0.0); /*Ici, noir*/
   

   Mais cette fonction n'affiche pas la couleur à l'écran d'où l'utilisation de la fonction :
   

   void glClear(GL_COLOR_BUFFER_BIT);
   

   qui efface les dessins dans la fenêtre et qui équivaut à remplir la fenêtre avec la couleur de fond choisie plus haut.

4. Initialisation de la projection

   void glOrtho(GLdouble left,GLdoubleright,GLdouble bottom,GLdouble top,GLdouble near,GLdouble far);
   

   ex:

   glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0);
   

Dessin dans une fenêtre

On utilise des fonctions qui ont un format général:
fonction n f
N est un entier correspondant au nombre de paramètre que l'on va envoyer ensuite,
f=1 ou 2 caractère précisant le format du paramètre.

Ex:

 glVertex2f(28.4,-3.7);

Vertex est le nom de la fonction à qui on passe 2 paramètres qui sont des floats.

Il existe différents formats:

1. b entier 8bits,
2. s entier 16bits,
3. i entier 32bits,
4. f flotant 32bits,
5. d flottant 64bits,
6. u(b,s,i) entier non signé 8/16/32 bits

Ex: choix de la couleur courante

glColor3f(0.0,0.0,0.0);/*donne noir*/
glColor3ub(0.0,0.0,0.0);/*donne également noir*/

Dans le premier cas, f est compris entre 0.0 et 1.1 alors que dans l'exemple 2, ub est compris entre 0.0 et 255.0.

Format général du code pour le dessin:

glBegin(FORME)
	glColornf(...);
	glVertexnf(...);
	....
glEnd();

FORME peut être du type:

1. GL_POINTS
2. GL_LINES
3. GL_LINESTRIP (bandes)
4. GL_LOOP (ferme la boucle)
5. GL_POLYGON (rempli l'intérieur)
6. GL_TRIANGLE (pas autant de sommet que possible 3maxi)
7. GL_TRIANGLE_FAN permet de réduire le nombre de points dans le cas de triangles contigus en escargots (genre trivial poursuite).
8. GL_TRIANGLE_STRIP idem mais pour des bandes de triangles en quiquonces.
   

On peut changer la couleur au milieu de la déclaration des points des sommets.

Ex:

glBegin(GL_LINES)
	glColor3f(0.2,0.5,0.5);
	glVertex2s(0,0);
	glVertex2s(0,100);
	glColor3f(1.0,1.0,1.0);
	glVertex2s(400,0);
	glVertex2s(-400,0);
GlEnd();

Puis à la fin

glFlush();/*Pour l'affichage*/

Si on a:

	glColor3f(1.0,1.0,1.0);
	glVertex2s(0,0);
	glColor3f(0.2,0.5,0.5);
	glVertex2s(0,100);

On obtient un segment dégradé, idem pour un triangle.

Ex: programme minimal de tout ce qui est nécessaire afin de réaliser 2 points :1 rouge et 1 jaune:

glClearColor(0.0,0.0,0.0); /*Fond=noir*/
glViewPort(0,0,600,600); /*Fenêtre*/
glMatrixModel(GL_PROJECTION);
glLoadIdentity();
GlMatrixMode(GL_MODELVIEW);
GloadIdentity();
glClear(GL_COLOR_BUFFER_BIT);
glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0,);
glBegin(GL_POINTS);
	glColor3f(1.0,0.0,0.0);
	glVertex2f(-0.5,0.0);
	glColor3f(1.0,1,0,0.0);
	glVertex2f(0.5,0.0);
glEnd();
glFlush();
SwapBuffers(); // si double buffer

Dessins et opérations en 3D

On utilise 3 coordonnées.

glVertex3f(1.0,2.0,4.0);

On peut faire des opérations géométriques qui sont traitées par la matrice GL_MODELVIEW.

1. Transformation de vecteur V(x,y,z)

   void glTranslatef(GLfloat x, GLfloat y, GLfloat z);
   

2. Rotation d'angle $\alpha$ et d'axe le vecteur V:

   Void glRotatef(GLfloat $\alpha$,GLfloat x, GLfloat y,GLfloat z);
   

3. Homothétie de rapport x selon Ox, y selon Oy et z selon Oz:

   Void glScalef(GLfloat x,GLfloat y, GLfloat z);
   

Pile de matrices

Elle permet de mémoriser l'état courant d'une matrice comme GL__MODELVIEW à un moment donné.
Cela se fait avec la fonction:

	glPushMatrix();

Pour récupérer l'état mémorisé en dernier, on utilise:

	glPopMatrix();

exemple:

glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
	DessineCube(); /*Fonction dessinant un cube unité centré en (0,0,0)*/
	glTranslatef(0.5,0.0,0.0);/*A partir d'ici, tout ce qui suit sera dessiné translaté de 0,5 selon Ox*/
	DessineCube();
	glPushMatrix();
	glRotate (45.0,0.0,0.0,1.0)/*A partir d'ici, tout ce qui suit sera tourné puis translaté*/
	glPopMatrix();/*Tout ce qui va suivre sera uniquement translaté, on revient à l'état enregistré*/
glFlush();