OpenGL ist ein leistungsfähiges 3D-Programmierwerkzeug, mit dem komplexe dreidimensionale Szenen aus einfachen Primitiven gezeichnet werden können. Dieser Artikel zeigt Ihnen, wie Sie einen einfachen Würfel zeichnen, den Sie drehen können, um ihn in drei Dimensionen zu betrachten.

Für dieses Projekt benötigen Sie einen Code-Editor und einige Kenntnisse der C-Programmierung.

Teil eins von vier:
Ersteinrichtung und main ()

1) Installieren Sie OpenGL

  • Um zu beginnen, folgen Sie diesen Schritten zur Installation von OpenGL auf Ihrem System. Wenn Sie bereits OpenGL und einen C-Compiler installiert haben, können Sie diesen Schritt überspringen und mit dem nächsten fortfahren.

2) Erstellen Sie das Dokument

  • Erstellen Sie eine neue Datei in Ihrem bevorzugten Code-Editor und speichern Sie sie als mycube.c

3) # beinhaltet

  • Dies sind die grundlegenden Funktionen, die wir für unser Programm benötigen. Es ist wichtig zu erkennen, dass für die verschiedenen Betriebssysteme tatsächlich unterschiedliche Includes erforderlich sind. Stellen Sie sicher, dass Sie alle diese Elemente einschließen, um sicherzustellen, dass Ihr Programm vielseitig ist und für jeden Benutzer ausgeführt werden kann.
     // Beinhaltet #einschließen  #einschließen  #einschließen  #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #einschließen  #sonst #einschließen  #endif

4) Funktionsprototypen und globale Variablen

  • Unser nächster Schritt ist, einige Funktionsprototypen zu deklarieren.
     // Funktionsprototypen Leere Anzeige(); Leere spezielle Schlüssel(); // Globale Variablen doppelt rotate_y=0; doppelt rotate_x=0;
  • Ich werde jede dieser Funktionen und die globalen Variablen im Detail erklären, wenn wir sie später in diesem Tutorial implementieren. Für jetzt ist es wichtig, dass Sie sie erklären.

5) Einrichten der Hauptfunktion () 

  •  int Main(int argc, verkohlen* argv[]) // GLUT initialisieren und Benutzerparameter verarbeiten glutInit(&argc,argv); // Fordern Sie ein doppelt gepuffertes Echtfarbenfenster mit Z-Puffer an glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  • Diese Aussage richtet unsere Umgebung ein. Eine große Sache zu erinnern, wenn OpenGL-Programme schreiben ist, dass Sie nach allem fragen müssen. Dies erfordert, dass Sie ein besseres Verständnis davon haben, wie Ihr Programm funktioniert und was Sie hinzufügen müssen, um die gewünschte Funktionalität zu erhalten. In dieser Zeile richten wir das Display mit Doppelpufferung, RGB-Farbe und einem Z-Puffer ein.
  • Doppelte Pufferung ist eine Technik, die in Grafikprogrammen verwendet wird, um ein Problem zu eliminieren, das dadurch entsteht, wie Bilder auf den Bildschirm gezeichnet werden. Jedes Mal, wenn wir die Szene neu zeichnen, muss das Display zuerst gelöscht werden, dann wird die neue Information gezeichnet. Ohne Doppelpufferung können Sie einen flackernden Effekt beobachten, wenn der Bildschirm wiederholt gelöscht und neu gezeichnet wird.
    Dieses Problem wird behoben, indem ein zweiter Puffer hinzugefügt wird, zu dem gezeichnet wird. Bei dieser Methode wird ein Bild in den ersten Puffer gezeichnet und dieser Puffer wird Ihnen angezeigt. Der nächste Frame wird in den zweiten Puffer gezogen und wenn das erledigt ist, wechseln die zwei Puffer die Plätze. Wir werden sofort den zweiten Puffer sehen, aber von uns ausgeblendet, wird der erste Puffer gelöscht und neu gezeichnet mit dem dritten Rahmen, der nach Beendigung des Vorgangs ersetzt wird.
  • Wir wollen auch das ermöglichen RGB-Farbe System in unserem Fenster. Ich werde mehr darüber erklären, wie Farbe in OpenGL verwendet wird, wenn wir an der Anzeigefunktion arbeiten.
  • Z-Pufferung ist, wie wir die 3D-Effekte bekommen, die wir wollen. OpenGL verwendet ein dreidimensionales Koordinatensystem mit x-, y- und z-Achsen. Um den Effekt zu erzielen, dass ein Objekt näher bei Ihnen ist, ist seine Position auf der z-Achse erhöht, um es jedoch weiter entfernt erscheinen zu lassen, wird seine Position auf der z-Achse verringert. Ich werde ein wenig mehr darüber sprechen, wenn wir unsere Eckpunkte für den Würfel zeichnen.

