Delphipage

Présentation

L'OpenGL a été développé par Silicon Graphics Inc. OpenGL (Open Graphics Library) est une bibliothèque graphique qui permet la manipulation d'objet en deux et trois dimensions. On peut ainsi dessiner des objets , également appelé primitives, géométrique tel que des points, lignes, polygones...
L'OpenGL existe sous plusieurs systèmes d'exploitation comme Windows, Linux, Mac OS,...

Ce tutorial est une approche à l'utilisation de l'OpenGL en Delphi.

Installation

Pour utiliser l'OpenGL en Delphi, vous devez effectuer quelques opérations :

1. Vous avez besoin d'une version de Delphi ultérieure à la version 3.
Vous pouvez utiliser l'OpenGL sous Delphi 3, Delphi 4, Delphi 5, Delphi 6, Delphi 7...

2. Vous devez avoir installé sur votre ordinateur, la DLL"OpenGl32.dll.
Cette DLL est généralement fournie et installée avec les drivers de votre carte graphique.

3. Télégargez ensuite la librairie OpenGL (43 Ko) pour Delphi.
Décompressez ce fichier dans le répertoire "Lib\Opengl" de Delphi.

4. Téléchargez, si vous le souhaitez l'aide pour l'OpenGL (542 Ko).
Vous y trouverez une aide pour les procédures et fonctions d'OpenGL.

Les bases de l'OpenGL

Le tableau suivant regroupe les types de données prédéfinis sous OpenGL.

Type de données OpenGL	Suffixe	Représentation
GLByte	b	Enier 8 bit
GLShort	s	Entier 16 bit
GLInt, GLSizei	i	Entier 32 bit
GLFloat, GLClampf	f	Flottante 32 bit
GLDouble, GLClampd	d	Flottante 64 bit
GLuByte, GLBoolean	ub	Entier non signé 8 bit
GLusShort	us	Entier non signé 16 bit
GLuInt, GLEnum, GLBitfield	ui	Entier non signé 32 bit

Lorsque vous utiliserez une fonction OpenGL avec comme paramètres des type de données, il faudra à chaque fois, choisir le type de données et mettre le suffixe correspondant à la fin de la fonction.

glVertex2i(1,2);
glVertex2f(1.0,2.0);

Le "2" représente que l'on travail en 2D sur X et Y.
Pour travailler en 3D sur X, Y, Z, on mettra "3".

Voici le tableau des primitives d'OpenGL.

Primitive	Description
GL_Points	Forme un point.
GL_Lines	Forme une ligne avec deux points.
GL_Line_Loop	Forme une série de lignes liées et relie le premier point avec le dernier.
GL_Line_Strip	Forme une série de lignes liées.
GL_Triangles	Forme un triangle avec trois points.
GL_Triangle_Strip	Forme une série de triangles liés.
GL_Triangle_Fan	Forme un éventail de triangles.
GL_Quads	Forme un carré.
GL_Quad_Strip	Forme une série de carrés liés.
GL_Polygon	Forme un polygone.

Voici un exemple d'utilisation des primitives.

glBegin(GL_QUADS);
glColor3f(1,1,1);
glVertex2d(2.0,-2.0);
glVertex2d( -2.0, -2.0 );
glVertex2d( -2.0, 2.0 );
glVertex2d( 2.0, 2.0 );
glEnd();

On trace, ici, un carré.
"glBegin" et "glEnd" délimite le tracé du carré.
"glColor" correspond à la couleur. Cette fonction a pour paramètres l'intensité de couleur RVB (Rouge Vert Bleu).
"glVertex" est les coordonées des tracés. On pourrait comparer cette fonction à la fonction "LineTo" de Delphi.

Lier OpenGL à une fenêtre

Lorsque vous utilsez OpenGL, vous devez pour chaque programme, liez OpenGL à la fenêtre (form).
Tout d'abord, créez une nouvelle application puis liez l'unité "OpenGL12" au programme.

Uses OpenGL12;

On va maintenant créer avec la variable "RC" qui est l'adresse du contexte graphique où OpenGL dessinera.
Cliquez deux fois sur la propriété OnCreate de la Form. Dans cet événement, on va créer le contexte graphique pour notre fenêtre (Form1). On définit le handle de notre fenêtre, le mode de travail "opGDI".
"32" signifie que l'on va travailler en 32 bit. Ensuite, avec "wglMakeCurrent", on crée le contexte graphique pour notre fenêtre.

