Hallo,

ich habe noch einmal eine Frage zum engültigen Verständnis. Wenn ich ein Objekt mehrmals rotieren lassen möchte, dann mache ich dies wie folgt:

Rotation um - Z-Achse 90 Grad .

Nun dreht sich das Koordinatensystem mit, so dass nach der Rotation die Y-Achse auf der X-Achse liegt.
Will ich nun um die eigentliche y-Achse drehen, so drehe ich um die -X - Achse .


Es geht doch nicht, dass das Objekt an der Stelle liegen bleibt und die Achsen wieder in Ihren Ursprung gehen?
Also Y ist wieder die Y Achse und mein Objekt verharrt trotzdem in der Ebene nach der Rotation?

Ich speichere nach einer Rotation meine Matrix und hangel mich von einer Aktion zur Nächsten...

Daran fürhrt wohl kein Weg vorbei?


Vielen Dank . Ist mir sehr wichtig


Viele Grüße
SOA

Wenn ich dich richtig verstanden habe, sollte glPushMatrix bzw. glPopMatrix das tun, was du willst. Du benutzt erst glPushMatrix, führst deine Rotation durch und stellst danach mit glPopMatrix die vorherige Matrix wieder her, sodass du wieder vom Ursprung ausgehen kannst.

soa schrieb:

Ich hab eigentlich den Eindruck, Du beklagst Dich darüber, das das ganze so verwirrend und unanschaulich ist?


Was würdest Du denn wollen? Und das soll jetzt keine aggressive Frage sein.
Traude

anschaulicher wäre es, das objekt zu drehen und bewegen, anstatt die welt. darauf will er glaub ich hinaus. das kann man natürlich machen, ist aber wesentlich langsamer, da man jeden punkt einzeln rechnen muss.

_________________
Gruß McWurscht - sorry für's Posting.

Wer mal meinen bisher erfolgreichsten Erguss in Sachen Web-Programmierung sehen will: RCV

Aber das tut man doch - nur das Objekt manipulieren, meine ich. Für das Drehen der Welt ist die Kamera zuständig.

@Soa: hilft Dir vermutlich jetzt nicht viel?

jetzt hast du mich glatt ins straucheln gebracht. ich war die ganze zeit der meinung, das ich das weltkoordinatensystem verändere, nicht die vertices an sich. da werd ich gleich noch ma ne runde recherchieren.

_________________
Gruß McWurscht - sorry für's Posting.

Wer mal meinen bisher erfolgreichsten Erguss in Sachen Web-Programmierung sehen will: RCV

Hey, keine Panik. OpenGL transformiert nur die Vertices, die man hineinfüttert, weiter nichts.

@Soa: würde es Dir helfen, wenn wir miteinander gedanklich folgende Szene erzeugen: Ein Propeller-Flugzeug, das grade abhebt, gesehen aus einiger Entfernung.
Vorgabe1: wir müssen das ohne OpenGL machen, also ein Software Renderer.
Vorgabe2: wir müssen genauso arbeiten wie OpenGL (ich wüßte auch gar nicht, wie ich es sonst machen sollte)

Hättest Du Lust? Ich kann aber erst heute abend, denn heute ist Sonntag und da gibts ein Familienessen und rate mal, wer für den Constructor der Wiener Schnitzeln zuständig ist.

Ich bin dabei Das wäre prächtig Traude.

glPopMatrix() glPushMatrix() ist wohl nicht das was ich suche. Ich möchte ein Objekt um verschiedene Achsen drehen lassen:

Mein Code dazu sieht wie Folgt aus:



Verzeiht den Java Code. Im Grunde aber wie Delphi: Zuerst lade ich die gespeicherte Matrix . Dann wird das Objekt um winkel Einheiten gekippt. Ich setze das Objekt auf die Achse, damit das Objekt nicht um den Schwerpunkt kippt. Bei 90 Grad ist der Kippvorgang beendet. Die Matrix wird wieder gespeichert und die nächste Translation oder Rotation wird eingeleitet.

@Traude : Es wäre schön, wenn ich natürlich immer die gleichen Achsen hätte , wenn ich eine Rotation durchführe. Dann wäre es ja auch egal um welche Achse ich drehe. Alles wäre flexibler...


VG