6) Erstellen des Fensters

  • Der nächste Schritt ist zu Erstelle das Fenster in dem wir den Würfel zeichnen werden. In diesem Tutorial nenne ich unser Fenster "Awesome Cube".
     // Erzeuge Fenster glutCreateWindow("Super Würfel");

7) Aktivieren Sie den Tiefen Test

  • OpenGL ist eine strenge Sprache, in der nicht davon ausgegangen wird, dass spezielle Funktionen aktiviert sind. Damit unser Programm in 3-Dimensionen mit dem Z-Puffer, den wir uns vorher angeschaut haben, richtig angezeigt wird, müssen wir Tiefenprüfung aktivieren. Wenn Sie OpenGL weiter erkunden, werden Sie viele Funktionen entdecken, die Sie aktivieren müssen, einschließlich Beleuchtung, Texturen, Cull-Facing und vieles mehr.
     // Aktivieren Sie den Z-Puffer-Tiefentest glEnable(GL_DEPTH_TEST);

8) Rückruffunktionen

  • Hier sind die Callback-Funktionen, für die wir die Prototypen früher geschrieben haben. Diese Funktionen werden jedes Mal durch die Hauptschleife aufgerufen. Die Anzeigefunktion zeichnet die Szene basierend auf Änderungen an Variablen, die seit dem vorherigen Aufruf vorgenommen wurden, neu. Die specialKeys-Funktion ermöglicht es uns, mit dem Programm zu interagieren.
     // Callback-Funktionen glutDisplayFunc(Anzeige); glutSpecialFunc(spezielle Schlüssel);

9) Rückruffunktionen

  • Der letzte Schritt in unserer anfänglichen Einstellung ist zu starte den MainLoop. Dadurch wird die Hauptfunktion aufgerufen, bis wir das Programm schließen, um Animationen und Benutzerinteraktionen zu ermöglichen.
     // Übergeben Sie die Steuerung an GLUT für Ereignisse glutMainLoop(); // Zurück zum Betriebssystem Rückkehr 0;

Teil zwei von vier:
Die Anzeige () Funktion

  • In dieser Funktion wird die gesamte Arbeit zum Zeichnen unseres Würfels ausgeführt. Die Grundidee hinter unserem Würfel ist es, alle sechs Seiten einzeln zu zeichnen und in die richtige Position zu bringen.
  • Konzeptionell wird jede Seite gezeichnet, indem die vier Ecken definiert werden und OpenGL die Linien verbinden und mit einer von uns definierten Farbe ausfüllen. Im Folgenden finden Sie die Schritte dazu.

1) glClear ()

  • Der erste Schritt, den wir in dieser Funktion machen müssen, ist Löschen Sie die Farbe und den Z-Puffer. Ohne diese Schritte sind die alten Zeichnungen unter den neuen Zeichnungen möglicherweise immer noch sichtbar, und die gezeichneten Objekte befinden sich nicht an der richtigen Stelle auf dem Bildschirm.
     Leere Anzeige() // Lösche Bildschirm und Z-Puffer glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

2) glBegin () und glEnd ()

  • OpenGL definiert Objekte als Kombinationen verschiedener Polygone. Verwendung der glBegin () Befehl, legen wir effektiv einen Bleistift, der eine Form zeichnen wird.Um den Bleistift anzuheben und eine neue Form zu beginnen, müssen wir die glEnd () Befehl. In diesem Tutorial verwenden wir GL_POLYGON, um jede Seite des Cubes zu zeichnen. Es ist jedoch möglich, andere Parameteroptionen wie GL_LINE, GL_QUAD oder GL_TRIANGLE zu verwenden, um andere Formen zu erstellen.
  • Hier beginnen wir mit der Vorderseite unseres Würfels. Später werden wir allen 6 Seiten Farbe hinzufügen.
     // Mehrfarbige Seite - FRONT glBegin(GL_POLYGON); // Scheitelpunkte werden im nächsten Schritt hinzugefügt glEnd();

