Inhalt

• Schritte
• Teil 1 von 3: Erstinstallation
• Teil 2 von 3: Das Display () Funktion
• Teil 3 von 3: Programminteraktivität

OpenGL ist ein 3D-Programmiertool, mit dem Sie komplexe 3D-Bilder aus einfachen Formen erstellen können. In diesem Artikel erfahren Sie, wie Sie mit seiner Hilfe einen einfachen Würfel zeichnen, der in drei Dimensionen gedreht werden kann!

Schritte

Teil 1 von 3: Erstinstallation

1. 1 OpenGL installieren. Beginnen Sie mit einem Tutorial zur Installation von OpenGL auf Ihrem Computer. Wenn Sie bereits über OpenGL und einen C-Compiler verfügen, können Sie diesen Schritt überspringen und zum nächsten übergehen.
2. 2 Erstellen Sie ein Dokument. Erstellen Sie eine neue Datei in Ihrem bevorzugten Code-Editor und speichern Sie sie als mycube.c
3. 3 #inklusive hinzufügen. Hier sind die grundlegenden #include-Anweisungen, die Sie benötigen. Es ist wichtig, sich daran zu erinnern, dass die Anweisungen für verschiedene Betriebssysteme unterschiedlich sind und Sie daher alles auswählen müssen, damit das Programm universell ist und auf jedem System ausgeführt werden kann.

   // Enthält #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else #include GL / glut.h> #endif

4. 4 Fügen Sie funktionale Prototypen und Globals hinzu. Der nächste Schritt besteht darin, funktionale Prototypen zu deklarieren.

   // Funktionsprototypen void display (); void Spezialschlüssel(); // Globale Variablen double rotate_y = 0; Doppelrotation_x = 0;

5. 5 Definieren Sie die Hauptfunktion ().

   int main (int argc, char * argv []) // GLUT initialisieren und benutzerdefinierte Parameter verarbeiten glutInit (& argc, argv); // Fordern Sie ein Fenster mit Unterstützung für Double Buffering, Z-Buffering und True Color an glutInitDisplayMode (GLUT_DOUBLE

Teil 2 von 3: Das Display () Funktion

1. 1 Verstehen Sie den Zweck der Anzeigefunktion (). Die gesamte Arbeit beim Rendern des Würfels fällt auf die fragilen Linien dieser Funktion. Die Grundidee ist folgende: Sie zeichnen sechs separate Flächen des Würfels und platzieren sie an ihren jeweiligen Positionen.
   • Für jede Fläche definieren Sie vier Ecken, und OpenGL verbindet sie mit Linien und füllt sie mit Ihrer gewählten Farbe. Wie das geht, wird im Folgenden erklärt.
2. 2 Fügen Sie die Funktion glClear() hinzu. Wenn wir mit dieser Funktion arbeiten, brauchen wir zunächst klare Farbe und Z-Puffer... Andernfalls ist das alte unter dem neuen Bild sichtbar und die vom Programm gezeichneten Objekte werden falsch positioniert.

   void display () // Löschen Sie den Bildschirm und den Z-Puffer glClear (GL_COLOR_BUFFER_BIT

   • Achten Sie auf die letzten beiden Zeilen. Das sind die Funktionen glFlush (); und glutSwapBuffer ();, was den oben beschriebenen Effekt der Doppelpufferung ergibt.

Teil 3 von 3: Programminteraktivität

