Konvertieren Sie das von CKER übersetzte VC OPENGL-Framework von NeHe in die Delphi-Version.
Ich hoffe, dass es für Brüder hilfreich sein wird, die Delphi verwenden, um OPENGL zu lernen.
Ich weiß nicht warum, aber es kann nicht direkt in meiner Delphi-Umgebung ausgeführt werden, aber auf anderen Computern scheint es in Ordnung zu sein.
Mein Computer kann nur EXE-Dateien kompilieren und ausführen.
Vielen Dank an NeHe für die Bereitstellung eines so guten Frameworks und an CKER für die Übersetzung der VC-Informationen.
PROgram Project1;
Verwendungsmöglichkeiten
opengl,
Fenster,
Nachrichten;
Konst
WND_TITLE = 'OPenGl-Grundgerüst'; //Titel
Var
//============================================= ===========================
// Jedes OpenGL ist mit einem Schattierungskontext verbunden. Die Shading-Kontexttabelle verbindet alle OpenGL-Aufrufe mit
// Empfangen Sie den Gerätekontext (Gerätebeschreibungstabelle) und definieren Sie die OpenGL-Shading-Beschreibungstabelle als hRC, damit das Programm dies kann
// Wenn es ausreicht, das Fenster zu zeichnen, müssen Sie auch eine Gerätebeschreibungstabelle erstellen. Die Windows-Gerätebeschreibungstabelle ist als hDC definiert.
// DC verbindet das Fenster mit GDI (Graphics Device Interface). Und RC verbindet OpenGL
// nach DC.
//============================================= ===========================
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
{$R *.res}
//============================================= ==============================
//Setzen Sie die Größe der OpenGL-Szene zurück, unabhängig davon, ob sich die Fenstergröße geändert hat (vorausgesetzt, der Vollbildmodus wird nicht verwendet).
//Auch wenn die Größe des Fensters nicht geändert werden kann (z. B. im Vollbildmodus), wird es dennoch mindestens einmal ausgeführt————————
//Stellen Sie die Perspektive am Anfang des Programms ein. Die Größe der OpenGL-Szene wird auf die Größe des Fensters eingestellt, in dem sie angezeigt wird.
//============================================= ==============================
Prozedur glResizeWnd(Width, Height: Integer); // GL-Fenstergröße zurücksetzen und initialisieren
Beginnen
If (Height = 0) Then // Verhindern Sie, dass die Höhe 0 ist und eine Division-durch-0-Ausnahme verursacht.
Höhe := 1;
glViewport(0, 0, Breite, Höhe); //Das aktuelle Ansichtsfenster (Viewport) zurücksetzen
//Die folgenden Zeilen richten den Perspektivbildschirm ein. Das bedeutet, dass weiter entfernte Dinge kleiner erscheinen. Dadurch entsteht eine Realität
//Auftrittsszene. Die Perspektive wird hier als Betrachtungswinkel von 45 Grad basierend auf der Breite und Höhe des Fensters berechnet. 0,1f, 100,0f sind
// Der Start- und Endpunkt der Tiefe, die wir in der Szene zeichnen können.
//glMatrixMode(GL_PROJECTION) gibt an, dass sich die nächsten beiden Codezeilen auf die Projektionsmatrix auswirken.
//Die Projektionsmatrix ist dafür verantwortlich, unserer Szene Perspektive hinzuzufügen.
//glLoadIdentity() ähnelt dem Zurücksetzen. Es stellt den ursprünglichen Zustand des ausgewählten Matrixzustands wieder her.
//Nach dem Aufruf von glLoadIdentity() legen wir die Perspektive für die Szene fest.
glMatrixMode(GL_PROJECTION); //Wählen Sie die Projektionsmatrix aus
glLoadIdentity(); // Projektionsmatrix zurücksetzen
gluPerspective(45.0, Breite / Höhe, 0.1, 100.0); // Berechnen Sie das Erscheinungsbild des Fensters
//glMatrixMode(GL_MODELVIEW) gibt an, dass sich jede neue Transformation auf die Modelview-Matrix (Modellbeobachtungsmatrix) auswirkt.
//Unsere Objektinformationen werden in der Modellbeobachtungsmatrix gespeichert.
glMatrixMode(GL_MODELVIEW); //Modellbeobachtungsmatrix auswählen
glLoadIdentity(); //Modellbeobachtungsmatrix zurücksetzen
//Wenn Sie die Bedeutung dieser Begriffe noch nicht verstehen, machen Sie sich keine Sorgen.
//Wissen Sie nur, dass Sie dies tun müssen, wenn Sie eine großartige perspektivische Szene erhalten möchten.
Ende;
//============================================= ==============================
// Alle Einstellungen für OpenGL vornehmen. Stellen Sie die Farbe ein, um den Bildschirm zu löschen, schalten Sie den Tiefencache ein,
// Glatte Schattierung (Schattenglättung) usw. aktivieren. Diese Routine wird erst aufgerufen, wenn das OpenGL-Fenster erstellt wird.
// Dieser Prozess wird einen Rückgabewert haben. Aber die Initialisierung ist hier nicht so kompliziert und über den Rückgabewert muss man sich noch keine Gedanken machen.
//============================================= ==============================
Prozedur glInit();
Beginnen
//Legen Sie die Farbe fest, die beim Löschen des Bildschirms verwendet wird. Wenn Sie nicht sicher sind, wie Farbe funktioniert, finden Sie hier eine kurze Erklärung.
//Farbwerte reichen von 0,0f bis 1,0f. 0,0f stellt die dunkelste Situation dar und 1,0f ist die hellste Situation.
// Der erste Parameter nach glClearColor ist die Rotintensität (rote Komponente), der zweite ist grün und der dritte ist blau.
//Der Maximalwert beträgt ebenfalls 1,0f, was den hellsten Fall einer bestimmten Farbkomponente darstellt. Der letzte Parameter ist der Alpha-Wert.
// Wenn es zum Löschen des Bildschirms verwendet wird, ist die vierte Zahl egal. Nun sei es 0,0f.
//Durch das Mischen von drei Grundfarben (Rot, Grün, Blau) können Sie verschiedene Farben erhalten
//Verwenden Sie also glClearColor(0.0f,0.0f,1.0f,0.0f), Ihr Blau, um den Bildschirm zu löschen.
//Wenn Sie glClearColor(0.5f,0.0f,0.0f,0.0f) verwenden, wird mittleres Rot verwendet, um den Bildschirm zu löschen.
//Nicht das hellste (1,0f) und auch nicht das dunkelste (0,0f). Um einen weißen Hintergrund zu erhalten, sollten alle Farben auf die hellste Stufe (1,0 f) eingestellt werden.
//Wenn Sie einen schwarzen Hintergrund wünschen, stellen Sie alle Farben auf die dunkelste (0,0f) ein.
glClearColor(0.0, 0.0, 0.0, 0.0); // schwarzer Hintergrund
//Schattenglättung mischt Farben fein durch Polygone und glättet externes Licht.
glShadeModel(GL_SMOOTH); // Schattenglättung aktivieren
// Als nächstes muss der Tiefenpuffer erledigt werden. Stellen Sie sich den Tiefenpuffer als eine Schicht hinter dem Bildschirm vor.
//Der Tiefenpuffer verfolgt kontinuierlich, wie tief das Objekt in den Bildschirm eindringt. Dieses Programm verwendet den Tiefencache tatsächlich nicht.
//Aber fast alle OpenGL-Programme, die 3D-Szenen auf dem Bildschirm anzeigen, verwenden Tiefenpuffer. Seine Reihenfolge bestimmt, welches Objekt zuerst gezeichnet wird.
//Auf diese Weise zeichnen Sie kein Quadrat hinter einem Kreis auf den Kreis. Der Tiefenpuffer ist ein sehr wichtiger Bestandteil von OpenGL.
glClearDepth(1.0); //Setze den Tiefenpuffer
glEnable(GL_DEPTH_TEST); // Tiefentest aktivieren
glDepthFunc(GL_LESS); // Art des durchgeführten Tiefentests
//Sagen Sie dann OpenGL, dass wir die bestmögliche Perspektivkorrektur wünschen.
//Dies wird sich geringfügig auf die Leistung auswirken. Lässt die Perspektive aber etwas besser aussehen.
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Wirklich gute Perspektivenkorrektur
Ende;
//============================================= ==============================
//Alle Zeichnungscodes. Alles, was Sie auf dem Bildschirm anzeigen möchten, wird in diesem Code angezeigt.
//Jedes zukünftige Programm wird hier neuen Code hinzufügen.
//============================================= ==============================
Prozedur glDraw();
Beginnen
glClear(GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT); // Bildschirm- und Tiefenpuffer löschen
glLoadIdentity(); //Setzen Sie die aktuelle Modellbeobachtungsmatrix zurück
Ende;
Funktion WndProc(hWnd: HWND; // Handle des Fensters
Msg: UINT; // Fensternachricht
wParam: WPARAM; // Zusätzlicher Nachrichteninhalt
lParam: LPARAM // Zusätzlicher Nachrichteninhalt
): LRESULT; stdcall;
Beginnen
Ergebnis := 0;
Case (Msg) Of // Windows-Meldungen prüfen
WM_ACTIVATE: // Fensteraktivierungsmeldung überwachen
Beginnen
Ende;
WM_CREATE: // Erstellen
Beginnen
Ende;
WM_CLOSE: // schließen
Beginnen
PostQuitMessage(0); //Exit-Nachricht senden
Ergebnis := 0
Ende;
WM_KEYDOWN: // Taste gedrückt
Beginnen
keys[wParam] := True; // Wenn ja, auf TRUE setzen
Ergebnis := 0;
Ende;
WM_KEYUP: // Lassen Sie die Taste los
Beginnen
keys[wParam] := False; // Wenn ja, auf FALSE setzen
Ergebnis := 0;
Ende;
WM_SIZE: //OpenGL-Fenstergröße anpassen
Beginnen
glResizeWnd(LOWord(lParam), HIWORD(lParam)); //LoWord=Width,HiWord=Height
Ergebnis := 0;
Ende;
WM_TIMER: //Timer
Beginnen
Ende;
Else //Überlassen Sie Windows den Rest.
Ergebnis := DefWindowProc(hWnd, Msg, wParam, lParam); // Alle unverarbeiteten Nachrichten an DefWindowProc übergeben.
Ende;
Ende;
//============================================= ==============================
// Wird nur aufgerufen, bevor das Programm beendet wird. Die Funktion besteht darin, die Farbkontexttabelle, die Gerätekontexttabelle und das Fensterhandle nacheinander freizugeben.
// Viele Fehlerprüfungen hinzugefügt. Wenn das Programm keinen Teil des Fensters zerstören kann, erscheint eine entsprechende Fehlermeldung.
// Nachrichtenfenster,
//============================================= ==============================
Prozedur glKillWnd(Fullscreen: Boolean);
Beginnen
//Das erste, was in KillGLWindow() gemacht wird, ist zu prüfen, ob es sich im Vollbildmodus befindet.
//Wenn ja, wechseln Sie zurück zum Desktop. Das Fenster hätte zerstört werden müssen, bevor der Vollbildmodus deaktiviert wurde.
//Bei einigen Grafikkarten kann dies jedoch zum Absturz des Desktops führen. Daher ist es besser, zuerst den Vollbildmodus zu deaktivieren.
//Dies verhindert Desktop-Abstürze und funktioniert hervorragend auf Nvidia- und 3dfx-Grafikkarten!
Wenn Vollbild, dann // Im Vollbildmodus?
Beginnen
// ChangeDisplaySettings(NULL,0) verwenden, um zum ursprünglichen Desktop zurückzukehren.
// Nimm NULL als ersten Parameter,
// Durch die Übergabe von 0 als zweiten Parameter wird Windows gezwungen, den aktuell in der Registrierung gespeicherten Wert zu verwenden
// (Standardauflösung, Farbtiefe, Bildwiederholfrequenz usw.), um meinen ursprünglichen Desktop effektiv wiederherzustellen.
// Nach dem Zurückschalten auf den Desktop muss der Mauszeiger wieder sichtbar gemacht werden.
ChangeDisplaySettings(devmode(Nil^), 0); // Wenn ja, zurück zum Desktop wechseln
ShowCursor(True); //Maus anzeigen
Ende;
//Ob es eine Farbbeschreibungstabelle (hRC) gibt.
Wenn h_RC > 0, dann
//Schauen Sie, ob wir es freigeben können (hRC von hDC trennen).
If (Not wglMakeCurrent(h_DC, 0)) Then
MessageBox(0, 'DC und RC können nicht freigegeben werden!', 'Fehler', MB_OK Oder
MB_ICONERROR);
// Kann die Shading-Beschreibungstabelle gelöscht werden?
Wenn (Nicht wglDeleteContext(h_RC)) Dann
Beginnen
MessageBox(0, „Schattierungskontexttabelle konnte nicht gelöscht werden!“, „Fehler“, MB_OK Oder
MB_ICONERROR);
h_RC := 0;
Ende;
//Ob die Gerätekontexttabelle vorhanden ist, und wenn ja, versuchen Sie, sie freizugeben.
Wenn ((h_DC > 0) und (ReleaseDC(h_Wnd, h_DC) = 0)) dann
Beginnen
MessageBox(0, „Gerätekontext konnte nicht freigegeben werden!“, „Fehler“, MB_OK Oder
MB_ICONERROR);
h_DC := 0;
Ende;
//Ob ein Fensterhandle vorhanden ist, rufen Sie DestroyWindow(hWnd) auf, um zu versuchen, das Fenster zu zerstören
Wenn ((h_Wnd <> 0) And (Not DestroyWindow(h_Wnd))) Dann
Beginnen
MessageBox(0, 'Formular kann nicht zerstört werden!', 'Fehler', MB_OK Oder
MB_ICONERROR);
h_Wnd := 0;
Ende;
//Fensterklasse abmelden
//Dies ermöglicht es uns, das Fenster normal zu zerstören und dann andere Fenster zu öffnen,
//Sie erhalten keine Fehlermeldungen wie „Windows Class bereits registriert“ (Fensterklasse bereits registriert).
If (Not UnRegisterClass('OpenGL', hInstance)) Then
Beginnen
MessageBox(0, 'Fensterklasse konnte nicht abgemeldet werden!', 'Fehler', MB_OK Oder
MB_ICONERROR);
hInstanz := 0;
Ende;
Ende;