{
Texturen können die CPU-Zeit erheblich einsparen. Haha, aber dieser Abschnitt hat mich viel Zeit gekostet: (
Da die OpenGL-Hilfsbibliothek verwendet wird, nutzen derzeit nur wenige Leute die Funktionen dieser Bibliothek, aber ich habe sie trotzdem gefunden. Dank zdcnow (Magnetic Effect) hat er mir die Delphi-Version dieser Hilfsbibliothek zur Verfügung gestellt. Bevor Sie diesen Abschnitt studieren, laden Sie bitte die Dateien glaux.dll und Glaux.pas online herunter und fügen Sie sie dem Projekt hinzu.
Okay, lasst uns den Weg nach OPENGL fortsetzen.
Zuerst müssen wir die SysUtils-Unit hinzufügen, da wir in diesem Abschnitt Dateioperationen verwenden werden, und wir müssen auch die Glaux-Unit hinzufügen.
Dann fügen wir basierend auf der ersten Lektion mehrere Variablen hinzu, xrot, yrot und zrot. Diese Variablen werden verwendet, um den Würfel um die X-, Y- und Z-Achse zu drehen. textur[] weist Speicherplatz für eine Textur zu. Wenn Sie mehr als eine Textur benötigen, sollten Sie die Nummer 1 in die von Ihnen benötigte Nummer ändern.
}
VAR
h_RC: HGLRC; // Rendering-Kontext (Schattierungsbeschreibungstabelle).
h_DC: HDC; // Gerätekontext (Gerätebeschreibungstabelle)
h_Wnd: HWND; // Fensterhandle
h_Instance: HINST; // Programminstanz (Instanz).
Tasten: Array[0..255] Of Boolean; // Array für Tastaturroutinen
xrot, // X-Rotationsbetrag (neu)
yrot, // Y-Rotationsbetrag (neu)
zrot: GLfloat; // Z-Rotationsbetrag (neu)
Texture: Array[0..1] Of GLuint; // Eine Textur speichern (neu)
{Dann laden Sie die beiden Prozesse in opengl32.dll, wir müssen sie verwenden}
PROcedure glGenTextures(n: GLsizei; Var Textures: GLuint);
opengl32;
Prozedur glBindTexture(target: GLenum; texture: GLuint);
opengl32;
{Als nächstes müssen wir eine neue Funktion hinzufügen, um das Bild erneut einzugeben. Der Rückgabetyp dieser Funktion ist in Glaux.pas wie folgt definiert:
TAUX_RGBImageRec= Datensatz
sizeX, sizeY: GLint;
Daten: Zeiger;
Ende;
PTAUX_RGBImageRec= ^TAUX_RGBImageRec;
Die spezifische Bedeutung wird später eingeführt}
Funktion LoadBmp(filename: pchar): PTAUX_RGBImageRec;
Var
BitmapFile: Thandle; // Dateihandle
Beginnen
//Überprüfen Sie als Nächstes, ob der Dateiname angegeben wurde
Wenn Dateiname = '' Dann // Stellen Sie sicher, dass der Dateiname angegeben ist.
result := Nil; // Wenn nicht angegeben, NULL zurückgeben
//Dann prüfen Sie, ob die Datei existiert.
BitmapFile := FileOpen(Filename, fmOpenWrite); //Versuchen Sie, die Datei zu öffnen
//Wenn wir die Datei öffnen können, existiert die Datei offensichtlich.
If BitmapFile > 0 Then // Existiert die Datei?
Beginnen
//Schließe die Datei.
FileClose(BitmapFile); //Handle schließen
//auxDIBImageLoad(Filename) liest Bilddaten und gibt sie zurück.
result := auxDIBImageLoadA(filename); //Bitmap laden und Zeiger zurückgeben
Ende
Anders
//Wenn wir die Datei nicht öffnen können, geben wir NiL zurück.
result := Nil; // Wenn das Laden fehlschlägt, niL zurückgeben.
Ende;
//Als nächstes eine neue Funktion erstellen, um die Texturkarte zu laden
Funktion LoadTexture: boolean;
//Statusvariable. Damit verfolgen wir, ob die Bitmap geladen und die Textur erstellt werden kann.
// Status ist standardmäßig auf FALSE gesetzt (was anzeigt, dass nichts geladen oder erstellt wird).
//TextureImage-Variable vom Typ PTAUX_RGBImageRec speichert den Bilddatensatz der Bitmap.
//Dieser Datensatz enthält die Breite, Höhe und Daten der Bitmap.
Var
Status: boolean;
TextureImage : Array[0..1] Of PTAUX_RGBImageRec;
Beginnen
Status := false;
ZeroMemory(@TextureImage, sizeof(TextureImage)); // Zeiger auf NULL setzen
TextureImage[0] := LoadBMP('Texture.bmp');
Wenn TextureImage[0] <> Null, dann
Beginnen
Status := TRUE; // Status auf TRUE setzen
//Verwenden Sie nun die Daten in TextureImage[0], um eine Textur zu erstellen.
//glGenTextures(1, Texture[0]) teilt OpenGL mit, dass wir einen Texturnamen generieren möchten
//(Wenn Sie mehrere Texturen laden möchten, erhöhen Sie die Anzahl).
//glBindTexture(GL_TEXTURE_2D, Texture[0]) weist OpenGL an, den Texturnamen Texture[0] an das Texturziel zu binden.
//2D-Texturen haben nur Höhe (auf der Y-Achse) und Breite (auf der X-Achse).
// Die Hauptfunktion weist den Texturdaten den Texturnamen zu.
//In diesem Beispiel teilen wir OpenGL mit, dass der Speicher bei &texture[0] verfügbar ist.
// Die von uns erstellte Textur wird in dem Speicherbereich gespeichert, auf den &texture[0] zeigt.
glGenTextures(1, Texture[0]); // Textur erstellen
glBindTexture(GL_TEXTURE_2D, textur[0]); //Verwende eine typische Textur, die aus Bitmap-Daten generiert wird
//Nach unten erstellen wir die echte Textur.
//Die folgende Zeile teilt OpenGL mit, dass es sich bei dieser Textur um eine 2D-Textur (GL_TEXTURE_2D) handelt.
//Die Zahl Null stellt den Detailgrad des Bildes dar, der normalerweise bei Null belassen wird.
//Die Zahl drei ist die Anzahl der Komponenten der Daten. Weil das Bild aus drei Komponenten besteht: roten Daten, grünen Daten und blauen Daten.
//TextureImage[0].sizeX ist die Breite der Textur.
//Wenn Sie die Breite kennen, können Sie sie hier eingeben, aber der Computer kann dies leicht für Sie ermitteln.
// TextureImage[0].sizey ist die Höhe der Textur.
//Die Zahl Null ist der Wert der Grenze, normalerweise Null.
// GL_RGB teilt OpenGL mit, dass die Bilddaten aus roten, grünen und blauen Farbdaten bestehen.
//GL_UNSIGNED_BYTE bedeutet, dass die Daten, aus denen das Bild besteht, vom Typ vorzeichenloses Byte sind.
//Endlich... TextureImage[0].data teilt OpenGL die Quelle der Texturdaten mit.
//Dieses Beispiel verweist auf die im TextureImage[0]-Datensatz gespeicherten Daten.
// Textur erzeugen
glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0].sizeX,
TextureImage[0].sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE,
TextureImage[0].data);
// Die folgenden zwei Zeilen teilen OpenGL mit, wann das Bild angezeigt wird.
//Wenn es größer ist als die vergrößerte Originaltextur (GL_TEXTURE_MAG_FILTER)
//Oder die von OpenGL verwendete Filtermethode, wenn die Textur auf eine Größe reduziert wird, die kleiner als die Originaltextur ist (GL_TEXTURE_MIN_FILTER).
//Normalerweise verwende ich in beiden Fällen GL_LINEAR. Dadurch können Texturen von weit entfernt bis ganz nah am Bildschirm flüssig dargestellt werden.
//Bei Verwendung von GL_LINEAR müssen CPU und Grafikkarte mehr Vorgänge ausführen.
//Wenn Ihr Computer langsam ist, sollten Sie wahrscheinlich GL_NEAREST verwenden.
//Wenn die gefilterte Textur vergrößert wird, sieht sie sehr mosaikartig aus.
//Sie können diese beiden Filtermethoden auch kombinieren. Verwenden Sie GL_LINEAR in der Nähe und GL_NEAREST in der Ferne.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Lineare Filterung
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Lineare Filterung
Ende;
//Jetzt geben wir den Speicher frei, der zuvor zum Speichern von Bitmap-Daten verwendet wurde.
//Wir prüfen zunächst, ob die Bitmap-Daten gespeichert sind.
//Wenn ja, prüfen Sie, ob die Daten gespeichert wurden.
//Wenn es gespeichert wurde, löschen Sie es.
// Geben Sie dann die Bildstruktur TextureImage[0] frei, um sicherzustellen, dass der gesamte Speicher freigegeben werden kann.
Wenn zugewiesen(TextureImage[0]) Dann // Ob die Textur existiert
Wenn zugewiesen(TextureImage[0].data) Dann // Ob das Texturbild vorhanden ist
TextureImage[0].data := Nil; // Den vom Texturbild belegten Speicher freigeben
TextureImage[0] := Nil; // Bildstruktur freigeben
//Zum Schluss die Statusvariable zurückgeben. Wenn alles in Ordnung ist, hat die Variable Status den Wert TRUE. Ansonsten FALSCH
Ergebnis := Status; // Rückgabestatus
Ende;