OpenGL avec Delphi

OpenGl est selon moi le meilleur outil mis au point pour faire de la 3D ou encore du 2D. Il est compatible avec Mac® OS, OS/2®, UNIX, Windows 95, Windows NT, Linux… et beaucoup d'autres encore. Il est plus que souvent le moteur principal dans les meilleurs shooting games tels que : Unreal, Dai-Katana, Half-Life, SpecOps… Son initialisation et son utilisation sont beaucoup plus faciles que celles de Direct3D et permettent une plus grande quantité de fonctions intéressantes. Il se compose d'environ 250 commandes distinctes pour travailler des objets et opérations permettant la troisième dimension. On peut construire des objets de plusieurs manières intéressantes à l'aide de formes basiques telles que : des points, lignes et polygones. OpenGL possède beaucoup de kits d'outils, mais j'aborderai le plus connu et facile qu'est : Glut (OpenGL Utility Library). Pour bien comprendre il est nécessaire de posséder une bonne petite base en langage Pascal ainsi que, le plus important, les mathématiques (algèbre linéaire et vectorielle, géométrie dans l'espace, etc.). Bonne chance, j'espère que vous apprécierez mes efforts.

Pour plus de détails sur ce puissant outil, allez jeter un coup d'œil sur le site officiel : https://www.opengl.org/

1. Tout d'abord vous aurez besoin de Borland Delphi v3.0 ou ultérieur.
2. Il est nécessaire de posséder la bibliothèque d'OpenGL donc OpenGL32.dll. Qui est plus que souvent déjà fourni avec les pilotes de votre carte vidéo. Si toutefois vous ne disposez pas de celui-ci alors vous pourrez télécharger à l'adresse suivante : GLSetup un petit utilitaire très pratique pour l'installer sur votre ordinateur.
3. L'utilitaire Glut(Optionnel). Si vous désirez plus d'informations sur cet outil, voici son concepteur : Nate Robins ou encore directement sur le site d'OpenGL.
4. Pour ceux qui aimeraient avoir plus de détails sur les procédures, fonctions et instructions dont je me sers tout au long de ces tutoriels, il vous serait pratique de vous procurer le fichier OpenGL HLP (anglais). En ouvrant ce fichier on obtient une erreur d'index, mais ce n'est pas grave, dirigez-vous directement vers le bouton Index pour retrouver la commande sur laquelle vous désirez de l'aide.
5. De l'intérêt pour la 3D.

Ce fichier contient la plupart des types, fonctions et procédures permettant l'accès à la bibliothèque OpenGl32.Dll.

Pour glut suivez les instructions du fichier ReadMe.Txt. (Si vous avez des problèmes à l'installation alors, contactez-moi.) Ce fichier contient un Kit de développement qui facilite quelques commandes soit pour construire des primitives ou encore effectuer des actions qui nécessitent beaucoup de code.

Vous devez probablement vous demander pourquoi je débute avec les types de données d'OpenGL. La réponse est assez simple, c'est que, pour construire des polygones, il faut spécifier des coordonnées de sommets et ces coordonnées seront spécifiées par des valeurs qui elles seront d'un type listé dans le tableau précédent. Ainsi il est possible de positionner des coordonnées de polygones ou ajuster leur couleur en se servant soit d'entiers ou de nombres réels. Mais avant de créer des polygones, nous allons commencer par initialiser OpenGL.

• Démarrez une nouvelle application comme à l'habitude.
• Spécifiez la couleur clBlack pour votre fenêtre (cela réduira les effets indésirés).
• Dans la clause Uses liez le fichier suivant : OpenGL, pour le fichier (OpenGl.pas).

Avant de commencer les bouts de code, vous devez comprendre deux concepts abstraits quant aux préalables de la liaison d'OpenGL et de votre fenêtre. Tout d'abord vous aurez besoin de conserver deux valeurs :

• DC : adresse d'un contexte graphique ou plutôt d'une surface dessinable. Dans notre cas la surface dessinable sera notre fenêtre. Cette adresse est nécessaire, car il faut mentionner à OpenGL sur quoi (surface) et où il doit dessiner ;
• HGLRC : adresse du contexte graphique de OpenGL. Cette valeur est comme une sorte de passerelle entre notre DC et OpenGL donc elle est très importante du fait qu'elle est en grande partie responsable du lien entre OpenGL et notre fenêtre.

Bon maintenant je vais vous bourrer de code

Ce code vous permettra seulement de connecter OpenGL à votre application Delphi. Au départ, ces extraits de code ne seront peut-être pas explicites pour vous, mais vous comprendrez mieux avec la suite. Le début :

Unit Utils;
Interface
Uses Windows, SysUtils, OpenGL;

...

Implementation
Var
   hDCGlobal   :HDC;
   GLContext   :HGLRC;

Voilà les deux seules variables globales privées de ce Unit :

• hDCGlobal : cette variable récupère le contexte graphique de la fenêtre. Comme le contexte graphique de la fenêtre est reçu comme paramètre dans la fonction InitOpenGL alors il faut la garder précieusement, car elle nous sera utile à la toute fin pour briser le lien entre OpenGL et notre contrôle fenêtré ;
• GLContext

Voici la procédure permettant d'initialiser OpenGL à notre composant fenêtré :

Function InitOpenGL( DC :HDC; ColorBits :Integer; 
                     DoubleBuffer :Boolean ) :Boolean;

Voici la fonction qui initialisera OpenGL sur notre fenêtre. Cette fonction requiert trois paramètres que voici :

• DC : le DC est l'adresse graphique de la fenêtre qui doit être liée à OpenGL. Sous Delphi, l'adresse graphique d'un composant se récupère à l'aide de la propriété « Canvas.Handle ». Ce paramètre a été nommé DC, car en anglais on dit (Device Context) ;
• ColorBits : ce paramètre spécifie le nombre de bits utilisé pour spécifier une couleur. Ce paramètre devrait être à 16. Par contre ce paramètre pourrait prendre la valeur de 32 si nous désirons effectuer du Blending, cela sera expliqué plus tard… ;
• DoubleBuffer : désirons-nous travailler en mode double tampon ou en mode simple ? Cela sera expliqué dans le prochain tutoriel.

Voici les variables nécessaires à la procédure InitOpenGL :

Var
    PixelFormat    :TPixelFormatDescriptor;
    cPixelFormat   :Integer;

La première variable (PixelFormat) sera utilisée pour notre requête d'un format spécifique de tampon de pixels.
La deuxième variable (cPixelFormat) contiendra le numéro d'identification du format de tampon de pixels qui nous aura été attribué par Windows. Précisons que chaque surface dessinable a toujours un descripteur de tampon de pixels.

     FillChar( PixelFormat, SizeOf(PixelFormat), 0 );
     With PixelFormat Do
     Begin
          nSize      := Sizeof(TPixelFormatDescriptor);
          If DoubleBuffer Then
             dwFlags    := PFD_DOUBLEBUFFER OR PFD_DRAW_TO_WINDOW 
                           OR PFD_SUPPORT_OPENGL
          Else
              dwFlags    := PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL;
          iLayerType := PFD_MAIN_PLANE;
          iPixelType := PFD_TYPE_RGBA;
          nVersion   := 1;
          cColorBits := 16;
          CdepthBits := 16;
     End;

Tout d'abord la fonction FillChar remplit notre structure de tampon de pixels avec des 0. Ce remplissage de 0 n'est pas ultimement nécessaire, mais il peut parfois éviter des problèmes avec des valeurs non désirées. Ensuite il faut spécifier le format du tampon de pixels alors je ne vous expliquerai pas toute la structure en détail, car elle a beaucoup de membres. Ce que je vous conseille c'est de presser la touche F1 sur celle-ci. Les membres les plus importants pour ce tutoriel sont expliqués ici :

• dwFlags : ce membre spécifie les propriétés du tampon de pixels. Ici nous lui demandons de pouvoir dessiner sur une fenêtre, et de supporter OpenGL. La variable DoubleBuffer détermine si le tampon de pixels est doublé. Si ce n'est pas très clair alors vous comprendrez au deuxième tutoriel.
• cColorBits

cPixelFormat := ChoosePixelFormat(DC, @PixelFormat);

Une fois que la structure de spécification du tampon de pixels est spécifiée alors il suffit de la proposer à Windows qui lui déterminera quel type de tampon de pixels est le plus adapté pour votre fenêtre.

SetPixelFormat( DC, cPixelFormat, @PixelFormat);

Cette fonction applique le nouveau format de tampon de pixels à la fenêtre, le format est appliqué par l'entremise du contexte graphique (DC) de la fenêtre.

GLContext := wglCreateContext( DC );

C'est ici que la passerelle entre OpenGL et votre DC est créée. Par contre il faut faire attention, car elle n'est pas encore activée ou plutôt dire qu'elle est créée, mais le passage est bouché, alors le lien n'est pas fait. La fonction suivante démontre comment la rendre active (Débouché).

wglMakeCurrent( DC, GLContext );

Et pour finir, cette fonction rend la passerelle active entre les deux contextes graphiques. Eh! Ne partez pas ! Il reste juste une procédure, celle qui détruit le lien entre OpenGL et votre fenêtre.

Procedure Terminer;
Begin
     wglMakeCurrent( hDCGlobal, 0 );
     wglDeleteContext( GLContext );
End;

La première fonction rebouche la passerelle ou plutôt elle la désactive.
Ensuite il ne reste plus qu'à supprimer la passerelle.

Bien sûr le code que je vous ai montré ne gère vraiment pas les erreurs et je crois sincèrement que c'est primordial qu'il le fasse alors le code source que vous téléchargerez tantôt sera optimisé en ce sens.

Ce programme montre la plus petite application OpenGL sous Dephi. Pour l'instant rien de visuel ne se produit, mais si tout se déroule bien vous constaterez que OpenGL est lié à votre fenêtre. Source

P.-S. : ne vous en faites pas pour le code supplémentaire dans les autres événements de la fenêtre, ils seront expliqués dans le tutoriel suivant alors ne vous gênez pas, pressez la flèche de droite .

pour ceux que cela intéresse, voici l'autre manière de créer une application OpenGL avec Delphi. Source (à la C++).

P.-S. - 2 : si vous ne savez pas comment créer votre propre fenêtre (comme à la C++) alors je vous conseille d'aller jeter un coup d'œil ici avant.