3) glVertex3f ()

  • Sobald wir angegeben haben, dass wir mit unserem Polygon beginnen wollen, müssen wir es tun Definieren Sie die Scheitelpunkte des Objekts. glVertex hat mehrere Formen abhängig davon, was Sie mit Ihrem Objekt tun möchten.
  • Die erste ist, wie viele Dimensionen Sie arbeiten. Die 3 oben in glVertex3f sagt, dass wir in 3 Dimensionen zeichnen. Es ist auch möglich, in 2 oder 4 Dimensionen zu arbeiten. Das obige f in glVertex3f sagt, dass wir mit Gleitkommazahlen arbeiten. Sie können auch Shorts, Integer oder Doubles verwenden.
  • Beachten Sie, dass diese Punkte in a definiert sind gegen den Uhrzeigersinn Weise. Dies ist im Moment nicht sehr wichtig, aber wenn wir anfangen, mit Licht, Texturen und Cull-Facing zu arbeiten, wird das unglaublich wichtig, also gewöhn dich an, deine Punkte gegen den Uhrzeigersinn zu definieren.
  • Jetzt fügen wir die Scheitelpunkte zwischen den glBegin () und glEnd () Zeilen hinzu.
     // Mehrfarbige Seite - FRONT glBegin(GL_POLYGON); glVertex3f( -0.5, -0.5, -0.5); // P1 glVertex3f( -0.5, 0.5, -0.5); // P2 glVertex3f( 0.5, 0.5, -0.5); // P3 glVertex3f( 0.5, -0.5, -0.5); // P4 glEnd();

4) glColor3f ()

  • glColor funktioniert ähnlich wie glVertex. Wir können Punkte als Shorts, Integer, Doubles oder Floats definieren. Jede Farbe hat einen Wert von 0 bis 1. Alle Nullen machen den Punkt schwarz und alle 1en machen den Punkt weiß. Die 3 in glColor3f () bezieht sich auf das RGB-Farbsystem ohne Alphakanal. Das Alpha einer Farbe definiert ihre Transparenz. Verwenden Sie glColor4f (), um den Alpha-Wert zu ändern, wobei der letzte Parameter den Wert 0 bis 1 für undurchsichtig bis transparent hat.
  • Wenn wir glColor3f () aufrufen, wird jeder Vertex, der von diesem Punkt an gezeichnet wird, diese Farbe haben. Wenn also alle vier Vertices rot sein sollen, setzen Sie die Farbe einfach einmal vor den glVertex3f () - Befehlen und alle Vertices sind rot.
  • Die Vorderseite, die unten definiert wird, zeigt, wie eine neue Farbe für jeden Eckpunkt definiert wird. Wenn wir dies tun, können wir eine interessante Eigenschaft der OpenGL-Farben sehen. Da jeder Eckpunkt des Polygons eine eigene Farbe hat, wird OpenGL die Farben automatisch mischen! Im nächsten Schritt wird gezeigt, wie vier Vertices mit derselben Farbe zugewiesen werden.
     // Mehrfarbige Seite - FRONT glBegin(GL_POLYGON); glColor3f( 1.0, 0.0, 0.0 ); glVertex3f( 0.5, -0.5, -0.5 ); // P1 ist rot glColor3f( 0.0, 1.0, 0.0 ); glVertex3f( 0.5, 0.5, -0.5 ); // P2 ist grün glColor3f( 0.0, 0.0, 1.0 ); glVertex3f( -0.5, 0.5, -0.5 ); // P3 ist blau glColor3f( 1.0, 0.0, 1.0 ); glVertex3f( -0.5, -0.5, -0.5 ); // P4 ist violett glEnd();

