Im vorherigen Abschnitt haben Sie gelernt, wie man Dreiecke und Vierecke einfärbt. In dieser Lektion lernen Sie, wie Sie diese farbigen Objekte um ihre Koordinatenachsen drehen.
Fügen Sie einfach ein paar Zeilen zum Code im vorherigen Abschnitt hinzu. Schreiben wir die gesamte Routine noch einmal neu. Es ist für Sie praktisch zu wissen, was hinzugefügt und was geändert wurde.
Fügen Sie zwei Variablen hinzu, um die Drehung dieser beiden Objekte zu steuern. Diese beiden Variablen werden nach den anderen Variablen am Anfang des Programms hinzugefügt (bool fullscreen=TRUE; zwei Zeilen darunter). Es handelt sich um Gleitkommavariablen, die es uns ermöglichen, Objekte sehr präzise zu drehen. Gleitkommazahlen enthalten Dezimalstellen, was bedeutet, dass wir keine Winkel von 1, 2, 3 ... verwenden müssen. Sie werden feststellen, dass Gleitkommazahlen die Grundlage der OpenGL-Programmierung sind. Die neue Variable namens rtri wird zum Drehen des Dreiecks und rquad zum Drehen des Vierecks verwendet.
Var
…
rtri : GLfloat; // Winkel für Dreieck (neu)
rquad : GLfloat; // Winkel für Viereck (neu)
…
Dann modifizieren Sie glDraw() wie folgt:
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
//Die nächste Codezeile ist neu. glRotatef(Angle,Xvector,Yvector,Zvector) ist für die Drehung des Objekts um eine bestimmte Achse verantwortlich.
//Dieser Befehl hat viele Verwendungsmöglichkeiten. Der Winkel ist normalerweise eine Variable, die den Winkel angibt, um den das Objekt gedreht wird.
//Die drei Parameter Xvector, Yvector und Zvector bestimmen gemeinsam die Richtung der Rotationsachse.
//Zum Beispiel verläuft der durch (1,0,0) beschriebene Vektor durch 1 Einheit der X-Koordinatenachse und ist nach rechts gerichtet.
//Der durch (-1,0,0) beschriebene Vektor verläuft durch 1 Einheit der X-Koordinatenachse, jedoch in der linken Richtung.
//D. Michael Traub: Bietet die obige Erklärung von Xvector, Yvector und Zvector.
//Um die Drehung von X, Y und Z besser zu verstehen, möchte ich einige Beispiele nennen ...
//X-Achse – Sie verwenden eine Tischkreissäge. Die Achse in der Mitte des Blades wird von links nach rechts platziert (genau wie die X-Achse in OpenGL).
//Die scharfen Sägezähne rotieren wild um die X-Achse und scheinen sich nach oben oder unten zu drehen.
//Hängt von der Richtung ab, in die sich das Sägeblatt zu drehen beginnt. Dies ist die gleiche Situation wie wenn wir in OpenGL etwas um die X-Achse drehen.
//(Anmerkung des Übersetzers: Wenn Sie in diesem Moment Ihr Gesicht zum Monitor richten, werden Sie auf jeden Fall aufgesägt^-^.)
//Y-Achse – Nehmen wir an, Sie befinden sich im Zentrum eines riesigen Tornados, wobei die Mitte des Tornados vom Boden zum Himmel zeigt (genau wie die Y-Achse in OpenGL).
//Müll und Trümmer rotieren wild um die Y-Achse von links nach rechts oder von rechts nach links.
//Dies ist die gleiche Situation wie wenn wir in OpenGL etwas um die Y-Achse drehen.
//Z-Achse – Sie blicken geradeaus auf einen Ventilator. Die Mitte des Lüfters ist direkt auf Sie gerichtet (wie die Z-Achse in OpenGL).
//Die Lüfterflügel drehen sich wild im oder gegen den Uhrzeigersinn um die Z-Achse. Dies ist die gleiche Situation wie wenn wir in OpenGL etwas um die Z-Achse drehen.
glTranslatef(-1.5, 0.0, -6.0); // 1,5 Einheiten nach links und in den Bildschirm 6.0 verschieben
//Wenn in der folgenden Codezeile rtri gleich 7 ist, drehen wir das Dreieck um 7 von links nach rechts um die Y-Achse.
//Sie können auch den Wert des Parameters ändern, um das Dreieck gleichzeitig um die X- und Y-Achse zu drehen.
glRotatef(rtri, 0.0, 1.0, 0.0); // Das Dreieck um die Y-Achse drehen (neu)
//Es gibt keine Änderungen am folgenden Code. Auf der linken Seite des Bildschirms wird ein farbiges Verlaufsdreieck gezeichnet und von links nach rechts um die Y-Achse gedreht.
glBegin(GL_TRIANGLES); // Dreiecke zeichnen
glColor3f(1.0, 0.0, 0.0); //Setzt die aktuelle Farbe auf Rot
glVertex3f(0.0, 1.0, 0.0); // Oberer Scheitelpunkt
glColor3f(0.0, 1.0, 0.0); //Setzt die aktuelle Farbe auf Grün
glVertex3f(-1.0, -1.0, 0.0); // Unten links
glColor3f(0.0, 0.0, 1.0); //Setzt die aktuelle Farbe auf Blau
glVertex3f(1.0, -1.0, 0.0); // Unten rechts
glEnd(); // Ende der Dreieckszeichnung
//Sie werden im Code unten bemerken, dass wir einen weiteren glLoadIdentity()-Aufruf hinzugefügt haben.
// Der Zweck besteht darin, die Modellbeobachtungsmatrix zurückzusetzen.
//Wenn wir glTranslate nicht zurücksetzen und direkt aufrufen, treten unerwartete Ergebnisse auf.
//Da die Koordinatenachse gedreht wurde, liegt sie wahrscheinlich nicht in der gewünschten Richtung.
//Das, was wir ursprünglich wollten, um das Objekt nach links und rechts zu bewegen, kann also nach oben und unten werden, je nachdem, wie stark Sie die Koordinatenachse drehen.
//Versuchen Sie, glLoadIdentity() auszukommentieren und zu sehen, welche Ergebnisse angezeigt werden.
// Nach dem Zurücksetzen der Modellbeobachtungsmatrix werden alle X-, Y- und Z-Achsen zurückgesetzt und wir rufen glTranslate auf.
//Sie werden feststellen, dass wir dieses Mal nur 1,5 Einheiten nach rechts verschoben haben, statt 3,0 Einheiten wie in der letzten Lektion.
//Denn wenn wir die Szene zurücksetzen, kehrt der Fokus in die Mitte der Szene zurück (bei 0,0).
//Auf diese Weise müssen Sie nur 1,5 Einheiten nach rechts verschieben.
//Wenn wir uns an die neue Position bewegen, drehen Sie das Quad um die X-Achse. Das Quadrat dreht sich auf und ab.
glLoadIdentity(); //Modellbeobachtungsmatrix zurücksetzen
glTranslatef(1.5, 0.0, -6.0); // 1,5 Einheiten nach rechts bewegen und in Bildschirm 6.0 wechseln
glRotatef(rquad, 1.0, 0.0, 0.0); // Das Viereck um die X-Achse drehen (neu)
glBegin(GL_QUADS); // Zeichne ein Quadrat
glColor3f(0.6, 0.2, 2.0); //Setzt die aktuelle Farbe auf Lila
glVertex3f(-1.0, 1.0, 0.0); // Oben links
glVertex3f(1.0, 1.0, 0.0); // Oben rechts
glVertex3f(1.0, -1.0, 0.0); // Unten links
glVertex3f(-1.0, -1.0, 0.0); // Unten rechts
glEnd(); // Ende der quadratischen Zeichnung
//Die nächsten beiden Zeilen sind neu.
//Wenn man sich rtri und rquad als Container vorstellt,
//Dann haben wir am Anfang des Programms Container erstellt (rtri und rquad).
//Wenn der Container erstellt wird, ist er leer.
//Die erste Codezeile unten fügt dem Container 0,2 hinzu.
//Jedes Mal, wenn wir den vorherigen Code ausführen, wird der Wert im RTRI-Container hier um 0,2 erhöht.
//Die folgende Zeile reduziert den Wert im rquad-Container um 0,15.
//In ähnlicher Weise sinkt der Wert im rquad-Container hier jedes Mal um 0,15, wenn wir den vorherigen Code ausführen.
//Der Fall führt schließlich dazu, dass sich das Objekt in die entgegengesetzte Richtung zur Wachstumsrichtung dreht.
rtri := rtri + 0,2; // Erhöhen Sie die Rotationsvariable des Dreiecks (neu)
rquad := rquad - 0,15; // Reduziere die Rotationsvariable des Vierecks (neu)
Ende;