• Tutorials
• Downloads
• Referenz
• NoPaste
• FAQ

Tutorial

OpenGL und FreeBASIC - eine kleine Einführung - Teil 4 - Rotieren

von Eastler_dart

Seite 2 von 4

Na gut, dann lassen wir die Pyramide mal rotieren:

die Pyramiede drehen

Der Befehl, um Drehbewegungen zu bewirken, heißt bei OpenGL glRotate.
Der Einfachheit halber, hängen wir ein f wie floating dran, damit erwartet glRotate Kommazahlen als Parameter, auch wenn wir vorerst mit ganzen (Integer) Gradwerten arbeiten werden.
Als Parameter sucht glRotate 4 Werte wie folgt:

Wenn wir z.B. unser Objekt um 45 Grad um die Y-Achse drehen wollten, dann müßten wir schreiben: glRotatef 45, 0, 1, 0.
Also erst den Befehl, glRotatef dann die Gradzahl 45 danach angeben, ob um die X-Achse gedreht wird (0=nein 1=ja) 0 danach angeben, ob um die Y-Achse gedreht wird (0=nein 1=ja) 1 zuletzt noch, ob um die Z-Achse gedreht wird (0=nein 1=ja) 0.

Dabei kann man auch um zwei oder alle drei Achsen gleichzeitig drehen lassen:
glRotatef 36, 1, 1, 1 würde alles, was nach dem Befehl kommt,
um 36 Grad um die X-Achse, um 36 Grad um die Y-Achse und um 36 Grad um die Z-Achse drehen.
Sie merken, wenn Sie in mehrere Richtungen gleichzeitig drehen wollen, können Sie nur eine Gradzahl für die Drehungen angeben, glRotate ließt ja nur vier Parameter.
Wollen Sie z.B. 45 Grad um Z-Achse und 10 Grad um X-Achse drehen, dann müßten Sie folgenden Zweizeiler programmieren:
glRotatef 45, 0, 0, 1
glRotatef 10, 1, 0, 0

Probieren wirs doch einfach mal aus.
Wir nehmen das Beispielprogramm von vorhin mit der Pyramide, und setzen nur noch einen glRotatef-Befehl rein:

Also in die SUB Pyramide, im Select-Case-Fall "BESCHREIBUNGSLISTE" gleich als Erstes den Rotierbefehl rein, kompilieren und starten.

Hier zwei Bilder, das Erste noch ohne Rotate-Befehl, das Zweite mit der 45Grad-Rotation um die Y-Achse:

OpenGL_Tut_Pyramide_0grad

OpenGL_Tut_Pyramide_45grad

Sie sehen die Wirkung? Die Pyramide hat eine Ecke der Grundfläche zur Kamera gedreht.

Aber wie beim Verschieben auch hier, ein Stillleben. Die Pyramide wird bei jeder Bilderstellung(Schleifendurchlauf) um 45 Grad um Y gedreht, kommt also bei jedem erstellten Bild(Schleifendurchlauf) immer wieder auf ein und dieselbe Ausrichtung, somit auf jedem Bild immer gleich.

kontrolliertes Rotieren

Um jetzt hier Bewegung reinzukriegen, machen wir das auf die selbe Art, wie beim Verschieben. Wir "füttern" glRotate mit Variablen anstelle von festen Werten. Und den Inhalt dieser Variablen ändern wir in Abhängigkeit von der Tastatur. Und gleich noch für alle drei Achsen:

Also brauchen wir erst mal 3 Variablen, in denen die jeweilige Gradzahl für die Drehung gespeichert werden kann. Diese Variablen nennen wir sinnigerweise: PyraXDrehw, PyraYDrehw, PyraZDrehw.
Auch wenn uns hier Integerwerte(Ganzzahlen ohne Kommastellen) reichen würden, der Einfachheit halber nehmen wir wieder SINGLE-Variablen, welche auch Kommastellen speichern können. Wir dimmen also im Hauptprogramm diese drei Variablen:

Einen Speicherplatz für die drei verschiedenen Winkelwerte für das Rotieren haben wir jetzt. Nun müssen wir diese Variablen mit Werten belegen, wie gesagt, in Abhängigkeit von der Tastatur.

Schlage vor, wir nehmen einfach die Buchstaben X, Y, und Z. Und dabei unterscheiden wir noch, ob diese Buchstaben als kleine oder als große Buchstaben gedrückt wurden. Je nachdem erhöhen oder vermindern wir den Variableninhalt.

Also brauchen wir neue CASE-Fälle in unserer Tastaturauswertung per SELECT CASE im Hauptteil:

Tja, da fällt mir ein, es wird ja jetzt recht chaotisch werden, wenn man mal die Pyramide z.B. um 128 Grad über X gedreht hat, und dann Z oder Y drückt.
Damit man auch abfragen kann, um wieviele Grad denn nun um welche Achse grad gedreht wird, sollte man das auch anzeigen.

Da wir noch nicht soweit sind, mit OpenGL Texte anzuzeigen und gleichzeitig wissen, mit FreeBasic-Print gehts in einem OpenGL-Fenster auch nicht, weichen wir auf das Console-Fenster aus.
Falls Sie routinierter FreeBasicler sind, könnte es sein, daß Sie Basic-Listings mit dem Parameter -s gui compilieren. Das ist schön und gut, stört uns hier aber. Bitte compilieren Sie hier ohne diesen Parameter, sodaß beim Programmstart dann zwei Fenster auf sind, das Console-Fenster und auch das Open-GL-Fenster.

Also, die Gradzahlen der Drehung zu jeder Achse auf dem Konsolefenster ausgeben läuft über den Open-Befehl - mit Open die Konsole für Ausgabe öffnen, mit Print # reinschreiben und danach schließen. Das ganze aber nicht durchweg, sonst scrollt das Fenster nur noch und OpenGL schläft ein, sondern nur dann, wenn der Anwender das will.

Jedoch wird das Ausgeben von SINGLE-Variablen von FreeBasic gern mal mit Exponential oder sonstigen Schreibweisen durchgeführt, deshalb würde ich die Ausgabe gerne mit dem Format-Befehl in eine klare Ausgabeform umsetzen. Dafür muß aber eine zusätzliche Datei, die vbcompat.bi, includet werden, weil dort erst der Formatbefehl drin steht:

Für den Open-Befehl brauchen wir noch eine Dateinummer, welche wir in der Integer-Variablen ConNrfesthalten müssen.
Also diese erst dimmen:

Nun hängen wir die Ausgabe der Winkelwerte in die Tastaturabfrageroutine, und zwar, wenn der Anwender "I" oder "i" drückt (für Info als Eselsbrücke). Da wir nun Werte anzeigen, nehm ich gleich noch die Positionswerte der Kamera mit dazu, diese Infos sind auch manchmal interessant:

Nachdem nun die Variablen vorhanden sind, per Tastendruck mit Werten gefüllt werden und auch angezeigt werden können, müssen wir nur noch der Pyramidenroutine sagen, "dreh die Pyramide". Das mach ich nun mal über den Sub-Aufruf, damit Sie diese Möglichkeit auch mal sehen, also in der Hauptschleife, beim Aufruf der Pyramidensub die Drehwerte mit übergeben:

Nun stehen die Drehwerte in der Sub Pyramide zur Verfügung, die wie folgt zu einer Rotation zusammengebastelt werden.
Da wir mit drei verschiedenen Drehwinkelwerten arbeiten, müssen wir die Rotation in drei Befehlszeilen aufteilen. Die erste Zeile nimmt Para1(übergebner Wert in PyraXDrehw) und dreht um die X-Achse, die Zweite nimmt Para2(übergebener Wert in PyraYDrehw) und dreht um Y-Achse, die dritte Zeile macht das gleiche für die Z-Achse:

Wenn Sie das jetzt kompilieren und ausführen, können Sie mit den Cursortasten wie gehabt die Kamera steuern: links, rechts, hoch und runter, sowie mit Ctrl+CrsrHoch bzw. Ctrl+CrsrRunter die Kamera auf der Z-Achse vor und zurück bewegen.
Zusätztlich jetzt:

• mit jedem x- und X-Tastendruck die Pyramide um die X-Achse ein Grad vor- und zurückdrehen
• mit jedem y- und Y-Tastendruck die Pyramide um die Y-Achse ein Grad vor- und zurückdrehen
• mit jedem z- und Z-Tastendruck die Pyramide um die Z-Achse ein Grad vor- und zurückdrehen

zwei Pyramiden und beide rotieren

Was aber nun, wenn wir zwei Pyramiden erstellen wollen? Probieren wirs einfach mal, in der Hauptschleife, nach dem Aufruf der PyramidenSUB für die erste Pyramide einfach einen Verschiebe-Befehl anfügen und danach nochmal die PyramidenSUB aufrufen:

Das Programm mit diesen Änderungen kompiliert und gestartet, mit den Cursortasten die Kamera auf eine geeignete Position gesetzt zeigt sich beim "y"-Drücken folgende Animation:

Hier ist zu erkennen, daß viel mehr rotiert wird, als wir dies wollten :-O

Was passiert:
Die erste Pyramide, welche zentriert im Koordinatensystem steht, läuft richtig, sie dreht sich um Ihre innere Achse.

Aber unsere Verschiebung vor der zweiten Pyramide wird relativ zur Drehrichtung der ersten Pyramide verschoben, und da bei jedem Tastendruck(y) diese erste Pyramide um ein weiteres Grad gedreht wird, wird die Verschiebung für die zweite Pyramide um eben dieses weitere Grad in der Richtung geändert. Daraus ergibt sich dann, daß die zweite Pyramide um die erste rotiert, so wie der Mond um die Erde.
Gleichzeitig senden wir für den Aufbau der zweiten Pyramide nochmal die gleichen Gradzahlen für eine Rotation der zweiten Pyramide, diese Rotation erfolgt dann richtiger Weise um die innere senkrechte Achse dieser zweiten Pyramide.
Damit Rotiert diese zusätzlich noch um sich selbst.

HM. Überlegen. Eine Verschiebung nach einem Rotate richtet sich also nach der Gradzahl des Rotate-Befehls.

Richtig. Der Rotationswert wird ebenfalls auf dem Stack gespeichert! Also dort, wo wir im vorigen Kapitel OpenGL Zettel untergeschoben hatten. Auf diesen Zetteln steht also nicht nur die grad aktuelle Verschiebeposition, sondern auch der Rotationswert der drei Achsen.

Ja, dann, äh, klar, auch bei einer Rotation müssen wir vorher einen zusätzlichen Zettel unterschieben(push) dann rotieren, das Objekt rotiert anzeigen, und hinterher per pop den zusätzlichen, nun veränderten Zettel wegschmeißen. Nur so richtet sich alles, was danach kommt, nach der von uns gewollten Position.

Also, bevor wir die SUB für die erste Pyramide aufrufen, pushen wir einen zusätzlichen Zettel auf den Stapel. Nachdem die erste Pyramide angezeigt ist, popen wir diesen zusätzlichen Zettel vom Stapel (in Mülleimer), die zweite Pyramide wird dann vom Nullpunkt unserer 3D-Welt aus verschoben, genau so, wie wir das wollten.

Wir ändern also in der Hauptschleife bei den Pyramidenaufrufen:

So, jetzt paßts, die Pyramiden aus einer einzige SUB stehen wie geplant nebeneinander und drehen sich (nur) um die eigene, innere, senkrechte Mittelachse. Schön.

Das einzigste, was uns zu denken gibt, ist wenn man z.B.
- mit Z die beiden Pyramiden zur Seite neigt, um danach
- mit Y wieder um die senkr. Mittelachse der Pyramiden
drehen zu wollen, das läuft dann anderst!
Die drehen um die viertuelle, wirkliche senkrechte Achse, nicht um die durch die Z-Rotation gekippte eigentliche Achse der Pyramiden!
Das läßt sich für diesen speziellen Fall beheben, indem man die Reihenfolge der drei Rotationsbefehle in der Pyramidensub umkehrt, also zuerst um die Z-Achse, dann um Y und danach um X-Achse rotieren. Damit würden in dem erwähnten Beispiel die Pyramiden zur Seite gekippt werden und danach trotzdem um die eigene Mittelachse rotieren.
Wenn man nun aber in dieser Konstellation mit der umgekehrten Rotationsreihenfolge zuerst um die X-Achse dreht, um danach um Y zu drehen, ergibt sich das Problem dann wieder, was in der ursprünglichen Programmierung mit zuerst X, dann Y und zuletzt Z-Drehung nicht vorhanden war.

Wir merken uns also, man kann nicht wahllos einfach alle drei Richtungen für die Rotation angeben, man muß dabei die jeweils notwendige Reihenfolge der Drehbefehle beachten!

Zur Übersichtlichkeit das gesamte Listing hier nochmal:

Ist doch schon ganz interessant? Die Kamera bewegen, die Pyramiden drehen, egal, wo wir mit der Kamera hinfahren, die Pyramide drehen sich auf Tastendruck...

Aber eigentlich wollten wir die Kamera und nicht die Pyramide drehen? Blättern Sie um, dann gehen wirs an.

Gehe zu Seite  1  2  3  4  

Zusätzliche Informationen und Funktionen
Das Tutorial wurde am 17.08.2008 von Eastler_dart angelegt. Die aktuellste Version wurde am 22.07.2012 von Affemitwaffel gespeichert.	Bearbeiten     Versionen