1. 1 Fügen Sie die Funktion specialKeys() hinzu. Im Prinzip ist alles fast fertig, aber der Würfel wird nur gezeichnet und nicht gedreht. Dazu müssen Sie erstellen die specialKeys()-Funktion, mit dem Sie den Würfel durch Drücken der Pfeiltasten drehen können!
   • Für diese Funktion wurden die globalen Variablen Rotate_x und Rotate_y deklariert. Wenn Sie die linke und rechte Pfeiltaste drücken, wird der Wert von rotation_y um fünf Grad erhöht oder verringert. Der Wert von rotation_x ändert sich auf die gleiche Weise, diesmal jedoch durch Drücken der Auf- und Ab-Pfeiltasten.

   void specialKeys (int key, int x, int y) {// Pfeil nach rechts - Drehung um 5 Grad erhöhen if (key == GLUT_KEY_RIGHT) rotation_y + = 5; // Pfeil nach links - Drehung um 5 Grad verringern else if (key == GLUT_KEY_LEFT) rotation_y - = 5; sonst if (Schlüssel == GLUT_KEY_UP) rotation_x + = 5; sonst if (Taste == GLUT_KEY_DOWN) rotation_x - = 5; // Bildschirmaktualisierung anfordern glutPostRedisplay (); }

2. 2 glRotate () hinzufügen. Als letztes fügen wir eine Linie hinzu, mit der wir das Objekt drehen können. Zurück zur Funktion Anzeige () und vor der Beschreibung der FRONT-Seite hinzufügen:

   // Transformationen zurücksetzen glLoadIdentity (); // Rotate, wenn der Benutzer ändert Die Werte rotate_x und rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0.0, 1.0, 0.0); // Mehrfarbige Seite - FRONT ....

   • Bitte beachten Sie, dass die Syntax glRotatef ()was der Syntax von glColor3f() und glVertex3f() ähnlich ist, aber immer vier Parameter benötigt. Der erste ist der Drehwinkel in Grad. Die nächsten drei sind die Achsen, entlang derer die Drehung erfolgt, in der Reihenfolge x, y, z. Im Moment müssen wir den Würfel entlang zweier Achsen, x und y, drehen.
   • Alle Transformationen, die wir im Programm definieren, benötigen ähnliche Zeilen. Grundsätzlich stellen wir die Drehung eines Objekts entlang der x-Achse als Änderung des Wertes von rotation_x und die Drehung entlang der y-Achse als Änderung des Wertes von rotation_y dar. OpenGL wird jedoch alles in einer Transformationsmatrix bündeln. Bei jedem Aufruf von display erstellen Sie eine Transformationsmatrix und glLoadIdentity () ermöglicht es Ihnen, jedes Mal mit einer neuen Matrix zu beginnen.
   • Andere Transformationsfunktionen, die Sie möglicherweise verwendet haben, sind glTranslatef () und glScalef (). Sie ähneln glRotatef(), benötigen jedoch nur drei Parameter: die x-, y- und z-Werte, um die Größe des Objekts zu ändern und zu skalieren.
   • Damit alles richtig angezeigt wird, wenn alle drei Transformationen auf ein Objekt angewendet werden, müssen Sie die Transformationen in der richtigen Reihenfolge einstellen, nämlich glTranslate, glRotate, glScale - und nie anders. OpenGL transformiert das Objekt, indem es das Programm von unten nach oben liest. Um dies besser zu verstehen, stellen Sie sich vor, wie der 1x1x1-Würfel nach allen Transformationen aussehen würde, wenn OpenGL sie in der gezeigten Reihenfolge (von oben nach unten) anwendet, und überlegen Sie sich dann, wie OpenGL den Würfel verarbeiten würde, indem Sie die Anweisungen von unten nach oben lesen.
3. 3 Fügen Sie die folgenden Befehle hinzu, um den Würfel zweimal in x- und y-Richtung zu skalieren, um den Würfel um 180 Grad auf der y-Achse zu drehen und um den Würfel um 0,1 auf der x-Achse zu bewegen. Stellen Sie sicher, dass alle relevanten Befehle, einschließlich der zuvor angegebenen glRotate()-Befehle, in der richtigen Reihenfolge sind. Wenn Sie Angst haben, einen Fehler zu machen, lesen Sie die endgültige Version des Programms am Ende des Artikels.

   // Weitere Transformationen glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0,0, 1,0, 0,0); gScalef (2,0, 2,0, 0,0);

4. 4 Kompilieren Sie den Code und führen Sie ihn aus. Nehmen wir an, Sie verwenden gcc als Compiler, also geben Sie die folgenden Befehle in Ihr Terminal ein:

   Unter Linux: gcc cube.c -o cube -lglut -lGL ./ mycube Unter Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL ./ mycube Unter Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32 ./ mycube

5. 5 Überprüfen Sie den endgültigen Code. Hier ist der endgültige Code, der vom Autor des Artikels erstellt wurde und die Kommentare nicht übersetzt.

   // // Datei: mycube.c // Autor: Matt Daisley // Erstellt: 25.04.2012 // Projekt: Quellcode für Make a Cube in OpenGL // Beschreibung: Erstellt ein OpenGL-Fenster und zeichnet einen 3D-Würfel / / Dass der Benutzer mit den Pfeiltasten drehen kann // // Steuerung: Linkspfeil - Nach links drehen // Rechtspfeil - Nach rechts drehen // Pfeil nach oben - Nach oben drehen // Pfeil nach unten - Nach unten drehen // ------ -------------------------------------------------- - // Beinhaltet // ------------------------------------------ - -------------- #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else # include GL / glut.h> #endif // --------------------------------------- - ------------------ // Funktionsprototypen // -------------------------- - -------------------------------- Leere Anzeige (); void Spezialschlüssel(); // ------------------------------------------------ ---------- // Globale Variablen // ---------------------------------- ------------------------ Doppelrotation_y = 0; Doppelrotation_x = 0; // ------------------------------------------------ ---------- // display() Callback-Funktion // ------------------------------ --------------------------------------- void display () // Clear screen and Z-buffer glClear (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- - // specialKeys () Callback-Funktion // --------------------------------------- - ------------------ void specialKeys (int key, int x, int y) {// Pfeil nach rechts - Drehung um 5 Grad erhöhen if (key == GLUT_KEY_RIGHT) rotation_y + = 5; // Pfeil nach links - Drehung um 5 Grad verringern else if (Taste == GLUT_KEY_LEFT) Rotation_y - = 5; else if (Taste == GLUT_KEY_UP) Rotation_x + = 5; else if (Taste == GLUT_KEY_DOWN) Rotation_x - = 5; // Anzeige-Update anfordern glutPostRedisplay ();} // ----------------------------------- - ---------------------- // main()-Funktion // ------------------- - -------------------------------------------------- int main (int argc, char * argv [ ] ) GLUT_RGB