5) Die anderen Seiten

  • Ich ermutige Sie, herauszufinden, wo sich die einzelnen Vertexpunkte für die anderen fünf Seiten des Würfels befinden, aber aus Gründen der Einfachheit habe ich diese für Sie berechnet und in unsere Berechnungen einbezogen letzte Anzeige () -Funktion unten.
     // Weiße Seite - ZURÜCK glBegin(GL_POLYGON); glColor3f( 1.0, 1.0, 1.0 ); glVertex3f( 0.5, -0.5, 0.5 ); glVertex3f( 0.5, 0.5, 0.5 ); glVertex3f( -0.5, 0.5, 0.5 ); glVertex3f( -0.5, -0.5, 0.5 ); glEnd(); // Lila Seite - RECHTS glBegin(GL_POLYGON); glColor3f( 1.0, 0.0, 1.0 ); glVertex3f( 0.5, -0.5, -0.5 ); glVertex3f( 0.5, 0.5, -0.5 ); glVertex3f( 0.5, 0.5, 0.5 ); glVertex3f( 0.5, -0.5, 0.5 ); glEnd(); // Grüne Seite - LINKS glBegin(GL_POLYGON); glColor3f( 0.0, 1.0, 0.0 ); glVertex3f( -0.5, -0.5, 0.5 ); glVertex3f( -0.5, 0.5, 0.5 ); glVertex3f( -0.5, 0.5, -0.5 ); glVertex3f( -0.5, -0.5, -0.5 ); glEnd(); // Blaue Seite - TOP glBegin(GL_POLYGON); glColor3f( 0.0, 0.0, 1.0 ); glVertex3f( 0.5, 0.5, 0.5 ); glVertex3f( 0.5, 0.5, -0.5 ); glVertex3f( -0.5, 0.5, -0.5 ); glVertex3f( -0.5, 0.5, 0.5 ); glEnd(); // Rote Seite - UNTEN glBegin(GL_POLYGON); glColor3f( 1.0, 0.0, 0.0 ); glVertex3f( 0.5, -0.5, -0.5 ); glVertex3f( 0.5, -0.5, 0.5 ); glVertex3f( -0.5, -0.5, 0.5 ); glVertex3f( -0.5, -0.5, -0.5 ); glEnd(); glFlush(); glutSwapBuffer();


  • Wir wollen auch zwei letzte Codezeilen für diese Funktion hinzufügen. Diese sind glFlush (); und glutSwapBuffer (); was uns den doppelt puffernden Effekt gibt, von dem wir früher erfahren haben.

Teil drei von vier:
Benutzerinteraktivität

1) specialKeys ()

  • Wir sind fast fertig, aber im Moment können wir einen Würfel zeichnen, aber wir haben keine Möglichkeit ihn zu drehen. Um dies zu tun, werden wir Erstelle ein specialKeys () Funktion, damit wir die Pfeiltasten drücken und den Würfel drehen können!
  • Mit dieser Funktion haben wir die globalen Variablen rotate_x und rotate_y deklariert. Wenn wir die rechte und die linke Pfeiltaste drücken, wird rotate_y um 5 Grad erhöht oder verringert. Wenn wir die Aufwärts- und Abwärtspfeiltasten drücken, ändert sich rotate_x entsprechend.
     Leere spezielle Schlüssel( int Schlüssel, int x, int y )  // Pfeil nach rechts - Drehung um 5 Grad erhöhen ob (Schlüssel == GLUT_KEY_RIGHT) rotate_y += 5; // Pfeil nach links - Drehung um 5 Grad verringern sonst ob (Schlüssel == GLUT_KEY_LEFT) rotate_y -= 5; sonst ob (Schlüssel == GLUT_KEY_UP) rotate_x += 5; sonst ob (Schlüssel == GLUT_KEY_DOWN) rotate_x -= 5; // Anzeigeaktualisierung anfordern glutPostRedisplay();

