OPENGL-Grafikprogrammierung
OPENGL ist eine dreidimensionale Grafik- und Modellbibliothek. Aufgrund seiner herausragenden Leistung in dreidimensionalen Grafiken bieten viele Hochsprachen derzeit Schnittstellen mit OPENGL, wie zum Beispiel: VC, DELPHI, C++Builder usw. Durch die Verwendung von OPENGL kann die Schwierigkeit für Benutzer bei der Entwicklung von Grafiken und Bildern erheblich verringert werden, sodass Benutzer hochwertige kommerzielle Werbung, grafisches CAD, dreidimensionale Animationen, grafische Simulationen sowie Film- und Fernsehsammlungen erstellen können.
1. Funktionen von OPENGL
OPENGL war ursprünglich eine Grafiksoftwarebibliothek für Workstations. Aufgrund seiner breiten Anwendung in den Bereichen Wirtschaft, Militär, Medizin, Luft- und Raumfahrt und anderen Bereichen können nun Grafiken, die den Benutzeranforderungen entsprechen, auf Low-End-Computern entwickelt werden. OPENGL kann nicht nur einfache Bilder zeichnen, sondern bietet auch zahlreiche Funktionen und Verfahren zur Verarbeitung grafischer Bilder.
1. Grafische Transformation
Es ist die Grundlage der grafischen Darstellung und der Animationsdarstellung. Die grafische Transformation erfolgt mathematisch durch die Multiplikation von Rechtecken. Entsprechend den Anzeigeeigenschaften von Grafiken: Ansichtspunkttransformation, Modelltransformation, Projektionstransformation, Clipping-Transformation und Ansichtsfenstertransformation usw.
2. Lichteffekt
Die Farbe eines nicht leuchtenden Objekts wird dadurch verursacht, dass das Objekt externes Licht reflektiert, also Beleuchtung. Bei dreidimensionalen Grafiken verlieren die dreidimensionalen Grafiken bei unsachgemäßer Verwendung ihren wahren dreidimensionalen Sinn. OPENGL unterteilt die Beleuchtung in: strahlendes Licht, Umgebungslicht, Streulicht, reflektiertes Licht usw.
3. Texturzuordnung
Mit der Texturzuordnung können Sie dreidimensionalen Oberflächen reale Texturen hinzufügen. Beispiel: Ein Rechteck kann kein Objekt in der realen Welt darstellen. Wenn es mit einer „wesentlichen“ Textur gefüllt ist, wird es realistisch.
4. Grafische Spezialeffekte
Die Mischfunktion, die Anti-Aliasing-Funktion und die Nebelfunktion können die Transparenz und Durchsichtigkeit dreidimensionaler Grafiken verwalten, das Objekt glatt machen, Liniensegmente zum Glätten verwenden und einen Nebeleffekt erzielen.
5. Bildspezialeffekte
Grundfunktionen zur Verarbeitung von Bitmaps: Bildzeichnen, Bildkopieren und -speichern, Zuordnen und Übertragen, Bildskalierung usw. Die Bitmap-Operationsfunktion kann den Entstehungsprozess chinesischer Schriftzeichen auf der unteren Ebene der Originalzeichnung erklären.
2. Erstellen Sie eine OPENGL-Anwendung
1. Allgemeine Grundsätze
A. OPENGL-Unterstützungseinheit hinzufügen in: OpenGL;
B OPENGL während des OnCreate-Ereignisses des Formulars initialisieren;
C initialisiert OPENGL während des OnPaing-Ereignisses des Fensters;
D initialisiert OPENGL während des OnResize-Ereignisses des Fensters;
E initialisiert OPENGL während des OnDestroy-Ereignisses des Fensters;
2. Einfaches Beispiel
A Erstellen Sie ein Projekt DATEI->Neue Anwendung
B Fügen Sie Code im OnCreate-Ereignis hinzu:
PROcedure TfrmMain.FormCreate(Sender: TObject);
var
pfd:TPixelFormatDescriptor; //Beschreibungstabelle festlegen
PixelFormat:Integer;
beginnen
ControlStyle:=ControlStyle+[csOpaque];
FillChar(pfd,sizeof(pfd),0);
mit pfd do
beginnen
nSize:=sizeof(TPixelFormatDescriptor);
nVersion:=1;
dwFlags:=PFD_DRAW_TO_WINDOW oder
PFD_SUPPORT_OPENGL oder PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cDepthBits:=32;
iLayerType:=PFD_MAIN_PLANE;
Ende;
PixelFormat:=ChoosePixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClientWidth;
h:=ClientHeight;
Ende;
C-Code im OnDestroy-Ereignis
procedure TfrmMain.FormDestroy(Sender: TObject);
beginnen
wglDeleteContext(hrc);
Ende;
D-Code im OnPaint-Ereignis
procedure TfrmMain.FormPaint(Sender: TObject);
beginnen
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT oder GL_DEPTH_BUFFER_BIT);
MyDraw;
glFlush;
SwapBuffers(Canvas.Handle);
Ende;
E-Code im OnResize-Ereignis
procedure TfrmMain.FormResize(Sender: TObject);
beginnen
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,ClientWidth,ClientHeight);
MyDraw;
Ende;
F-Code in der MyDraw-Funktion (vom Benutzer in der Fensterklasse deklariert)
procedure TfrmMain.MyDraw;
beginnen
glPushMatrix;
Sphere:=gluNewQuadric;
gluQuadricDrawStyle(Sphere,GLU_LINE);
gluSphere(Sphere,0.5,25,25);
glPopMatrix;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Sphere);
Ende;
Im Anhang finden Sie den Originalcode dieses Programms:
Einheit MainFrm;
Schnittstelle
verwendet
Windows, Nachrichten, SysUtils, Varianten, Klassen, Grafiken, Steuerelemente, Formulare,
Dialoge, OpenGL;
Typ
TfrmMain = Klasse(TForm)
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormPaint(Sender: TObject);
procedure FormResize(Sender: TObject);
Privat
{Private Erklärungen}
hrc:HGLRC;
w,h:glFloat;
Sphere:GLUquadricObj;
öffentlich
{Öffentliche Erklärungen}
Prozedur MyDraw;
Ende;
var
frmMain: TfrmMain;
Durchführung
{$R *.dfm}
procedure TfrmMain.FormCreate(Sender: TObject);
var
pfd:TPixelFormatDescriptor;
PixelFormat:Integer;
beginnen
ControlStyle:=ControlStyle+[csOpaque];
FillChar(pfd,sizeof(pfd),0);
mit pfd do
beginnen
nSize:=sizeof(TPixelFormatDescriptor);
nVersion:=1;
dwFlags:=PFD_DRAW_TO_WINDOW oder
PFD_SUPPORT_OPENGL oder PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cDepthBits:=32;
iLayerType:=PFD_MAIN_PLANE;
Ende;
PixelFormat:=ChoosePixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClientWidth;
h:=ClientHeight;
Ende;
procedure TfrmMain.FormDestroy(Sender: TObject);
beginnen
wglDeleteContext(hrc);
Ende;
procedure TfrmMain.FormPaint(Sender: TObject);
beginnen
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT oder GL_DEPTH_BUFFER_BIT);
MyDraw;
glFlush;
SwapBuffers(Canvas.Handle);
Ende;
procedure TfrmMain.MyDraw;
beginnen
glPushMatrix;
Sphere:=gluNewQuadric;
gluQuadricDrawStyle(Sphere,GLU_LINE);
gluSphere(Sphere,0.5,25,25);
glPopMatrix;
SwapBuffers(Canvas.handle);
gluDeleteQuadric(Sphere);
Ende;
procedure TfrmMain.FormResize(Sender: TObject);
beginnen
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,ClientWidth,ClientHeight);
MyDraw;
Ende;
Ende.
3. Konventionen zu OPENGL-Variablen und -Funktionen
1. Konventionen der OPENGL-Bibliothek
Insgesamt verfügt sie über drei Bibliotheken: Basisbibliothek, Praxisbibliothek und Hilfsbibliothek. In DELPHI wird die Basisbibliothek durch die OpenGL-Einheit implementiert. In der Windows-Umgebung werden Hilfsbibliotheken im Allgemeinen nicht verwendet.
2. OPENGL-Konstantenkonvention
OPENGL-Konstanten verwenden Großbuchstaben, beginnend mit „GL“, und verwenden Unterstriche zum Trennen von Wörtern, z. B. GL_LINES, was bedeutet, dass die Basisbibliothek zum Zeichnen gerader Linien verwendet wird.
3. Namenskonvention von OPENGL-Funktionen
A Der erste Teil beginnt mit gl oder wgl, wie gl in glColor3f.
B Der zweite Teil ist die auf Englisch ausgedrückte Funktion, wobei der erste Buchstabe des Wortes groß geschrieben wird.
Der dritte Teil von C ist eine Zahl, die die Parameter der Funktion darstellt.
Der vierte Teil von D ist ein Kleinbuchstabe, der den Funktionstyp angibt.
b9-Bit-Ganzzahl
s16-Bit-Ganzzahl
i32-Bit-Ganzzahl
f32-Bit-Gleitkommazahl
d64-Bit-Gleitkommazahl
ub9-Bit-Ganzzahl ohne Vorzeichen
Beispiel: glVertex2f(37,40); {zwei 32-Bit-Gleitkommazahlen als Parameter}
glVertex3d(37,40,5); {Drei 64-Bit-Gleitkommazahlen als Parameter}
p[1..3]:array of glFloat;
glVertes3fv(p); {3f stellt drei Gleitkommazahlen dar, v stellt den Aufruf eines Arrays als Scheitelpunktkoordinateneingabe dar}
4. Initialisierung von OPENGL
1. PIXELFORMATDESCRIPTOR-Struktur
Es beschreibt hauptsächlich die Eigenschaften von Pixeln, wie z. B. den Farbmodus von Pixeln und die Zusammensetzung der Farben Rot, Grün und Blau.
tagPIXELFORMATDESCRIPTOR = gepackter Datensatz
nSize: Word;
nVersion: Word;
dwFlags: DWORD;
iPixelType: Byte;
cColorBits: Byte;
cRedBits: Byte;
cRedShift: Byte;
cGreenBits: Byte;
cGreenShift: Byte;
cBlueBits: Byte;
cBlueShift: Byte;
cAlphaBits: Byte;
cAlphaShift: Byte;
cAccumBits: Byte;
cAccumRedBits: Byte;
cAccumGreenBits: Byte;
cAccumBlueBits: Byte;
cAccumAlphaBits: Byte;
cDepthBits: Byte;
cStencilBits: Byte;
cAuxBuffers: Byte;
iLayerType: Byte;
bReserviert: Byte;
dwLayerMask: DWORD;
dwVisibleMask: DWORD;
dwDamageMask: DWORD;
Ende;
TPixelFormatDescriptor = tagPIXELFORMATDESCRIPTOR;
dwFlags repräsentiert die Attribute des Punktformats:
PFD_DRAW_TO_WINDOW-Grafiken werden auf dem Bildschirm oder der Geräteoberfläche gezeichnet
PFD_DRAW_TO_BITMAP zeichnet eine Bitmap im Speicher
PFD_SUPPORT_GDI unterstützt GDI-Zeichnung
PFD_SUPPORT_OPENGL unterstützt OPENGL-Funktionen
PFD_DOUBLEBUFFER verwendet doppelte Pufferung
PFD_STEREO Stereo-Cache
PFD_NEED_PALLETTE verwendet die RGBA-Palette
PFD_GENERIC_FORMAT wählt die von GDI unterstützte Formatzeichnung aus
PFD_NEED_SYSTEM_PALETTE verwendet die von OPENGL unterstützte Hardwarepalette
iPixelType legt den Pixelfarbmodus fest: PFD_TYPE_RGBA oder PFD_TYPE_INDEX.
cColorBits legt die Farbbits fest. Wenn es 9 ist, bedeutet dies, dass 256 Farben vorhanden sind, um die Farbe des Punkts darzustellen.
cRedBits, cGreenBits, cBlueBits Bei Verwendung von RGBA die Anzahl der Bits, die für die drei Primärfarben verwendet werden.
cRedShitfs, cGreenShifts, cBlueShifts Bei Verwendung von RGBA die Anzahl der Stellen, die für die drei Primärfarben angepasst werden können.
cAlphaBits, cAlphaShifts Bei Verwendung von RGBA die Anzahl der von Alpha verwendeten Bits und die Anzahl der einstellbaren Bits.
cAccumBits legt die Gesamtzahl der Bits im Akkumulationspufferbereich fest.
cAccumRedBits, cAccumGreenBits und cAccumBlueBits legen die Gesamtzahl der drei Primärfarbebenen im Akkumulationspufferbereich fest.
cAccumAlphaBits legt die Gesamtzahl der Alpha-Bits im Akkumulationspuffer fest.
cDepthBits legt die Tiefe des Konzentrationspuffers fest.
cStencilBits legt die Tiefe des Schablonencaches fest.
cAuxBuffers bezieht sich auf die Größe des Hilfspuffers.
iLayerType gibt den Typ der Ebene an.
bReserved wird nicht verwendet und muss Null sein.
dwLayerMask gibt die Maske des Overlays an.
dwDamageMask legt fest, ob derselbe Pixelmodus im selben Frame-Cache gemeinsam genutzt wird.
2. Initialisierungsschritte von OPENGL
A Verwenden Sie Canvas.Handle, um das Fensterhandle abzurufen.
B Erstellen Sie eine TPixelFormatDescriptor-Variable, um das Pixelformat zu definieren.
C Verwenden Sie die Funktion ChoosePixelFormat, um das Pixelformat auszuwählen.
D Verwenden Sie die SetPixelFormat-Funktion, um das Pixelformat wirksam zu machen.
E Verwenden Sie die Funktion wglCreateContext, um eine Übersetzungsbeschreibungstabelle zu erstellen.
F Verwenden Sie die Funktion wglMakeCurrent, um die erstellte Übersetzungsbeschreibungstabelle als aktuelle Übersetzungsbeschreibungstabelle zu verwenden.
3. Ressourcenfreigabe
A Verwenden Sie die Prozedur wglDeleteContext, um die Pixelkontexttabelle zu löschen.
B Verwenden Sie die ReleaseDC-Prozedur, um Fensterspeicher freizugeben.
Im OnDestroy-Ereignis des Fensters:
beginnen
wenn hrc<>null dann
wglDeleteCurrent(hrc);
wenn hdc<>null dann
ReleaseDC(Handle,hdc);
Ende;
5. Zeichnen von OPENGL-Grundgrafiken
1. Farbe der Grafiken
Achten Sie auf die Einstellung der Hintergrundfarbe. Die Farbeinstellung hängt normalerweise mit der Pixelbeschreibungsvariablen zusammen, also mit dem iPixelType-Mitglied in der TPixelFormatDescriptor-Definition.
iPixelType:=PFD_TYPE_COLORINDEX;
Dann können Sie nur die Prozeduren glIndexd, glIndexf, glIndexi, glIndexs, glIndexv, glIndexfv, glIndexiv, glIndexsv verwenden, um die Grafikfarbe festzulegen.
iPixelType:=PFD_TYPE_RGBA;
Dann können Sie nur glColor3b, glColor3f, glColor4b, glColor4f, glColor4fv verwenden, um die Grafikfarbe festzulegen.
A Hintergrundfarbe der Grafik: Die Farbe des Bildschirms und des Fensters, also die Farbe des Farbpuffers. Um die Hintergrundfarbe von Grafiken zu ändern, sollten Sie zunächst die glClearColor-Prozedur verwenden, um die Hintergrundfarbe festzulegen, und dann die glClear-Prozedur verwenden, um das Fenster und den Bildschirm mit dieser Hintergrundfarbe zu aktualisieren.
Prozedur glClearColor(red:GLClampf,green:GLClampf,blue:GLClampf,alpha:GLClampf);
procedure glClear(mask:GLBitField);
Rot, Grün, Blau und Alpha sind die festzulegenden Hintergrundfarben und ihre Werte liegen zwischen 0 und 1. Mit der Maske können Sie die Hintergrundfarbe aktualisieren.
Beispiel: Stellen Sie das Farbfenster auf Grün ein
glClearColor(0,1,0,1);
glClear(GL_COLOR_BUFFER_BIT);
Der Wert und die Bedeutung der Maske:
GL_COLOR_BUFFER_BIT legt den aktuellen Farbpuffer fest
GL_DEPTH_BUFFER_BIT legt den aktuellen Tiefenpuffer fest
GL_ACCUM_BUFFER_BIT legt den aktuellen Akkumulationspuffer fest
GL_STENCIL_BUFFER_BIT legt den aktuellen STENCIL-Puffer (Vorlage) fest
Das Zeichenfenster ist auf Grau eingestellt
glClearColor(0.3,0.3,0.3,1);
glClear(GL_COLOR_BUFFER_BIT);
B Grafikfarbe
Verwenden Sie glClear3f und glClear4f, um die Zeichenfarbe von Grafiken festzulegen. Wenn drei Parameter verwendet werden, bedeutet dies, dass die drei Farben rotes, blaues und grünes Licht eingestellt werden. Wenn vier Parameter verwendet werden, stellt der vierte den RGBA-Wert dar.
Beispiel für die Einstellung der aktuellen Zeichenfarbe auf Blau:
glColor3f(0,0,1);
Stellen Sie die Plotfarbe auf Weiß ein:
glColor3f(1,1,1);
2. Zeichnen einfacher Grafiken
Zeichnen Sie einfache Grafiken wie Punkte, Linien, Polygone usw. zwischen den Prozeduren glBegin und glEnd.
glBegin(mode:GLenum);{Zeichnungsprozess}glEnd;
Der Wert des Modus:
GL_POINTS zeichnet mehrere Punkte
GL_LINES zeichnet mehrere Linien und zeichnet alle zwei Punkte eine gerade Linie
GL_LINE_STRIP zeichnet eine Polylinie
GL_LINE_LOOP zeichnet geschlossene Polygone, die Ende an Ende verbunden sind
GL_TRIANGLES zeichnet Dreiecke
GL_TRIANGLE_STRIP zeichnet ein Dreieck und zeichnet alle drei Punkte ein Dreieck
GL_TRIANGLE_FAN zeichnet Dreiecke
GL_QUADS zeichnet Vierecke
GL_QUAD_STRIP zeichnet viereckige Streifen, ein viereckiger Streifen wird für jeweils vier Punkte gezeichnet
GL_POLYGON zeichnet Polygone
Beispiel für das Zeichnen von drei Punkten:
beginnen
glPushMatrix;
glBegin(GL_POINT);
glVertex2f(0.1,0.1);
glVertex2f(0.5,0.5);
glVertex2f(0.1,0.3);
glEnd;
SwapBuffers(Canvas.Handle);
Ende;
Wenn Sie GL_POINT in GL_LINES ändern, ist der dritte Punkt ungültig. Wenn Sie glColor3f(0,0,1) vor glVertex2f ausführen, ändert sich die Farbe der Linie in Grün. Wenn Sie GL_LINES in GL_LINE_STRIP ändern, können Sie zeichnen zwei Eine gerade Linie.
Verwenden Sie die glPointSize-Prozedur, um die Punktgröße festzulegen; verwenden Sie die glLineWidth-Prozedur, um die Linienbreite festzulegen.
Verwenden Sie die glLineStipple-Prozedur, um die Vorlage für gepunktete Linien festzulegen, und verwenden Sie die glEnable(GL_LINE_STIPPLE)-Prozedur und die entsprechenden Parameter, um das Zeichnen zum Zeichnen gepunkteter Linien zu aktivieren. Die glDisable(GL_LINE_STIPPLE)-Prozedur und die entsprechenden Parameter schalten gepunktete Linien aus.
procedure glLineStipple(factor:GLint,pattern:GLushort);
Der Parameter Faktor stellt die Anzahl der Wiederholungen des Musters der Punkt-Strich-Linie dar. Der Wert des Faktors ist 1255. Muster ist eine binäre Sequenz.
glLineStipple(1,0,0x11C);{0x11C wird als 10001110 dargestellt, 0 bedeutet, keine Punkte zu zeichnen, 1 bedeutet, Punkte zu zeichnen}
Beispiel: beginnen
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);
Ende;
Das Zeichnen von Polygonen ähnelt dem Zeichnen von Punktlinien. Sie müssen die Parameter in GL_POLYGON, GL_QUADS, GL_TRANGLES ändern.
Die Seiten eines Polygons schneiden sich nur an den Eckpunkten
Das B-Polygon muss ein konvexes Polygon sein. Wenn es sich um ein konkaves Polygon handelt, kann der Benutzer es nur in ein konvexes Polygon falten, um das Zeichnen zu beschleunigen.
Beispiel: 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;
Polygone haben Vorder- und Rückseiten und die damit verbundenen Prozesse sind:
glPolygonMode steuert die Zeichenmodi für die Vorder- und Rückseite von Polygonen
glFrontface gibt die Vorderseite des Polygons an
glCullFace zeigt Polygone an, die so eingestellt sind, dass sie Flächen eliminieren
glPolygonStripple bildet den Stil einer Polygonfüllung
3. Einfache quadratische Fläche
Zylinder, Ringe und Kugeln sind alle quadratische Flächen.
Ein Zylinder
gluCylinder(qobj:GLUquadricObj,baseRadius:GLdouble,topRadius:GLdouble,height:GLdouble,
scheiben:GLint,stacks:GLint);
qobj gibt eine quadratische Oberfläche an, baseRadius ist der obere Radius des gezeichneten Zylinders; height ist die Anzahl der Teilungslinien um die Z-Achse; Trennlinien entlang der Z-Achse.
Wenn baseRadius und topRadius nicht gleich sind, können Sie einen Kegelstumpf und einen Kegel zeichnen.
procedure TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
beginnen
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT oder GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
gluCylinder(qObj,0.5,0.1,0.2,10,10);
Ende;
Bringen
gluDisk(qobj:GLUquadricObj,innerRadius:GLdouble,outerRadius:GLdouble,slices:GLint,
Schleifen:GLint);
procedure TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
beginnen
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT oder 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);
Ende;
C Halbkreis
gluPartialDisk(qobj:GLUquadricObj,innerRadius:GLdouble,outerRadius:GLdouble,slices:GLint,
loops:GLint,startAngle:GLdouble,sweepAngle:GLdouble);
startAngle, SweepAngle sind der Startwinkel und der Endwinkel des Halbkreises.
procedure TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
beginnen
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT oder 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);
Ende;
D-Kugel
Funktion gluSphere(qObj:GLUquadricObj,radius:GLdouble,slices:GLint,stacks:GLint);
procedure TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
beginnen
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT oder GL_DEPTH_BUFFER_BIT);
glColor3f(1,0,0);
qObj:=gluNewQuadric;
gluQuadricDrawStyle(qObj,GLU_LINE);
{ Silhouette[ silu(:)5et ]n Silhouette, Umriss}
gluSphere(qObj,0.5,20,20);
SwapBuffers(Canvas.Handle);
Ende;
E Über den Prozess der quadratischen Fläche
gluNewQuadric erstellt ein neues quadratisches Oberflächenobjekt
gluDeleteQuadric löscht ein quadratisches Oberflächenobjekt
gluQuadricDrawStyle gibt den Typ der zu zeichnenden quadratischen Oberfläche an
gluQuadricNormal legt den Normalenvektor der quadratischen Oberfläche fest
gluQuadricOrientation legt fest, ob die quadratische Oberfläche intern oder extern gedreht wird
gluQuadricTexture legt fest, ob die quadratische Oberfläche Textur verwendet
F Allgemeine Schritte zum Zeichnen quadratischer Flächen
Definieren Sie zunächst ein GLUquadricObj-Objekt.
Zweitens erstellen Sie ein Oberflächenobjekt gluNewQuadric;
Legen Sie die Eigenschaften der quadratischen Oberfläche erneut fest (gluQuadricDrawStyle, gluQuadricTexture)
Quadratische Flächen zeichnen (gluCylinder, gluSphere, gluDisk, gluPartialDisk)
6. Transformation in OPENGL
Transformation ist die Grundlage des Animationsdesigns, einschließlich grafischer Übersetzung, Drehung, Skalierung und anderer Operationen, die mathematisch durch Matrizen implementiert werden.
1 glLoadIdentity-Prozess
Kann die aktuelle Matrix in eine Identitätsmatrix umwandeln.
2 glLoadMatrix-Prozess
Kann die angegebene Matrix als aktuelle Matrix festlegen.
procedure glLoadmatrixd(m:GLdouble);
procedure glLoadmatrixf(m:GLfloat);
m stellt eine 4X4-Matrix dar, der folgende Code definiert und macht sie zur aktuellen Matrix
M:array[1..4,1..4] von GLfloat;
glLoadMatrix(@M);
3 glMultMatrix-Prozess
Kann den aktuellen Moment mit der angegebenen Matrix multiplizieren und das Ergebnis als aktuellen Moment verwenden.
procedure glMultMatrixd(M:GLdouble);
procedure glMultMatrixf(M:GLfloat);
4 glPushMatrix und glPopmatrix
glPushMatrix kann den aktuellen Moment in den Matrixstapel verschieben, und glPopMatrix kann den aktuellen Moment aus dem Matrixstapel entfernen.
glPushMatrix kann sich die aktuelle Position der Matrix merken und glPopmatrix kann die vorherige Position zurückgeben.
Hinweis: glPushMatrix und glPopMatrix müssen außerhalb von glBegin und glEnd platziert werden.
5 Projektionstransformation
Ein glOrtho kann eine orthographische Projektionsmatrix erstellen, den aktuellen Moment mit der orthographischen Projektionsmatrix multiplizieren und das Ergebnis als aktuelle Matrix verwenden.
Funktion glOrtho(left:GLdouble,right:GLdouble,bottom:GLdouble,top:GLdouble,
near:GLdouble,far:GLdouble);
procedure TfrmMain.FormResize(Sender: TObject);
var
nRange:GLfloat;
beginnen
nRange:=50.0;
w:=clientWidth;
h:=clientHeight;
wenn h=0 dann
h:=1;
glViewPort(0,0,w,h);
wenn w<=h dann
glOrtho(-nRange,nRange,-nRange*h/w,nRange*h/w,
-nRange,nRange)
anders
glOrtho(-nRange*h/w,nRange*h/w,-nRange,nRange,
-nRange,nRange);
neu streichen;
Ende;
B glOrtho2D definiert nur die Vorderseite, die Rückseite, die linke und die rechte Seite des orthografischen Betrachtungsvolumens.
procedure glOrtho(left:GLdouble,right:GLdouble,bottom:GLdouble,top:GLdouble);
C glMatrixMode-Prozedur
Möglichkeit, den Typ der aktuellen Operationsmatrix festzulegen
procedure glMatrixMode(mode:GLenum);
Der Wert des Modus:
GL_MODELVIEW gibt an, dass nachfolgende Matrixoperationen Modellmatrixstapel sind
GL_PROJECTION gibt an, dass nachfolgende Matrixoperationen Projektionsmatrixstapel sind
GL_TEXTURE gibt an, dass nachfolgende Matrixoperationen Texturmatrixstapel sind
D glFrustum-Prozess
Erstellen Sie eine perspektivische Schrägprojektionsmatrix und multiplizieren Sie die aktuelle Matrix mit der Schrägprojektionsmatrix. Das Ergebnis ist die aktuelle Matrix.
Prozedur glFrustum(left:GLdouble,right:GLdouble,bottom:GLdouble,top:GLdouble,
next:GLdouble,far:GLdouble);
Diese Parameter definieren die linke, rechte, obere, untere, vordere und hintere Schnittebene der schrägen Projektion.
E gluPerspective-Prozess
Kann ein vierseitiges Pyramidenansichtsvolumen mit der Z-Achse als Mittellinie definieren.
procedure gluPerspetive(fovy:GLdouble,aspect:GLdouble,zNear:GLdouble,zFar:GLdouble);
fovy definiert die Perspektive der xoz-Ebene, Aspect definiert das Verhältnis in x- und y-Richtung, zNear und zFar definieren die Abstände vom Blickpunkt zur Clipping-Ebene bzw. zur hinteren Clipping-Ebene.
procedure TfrmMain.FormResize(Sender: TObject);
var
Aspekt:GLfloat;
beginnen
w:=ClientWidth;
h:=ClientHeight;
wenn h=0 dann
h:=1;
glViewPort(0,0,clientWidth,Clientheight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
Aspekt:=B/H;
gluPerspective(30.0,aspect,1.0,50.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity;
Ende;
6 Geometrische Transformationsmatrix
Die Transformation der Bewegungshaltung eines dreidimensionalen Objekts bezieht sich auf die Übersetzung, Drehung und Skalierung des Objekts.
Ein glTranslate-Prozess kann den Koordinatenursprung nach (x, y, z) verschieben, seine Deklarationssyntax:
procedure glTranslated(x:GLdouble,y:GLdouble,z:GLdouble);
procedure glTranslatef(x:GLdouble,y:GLdouble,z:GLdouble);
B glRotate kann ein Objekt um einen bestimmten Winkel drehen. Die Deklarationssyntax lautet:
procedure glRotated(angle:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
procedure glRotatef(angle:GLdouble,x:GLdouble,y:GLdouble,z:GLdouble);
Unter ihnen ist Winkel der Drehwinkel und die zentrale Drehachse ist die Linie, die die beiden Punkte (0,0,0) und (x,y,z) verbindet.
C glScale kann das Koordinatensystem skalieren und seine Deklarationssyntax lautet:
procedure glScaled(x:GLdouble,y:GLdoble,z:GLdouble);
procedure glScalef(x:GLdouble,y:GLdoble,z:GLdouble);
Werte von x, y und z größer als 1 stellen eine Vergrößerung dar, und Werte kleiner als 1 stellen eine Verkleinerung dar.
Beispiel-Originalcode:
Einheit MainFrm;
Schnittstelle
verwendet
Windows, Nachrichten, SysUtils, Varianten, Klassen, Grafiken, Steuerelemente, Formulare,
Dialoge, OpenGL, ExtCtrls;
Typ
TfrmMain = Klasse(TForm)
Timer1: TTimer;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormPaint(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Schicht: TShiftState);
procedure FormResize(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
Privat
{Private Erklärungen}
hrc:HGLRC;
w,h:Integer;
Breitengrad, Längengrad:GLfloat;
Radius:GLdouble;
öffentlich
{Öffentliche Erklärungen}
Prozedur MyDraw;
procedure InitializeGL(var width:GLsizei;height:GLsizei);
Ende;
var
frmMain: TfrmMain;
Durchführung
{$R *.dfm}
procedure TfrmMain.FormCreate(Sender: TObject);
var
pfd:TPixelFormatDescriptor;
PixelFormat:Integer;
beginnen
ControlStyle:=ControlStyle+[csOpaque];
FillChar(pfd,sizeof(pfd),0);
mit pfd do
beginnen
nSize:=sizeof(TPixelFormatDescriptor);
nVersion:=1;
dwFlags:=PFD_DRAW_TO_WINDOW oder
PFD_SUPPORT_OPENGL oder PFD_DOUBLEBUFFER;
iPixelType:=PFD_TYPE_RGBA;
cColorBits:=24;
cDepthBits:=32;
iLayerType:=PFD_MAIN_PLANE;
Ende;
PixelFormat:=ChoosePixelFormat(Canvas.Handle,@pfd);
SetPixelFormat(Canvas.Handle,PixelFormat,@pfd);
hrc:=wglCreateContext(Canvas.Handle);
w:=ClientRect.Right;
h:=ClientRect.Bottom;
InitializeGL(w,h);
Ende;
procedure TfrmMain.FormDestroy(Sender: TObject);
beginnen
wglDeleteContext(hrc);
Ende;
procedure TfrmMain.FormPaint(Sender: TObject);
beginnen
wglMakeCurrent(Canvas.Handle,hrc);
glClearColor(1,1,1,1);
glColor3f(1,0,0);
glClear(GL_COLOR_BUFFER_BIT oder GL_DEPTH_BUFFER_BIT);
MyDraw;
glFlush;
Ende;
procedure TfrmMain.MyDraw;
var
qObj:GLUQuadricObj;
beginnen
glPushMatrix;
glClear(GL_COLOR_BUFFER_BIT oder 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);
Ende;
{procedure TfrmMain.FormResize(Sender: TObject);
var
nRange:GLfloat;
beginnen
nRange:=50.0;
w:=clientWidth;
h:=clientHeight;
wenn h=0 dann
h:=1;
glViewPort(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
wenn w<=h dann
glOrtho(-nRange,nRange,-nRange*h/w,nRange*h/w,
-nRange,nRange)
anders
glOrtho(-nRange*h/w,nRange*h/w,-nRange,nRange,
-nRange,nRange);
glMatrixMode(GL_MODELVIEW);
glLoadidentity;
neu streichen;
Ende;
}
procedure TfrmMain.FormKeyDown(Sender: TObject; var Key: Word;
Schicht: TShiftState);
beginnen
wenn Key=VK_ESCAPE dann
Schließen;
wenn Key=VK_UP dann
glRotatef(-5,1.0,0.0,0.0);
wenn Key=VK_DOWN dann
glRotatef(5,1.0,0.0,0.0);
wenn Key=VK_LEFT dann
glRotatef(-5,0.0,1.0,0.0);
wenn Key=VK_RIGHT dann
glRotatef(5.0,0.0,1.0,0.0);
neu streichen;
Ende;
procedure TfrmMain.FormResize(Sender: TObject);
beginnen
glMatrixMode(GL_PROJECTION);
glLoadIdentity;
glFrustum(-1.0,1.0,-1.0,1.0,3.0,7.0);
glViewPort(0,0,clientWidth,clientHeight);
neu streichen;
ungültig machen;
Ende;
procedure TfrmMain.InitializeGL(var width: GLsizei; height: GLsizei);
var
maxObjectSize,aspect:GLfloat;
near_plane:GLdouble;
beginnen
glClearindex(0);
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
Aspekt:=1.0;
gluPerspective(45.0,aspect,3.0,7.0);
glmatrixMode(GL_MODELVIEW);
near_plane:=0.3;
maxObjectSize:=0.3;
Radius:=near_plane+maxObjectSize/2.0;
Breitengrad:=0,3;
Längengrad:=0,6;
Ende;
procedure TfrmMain.Timer1Timer(Sender: TObject);
beginnen
timer1.Enabled:=false;
MyDraw;
Ertrag;
Timer1.Enabled:=true;
Ende;
procedure TfrmMain.FormClose(Sender: TObject; var Action: TCloseAction);
beginnen
timer1.Enabled:=false;
wenn hrc<>null dann
wglDeleteContext(hrc);
Ende;
Ende.
7. Beleuchtung und Textur von OPENGL
Sie alle dienen dazu, den dreidimensionalen Effekt und den Farbeffekt zu verstärken. Beleuchtung kann die Helligkeit und den dreidimensionalen Effekt von Grafiken erhöhen, und Texturen können Grafiken realistischer machen. Durch den Einsatz von Beleuchtung kann das Erscheinungsbild eines Objekts stark zum Ausdruck gebracht werden, und Texturen können dem Objekt unterschiedliche Erscheinungsbilder verleihen.
1 Beleuchtungs- und Lichtquellenprozesse und -anwendungen
Eine glIndex-Prozedur macht eine Farbe in der Farbindextabelle zur aktuellen Farbe.
procedure glIndexd(c:GLdouble);
Prozedur glIndexf(c:GLdouble);
procedure glIndexi(c:GLdouble);
Prozedur glIndexs(c:GLdouble);
Parameter C ist der Indexwert. Wenn die glIndex-Prozedur verwendet wird, wird das iPixelType-Mitglied in der TPiexlFormatDescriptor-Struktur auf PFD_TYPE_COLORINDEX gesetzt.
B glShadeModel-Prozedur
Der glShadeModel-Prozess legt den Füllmodus fest, Wert: GL_SMOOTH.
procedure glShadeModel(mode:GLenum);
Hinweis: Die beiden oben genannten Prozesse können nur außerhalb von glBegin....glEnd verwendet werden.
C glLight-Prozedur definiert die Lichtquelle
procedure glLightf(light:GLenum,pname:GLenum,param:GLfloat);
procedure glLighti(light:GLenum,pname:GLenum,param:GLfloat);
Der Parameter Licht definiert die Lichtquelle, sein Wert kann sein: GL_LIGHT0....GL_LIGHTN, der N-Wert ist kleiner als GL_MAX_LIGHT.
Der Parameter pname gibt die Lichtquellenparameter an:
GL_AMBIENT-Komponentenintensität des Umgebungslichts
GL_DIFFUSE Komponentenintensität des Streulichts
GL_SPECULAR Komponentenintensität des reflektierten Lichts
GL_POSITION Lichtquellenposition
GL_SPOT_DIRECTION Die Fokusrichtung der Lichtquelle
GL_SPOT_EXPONENT Lichtquellenindex
GL_SPOT_CUTOFF Lichtquellenrichtung
GL_CONSTANT_ATTENUATION Abklingfaktor der Lichtkonstante
GL_LINEAR_ATTENUATION leichter sekundärer Dämpfungsfaktor
Aktivieren und deaktivieren Sie Lichtquellen mit den Prozeduren glEnable() und glDisable()
glEnable(GL_LIGHTING); //Lichtquelle aktivieren
glDisable(GL_LIGHTING); //Schalten Sie die Lichtquelle aus
glEnable(GL_LIGHT0); //Die 0. Lichtquelle aktivieren
glDisable(GL_LIGHT0); //Die 0. Lichtquelle ausschalten
Beispiel für die Einstellung der Lichtquelle:
var
sdirection:Array[1..4] of GLfloat:={0.0,1.0,0.0,0.0};
glLightfv(GL_LIGHT0,GL_SPOT_CUTOFF,60);
glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,sdirection);
2 Material- und Beleuchtungsmodell
Eine glMaterial-Prozedur legt Materialparameter fest
procedure glMaterialf(face:GLenum,pname:GLenum,param:GLfloat);
procedure glMateriali(face:GLenum,pname:GLenum,param:GLfloat);
procedure glMaterialfv(face:GLenum,pname:GLenum,param:GLfloat);
procedure glMaterialiv(face:GLenum,pname:GLenum,param:GLfloat);
Der Parameter face gibt die Oberfläche des Objekts an und seine Werte sind: GL_FRONT, GL_BACK, GL_FRONT_BACK.
pname, param werden in diesem Material nicht vorgestellt.
B glLightModel-Prozess
procedure glLightModelf(pname:GLenum,param:GLfloat);
Der Parameter pname ist der Parameter des Lichtquellenmodells, der den Wert GL_LIGHT_MODEL_AMBIENT annehmen kann.
GL_LIGHT_MODEL_LOCAL_VIEWER,GL_LIGHT_MODEL_TWO_SIDE.
Beispielcode:
procedure TfrmMain.SetLighting;
var
MaterialAmbient:array[1..4] von GLfloat;
MaterialDiffuse:Array[1..4] of GLfloat;
MaterialSpecular:Array[1..4] von GLfloat;
AmbientLightPosition:Array[1..4] of GLfloat;
LightAmbient:Array[1..4] of GLfloat;
MaterialGlanz:GLfloat;
beginnen
MaterialAmbient[1]:=0,5;
MaterialAmbient[2]:=0,8;
MaterialAmbient[1]:=0.2;
MaterialAmbient[1]:=1.0;
MaterialDiffuse[1]:=0,4;
MaterialDiffuse[2]:=0,8;
MaterialDiffuse[3]:=0.1;
MaterialDiffuse[4]:=1.0;
MaterialSpecular[1]:=1.0;
MaterialSpecular[2]:=0,5;
MaterialSpecular[3]:=0.1;
MaterialSpecular[4]:=1.0;
MaterialGlanz:=50,0;
AmbientLightPosition[1]:=0.5;
AmbientLightPosition[2]:=1.0;
AmbientLightPosition[3]:=1.0;
AmbientLightPosition[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_SPECULAR,@MaterialSpecular);
glMaterialfv(GL_FRONT,GL_SHININESS,@MaterialShininess);
glLightfv(GL_LIGHT0,GL_POSITION,@AmbientLightPosition);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,@LightAmbient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLShadeModel(GL_SMOOTH);
Ende;
3 Auftragen der Textur
Ein glTexImage1D definiert eine eindimensionale Texturkarte.
procedure glTexImage1D(target:GLenum,level:GLint,components:GLint,width:GLsizei,
border:GLint,format:GLenum,type:GLenum,pixels:GLvoid);
Der Parameterzielwert ist GL_TEXTURE_1D, der als Texturzuordnung definiert ist. Level ist die Ebene des Texturbildes mit mehrstufiger Auflösung, Breite ist die Texturbreite, der Wert ist 2n und der Wert von n ist 32, 64, 129 usw. Border ist die Grenze der Textur und ihr Wert ist 0 oder 1. Pixel ist die Position der Textur im Speicher. Die Komponente gibt die Mischung und Anpassung von RGBA an:
1Wählen Sie Zutat B
2Wählen Sie die Zutaten B und A aus
3Wählen Sie die Zutaten R, G, B aus
4Wählen Sie die Zutaten R,G,B,A aus
B glTexImage2D definiert zweidimensionale Texturabbildung
procedure glTexImage2D(target:GLenum,level:GLint,components:GLint,width:GLsizei,
border:GLint,format:GLenum,type:GLenum,pixels:GLvoid);
Wenn das Parameterziel GL_TEXTURE_2D ist, ist die Bedeutung eine zweidimensionale Texturzuordnung, die Höhe ist die Höhe der Textur und die anderen Parameter in der Funktion sind dieselben wie bei glTexImage1D. Der Wert des Komponentenparameters ist derselbe wie oben.
Beispielcode:
procedure TfrmMain.SetTextures;
var
Bits:Array[1..64,1..64,1..64] von GLubyte;
bmp:TBitmap;
i,j:Integer;
beginnen
bmp:=TBitmap.Create;
bmp.LoadFromFile('d:/dsoft/1119/01/logon.bmp');
für i:=1 bis 64 do
für j:=1 bis 64 do
beginnen
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;
Ende;
{0 stellt eine einzelne Farbschattierungsstufe dar, GL_RGBA stellt einen gemischten Wert dar
64X64 stellt die Höhe und Breite der Textur dar, 0 stellt keinen Rand dar,
GL_RGBA repräsentiert den Texturtyp, GL_unsigned_type repräsentiert den Datentyp @generation Object Adresse}
Glteximage2D (GL_TEXTURE_2D, 0, GL_RGBA, 64,64,0, GL_RGBA,
GL_unsigned_byte,@bit);
Glenable (GL_TEXTURE_2D);
Ende;
C Gltexameter -Prozedur legt Texturparameter fest
Prozedur GltexAmeterf (Ziel: Glenum, Pname: Glenum, Param: Glfloat);
Prozedur GltexAperi (Ziel: Glenum, Pname: Glenum, Param: Glfloat);
Das Parameterziel repräsentiert GL_TEXTURE_1D oder GL_TEXTURE_2D, und der Param ist der Texturwert.
D GLTEXENV -Funktion legt die Umgebungsparameter der Textur fest
Funktion Gltexenvf (Ziel: Glenum, Pname: Glenum, Param: Glfloat);
Funktion Gltexenvi (Ziel: Glenum, Pname: Glenum, Param: Glfloat);
Das Parameterziel ist GL_TEXTURE_ENV,
Der Parameter -PName ist der Texturparameterwert, und der Wert ist GL_TEXTURE_ENV_MODE
Der Parameterparameter ist der Umgebungswert und seine Werte sind GL_MODULD, GL_DECAL und GL_BLEND.
Beispielcode für dieses Programm:
Einheit Mainfrm;
Schnittstelle
verwendet
Fenster, Nachrichten, Systeme, Varianten, Klassen, Grafiken, Steuerelemente, Formulare,
Dialoge, OpenGL, extctrls;
Typ
TfrmMain = Klasse(TForm)
Timer1: TTimer;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
Verfahrensformung (Absender: Tobject);
Procedure FormKeydown (Absender: Tobject; var Key: Word;
Schicht: TShiftState);
ProzedurformResize (Absender: Tobject);
procedure Timer1Timer(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
Privat
{Private Erklärungen}
HRC: HGLRC;
W, H: Ganzzahl;
Breite, Länge: Glfloat;
Radius: Gldouble;
öffentlich
{Öffentliche Erklärungen}
Verfahrensabschluss;
Prozedur -SetTextures;
Verfahren mydraw;
Prozedur initializegl (var breit: glsizei; Höhe: glSIZEI);
Ende;
var
frmmain: tfrmmain;
Durchführung
{$R *.dfm}
procedure tfrmmain.formcreate (Absender: tobject);
var
PFD: TpixelFormatDescriptor;
PixelFormat: Ganzzahl;
beginnen
Controlstyle: = Controlstyle+[csopaque];
Fillchar (pfd, sizeof (pfd), 0);
mit PFD tun
beginnen
NSIZE: = sizeof (tpixelformatDescriptor);
Nversion: = 1;
DWFLAGS: = Pfd_draw_to_window oder
PFD_SUPPORT_OPENGL oder PFD_DOUBLEBUFFER;
ipixEtype: = pfd_type_rgba;
ccolorbits: = 24;
CDEPTHBITS: = 32;
IlayerType: = Pfd_main_plane;
Ende;
Pixelformat: = choosepixelformat (canvas.handle,@pfd);
Setpixelformat (canvas.handle, pixelformat,@pfd);
HRC: = wGlCreateContext (Canvas.Handle);
W: = clientRect.Right;
H: = clientRect.bottom;
Initializegl (w, h);
Ende;
Prozedur tfrmmain.FormDestroy (Absender: Tobject);
beginnen
WGLDELETECONTEXT (HRC);
Ende;
procedure tfrmmain.formpaint (Absender: tobject);
beginnen
WGLMakeCurrent (Leinwand.Handle, HRC);
Glclearcolor (1,1,1,1);
GLCOLOR3F (1,0,0);
glclear (GL_COLOR_BUFFER_BIT oder GL_DEPTH_BUFFER_BIT);
SetTextures;
Mydraw;
SetLighting;
Glflush;
Ende;
Verfahren tfrmmain.mydraw;
var
QOBJ: Gluquadricobj;
beginnen
glpushmatrix;
glclear (GL_COLOR_BUFFER_BIT oder GL_DEPTH_BUFFER_BIT);
GLCOLOR3F (1,0,0);
glrotiert (0,5,0,0,1,0,0,0);
glrotiert (-Latitude, 1,0,0,0,0,0);
GLROTATED (Längengrad 0,0,0,0,1,0);
QOBJ: = Glunewquadric;
GluquadricDrawStyle (Qobj, Glu_line);
Glusphere (Qobj, 0,5,20,20);
Swapbuffer (Leinwand.Handle);
SetLighting;
SetTextures;
Ende;
{procedure tfrmmain.formResize (Absender: tobject);
var
Nrange: Glfloat;
beginnen
NRANGE: = 50,0;
W: = Clientbreite;
H: = clientHeight;
Wenn H = 0 dann
H: = 1;
Glviewport (0,0, W, H);
GLMATRIXMODE (GL_PROJECTION);
Gladidentität;
Wenn w <= h dann
Glortho (-nrange, nrange, -nrange*h/w, nrange*h/w,
-nrange, nrange)
anders
Glortho (-nrange*h/w, nrange*h/w, -nrange, nrange,
-nrange, nrange);
GLMATRIXMODE (GL_MODELVIEW);
Gladidentität;
Repaint;
Ende;
}
procedure tfrmmain.formKeyDown (Absender: Tobject; var key: word;
Schicht: TShiftState);
beginnen
Wenn Key = vk_escape dann
Schließen;
Wenn Key = vk_up dann
GLROTATEF (-5,1,0,0,0,0,0);
Wenn Key = vk_down dann
GLROTATEF (5,1,0,0,0,0,0);
Wenn Key = vk_left dann
GLROTATEF (-5,0,0,1,0,0,0);
Wenn Key = vk_right dann
GLROTATEF (5,0,0,0,1,0,0,0);
Repaint;
Ende;
procedure tfrmmain.formResize (Absender: tobject);
beginnen
GLMATRIXMODE (GL_PROJECTION);
Gladidentität;
glfrustum (-1,0,1,0, -1,0,1,0,3,0,7,0);
Glviewport (0,0, Clientwidth, ClientHeight);
Repaint;
ungültig machen;
Ende;
Prozedur tfrmmain.initializegl (var breite: glsizei; Höhe: glSIZEI);
var
MaxObjectSize, Aspekt: Glfloat;
non_planane: bldouble;
beginnen
GlclearIndex (0);
Glcleardepth (1,0);
Glenable (GL_Depth_test);
GLMATRIXMODE (GL_PROJECTION);
Aspekt: = 1,0;
Gluperspektive (45,0, Aspekt, 3,0, 7,0);
GLMATRIXMODE (GL_MODELVIEW);
NEHSPLANE: = 0,3;
MaxObjectsize: = 0,3;
Radius: = NEHSE_PLANE+MAXOBJECTSIZE/2.0;
Breitengrad: = 0,3;
Länge: = 0,6;
Ende;
procedure tfrmmain.timer1timer (Absender: tobject);
beginnen
timer1.Enabled:=false;
Mydraw;
Ertrag;
Timer1.Enabled: = true;
Ende;
Prozedur tFrmmain.formclose (Absender: tobject; var action: tcloseaction);
beginnen
timer1.Enabled:=false;
Wenn HRC <> null dann
WGLDELETECONTEXT (HRC);
Ende;
Prozedur tFrmmain.Setlighting;
var
Materialambient: Array [1..4] von Glfloat;
Materialdiffuse: Array [1..4] von Glfloat;
Materialspekular: Array [1..4] von Glfloat;
AmbientlightPosition: Array [1..4] von Glfloat;
Lightambient: Array [1..4] von Glfloat;
MATERIALSHINISINITY: GLFLOAT;
beginnen
Materialambient [1]: = 0,5;
Materialambient [2]: = 0,8;
Materialambient [1]: = 0,2;
Materialambient [1]: = 1,0;
Materialdiffuse [1]: = 0,4;
Materialdiffuse [2]: = 0,8;
Materialdiffuse [3]: = 0,1;
Materialdiffuse [4]: = 1,0;
Materialspekular [1]: = 1,0;
Materialspekular [2]: = 0,5;
Materialspekular [3]: = 0,1;
Materialspekular [4]: = 1,0;
MATERIALSHINDINITION: = 50,0;
AmbientlightPosition [1]: = 0,5;
AmbientlightPosition [2]: = 1,0;
AmbientlightPosition [3]: = 1,0;
AmbientlightPosition [4]: = 0,0;
Lightambient [1]: = 0,5;
Lightambient [2]: = 0,2;
Lightambient [3]: = 0,8;
Lightambient [4]: = 1,0;
GLMATERIALFV (GL_FRONT, GL_AMBIENT,@MATERAMMAMBIENT);
GLMATERIALFV (GL_FRONT, GL_DIFFUSE,@Materialdiffuse);
GLMATERIALFV (GL_FRONT, GL_SPEKULAR,@MATERIALSPEKular);
GLMATERIALFV (GL_FRONT, GL_SHINNESS,@MATERIALSHINDESS);
Glightfv (GL_LIGHT0, GL_POSION,@AmbientlightPosition);
GlightModelfV (GL_LIGHT_MODEL_AMBIENT,@Lightambient);
glenable (gl_Lighting);
Glenable (GL_ILLIGE0);
Glhademodel (GL_Smooth);
Ende;
Prozedur tfrmmain.setTextures;
var
Bits: Array [1..64,1..64,1..64] von Glubyte;
BMP: tbitmap;
Ich, J: Ganzzahl;
beginnen
BMP: = tbitmap.create;
bmp.loadfromFile ('d: /dsoft/1119/02/logon.bmp');
für i: = 1 bis 64 tun
für J: = 1 bis 64 tun
beginnen
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;
Ende;
glpixelstorei (GL_Unpack_Alignment, 4);
GltexAmeteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
GltexAmeteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GltexAmeteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
{0 repräsentiert eine einzelne Farbschattierungsstufe, GL_RGBA repräsentiert einen gemischten Wert
64x64 repräsentiert die Höhe und Breite der Textur, 0 ist kein Rand,
GL_RGBA repräsentiert den Texturtyp, GL_unsigned_type repräsentiert den Datentyp @generation Object Adresse}
Glteximage2D (GL_TEXTURE_2D, 0, GL_RGBA, 64,64,0, GL_RGBA,
GL_unsigned_byte,@bit);
Glenable (GL_TEXTURE_2D);
Gltexenvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
Ende;
Ende.