Programmation graphique OPENGL
OPENGL est une bibliothèque de graphiques et de modèles tridimensionnels En raison de ses performances exceptionnelles en graphiques tridimensionnels, de nombreux langages de haut niveau fournissent actuellement des interfaces avec OPENGL, tels que : VC, DELPHI, C++Builder, etc. L'utilisation d'OPENGL peut réduire considérablement la difficulté pour les utilisateurs de développer des graphiques et des images, permettant aux utilisateurs de produire des publicités commerciales de haut niveau, de la CAO graphique, de l'animation tridimensionnelle, de la simulation graphique et des collections de films et de télévision.
1. Fonctions d'OPENGL
OPENGL était à l'origine une bibliothèque de logiciels graphiques pour postes de travail. En raison de sa large application dans les domaines commercial, militaire, médical, aérospatial et autres, des graphiques répondant aux besoins des utilisateurs peuvent désormais être développés sur des ordinateurs bas de gamme. OPENGL peut non seulement dessiner des images de base, mais fournit également un grand nombre de fonctions et de procédures de traitement d'images graphiques.
1. Transformation graphique
C'est la base de l'affichage et de la production graphiques. La conception et l'affichage d'animations sont indissociables de la transformation graphique. La transformation graphique est réalisée mathématiquement par la multiplication de rectangles. La transformation comprend généralement la translation, la rotation et la mise à l'échelle. Selon les propriétés d'affichage des graphiques : transformation de point de vue, transformation de modèle, transformation de projection, transformation de détourage et transformation de fenêtre, etc.
2. Effet d'éclairage
La couleur d'un objet non lumineux est causée par l'objet qui réfléchit la lumière externe, qui est l'éclairage. Dans les graphiques tridimensionnels, si l'éclairage est mal utilisé, les graphiques tridimensionnels perdront leur véritable sens tridimensionnel. OPENGL divise l'éclairage en : lumière rayonnante, lumière ambiante, lumière diffusée, lumière réfléchie, etc.
3. Cartographie des textures
Le mappage de texture vous permet d'ajouter des textures du monde réel à des surfaces tridimensionnelles. Par exemple : un rectangle ne peut pas représenter un objet dans le monde réel S'il est rempli de texture « essentielle », il deviendra réaliste.
4. Effets spéciaux graphiques
La fonction de fusion, la fonction anti-aliasing et la fonction de brouillard peuvent gérer la transparence et la translucidité des graphiques tridimensionnels, laisser l'objet être lisse, utiliser des segments de ligne pour lisser et fournir un effet de brouillard.
5. Effets spéciaux d'image
Fonctions de base pour le traitement des bitmaps : dessin d'images, copie et stockage d'images, mappage et transfert, mise à l'échelle de l'image, etc. La fonction d'opération bitmap peut expliquer le processus de formation des caractères chinois au niveau inférieur du dessin original.
2. Créer une application OPENGL
1. Principes généraux
A. Ajoutez l'unité de support OPENGL dans les utilisations : OpenGL ;
B initialiser OPENGL lors de l'événement OnCreate du formulaire ;
C initialise OPENGL lors de l'événement OnPaing de la fenêtre ;
D initialise OPENGL lors de l'événement OnResize de la fenêtre ;
E initialise OPENGL lors de l'événement OnDestroy de la fenêtre ;
2. Exemple simple
A Créer un projet FICHIER->Nouvelle application
B Ajoutez du code dans l'événement OnCreate :
PRocédure TfrmMain.FormCreate(Expéditeur : TObject);
var
pfd:TPixelFormatDescriptor; //Définir la table de description
Format de pixels : entier ;
commencer
StyleContrôle:=StyleContrôle+[csOpaque];
FillChar(pfd,sizeof(pfd),0);
avec pfd faire
commencer
nSize:=sizeof(TPixelFormatDescriptor);
nVersion :=1 ;
dwFlags :=PFD_DRAW_TO_WINDOW ou
PFD_SUPPORT_OPENGL ou PFD_DOUBLEBUFFER ;
iPixelType :=PFD_TYPE_RGBA ;
cColorBits :=24 ;
cDepthBits :=32 ;
iLayerType :=PFD_MAIN_PLANE ;
fin;
PixelFormat:=ChoosePixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClientLargeur;
h:=Hauteur du client ;
fin;
Code C dans l'événement OnDestroy
procédure TfrmMain.FormDestroy(Expéditeur : TObject);
commencer
wglDeleteContext(hrc);
fin;
Code D dans l'événement OnPaint
procédure TfrmMain.FormPaint(Expéditeur : TObject);
commencer
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
Mon dessin ;
glFlush ;
SwapBuffers(Canvas.Handle);
fin;
Code E dans l'événement OnResize
procédure TfrmMain.FormResize(Expéditeur : TObject);
commencer
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,ClientWidth,ClientHeight);
Mon dessin ;
fin;
Code F dans la fonction MyDraw (déclaré par l'utilisateur dans la classe window)
procédure TfrmMain.MyDraw ;
commencer
glPushMatrix;
Sphère :=gluNewQuadric ;
gluQuadricDrawStyle(Sphère,GLU_LINE);
gluSphère(Sphère,0.5,25,25);
glPopMatrix ;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Sphère);
fin;
Ci-joint le code original de ce programme :
unité MainFrm ;
interface
utilise
Windows, messages, SysUtils, variantes, classes, graphiques, contrôles, formulaires,
Boîtes de dialogue, OpenGL ;
taper
TfrmMain = classe (TForm)
procédure FormCreate(Expéditeur : TObject);
procédure FormDestroy(Expéditeur : TObject);
procédure FormPaint(Expéditeur : TObject);
procédure FormResize(Expéditeur : TObject);
privé
{Déclarations privées}
hrc:HGLRC;
w,h:glFloat;
Sphère : GLUquadricObj ;
publique
{Déclarations publiques}
procédure MyDraw ;
fin;
var
frmMain : TfrmMain ;
mise en œuvre
{$R *.dfm}
procédure TfrmMain.FormCreate(Expéditeur : TObject);
var
pfd: TPixelFormatDescriptor ;
Format de pixels : entier ;
commencer
StyleContrôle:=StyleContrôle+[csOpaque];
FillChar(pfd,sizeof(pfd),0);
avec pfd faire
commencer
nSize:=sizeof(TPixelFormatDescriptor);
nVersion :=1 ;
dwFlags :=PFD_DRAW_TO_WINDOW ou
PFD_SUPPORT_OPENGL ou PFD_DOUBLEBUFFER ;
iPixelType :=PFD_TYPE_RGBA ;
cColorBits :=24 ;
cDepthBits :=32 ;
iLayerType :=PFD_MAIN_PLANE ;
fin;
PixelFormat:=ChoosePixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClientLargeur;
h:=Hauteur du client ;
fin;
procédure TfrmMain.FormDestroy(Expéditeur : TObject);
commencer
wglDeleteContext(hrc);
fin;
procédure TfrmMain.FormPaint(Expéditeur : TObject);
commencer
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
Mon dessin ;
glFlush ;
SwapBuffers(Canvas.Handle);
fin;
procédure TfrmMain.MyDraw ;
commencer
glPushMatrix;
Sphère :=gluNewQuadric ;
gluQuadricDrawStyle(Sphère,GLU_LINE);
gluSphère(Sphère,0.5,25,25);
glPopMatrix ;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Sphère);
fin;
procédure TfrmMain.FormResize(Expéditeur : TObject);
commencer
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,ClientWidth,ClientHeight);
Mon dessin ;
fin;
fin.
3. Conventions sur les variables et fonctions OPENGL
1. Conventions de la bibliothèque OPENGL
Il dispose de trois bibliothèques au total : bibliothèque de base, bibliothèque pratique et bibliothèque auxiliaire. Dans DELPHI, la bibliothèque de base est implémentée par l'unité OpenGL. Dans l'environnement Windows, les bibliothèques auxiliaires ne sont généralement pas utilisées.
2. Convention constante OPENGL
Les constantes OPENGL utilisent des lettres majuscules, commençant par "GL", et utilisent des traits de soulignement pour séparer les mots, tels que : GL_LINES, ce qui signifie utiliser la bibliothèque de base pour tracer des lignes droites.
3. Convention de dénomination des fonctions OPENGL
R La première partie commence par gl ou wgl, comme gl dans glColor3f.
B La deuxième partie est la fonction exprimée en anglais, avec la première lettre du mot en majuscule.
La troisième partie de C est un nombre représentant les paramètres de la fonction.
La quatrième partie de D est une lettre minuscule indiquant le type de fonction.
b entier de 9 bits
entier s16 bits
i32 bits entier
nombre à virgule flottante f32 bits
nombre à virgule flottante d64 bits
entier non signé ub9 bits
Exemple : glVertex2f(37,40); {deux nombres à virgule flottante de 32 bits comme paramètres}
glVertex3d(37,40,5); {Trois nombres à virgule flottante de 64 bits comme paramètres}
p[1..3] : tableau de glFloat ;
glVertes3fv(p); {3f représente trois nombres à virgule flottante, v représente l'appel d'un tableau comme entrée de coordonnées de sommet}
4. Initialisation d'OPENGL
1. Structure PIXELFORMATDESCRIPTEUR
Il décrit principalement les propriétés des pixels, telles que le mode de couleur des pixels et la composition des couleurs rouge, verte et bleue.
tagPIXELFORMATDESCRIPTOR = enregistrement compressé
nTaille : Mot ;
nVersion : Word ;
dwFlags : DWORD ;
iPixelType : octet ;
cColorBits : octet ;
cRedBits : octet ;
cRedShift : octet ;
cGreenBits : octet ;
cGreenShift : octet ;
cBlueBits : octet ;
cBlueShift : octet ;
cAlphaBits : octet ;
cAlphaShift : octet ;
cAccumBits : octet ;
cAccumRedBits : octet ;
cAccumGreenBits : octet ;
cAccumBlueBits : octet ;
cAccumAlphaBits : octet ;
cDepthBits : octet ;
cStencilBits : octet ;
cAuxBuffers : octet ;
iLayerType : octet ;
bRéservé : octet ;
dwLayerMask : DWORD ;
dwVisibleMask : DWORD ;
dwDamageMask : DWORD ;
fin;
TPixelFormatDescriptor = tagPIXELFORMATDESCRIPTOR ;
dwFlags représente les attributs du format point :
Les graphiques PFD_DRAW_TO_WINDOW sont dessinés sur l'écran ou la surface de l'appareil
PFD_DRAW_TO_BITMAP dessine un bitmap en mémoire
PFD_SUPPORT_GDI prend en charge le dessin GDI
PFD_SUPPORT_OPENGL prend en charge les fonctions OPENGL
PFD_DOUBLEBUFFER utilise une double mise en mémoire tampon
Cache stéréo PFD_STEREO
PFD_NEED_PALLETTE utilise la palette RGBA
PFD_GENERIC_FORMAT sélectionne le format de dessin pris en charge par GDI
PFD_NEED_SYSTEM_PALETTE utilise la palette matérielle prise en charge par OPENGL
iPixelType définit le mode de couleur des pixels : PFD_TYPE_RGBA ou PFD_TYPE_INDEX.
cColorBits définit les bits de couleur. S'il vaut 9, cela signifie qu'il y a 256 couleurs pour représenter la couleur du point.
cRedBits, cGreenBits, cBlueBits Lors de l'utilisation de RGBA, le nombre de bits utilisés pour les trois couleurs primaires.
cRedShitfs, cGreenShifts, cBlueShifts Lors de l'utilisation de RGBA, le nombre de chiffres pouvant être ajustés pour les trois couleurs primaires.
cAlphaBits, cAlphaShifts Lors de l'utilisation de RGBA, le nombre de bits utilisés par Alpha et le nombre de bits réglables.
cAccumBits définit le nombre total de bits dans la zone tampon d'accumulation.
cAccumRedBits, cAccumGreenBits et cAccumBlueBits définissent le nombre total de trois plans de couleurs primaires dans la zone tampon d'accumulation.
cAccumAlphaBits définit le nombre total de bits Alpha dans le tampon d'accumulation.
cDepthBits définit la profondeur du tampon de concentration.
cStencilBits définit la profondeur du cache Stencil.
cAuxBuffers fait référence à la taille du tampon auxiliaire.
iLayerType spécifie le type de calque.
bReserved n’est pas utilisé et doit être nul.
dwLayerMask spécifie le masque de la superposition.
dwDamageMask définit si le même mode pixel est partagé dans le même cache d'images.
2. Étapes d'initialisation d'OPENGL
A Utilisez Canvas.Handle pour obtenir le handle de fenêtre.
B Créez une variable TPixelFormatDescriptor pour définir le format de pixel.
C Utilisez la fonction ChoosePixelFormat pour sélectionner le format de pixel.
D Utilisez la fonction SetPixelFormat pour utiliser le format de pixel pour prendre effet.
E Utilisez la fonction wglCreateContext pour créer une table de description de traduction.
F Utilisez la fonction wglMakeCurrent pour utiliser la table de description de traduction créée comme table de description de traduction actuelle.
3. Libération des ressources
A Utilisez la procédure wglDeleteContext pour supprimer la table contextuelle des pixels.
B Utilisez la procédure ReleaseDC pour libérer la mémoire de la fenêtre.
Dans l'événement OnDestroy de la fenêtre :
commencer
si hrc<>null alors
wglDeleteCurrent(hrc);
si hdc<>null alors
ReleaseDC (Poignée, hdc);
fin;
5. Dessin des graphiques de base OPENGL
1. Couleur des graphiques
Faites attention au paramètre de couleur d'arrière-plan. Le paramètre de couleur est généralement lié à la variable de description de pixel, c'est-à-dire au membre iPixelType dans la définition de TPixelFormatDescriptor.
iPixelType :=PFD_TYPE_COLORINDEX ;
Ensuite, vous ne pouvez utiliser que les procédures glIndexd, glIndexf, glIndexi, glIndexs, glIndexv, glIndexfv, glIndexiv, glIndexsv pour définir la couleur des graphiques.
iPixelType :=PFD_TYPE_RGBA ;
Ensuite, vous ne pouvez utiliser que glColor3b, glColor3f, glColor4b, glColor4f, glColor4fv pour définir la couleur des graphiques.
A Couleur d'arrière-plan graphique : la couleur de l'écran et de la fenêtre, c'est-à-dire la couleur du tampon de couleur. Pour modifier la couleur d'arrière-plan des graphiques, vous devez d'abord utiliser la procédure glClearColor pour définir la couleur d'arrière-plan, puis utiliser la procédure glClear pour actualiser la fenêtre et l'écran avec cette couleur d'arrière-plan.
procédure glClearColor (rouge: GLClampf, vert: GLClampf, bleu: GLClampf, alpha: GLClampf);
procédure glClear(masque:GLBitField);
le rouge, le vert, le bleu et l'alpha sont les couleurs d'arrière-plan à définir et leurs valeurs sont comprises entre 0 et 1. Le masque est un moyen de rafraîchir la couleur d'arrière-plan.
Exemple : définir la fenêtre de coloration sur vert
glClearColor(0,1,0,1);
glClear(GL_COLOR_BUFFER_BIT);
La valeur et la signification du masque :
GL_COLOR_BUFFER_BIT définit le tampon de couleur actuel
GL_DEPTH_BUFFER_BIT définit le tampon de profondeur actuel
GL_ACCUM_BUFFER_BIT définit le tampon d'accumulation actuel
GL_STENCIL_BUFFER_BIT définit le tampon STENCIL (modèle) actuel
La fenêtre de dessin est grisée
glClearColor(0.3,0.3,0.3,1);
glClear(GL_COLOR_BUFFER_BIT);
Couleur graphique B
Utilisez glClear3f et glClear4f pour définir la couleur de dessin des graphiques. Si trois paramètres sont utilisés, cela signifie régler respectivement les trois couleurs de lumière rouge, bleue et verte. Si quatre paramètres sont utilisés, le quatrième représente la valeur RGBA.
Exemple de définition de la couleur actuelle du dessin sur bleu :
glColor3f(0,0,1);
Définissez la couleur du tracé sur blanc :
glColor3f(1,1,1);
2. Dessin de graphiques simples
Dessinez des graphiques simples, tels que des points, des lignes, des polygones, etc., entre les procédures glBegin et glEnd.
glBegin(mode:GLenum);{Processus de dessin}glEnd;
La valeur du mode :
GL_POINTS dessine plusieurs points
GL_LINES dessine plusieurs lignes, en traçant une ligne droite tous les deux points
GL_LINE_STRIP dessine une polyligne
GL_LINE_LOOP dessine des polygones fermés connectés bout à bout
GL_TRIANGLES dessine des triangles
GL_TRIANGLE_STRIP dessine un triangle, en dessinant un triangle tous les trois points
GL_TRIANGLE_FAN dessine des triangles
GL_QUADS dessine des quadrilatères
GL_QUAD_STRIP dessine des bandes quadrilatérales, une bande quadrilatérale est dessinée tous les quatre points
GL_POLYGON dessine des polygones
Exemple de dessin de trois points :
commencer
glPushMatrix;
glBegin(GL_POINT);
glVertex2f(0.1,0.1);
glVertex2f(0.5,0.5);
glVertex2f(0.1,0.3);
glEnd;
SwapBuffers(Canvas.Handle);
fin;
Si vous remplacez GL_POINT par GL_LINES, vous tracerez une ligne. Le troisième point n'est pas valide. Faire glColor3f(0,0,1) avant glVertex2f changera la couleur de la ligne en vert. Si vous remplacez GL_LINES par GL_LINE_STRIP, vous pouvez dessiner. deux Une ligne droite.
Utilisez la procédure glPointSize pour définir la taille en points ; utilisez la procédure glLineWidth pour définir la largeur de ligne.
Utilisez la procédure glLineStipple pour définir le modèle pour les lignes pointillées, et utilisez la procédure glEnable(GL_LINE_STIPPLE) et les paramètres correspondants pour permettre au dessin de dessiner des lignes pointillées. La procédure glDisable(GL_LINE_STIPPLE) et les paramètres correspondants désactivent les lignes pointillées.
procédure glLineStipple(factor:GLint,pattern:GLushort);
Le paramètre factor représente le nombre de répétitions du modèle de ligne point-tiret. La valeur du facteur est 1255. Le motif est une séquence binaire.
glLineStipple(1,0,0x11C);{0x11C est représenté par 10001110, 0 signifie ne pas dessiner de points, 1 signifie dessiner des points}
Exemple : commencer
glColor3f(1,0,0);
glLineWidth(2);
glLineStipple(1,11C$);
glEnable(GL_LINE_STIPPLE);
glBegin(GL_LINES);
glVertex2f(-0.9,0.3);
glVertex2f(0.9,0.3);
glEnd;
glDisable(GL_LINE_STIPPLE);
glColor3f(1,0,1);
glLineStipple(2,11C$);
glEnable(GL_LINE_STIPPLE);
glBegin(GL_LINES);
glVertex2f(-0.9,0.1);
glVertex2f(0.9,0.1);
glEnd;
glDisable(GL_LINE_STIPPLE);
SwapBuffers(Canvas.Handle);
fin;
Le dessin de polygones est similaire au dessin de lignes de points. Vous devez modifier les paramètres en GL_POLYGON, GL_QUADS, GL_TRANGLES. Choses à noter lors du dessin :
Les côtés d'un polygone se coupent uniquement aux sommets
Le polygone B doit être un polygone convexe. S'il s'agit d'un polygone concave, l'utilisateur peut uniquement le plier en polygone convexe pour accélérer le dessin.
Exemple : glBegin(GL_POLYGON);
glVertex2f(-0.9,0.3);
glVertex2f(0.9,0.3);
glVertex2f(0,9,-0,6);
glVertex2f(0,5,-0,6);
glVertex2f(-0,9,-0,2);
glEnd;
Les polygones ont des faces avant et arrière, et les processus qui leur sont liés sont :
glPolygonMode contrôle les modes de dessin recto et verso des polygones
glFrontface spécifie la face avant du polygone
glCullFace affiche les polygones configurés pour éliminer les faces
glPolygonStripple forme le style d'un remplissage polygonal
3. Surface quadratique simple
Les cylindres, les anneaux et les sphères sont tous des surfaces quadratiques.
Un cylindre
gluCylinder(qobj:GLUquadricObj,baseRadius:GLdouble,topRadius:GLdouble,hauteur:GLdouble,
tranches : GLint, piles : GLint );
qobj spécifie une surface quadratique, baseRadius est le rayon de base du cylindre ; topRadius est le rayon supérieur du cylindre dessiné ; la hauteur est la hauteur des tranches du cylindre est le nombre de lignes de séparation autour de l'axe Z ; lignes de séparation le long de l'axe Z.
Si baseRadius et topRadius ne sont pas égaux, vous pouvez dessiner un tronc de tronc et un cône.
procédure TfrmMain.MyDraw ;
var
qObj:GLUQuadricObj;
commencer
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluCylinder(qObj,0.5,0.1,0.2,10,10);
fin;
Apporter
gluDisk (qobj: GLUquadricObj, innerRadius: GLdouble, externalRadius: GLdouble, tranches: GLint,
boucles:GLint);
procédure TfrmMain.MyDraw ;
var
qObj:GLUQuadricObj;
commencer
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluDisk(qObj,0.2,0.5,10,5);
SwapBuffers(Canvas.Handle);
fin;
C demi-cercle
gluPartialDisk (qobj:GLUquadricObj,innerRadius:GLdouble,outerRadius:GLdouble,slices:GLint,
boucles:GLint,startAngle:GLdouble,sweepAngle:GLdouble);
startAngle, scanningAngle sont l'angle de départ et l'angle de fin du demi-cercle.
procédure TfrmMain.MyDraw ;
var
qObj:GLUQuadricObj;
commencer
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluPartialDisk(qObj,0.2,0.5,10,5,90,190);
SwapBuffers(Canvas.Handle);
fin;
Sphère D
fonction gluSphere(qObj:GLUquadricObj,radius:GLdouble,slices:GLint,stacks:GLint);
procédure TfrmMain.MyDraw ;
var
qObj:GLUQuadricObj;
commencer
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
{ silhouette[ silu(:)5et ]n. silhouette, contour}
gluSphere(qObj,0.5,20,20);
SwapBuffers(Canvas.Handle);
fin;
E À propos du processus de surface quadratique
gluNewQuadric crée un nouvel objet surface quadratique
gluDeleteQuadric supprime un objet surface quadratique
gluQuadricDrawStyle spécifie le type de surface quadrique à dessiner
gluQuadricNormal définit le vecteur normal de la surface quadratique
gluQuadricOrientation définit si la surface quadratique subit une rotation interne ou externe.
gluQuadricTexture définit si la surface quadratique utilise la texture
F Étapes générales pour dessiner des surfaces quadratiques
Définissez d’abord un objet GLUquadricObj ;
Deuxièmement, créez un objet de surface gluNewQuadric ;
Définissez à nouveau les propriétés de la surface quadratique (gluQuadricDrawStyle, gluQuadricTexture)
Dessinez des surfaces quadratiques (gluCylinder, gluSphere, gluDisk, gluPartialDisk)
6. Transformation en OPENGL
La transformation est la base de la conception d'animation, y compris la traduction graphique, la rotation, la mise à l'échelle et d'autres opérations, qui sont mises en œuvre mathématiquement via des matrices.
1 processus glLoadIdentity
Capable de convertir la matrice actuelle en une matrice d'identité.
2 Processus glLoadMatrix
Capable de définir la matrice spécifiée comme matrice actuelle.
procédure glLoadmatrixd(m:GLdouble);
procédure glLoadmatrixf(m:GLfloat);
m représente une matrice 4X4, le code suivant la définit et en fait la matrice actuelle
M: tableau [1..4,1..4] de GLfloat ;
glLoadMatrix (@M);
3 Processus glMultMatrix
Capable de multiplier le moment actuel par la matrice spécifiée et d'utiliser le résultat comme moment actuel.
procédure glMultMatrixd(M:GLdouble);
procédure glMultMatrixf(M:GLfloat);
4 glPushMatrix et glPopmatrix
glPushMatrix peut pousser le moment actuel dans la pile matricielle, et glPopMatrix peut faire sortir le moment actuel de la pile matricielle.
glPushMatrix peut mémoriser la position actuelle de la matrice et glPopmatrix peut renvoyer la position précédente.
Remarque : glPushMatrix et glPopMatrix doivent être placés en dehors de glBegin et glEnd.
5 Transformation des projections
Un glOrtho peut créer une matrice de projection orthographique, multiplier le moment actuel par la matrice de projection orthographique et utiliser le résultat comme matrice actuelle.
fonction glOrtho (gauche: GLdouble, droite: GLdouble, bas: GLdouble, haut: GLdouble,
près:GLdouble,loin:GLdouble);
procédure TfrmMain.FormResize(Expéditeur : TObject);
var
nPlage : GLfloat ;
commencer
nPlage :=50,0 ;
w:=clientLargeur;
h:=clientHeight;
si h=0 alors
h:=1;
glViewPort(0,0,w,h);
si w<=h alors
glOrtho(-nRange,nRange,-nRange*h/w,nRange*h/w,
-nPlage,nPlage)
autre
glOrtho(-nRange*h/w,nRange*h/w,-nRange,nRange,
-nPlage,nPlage);
repeindre;
fin;
B glOrtho2D définit uniquement l'avant, l'arrière, la gauche et la droite du volume de visualisation orthographique.
procédure glOrtho(gauche:GLdouble,droite:GLdouble,bas:GLdouble,haut:GLdouble);
Procédure C glMatrixMode
Possibilité de définir le type de matrice d'opération actuelle
procédure glMatrixMode(mode:GLenum);
La valeur du mode :
GL_MODELVIEW spécifie que les opérations matricielles suivantes sont des piles de matrices de modèles
GL_PROJECTION spécifie que les opérations matricielles ultérieures sont des piles de matrices de projection
GL_TEXTURE spécifie que les opérations matricielles suivantes sont des piles de matrices de texture
Processus D glFrustum
Créez une matrice de projection oblique en perspective et multipliez la matrice actuelle par la matrice de projection oblique. Le résultat est la matrice actuelle.
procédure glFrustum(gauche:GLdouble,droite:GLdouble,bas:GLdouble,haut:GLdouble,
suivant:GLdouble,loin:GLdouble);
Ces paramètres définissent les plans de détourage gauche, droit, haut, bas, avant et arrière de la projection oblique.
E gluProcessus Perspective
Capable de définir un volume de visualisation pyramidal à quatre côtés avec l'axe Z comme ligne centrale.
procédure gluPerspetive(fovy:GLdouble,aspect:GLdouble,zNear:GLdouble,zFar:GLdouble);
fovy définit la perspective du plan xoz, aspect définit le rapport dans les directions x et y, zNear et zFar définissent respectivement les distances entre le point de vue et le plan de détourage arrière.
procédure TfrmMain.FormResize(Expéditeur : TObject);
var
aspect : GLfloat ;
commencer
w:=ClientLargeur;
h:=Hauteur du client ;
si h=0 alors
h:=1;
glViewPort(0,0,clientWidth,Clientheight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
aspect:=l/h;
gluPerspective(30.0,aspect,1.0,50.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity;
fin;
6 Matrice de transformation géométrique
La transformation de la posture et du mouvement d'un objet tridimensionnel fait référence à la translation, à la rotation et à la mise à l'échelle de l'objet.
Un processus glTranslate peut déplacer l'origine des coordonnées vers (x, y, z), sa syntaxe de déclaration :
procédure glTranslated(x:GLdouble,y:GLdouble,z:GLdouble);
procédure glTranslatef(x:GLdouble,y:GLdouble,z:GLdouble);
B glRotate peut faire pivoter un objet selon un certain angle. Sa syntaxe de déclaration est :
procédure glRotated(angle:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
procédure glRotatef(angle:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
Parmi eux, l'angle est l'angle de rotation et l'axe central de rotation est la ligne reliant les deux points (0,0,0) et (x, y, z).
C glScale peut mettre à l'échelle le système de coordonnées et sa syntaxe de déclaration est :
procédure glScaled(x:GLdouble,y:GLdoble,z:GLdouble);
procédure glScalef(x:GLdouble,y:GLdoble,z:GLdouble);
Les valeurs de x, y et z supérieures à 1 représentent un élargissement et les valeurs inférieures à 1 représentent une réduction.
Exemple de code d'origine :
unité MainFrm ;
interface
utilise
Windows, messages, SysUtils, variantes, classes, graphiques, contrôles, formulaires,
Boîtes de dialogue, OpenGL, ExtCtrls ;
taper
TfrmMain = classe (TForm)
Minuterie1 : TIminuterie ;
procédure FormCreate(Expéditeur : TObject);
procédure FormDestroy(Expéditeur : TObject);
procédure FormPaint(Expéditeur : TObject);
procédure FormKeyDown (Expéditeur : TObject ; var Clé : Word ;
Maj : TShiftState);
procédure FormResize(Expéditeur : TObject);
procédure Timer1Timer(Expéditeur : TObject);
procédure FormClose (Expéditeur : TObject ; var Action : TCloseAction);
privé
{Déclarations privées}
hrc:HGLRC;
w, h : entier ;
latitude, longitude : GLfloat ;
rayon:GLdouble;
publique
{Déclarations publiques}
procédure MyDraw ;
procédure InitializeGL(var width:GLsizei;height:GLsizei);
fin;
var
frmMain : TfrmMain ;
mise en œuvre
{$R *.dfm}
procédure TfrmMain.FormCreate(Expéditeur : TObject);
var
pfd: TPixelFormatDescriptor ;
Format de pixels : entier ;
commencer
StyleContrôle:=StyleContrôle+[csOpaque];
FillChar(pfd,sizeof(pfd),0);
avec pfd faire
commencer
nSize:=sizeof(TPixelFormatDescriptor);
nVersion :=1 ;
dwFlags :=PFD_DRAW_TO_WINDOW ou
PFD_SUPPORT_OPENGL ou PFD_DOUBLEBUFFER ;
iPixelType :=PFD_TYPE_RGBA ;
cColorBits :=24 ;
cDepthBits :=32 ;
iLayerType :=PFD_MAIN_PLANE ;
fin;
PixelFormat:=ChoosePixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClientRect.Right;
h:=ClientRect.Bottom;
InitialiserGL(w,h);
fin;
procédure TfrmMain.FormDestroy(Expéditeur : TObject);
commencer
wglDeleteContext(hrc);
fin;
procédure TfrmMain.FormPaint(Expéditeur : TObject);
commencer
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
Mon dessin ;
glFlush ;
fin;
procédure TfrmMain.MyDraw ;
var
qObj:GLUQuadricObj;
commencer
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT ou GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
glRotated(0.5,0.0,1.0,0.0);
glRotated(-latitude,1.0,0.0,0.0);
groté(longitude,0.0,0.0,1.0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluSphere(qObj,0.5,20,20);
SwapBuffers(Canvas.Handle);
fin;
{procédure TfrmMain.FormResize(Expéditeur : TObject);
var
nPlage : GLfloat ;
commencer
nPlage :=50,0 ;
w:=clientLargeur;
h:=clientHeight;
si h=0 alors
h:=1;
glViewPort(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
si w<=h alors
glOrtho(-nRange,nRange,-nRange*h/w,nRange*h/w,
-nPlage,nPlage)
autre
glOrtho(-nRange*h/w,nRange*h/w,-nRange,nRange,
-nPlage,nPlage);
glMatrixMode(GL_MODELVIEW);
glLoadidentity ;
repeindre;
fin;
}
procédure TfrmMain.FormKeyDown (Expéditeur : TObject ; var Clé : Word ;
Maj : TShiftState);
commencer
si Key=VK_ESCAPE alors
Fermer;
si Clé=VK_UP alors
glRotatef(-5,1.0,0.0,0.0);
si Clé=VK_DOWN alors
glRotatef(5,1.0,0.0,0.0);
si Clé=VK_LEFT alors
glRotatef(-5,0.0,1.0,0.0);
si Clé=VK_RIGHT alors
glRotatef(5.0,0.0,1.0,0.0);
repeindre;
fin;
procédure TfrmMain.FormResize(Expéditeur : TObject);
commencer
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,clientWidth,clientHeight);
repeindre;
invalider;
fin;
procédure TfrmMain.InitializeGL(var largeur : GLsizei ; hauteur : GLsizei) ;
var
maxObjectSize, aspect:GLfloat;
plan_proche:GLdouble;
commencer
glClairindex(0);
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
aspect :=1,0 ;
gluPerspective(45.0,aspect,3.0,7.0);
glmatrixMode(GL_MODELVIEW);
plan_proche :=0,3 ;
maxObjectSize:=0,3;
rayon :=near_plane+maxObjectSize/2.0 ;
latitude :=0,3 ;
longitude :=0,6 ;
fin;
procédure TfrmMain.Timer1Timer(Expéditeur : TObject);
commencer
timer1.Enabled:=false;
Mon dessin ;
Rendement;
Timer1.Enabled :=true ;
fin;
procédure TfrmMain.FormClose (Expéditeur : TObject ; var Action : TCloseAction);
commencer
timer1.Enabled:=false;
si hrc<>null alors
wglDeleteContext(hrc);
fin;
fin.
7. Éclairage et texture d'OPENGL
Ce sont tous des moyens d'améliorer l'effet tridimensionnel et l'effet de couleur. L'éclairage peut augmenter la luminosité et l'effet tridimensionnel des graphiques, et la texture peut rendre les graphiques plus réalistes. Grâce à l'utilisation de l'éclairage, l'apparence d'un objet peut être exprimée de manière forte et les textures peuvent donner à l'objet une variété d'apparences.
1 Processus et applications d'éclairage et de sources lumineuses
Une procédure glIndex fait d'une couleur de la table d'index des couleurs la couleur actuelle.
procédure glIndexd(c:GLdouble);
procédure glIndexf(c:GLdouble);
procédure glIndexi(c:GLdouble);
procédure glIndexs(c:GLdouble);
Le paramètre C est la valeur d'index Si la procédure glIndex est utilisée, le membre iPixelType dans la structure TPiexlFormatDescriptor est défini sur PFD_TYPE_COLORINDEX.
B Procédure glShadeModel
Le processus glShadeModel définit le mode de remplissage, valeur : GL_SMOOTH.
procédure glShadeModel(mode:GLenum);
Remarque : Les deux processus ci-dessus ne peuvent être utilisés qu'en dehors de glBegin....glEnd.
La procédure C glLight définit la source de lumière
procédure glLightf(light:GLenum,pname:GLenum,param:GLfloat);
procédure glLighti(light:GLenum,pname:GLenum,param:GLfloat);
Le paramètre light définit la source lumineuse, sa valeur peut être : GL_LIGHT0....GL_LIGHTN, la valeur N est inférieure à GL_MAX_LIGHT.
Le paramètre pname spécifie les paramètres de la source lumineuse :
Intensité du composant GL_AMBIENT de la lumière ambiante
GL_DIFFUSE composante intensité de la lumière diffusée
Intensité du composant GL_SPECULAR de la lumière réfléchie
GL_POSITION position de la source lumineuse
GL_SPOT_DIRECTION La direction de mise au point de la source lumineuse
Indice de source lumineuse GL_SPOT_EXPONENT
Direction de la source lumineuse GL_SPOT_CUTOFF
GL_CONSTANT_ATTENUATION facteur de décroissance constant de la lumière
GL_LINEAR_ATTENUATION facteur d'atténuation secondaire léger
Activer et éteindre les sources de lumière à l'aide des procédures glEnable() et glDisable()
glEnable(GL_LIGHTING); //Activer la source de lumière
glDisable(GL_LIGHTING); //Éteindre la source de lumière
glEnable(GL_LIGHT0); //Activer la 0ème source de lumière
glDisable(GL_LIGHT0); //Éteignez la 0ème source de lumière
Exemple de réglage de la source lumineuse :
var
sdirection:Array[1..4] de GLfloat:={0.0,1.0,0.0,0.0} ;
glLightfv(GL_LIGHT0,GL_SPOT_CUTOFF,60);
glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,sdirection);
2 Modèle de matériau et d'éclairage
Une procédure glMaterial définit les paramètres du matériau
procédure glMaterialf(face:GLenum,pname:GLenum,param:GLfloat);
procédure glMateriali(face:GLenum,pname:GLenum,param:GLfloat);
procédure glMaterialfv(face:GLenum,pname:GLenum,param:GLfloat);
procédure glMatériauiv(face:GLenum,pname:GLenum,param:GLfloat);
Le paramètre face précise la surface de l'objet, et ses valeurs sont : GL_FRONT, GL_BACK, GL_FRONT_BACK.
pname,param ne sont pas introduits dans ce document.
Processus B glLightModel
procédure glLightModelf(pname:GLenum,param:GLfloat);
Le paramètre pname est le paramètre du modèle de source lumineuse, qui peut prendre la valeur GL_LIGHT_MODEL_AMBIENT,
GL_LIGHT_MODEL_LOCAL_VIEWER,GL_LIGHT_MODEL_TWO_SIDE.
Exemple de code :
procédure TfrmMain.SetLighting ;
var
MaterialAmbient:array[1..4] de GLfloat ;
MaterialDiffuse:Array[1..4] de GLfloat ;
MaterialSpecular:Array[1..4] de GLfloat ;
AmbientLightPosition :Array[1..4] de GLfloat ;
LightAmbient :Array[1..4] de GLfloat ;
MatériauBrillant:GLfloat;
commencer
Matériau ambiant[1] :=0,5 ;
Matériau ambiant[2] :=0,8 ;
Matériau ambiant[1] :=0,2 ;
Matériau ambiant[1] :=1,0 ;
MatériauDiffuse[1] :=0,4 ;
MatériauDiffuse[2] :=0,8 ;
MatériauDiffuse[3] :=0,1 ;
MatériauDiffuse[4] :=1,0 ;
MatériauSpecular[1]:=1.0;
MatériauSpéculaire[2] :=0,5 ;
MatérielSpéculaire[3]:=0,1 ;
MatérielSpéculaire[4]:=1,0 ;
matériauBrillant :=50,0 ;
AmbientLightPosition[1] :=0,5 ;
AmbientLightPosition[2] :=1,0 ;
AmbientLightPosition[3] :=1,0 ;
AmbientLightPosition[4] :=0,0 ;
Lumière Ambiante[1] :=0,5 ;
Lumière Ambiante[2] :=0,2 ;
Lumière Ambiante[3] :=0,8 ;
Lumière Ambiante[4] :=1,0 ;
glMatériaufv(GL_FRONT,GL_AMBIENT,@MatérielAmbient);
glMatériaufv(GL_FRONT,GL_DIFFUSE,@MatérielDiffuse);
glMatériaufv(GL_FRONT,GL_SPECULAIRE,@MatérielSpeculaire);
glMatériaufv(GL_FRONT,GL_SHININESS,@MatérielShininess);
glLightfv(GL_LIGHT0,GL_POSITION,@AmbientLightPosition);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,@LightAmbient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLShadeModel(GL_SMOOTH);
fin;
3 Application de textures
Un glTexImage1D définit une carte de texture unidimensionnelle.
procédure glTexImage1D (cible: GLenum, niveau: GLint, composants: GLint, largeur: GLsizei,
border:GLint,format:GLenum,type:GLenum,pixels:GLvoid);
La valeur du paramètre targer est GL_TEXTURE_1D, qui est définie comme mappage de texture, le niveau est le niveau de l'image de texture avec une résolution à plusieurs niveaux, la largeur est la largeur de la texture, la valeur est 2n et la valeur de n est 32, 64, 129. , etc. Border est la limite de la texture, et sa valeur est 0 ou 1, Pixel est l'emplacement de la texture en mémoire. Le composant spécifie le mélange et l'ajustement de RGBA :
1Sélectionnez l'ingrédient B
2Sélectionner les ingrédients B et A
3Sélectionnez les ingrédients R, G, B
4Sélectionnez les ingrédients R, V, B, A
B glTexImage2D définit le mappage de texture bidimensionnel
procédure glTexImage2D (cible: GLenum, niveau: GLint, composants: GLint, largeur: GLsizei,
border:GLint,format:GLenum,type:GLenum,pixels:GLvoid);
Si le paramètre target est GL_TEXTURE_2D, la signification est un mappage de texture bidimensionnel, la hauteur est la hauteur de la texture et les autres paramètres de la fonction sont les mêmes que glTexImage1D. La valeur du paramètre de composant est la même que ci-dessus.
Exemple de code :
procédure TfrmMain.SetTextures;
var
bits : Tableau[1..64,1..64,1..64] de GLubyte ;
bmp:TBitmap;
je, j : entier ;
commencer
bmp:=TBitmap.Create;
bmp.LoadFromFile('d:/dsoft/1119/01/logon.bmp');
pour i:=1 à 64 fais
pour j:=1 à 64 faire
commencer
bits[i,j,1]:=GLbyte(GetRValue(bmp.Canvas.Pixels[i,j]));
bits[i,j,2]:=GLbyte(GetRValue(bmp.Canvas.Pixels[i,j]));
bits[i,j,3]:=GLbyte(GetRValue(bmp.Canvas.Pixels[i,j]));
bits[i,j,4] :=255 ;
fin;
{0 représente un niveau d'ombrage de couleur unique, GL_RGBA représente une valeur mixte
64x64 représente la hauteur et la largeur de la texture, 0 ne représente aucune bordure,
GL_RGBA représente le type de texture, GL_UNSIGNED_TYPE représente le type de données, Adresse d'objet @generation}
gltexage2d (gl_texture_2d, 0, gl_rgba, 64,64,0, gl_rgba,
Gl_unsigned_byte, @ bits);
GLENABLE (gl_texture_2d);
fin;
C GltexParamètre Définit les paramètres de texture
Procédure glTexParameterf (cible: glenum, pname: glenum, param: glfloat);
Procédure GltexParameteri (cible: Glenum, Pname: Glenum, Param: Glfloat);
La cible de paramètre représente GL_TTEXTURE_1D ou GL_TTEXTURE_2D, et Param est la valeur de texture.
D La fonction Gltexenv définit les paramètres d'environnement de la texture
Fonction Gltexenvf (cible: glenum, pname: glenum, param: glfloat);
fonction glTexenvi (cible: glenum, pname: glenum, param: glfloat);
La cible du paramètre est GL_TTEXTURE_ENV,
Le paramètre PNAME est la valeur du paramètre de texture, et la valeur est gl_texture_env_mode
Le paramètre paramètre est la valeur de l'environnement et ses valeurs sont GL_Modulate, GL_DECAL et GL_BLEND.
Exemple de code pour ce programme:
unité mainfrm;
interface
utilise
Windows, messages, systèmes, variantes, classes, graphiques, contrôles, formulaires,
Dialogues, OpenGL, Extctrls;
taper
TfrmMain = classe (TForm)
Minuterie1 : TIminuterie ;
procédure FormCreate(Expéditeur : TObject);
Procédure FormDestroy (expéditeur: tobject);
Procédure FormPaint (expéditeur: tobject);
Procédure FormKeyDown (Sender: TOBject; Var Key: Word;
Maj : TShiftState);
Procédure FormResize (expéditeur: tobject);
procédure Timer1Timer(Expéditeur : TObject);
procédure FormClose (Expéditeur : TObject ; var Action : TCloseAction);
privé
{Déclarations privées}
HRC: HGLRC;
W, H: entier;
Latitude, longitude: glfloat;
rayon: gldouble;
publique
{Déclarations publiques}
procédure setLighting;
procédure setTextures;
procédure mydraw;
Procédure InitializeGl (Var Largeur: GlSizei; hauteur: GLSizei);
fin;
var
frmmain: tfrmmain;
mise en œuvre
{$R *.dfm}
procédure tfrmmain.formCreate (expéditeur: tobject);
var
PFD: TpixelformatDescriptor;
Pixelformat: entier;
commencer
ControlStyle: = ControlStyle + [csopaque];
Fillchar (PFD, sizeof (PFD), 0);
avec PFD faire
commencer
nSize: = sizeof (tpixelformatDescriptor);
Nversion: = 1;
dwflags: = pfd_draw_to_window ou
Pfd_support_opengl ou pfd_doublebuffer;
iPixelType: = pfd_type_rgba;
ccolorbits: = 24;
CDEPTHBITS: = 32;
iLayerType: = pfd_main_plane;
fin;
Pixelformat: = ChoosePixElformat (canvas.handle, @ pfd);
SetPixelformat (canvas.handle, pixelformat, @ pfd);
hrc: = wglCreateContext (canvas.handle);
W: = ClientRect.Right;
H: = ClientRect.bottom;
InitializeGl (W, H);
fin;
Procédure tfrmmain.formDestroy (expéditeur: tobject);
commencer
wgldeleteContext (HRC);
fin;
procédure tfrmmain.formpaint (expéditeur: tobject);
commencer
WGLMAKECURRENT (Canvas.Handle, HRC);
glClearColor (1,1,1,1);
glColor3f (1,0,0);
glClear (gl_color_buffer_bit ou gl_depth_buffer_bit);
SetTextures;
Mydraw;
Setlighting;
glflush;
fin;
procédure tfrmmain.mydraw;
var
QOBJ: Gluquadricobj;
commencer
glpushmatrix;
glClear (gl_color_buffer_bit ou gl_depth_buffer_bit);
glColor3f (1,0,0);
glroTated (0,5,0,0,1,0,0,0);
glroTated (-Latitude, 1.0,0.0,0.0);
glrotated (longitude, 0,0,0,0,1,0);
Qobj: = Glunewquadric;
GluquadricDrawstyle (Qobj, Glu_line);
Glusphere (QOBJ, 0,5,20,20);
Swapbuffers (canvas.handle);
Setlighting;
SetTextures;
fin;
{Procédure tfrmmain.formResize (Sender: tobject);
var
NRANGE: Glfloat;
commencer
NRANGE: = 50,0;
W: = ClientWidth;
H: = ClientHeight;
Si h = 0 alors
H: = 1;
glviewport (0,0, w, h);
glMatrixMode (gl_projection);
gllolodIdentity;
Si w <= h alors
GLORTHO (-NRange, nrange, -nrange * h / w, nrange * h / w,
-NRange, nrange)
autre
GLORTHO (-NRANGE * H / W, NRANGE * H / W, -NRANGE, NRANGE,
-NRange, nrange);
glMatrixMode (GL_MODELVIEW);
gllolodIdentity;
repeindre;
fin;
}
Procédure tfrmmain.formKeyDown (Sender: Tobject; Var Key: Word;
Maj : TShiftState);
commencer
Si key = vk_escape alors
Fermer;
Si key = vk_up alors
glrotatef (-5,1.0,0.0,0.0);
Si key = vk_down alors
glrotatef (5,1,0,0,0,0,0);
Si key = vk_left alors
glrotatef (-5,0,0,1.0,0.0);
Si key = vk_right alors
glrotatef (5.0,0.0,1.0,0.0);
repeindre;
fin;
procédure tfrmmain.formresize (expéditeur: tobject);
commencer
glMatrixMode (gl_projection);
gllolodIdentity;
GLFRUSTUM (-1.0,1.0, -1.0,1.0,3.0,7.0);
glviewport (0,0, ClientWidth, ClientHeight);
repeindre;
invalider;
fin;
Procédure tfrmmain.InitializeGl (Var Largeur: GlSizei; hauteur: GlSizei);
var
MaxObjectSize, Aspect: Glfloat;
près de_plane: gldouble;
commencer
glClearIndex (0);
glCleardepth (1.0);
GLENABLE (gl_depth_test);
glMatrixMode (gl_projection);
Aspect: = 1,0;
GLUPERSPECTIVE (45,0, aspect, 3.0,7.0);
glMatrixMode (GL_MODELVIEW);
proche_plane: = 0,3;
MaxObjectSize: = 0,3;
RADIUS: = Near_plane + MaxObjectSize / 2.0;
Latitude: = 0,3;
longitude: = 0,6;
fin;
procédure tfrmmain.timer1timer (expéditeur: tobject);
commencer
timer1.Enabled:=false;
Mydraw;
Rendement;
Timer1.enabled: = true;
fin;
procédure tfrmmain.formClose (expéditeur: tobject; var action: tcloseAction);
commencer
timer1.Enabled:=false;
Si hrc <> null alors
wgldeleteContext (HRC);
fin;
procédure tfrmmain.setlighting;
var
MATÉRIAUXABIENT: Array [1..4] de Glfloat;
MaterialDiffuse: Array [1..4] de Glfloat;
MATÉRIAUX SPÉCULAIRE: Array [1..4] de Glfloat;
AMBIENTSLOSPOSITION: Array [1..4] de Glfloat;
Lightambient: tableau [1..4] de Glfloat;
Matériaux de santé: glfloat;
commencer
MatériauxAmbient [1]: = 0,5;
MatériauxAmbient [2]: = 0,8;
MatériauxAmbient [1]: = 0,2;
MaterialAmbient [1]: = 1,0;
MaterialDiffuse [1]: = 0,4;
MaterialDiffuse [2]: = 0,8;
MaterialDiffuse [3]: = 0,1;
MaterialDiffuse [4]: = 1,0;
Matériaux spécifiques [1]: = 1,0;
Matériau spécifique [2]: = 0,5;
Matériau spécifique [3]: = 0,1;
Matériaux spécifiques [4]: = 1,0;
Matériaux de santé: = 50,0;
AMBIENTLORTPOSITION [1]: = 0,5;
AMBIENTLORTPOSITION [2]: = 1,0;
AMBIENTLORTPOSITION [3]: = 1,0;
AMBIENTSLORTPOSITION [4]: = 0,0;
Lightambient [1]: = 0,5;
Lightambient [2]: = 0,2;
Lightambient [3]: = 0,8;
Lightambient [4]: = 1,0;
GlMaterialFv (GL_FRONT, GL_AMBIENT, @ MaterialAmbient);
GlMaterialFv (GL_FRONT, GL_DIFFUSE, @ MaterialDiffuse);
GlMaterialFv (GL_FRONT, GL_SPECULAL, @ MATÉRIAUX SPECULAR);
GlMaterialFv (GL_FRONT, GL_SHINNISS, @ MATERMESHINNISS);
GLlightfv (GL_LIGHT0, GL_POSITION, @ AMBIENTLORTPOSITION);
GLlightModelfv (GL_LIGHT_MODEL_AMBIENT, @ LightAmbient);
GLENABLE (GL_LIGHTING);
GLENABLE (GL_LIGHT0);
GlShadeModel (GL_SMOOTH);
fin;
procédure tfrmmain.setTextures;
var
Bits: Array [1..64,1..64,1..64] de Glubyte;
BMP: tbitmap;
I, J: entier;
commencer
bmp: = tbitmap.create;
bmp.loadFromfile ('d: /dsoft/1119/02/logon.bmp');
pour i: = 1 à 64
pour j: = 1 à 64
commencer
bits [i, j, 1]: = glByte (getrValue (bmp.canvas.pixels [i, j]));
bits [i, j, 2]: = glByte (getrValue (bmp.canvas.pixels [i, j]));
bits [i, j, 3]: = glByte (getrValue (bmp.canvas.pixels [i, j]));
bits [i, j, 4]: = 255;
fin;
glPixelStorei (gl_unpack_alignment, 4);
gltexParameteri (GL_TTEXTURE_2D, GL_TTEXTURE_WRAP_S, GL_CLAMP);
gltexParameteri (gl_texture_2d, gl_texture_mag_filter, gl_nearest);
gltexParameteri (gl_texture_2d, gl_texture_min_filter, gl_nearest);
{0 représente un niveau d'ombrage d'une seule couleur, GL_RGBA représente une valeur mixte
64x64 représente la hauteur et la largeur de la texture, 0 ne représente aucune bordure,
GL_RGBA représente le type de texture, GL_UNSIGNED_TYPE représente le type de données, Adresse d'objet @generation}
gltexage2d (gl_texture_2d, 0, gl_rgba, 64,64,0, gl_rgba,
Gl_unsigned_byte, @ bits);
GLENABLE (gl_texture_2d);
gltexenvf (gl_texture_env, gl_texture_env_mode, gl_decal);
fin;
fin.