2) glRotate ()

  • Unsere letzte Aussage besteht darin, die Aussage hinzuzufügen, die unser Objekt rotieren wird. Geh zurück zum Anzeige() Funktion und vor der FRONT-Seite, füge folgende Zeilen hinzu:
     // Setze Transformationen zurück glLoadIdentität(); // Drehen, wenn der Benutzer rotate_x und rotate_y ändert glRotatef( rotate_x, 1.0, 0.0, 0.0 ); glRotatef( rotate_y, 0.0, 1.0, 0.0 ); // Mehrfarbige Seite - FRONT…


  • Beachten Sie zuerst, dass die Syntax von glRotatef () ist ähnlich wie glColor3f () und glVertex3f (), benötigt aber immer 4 Parameter. Der erste Parameter ist der anzuwendende Grad der Rotation. Die nächsten drei Parameter definieren, um welche Achse gedreht werden soll, wobei die erste die x-Achse ist, die zweite die y-Achse und die dritte die z-Achse. Im Moment müssen wir nur um die x- und y-Achse rotieren.
  • Alle Transformationen, die wir in unserem Programm schreiben, benötigen ähnliche Zeilen. Konzeptuell denken wir daran, unser Objekt um die x-Achse um den Betrag rotieren zu lassen, der durch rotate_x definiert wird, und sich dann um rotate_y um die y-Achse zu drehen. OpenGL kombiniert jedoch alle diese Anweisungen in einer Matrixtransformation. Jedes Mal, wenn wir die Anzeigefunktion aufrufen, erstellen wir eine Transformationsmatrix und glLoadIdentity () stellt sicher, dass wir in jedem Durchgang mit einer neuen Matrix beginnen.
  • Die anderen Transformationsfunktionen, die wir anwenden könnten, sind glTranslatef () und glScalef (). Diese Funktionen ähneln glRotatef () mit der Ausnahme, dass sie nur 3 Parameter annehmen, die x-, y- und z-Beträge, um das Objekt zu übersetzen oder zu skalieren.
  • Um die richtige Wirkung zu erzielen, wenn alle drei Transformationen auf ein Objekt angewendet werden, müssen wir sie in der richtigen Reihenfolge anwenden. Schreibe sie immer in der Reihenfolge glTranslate, glRotate, dann glScale. OpenGL wendet die Transformationen im Wesentlichen von unten an. Um das zu verstehen, versuchen Sie sich vorzustellen, wie ein einfacher 1x1x1-Würfel mit den Transformationen aussehen würde, wenn OpenGL sie von oben nach unten anwendet und OpenGL sie von unten nach oben anwendet.
  • Fügen Sie die folgenden Befehle hinzu, um den Würfel um 2 entlang der X-Achse, 2 entlang der Y-Achse zu skalieren, den Würfel um 180 Grad um die Y-Achse zu drehen und den Würfel um 0,1 entlang der X-Achse zu verschieben. Stellen Sie sicher, dass Sie diese sowie die vorherigen glRotate () - Befehle wie oben beschrieben in der richtigen Reihenfolge anordnen. (Wenn Sie sich nicht sicher sind, habe ich dies im letzten Code am Ende des Tutorials getan.)
     // Andere Transformationen glTranslatef( 0.1, 0.0, 0.0 ); glRotatef( 180, 0.0, 1.0, 0.0 ); glScalef( 2.0, 2.0, 0.0 );

Kompilieren

  • Der allerletzte Schritt zum Abschluss Ihres ersten OpenGL-Projekts ist kompilieren und führen Sie Ihren Code aus. Angenommen, Sie verwenden gcc als Compiler, führen Sie diese Befehle von Ihrem Terminal aus, um Ihr Programm zu kompilieren und zu testen.
     Unter Linux: gcc Würfel.c -O Würfel -lglut -lGL ./ mycube Auf dem Mac: gcc -O foo foo.c -Rahmen GLUT -Rahmen OpenGL./ mycube Unter Windows: gcc -Mauer -oooo foo.c -lglut32cu -lglu32 -lopengl32 ./ mycube