public
{ Déclarations publiques }
RC :HGLRC;
end;

var
Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.FormCreate(Sender: TObject);
begin
RC:=CreateRenderingContext(Form1.Canvas.Handle,[opGDI],32,0,0,0,0);
wglMakeCurrent(Form1.Canvas.Handle,RC);
end;

Lorsqu'on a terminé, il faut supprimer le contexte graphique de notre fenêtre grâce à wglDeleteContext.

procedure TForm1.FormDestroy(Sender: TObject);
begin
wglDeleteContext(RC);
end;

Création d'un carré

On passe maintenant à la partie visuel.
Voici à ce que ressemblera notre carré. Pour l'instant, nous travaillons en 2D.

Lorsque la fenêtre se construit pour la première fois, l'événement OnResize est activé.
C'est dans cet événement que l'on va initialiser l'affichage. L'utilisation de cet événement permet de réinitialiser l'affichage si la fenêtre est redimensionné.
Dans un programme, pour afficher quelques chose en OpenGL, il faut faire ceci.

procedure TForm1.FormResize(Sender: TObject);
begin
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
gluPerspective(45,Width/Height,1,10);
glViewport(0,0,Form1.Width, Form1.Height);
glMatrixMode(GL_MODELVIEW);
Form1.Paint;
end;

"glMatrixMode" permet de spécifier la matrice de projection.
"glLoadIdentity" initialise la matrice de projection .
"gluPerspective" définit le champ de vision.

Voici la description des paramètres de "gluPerspective" :
"45" est l'angle de vue en degré. La valeur est comprise entre 0 et 180.
"Width/Height" est la largeur divisée par la hauteur.
"1" et "10" sont les valeurs correspondant à la distance du champ de vision.

Ensuite avec "Form1.Paint", on fait appelle à l'événement OnPaint de la fenêtre.

procedure TForm1.FormPaint(Sender: TObject);
begin
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glLoadIdentity;
glTranslatef(0,0,-10);
glBegin(GL_QUADS);
glColor3f(1,1,1);
glVertex2f(2,-2);
glVertex2f(-2,-2);
glVertex2f(-2,2);
glVertex2f(2,2 );
glEnd();
end;

"glClear" vide le tampon. Cela permet d'obtenir un raffraichissement de l'image.
"glTranslate" permet d'effectuer une translation vers les axes X,Y,Z.

Colororisé le carré en dégrader

Il est facile de réaliser un dégrader en OpenGL.

Il suffit d'ajouter "glColor3f" à chaque fois que l'on trace un coin du carré.
Pour le coin en haut à gauche la couleur est verte. Pour le coin en haut à droite, la couleur est jaune. Pour le coin en bas à gauche, la couleur est bleu. Pour le coin en bas à droite, la couleur est rouge.

procedure TForm1.FormPaint(Sender: TObject);
begin
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glLoadIdentity;
glTranslatef(0,0,-10);
glBegin(GL_QUADS);
glColor3f(1,0,0);
glVertex2f(2,-2);
glColor3f(0,0,1);
glVertex2f(-2,-2);
glColor3f(0,1,0);
glVertex2f(-2,2);
glColor3f(1,1,0);
glVertex2f(2,2 );
glEnd();
end;

OpenGL	[ 22-07-2002 ]
Déssine un carré coloré avec OpenGL. Télécharger : [6 Ko] [ opengl1.zip] Auteur : Yoann Site internet : http://delphipage.free.fr/

Réaliser un mouvemement

Voici que nous allons réaliser.

Pour réaliser un mouvement, la structure du programme sera différente puisque l'on travaillera maintanant en 3D. En effet, il faut passer du carré à un cube.
On va également changer le mode travail. On va maintenant travailler en double tampons.
Son principe est de dessiner dans le premier tampon puis de l'afficher dans le deuxième. Ce mode permet un affichage plus clair.

Il faut changer "opGDI" par "opDoubleBuffered" dans les paramètres de contexte graphique de notre fenêtre..

procedure TForm1.FormCreate(Sender: TObject);
begin
RC:=CreateRenderingContext(Form1.Canvas.Handle,[opDoubleBuffered],32,0,0,0,0);
wglMakeCurrent(Form1.Canvas.Handle,RC);
end;