Du benutzt Euler-Winkel, nehme ich an? Also ich meine: Drehungen um die X-/Y-/Z-Achse, um die Drehung um eine beliebige Achse zu erreichen?

Ja, genau so ist es. Ich drehe mein Objekt im Koordinatenursprung um eine Achse mit

gl.glRotated(90, 0, 0,-1);

Mit Euler-Winkel bin ich nicht vertraut. Würde es Dir etwas ausmachen, wenn wir die Rotation um eine beliebige Achse benutzen? Das ist genau das gleiche, wie es glRotate macht: man braucht einen Winkel (in Grad) und einen Vektor (normalisiert).

OK. sehr gern. Wie funktioniert das ?

Ich muss dann bestimmt gl.glNormal3f(1, 0,0); benutzen. Aber wie soll dann die Rotation aussehen ?

Das geht eigentlich gut mit glRotate. glRotate enthält nämlich genau das:
1) einen beliebigen Winkel und
2) eine beliebige Rotationsachse.

Allerdings bin ich ein bisschen verwirrt bei Kombinationen von glRotate und glTranslate, weil:

Sagen wir, ich habe ein ganz normales Quad, das in der XY-Ebene liegt.

Wenn ich zuerst glTranslate und dann erst glRotate verwende, dann erwarte ich eigentlich, dass mich das Objekt umkreist. Wäre ja nur zu logisch, denn ich schiebe es aus dem Koordinatenursprung heraus, damit hat es jetzt eine Entfernung vom Koordinatenursprung - also einen Radius - und wenn man es dann rotiert, müsste man eigentlich erwarten, dass es eine Umlaufbahn um den Koordinatenursprung einschlägt. Das tut es aber nicht. Es kreist vor meinen Augen um seine eigene Achse.
Ein solches Verhalten würde ich erwarten, wenn ich das Objekt zuerst rotiere und dann verschiebe.

Wenn ich zuerst glRotate verwende und dann erst glTranslate, schlägt es eine Umlaufbahn um den Ursprung ein. Und das verwirrt mich vollends, denn jetzt würde ich erwarten, dass es vor meinen Augen kreist. Es verhält sich also genau umgekehrt, wie ich es erwarten würde.

Das habe ich solange nicht verstanden, bis ich mir eine eigene Matrix gebastelt habe, die Rotationen um eine beliebige Achse durchführen kann und die auch Translationen ausführen kann.

Zunächst habe ich die Werte für die 3X3 Rotationsmatrix bestückt. Und dann habe ich den Verschiebevektor EINFACH IN DIE LETZTE SPALTE EINGEFÜLLT. Eine solche Matrix rotiert immer zuerst und verschiebt erst nachher. Das kann man sich nicht aussuchen.

Dann ist mir der Geduldsdfaden gerissen und ich habe folgendes gemacht: ich erzeuge Rotationsmatrizen und Translationsmatrizen immer getrennt. Diese werden dann multipliziert. Das Ergebnis ist immer so, wie ich es erwarte.

Schön zu sehen ist das an der folgenden Funktion, die eine Rotationsmatrix für ein Gelenk erzeugt (Delphi ist auch leicht zu lesen ):



Zur Erläuterung: Die Gelenkpunkte werden mit der Gelenkposition in den Ursprung verschoben (invers), dann rotiert und dann wieder zurückverschoben (revers). Ich bitte um Entschuldigung für das Quaternion. Ich habe vor kurzem auf Quaternions umgestellt. Das Ding namens ARotation ist so etwas, wie Du es von glRotate gewohnt bist: ein Winkel und eine Achse.

Ich wollte das nur vorausschicken, denn das ist wichtig zu wissen: man muss sich auf die Transformationsmatrizen verlassen können. Wenn ich sage: Rotieren, dann muss mir klar sein, dass meine Punkte um eine Achse rotieren, die durch den Ursprung geht. Beim Verschieben heisst es einfach Verschieben eben um einen gegeben Vektor. Die Reihenfolge ist durch die Reihenfolge der Matrizenmultiplikationen gegeben, und zwar wie oben zu sehen ist, von links.

Warnung: ich mache jetzt Mehrfachposts, um die einzelnen Punkte besser voneinander abzugrenzen. Und ich behellige Dich nicht mehr mit Matrizendetails.