Teil vier von vier:
Endgültiger Code

  • Hier hast du es. Dein erstes OpenGL-Programm! Ich habe Ihnen meinen Quellcode als Referenz zur Verfügung gestellt.
     // // Datei: mycube.c // Autor: Matt Daisley // Erstellt: 25.04.2012 // Projekt: Quellcode für Einen Cube in OpenGL erstellen // Beschreibung: Erstellt ein OpenGL-Fenster und zeichnet einen 3D-Würfel // Der Benutzer kann mit den Pfeiltasten drehen //  // Steuerelemente: Pfeil nach links - Nach links drehen // Rechter Pfeil - Nach rechts drehen // Pfeil nach oben - Nach oben drehen // Pfeil nach unten - Nach unten drehen  // ---------------------------------------------------------- // Beinhaltet // ---------------------------------------------------------- #einschließen  #einschließen  #einschließen  #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #einschließen  #sonst #einschließen  #endif // ---------------------------------------------------------- // Funktionsprototypen // ---------------------------------------------------------- Leere Anzeige(); Leere spezielle Schlüssel(); // ---------------------------------------------------------- // Globale Variablen // ---------------------------------------------------------- doppelt rotate_y=0; doppelt rotate_x=0; // ---------------------------------------------------------- // display () Callback-Funktion // ---------------------------------------------------------- Leere Anzeige() // Lösche Bildschirm und Z-Puffer glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); // Setze Transformationen zurück glLoadIdentität(); // Andere Transformationen // glTranslatef (0,1, 0,0, 0,0); // Nicht enthalten // glRotatef (180, 0.0, 1.0, 0.0); // Nicht enthalten // Drehen, wenn der Benutzer rotate_x und rotate_y ändert glRotatef( rotate_x, 1.0, 0.0, 0.0 ); glRotatef( rotate_y, 0.0, 1.0, 0.0 ); // Andere Transformationen // glScalef (2.0, 2.0, 0.0); // Nicht enthalten // Mehrfarbige Seite - FRONT glBegin(GL_POLYGON); glColor3f( 1.0, 0.0, 0.0 ); glVertex3f( 0.5, -0.5, -0.5 ); // P1 ist rot glColor3f( 0.0, 1.0, 0.0 ); glVertex3f( 0.5, 0.5, -0.5 ); // P2 ist grün glColor3f( 0.0, 0.0, 1.0 ); glVertex3f( -0.5, 0.5, -0.5 ); // P3 ist blau glColor3f( 1.0, 0.0, 1.0 ); glVertex3f( -0.5, -0.5, -0.5 ); // P4 ist violett glEnd(); // Weiße Seite - ZURÜCK glBegin(GL_POLYGON); glColor3f( 1.0, 1.0, 1.0 ); glVertex3f( 0.5, -0.5, 0.5 ); glVertex3f( 0.5, 0.5, 0.5 ); glVertex3f( -0.5, 0.5, 0.5 ); glVertex3f( -0.5, -0.5, 0.5 ); glEnd(); // Lila Seite - RECHTS glBegin(GL_POLYGON); glColor3f( 1.0, 0.0, 1.0 ); glVertex3f( 0.5, -0.5, -0.5 ); glVertex3f( 0.5, 0.5, -0.5 ); glVertex3f( 0.5, 0.5, 0.5 ); glVertex3f( 0.5, -0.5, 0.5 ); glEnd(); // Grüne Seite - LINKS glBegin(GL_POLYGON); glColor3f( 0.0, 1.0, 0.0 ); glVertex3f( -0.5, -0.5, 0.5 ); glVertex3f( -0.5, 0.5, 0.5 ); glVertex3f( -0.5, 0.5, -0.5 ); glVertex3f( -0.5, -0.5, -0.5 ); glEnd(); // Blaue Seite - TOP glBegin(GL_POLYGON); glColor3f( 0.0, 0.0, 1.0 ); glVertex3f( 0.5, 0.5, 0.5 ); glVertex3f( 0.5, 0.5, -0.5 ); glVertex3f( -0.5, 0.5, -0.5 ); glVertex3f( -0.5, 0.5, 0.5 ); glEnd(); // Rote Seite - UNTEN glBegin(GL_POLYGON); glColor3f( 1.0, 0.0, 0.0 ); glVertex3f( 0.5, -0.5, -0.5 ); glVertex3f( 0.5, -0.5, 0.5 ); glVertex3f( -0.5, -0.5, 0.5 ); glVertex3f( -0.5, -0.5, -0.5 ); glEnd(); glFlush(); glutSwapBuffer();  // ---------------------------------------------------------- // specialKeys () Callback-Funktion // ---------------------------------------------------------- Leere spezielle Schlüssel( int Schlüssel, int x, int y )  // Pfeil nach rechts - Drehung um 5 Grad erhöhen ob (Schlüssel == GLUT_KEY_RIGHT) rotate_y += 5; // Pfeil nach links - Drehung um 5 Grad verringern sonst ob (Schlüssel == GLUT_KEY_LEFT) rotate_y -= 5; sonst ob (Schlüssel == GLUT_KEY_UP) rotate_x += 5; sonst ob (Schlüssel == GLUT_KEY_DOWN) rotate_x -= 5; // Anzeigeaktualisierung anfordern glutPostRedisplay();  // ---------------------------------------------------------- // Hauptfunktion // ---------------------------------------------------------- int Main(int argc, verkohlen* argv[]) // GLUT initialisieren und Benutzerparameter verarbeiten glutInit(&argc,argv); // Fordern Sie ein doppelt gepuffertes Echtfarbenfenster mit Z-Puffer an glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Erzeuge Fenster glutCreateWindow("Super Würfel"); // Aktivieren Sie den Z-Puffer-Tiefentest glEnable(GL_DEPTH_TEST); // Callback-Funktionen glutDisplayFunc(Anzeige); glutSpecialFunc(spezielle Schlüssel); // Übergeben Sie die Steuerung an GLUT für Ereignisse glutMainLoop(); // Zurück zum Betriebssystem Rückkehr 0;