On va utiliser le composant TTimer de l'onglet "Système" de la palette de composants de Delphi pour réaliser le mouvement. On va utiliser une variable "Angle" de type TGLFloat que l'on incrémentera.

public
{ Déclarations publiques }
RC :HGLRC;
Angle :TGLfloat;
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
Angle := Angle + 3;
Form1.Paint;
end;

Si vous changez le chiffre "3" alors la vitesse augmentera ou diminuera.

L'événement OnResize de la fenêtre ne change pas.
Par contre l'événement On Paint va beaucoup changer. C'est ici, que l'on va passer du carré au cube effectuer le mouvement.
"glPushMatrix" sauvegarde la matrice active.
"glPopMatrix" récupérer la matrice précédemment sauvegarder.

"glTranslate" permet une translation d'axe X,Y et Z.
"glRotate" permet une rotation d'axe X,Y,Z.
"glScale" permet de redimensionner une primitive.

Il faut donc créer six faces pour le cube. N'oublions pas que bous travaillons en 3D, il y a donc l'axe Z qui intervient.

procedure TForm1.FormPaint(Sender: TObject);
begin
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glLoadIdentity;
glTranslatef(0,0,-10);
glPushMatrix();
glScalef(0.8,0.8,0.8);
glTranslatef(0,0,2.0);
glRotatef(Angle,1,0,0);
glRotatef(-Angle,0,1,0);
glRotatef(-Angle,0,0,1);
glBegin(GL_QUADS);
//1 ère face\\
glColor3f(1,0,0);
glVertex3f(2,2,2); //1p
glColor3f(0,0,1);
glVertex3f(2,-2,2); //2p
glColor3f(0,1,0);
glVertex3f(-2,-2,2); //3p
glColor3f(1,1,0);
glVertex3f(-2,2,2); //4p
//2 ème face\\
glColor3f(1,0,0);
glVertex3f(2,2,-2); //1p
glColor3f(0,0,1);
glVertex3f(2,-2,-2); //2p
glColor3f(0,1,0);
glVertex3f(-2,-2,-2); //3p
glColor3f(1,1,0);
glVertex3f(-2,2,-2); //4p
//3 ème face\\
glColor3f(1,0,0);
glVertex3f(2,2,2); //1p
glColor3f(0,0,1);
glVertex3f(2,-2,2); //2p
glColor3f(0,1,0);
glVertex3f(2,-2,-2); //3p
glColor3f(1,1,0);
glVertex3f(2,2,-2); //4p
//4 ème face\\
glColor3f(1,1,0);
glVertex3f(-2,2,2); //1p
glColor3f(0,1,0);
glVertex3f(-2,-2,2); //2p
glColor3f(0,0,1);
glVertex3f(-2,-2,-2); //3p
glColor3f(1,0,0);
glVertex3f(-2,2,-2); //4p
//5 ème face\\
glColor3f(0,1,0);
glVertex3f(-2,2,-2); //1p
glColor3f(1,1,0);
glVertex3f(-2,2,2); //2p
glColor3f(1,0,0);
glVertex3f(2,2,2); //3p
glColor3f(0,0,1);
glVertex3f(2,2,-2); //4p
//6 ème face\\
glColor3f(1,1,0);
glVertex3f(-2,-2,-2); //1p
glColor3f(0,1,0);
glVertex3f(-2,-2,2); //2p
glColor3f(0,0,1);
glVertex3f(2,-2,2); //3p
glColor3f(1,0,0);
glVertex3f(2,-2,-2); //4p
glEnd();
glPopMatrix();
SwapBuffers(Form1.Canvas.Handle);
end;

"SwapBuffers(Form1.Canvas.Handle)" permet de basculer le contenu du premier tampon vers le deuxième.

OpenGL	[ 22-07-2002 ]
Déssine un cube dégradé en mouvement avec OpenGL. Télécharger : [7 Ko] [ opengl2.zip] Auteur : Yoann Site internet : http://delphipage.free.fr/

Un peu plus loin

Comme vous le voyez, il est assez difficile de réaliser des formes géométrique plus complexes comme par exemple une sphère. C'est pour cela qu'il existe en Delphi, des outils facilitant la conception de 3D.
Les plus célébres sont Glut [93Ko] et GLScene. En une ligne de programmation, vous pouvez construire une sphère, un cube, une pyramide... Ils permettent également de gérer le placement de la lumière sur les primitives et d'insérer une texture sur les primitives.