Punkt1: Wir sehen uns unser Flugzeugmodell an und kümmern uns um die grundsätzliche Transformation.

Wir haben also ein Flugzeugmodell geladen und können es auf dem Bildschirm sehen. Wir sehen es von vorne, dh. wir sehen direkt auf den Rotor; die OpenGL Modelle "schauen" nach Z-Plus, also sie schauen Dich an. Bevor wir nicht irgendwas tun, sehen wir vermutlich nur die Teile vom Flugzeug, die in den Z-Minus-Bereich ragen. Sowohl das Modell als auch die Kamera befinden sich auf dem Koordinatenursrpung, also wir "stecken ineinander".

Wir wollen gerne, dass das Flugzeug von links nach rechts startet und dann abhebt, und wir wollen es dabei von der linken Seite sehen.

Was ist als erstes zu tun?

Lustigerweise ist das, worum man sich in OpenGL immer zuerst kümmert, nämlich die Projektion, sicher erst das letzte, was zu tun ist.

Wir wollen ein Flugzeug, dessen Rotor rotiert. Noch dazu alles so, dass das Flugzeug Loopings machen und dabei gleichzeitig um seine eigene Achse rotieren kann.

Wir kümmern uns zunächst um die Tranformationsmatrix unseres Flugzeugs insgesamt. Nach meinem Verständnis ist das Flugzeug zunächst mit der Y-Achse um 90 Grad (gegen den Uhrzeigersinn) zu rotieren. Dann sollte es eigentlich nach rechts schauen (von mir aus gesehen). Verschieben wollen wir es eigentlich nicht. Es soll auf dem Koordinatenursprung bleiben. Diese Matrix berechnen wir und merken wir uns.

Jetzt nehmen wir uns eine kleine Anleihe bei gluLookAt. Dieses verlangt nämlich einen Forward und einen Upward-Vektor. Tja, und so etwas brauchen wir auch. Es handelt sich hier um das persönliche Koordinatensystem des Flugzeugs. Es braucht nur zwei Vektoren, weil es sich den Dritten jederzeit aus den zwei anderen berechnen kann.

Wir merken uns hier aber alle drei Vektoren. NOTA BENE: die OpenGL Modelle schauen nach ZPlus. Unser Anfangs-Vorwärts-Vektor ist also der ZPlus-Vektor,
analog dazu ist der Aufwärts-Vektor der Y-Plus-Vektor und der Rechts-Vektor der X-Minus-Vektor. Immer, wenn wir die Matrix verändern, multiplizieren wir die Anfangs-Richtungsvektoren mit der Matrix und voila, wird wissen immer wo wir sind.

Und jetzt möchte ich das Flugzeug abheben lassen. Es hat ein persönliches Koordinatensystem .... Ich schlage vor, dass wir als Rotationsachse den transformierten Rechts-Vektor benutzen. Wir erzeugen also eine Rotationsmatrix, deren Rotationsachse der transformierte Rechts-Vektor des Flugzeugs ist (Du musst Dich da ins Flugzeug hineindenken), Winkel beliebig. Richtung? Öhm - da muss ich mich auch ins Flugzeug hineindenken, also vermute ich mal: auch gegen den Uhrzeigersinn - müsste man aber noch überprüfen. Und diese Rotationsmatrix multiplizieren wir zur ersten dazu.

Als Folge davon sollten wir das Flugzeug von links sehen und es ist leicht nach oben gekippt (der persönlich Vorwärtsvektor schaut schräg nach oben). Der Rotor bewegt sich derzeit noch nicht.

Was wäre eigentlich, wenn wir das Flugzeug auch noch um seine eigene Achse rotieren lassen wollten? Also, da gibt es jetzt diesen persönlichen Vorwärtsvektor, und den könnte man glatt als Rotationsachse verwenden....

Allerdings müßte man sich dann die Daten für drei Rotationen mitführen: Drei Winkel, drei Achsen. Und nicht vergessen, bei jeder Transformation muss man das persönliche Koordinatensystem auf den neuesten Stand bringen. Das ist aber nicht so schwer: Die Matrix, die man hat, ist immer nur EINE. Und mit dieser müssen die Anfangs-Richtungsvektoren multipliziert werden.