Hallo OpenGLer,

Bevor ich anfange mein Problem zu erläutern, möchte ich gerne mitteilen, dass ich OpenGL in java programmiere.
Das sollte aber keine Hürde darstellen, da es sich bei meinem Problem ausschließlich um OpenGL spezifische Themen handelt
und die Schnittstelle OpenGL und deren Arbeitsweise in allen sprachabhängigen Implementierungen gleich ist.


Um mein Problem zu erläutern, stelle ich kurz das "Projektchen" vor an dem ich arbeite:

Es geht darum einen Mars-Rover zu konstruieren den man über die Mars-Oberfläche fahren lassen kann.
Die Konstruktion des Rovers hat sehr gut funktioniert und ist abgeschlossen. Es gibt auch schon eine "Plane" über die man
den Rover bewegen kann. Er kann sich mit Hilfe von zwei Richtungsvektoren vorwärts, rückwärts und seitlich bewegen. Alles wunderbar!
Um den Rover nicht aus den Augen zu verlieren wenn ich mit ihm durch die Gegend cruise, habe ich zunächst meine Kammera an die Position
des Rovers gehängt. Die Position wird bei Bewegungsveränderungen des Rovers als "globale Koordinate" gespeichert und mit entsprechenden
Versatzwerten an die gluLookAt() Funktion übergeben.



Somit folgt die Kamera immer dem Rover. Allerdings vollzieht Sie keine Drehungen.
D.h. wenn ich den Rover nach links fahre, bewegt sich die Kammera auf der X-Achse auch nach links, die Rotation des Rovers wird hierbei allerdings nicht
nachvollzugen.
Soweit war das auch in Ordnung, schließlich ist es ja auch ganz nett sein Modell mal von der Seite zu betrachten.
Nun verfügt so ein Rover natürlich auch über eine Onboard- oder EgoCam, welche an einer bestimmten Position des Rovers befestigt ist und deren Blickrichtung
abhängig von der Ausrichtung des Rovers ist.
Somit könnte man dann wunderbar zwischen beiden Perspektiven hin und her switchen.


Und da fingen meine Probleme an:

Zuerst habe ich die zweite kamera (Onboard), wie die erste auch, einfach an die globale Position des Rovers gekoppelt.
Jetzt hat die kamera den Rover wie gewohnt, allerdings auf der neuen Kameraposition, verfolgt. Leider konnten, wie schon erwähnt, die Rotationen nicht nachvollzogen werden.
Wenn ich also den Rover nach links gesteuert habe, dann hat sich auch die Kamera nach links bewegt, allerdings hat sie weiterhin entlang der negativen Z-Achse geschaut und nicht in
Fahrtrichtung des Rovers.

Als nächstes habe ich mir überlegt, dass ich die Rotationen, und damit die Ausrichtung, des Rovers ja bereits berechne um den Rover auszurichten. (Richtungsvektoren)
Also warum dann nicht diese Rotationen auf die Koordinaten (Eye, Center) der Kamera direkt übertragen?
Jaaa, hört sich erst mal leicht an, hat sich dann aber in der Realisierung als sehr aufwendig erwiesen. Schließlich muss sich die Sichtlinie (Eye-Center) dabei um einen
vom globalen Koordinatensystem unabhängigen Punkt rotieren und die Parameter von gluLookAt() beziehen sich auf das globale Koordinatensystem.
Dies erschien mir alles zu umständlich.
"Desto mehr Schritte man macht umso mehr kommt man vom Weg ab"; hat glaub ich mal irgend ein weiser Mann gesagt

Mir ist dann eingefallen, dass die Position der zweiten Kamera ja abhängig von den Translationen / Rotationen die zum zeichenen der Kamera (also des Kameramodells am Rover)
bereits in der Modelview-Matrix gespeichert sein müssten. Also warum dann nicht anstatt eines gluLookAt() Aufrufes das laden einer Matrix die alle notwendigen
Translationen bereits enthält. (also die Translationen die die globale Position des Kameramodels bestimmen, abhängig von der Position des Rovers)

Allerdings weiß ich, dass die Modelview-Matrix nicht um sonst Model-View-Matrix heißt.
Soweit ich das richtig verstanden habe (Verbesserungen eurerseits sind gewünscht) beinhaltet die ModelView-Matrix sowohl die View-Information (also die Translationen
bis zum ersten Zeichnen als Analogie zum Positionieren der Kamera) als auch die Model-Informationen (also die Translationen nach dem Aufstellen der Kamera zur Ausrichtung
der Modelle).

Also müsste ich doch eigentlich nur die View-Informationen aus der Modelview-Matrix herausrechnen und hätte eine Matrix die die globale und Viewunabhängige
Position der Kamera bestimmt. Zumindest hat sich diese Idee in meinem Hirn festgesetzt und kann da nicht ohne fremde Hilfe weiterentwickelt oder verworfen werden.
Denn hier stoße ich an meine Grenzen. Ich bin nicht gerade ein Mathe-Ass und Matrizenrechnung habe ich auch nur so nebenbei mitbekommen.
Mit OpenGL beschäftige ich mich auch erst seit ein paar wochen.
Soll heißen, so ein super Verständnis hinsichtlich Matrizenrechnung hat sich bei mir noch nicht aufgebaut, ich bin aber trotzallem lernfähig


Zusammenfassung:

Es geht also darum eine Kameraposition abhängig von den globalen Koordinaten eines translierten Objektes zu erzeugen.
Mir wäre es am liebsten anstatt der gluLookAt() Funktion mit "globalen" Kamerakoordinaten
eine eigene lookAt()- Funktion mit Übergabe einer Matrix (als Positions- und Ausrichtungsanweisung gegenüber dem globalen System)
und lokalen Kamerakoordinaten welche sich auf die übergebene Matrix beziehen zu benutzen.
Dies könnte man auch gut in einer Klasse kapseln.
Dazu benötige ich aber eine Möglichkeit die erforderliche Matrix aus der Objektposition (Modelview-Matrix des Objektes) zu berechnen.


Da ich jetz nen ganz schön langen Text hier hingezaubert habe der den einen oder anderen von euch sicher erst mal in Verwirrung zurücklässt,
hier ein paar Fragen die euch bei der Beantwortung unterstützen sollen:

1. Bin ich total auf dem Holzweg oder beweg ich mich schon in die richtige Richtung?
2. Wenn ich mit meiner Matrizen-Theorie richtig liege, wie kann ich die Model-Informationen aus der Modelview-Matrix extrahieren?
3. Wie würdet ihr das Problem lösen?

PS: Seit bitte nicht allzu hart wenn das, was ich hier geschrieben habe, alles riesen Müll ist.
Danke schon mal für jede Antwort!

Also, es ist sicherlich möglich die Model-Matrix aus der ModelView-Matrix zu extrahieren. Dafür musst du die ModelView-Matrix aber erst einmal haben. Diese enthält die View-Matrix...aber die willst du ja berechnen


Ok, du hast also zwei Richtungsvektoren? Einer zeigt immer dahin wo beim Rover vorne ist und der andere dahin wo beim Rover links (oder rechts) ist, verstehe ich das richtig?
Wenn nein: Genau solche Vektoren brauchst du
Wenn ja:
Du sagst du hast bereits die globale Position des Rovers. Außerdem hast du sicherlich einen Vektor der nach oben zeigt, z.B. einfach (0,1,0) oder das Kreuzprodukt aus den beiden anderen Richtungsvektoren. Was die fehlt ist die Position der Kamera:

Die Kamera setzt du dann mit:

Über die Faktoren distanceBehind und distanceAbove kannst du steuern wie weit die Kamera hinter dem Rover zurückbleiben soll bzw. wie weit sie sich über dem Rover befinden soll.

Die Onboard-Kamera funktioniert eigentlich genauso, der Unterschied ist nur, dass du die Rollen der berechneten Punkte vertauscht. Du wählst den Rover als Kameraposition und berechnest einen Zielpunkt vor dem Rover.

Das wäre schon alles

_________________
Yeah!

Zusatz für den Fall das du die Model-Matrix (nicht ModelView) hast:
Angenommen deine Matrix wird in der folgenden Reihenfolge an OpenGL übergeben

und weiterhin angenommen dein Rover ist so modelliert das "Vorne" in Richtung der X-Achse ist und "Oben" die Y-Achse, dann ist:
(_11, _12, _13) der Vorne-Vektor
(_21, _22, _23) der Oben-Vektor
(_31, _32, _33) der Links-Vektor (oder Rechts)
(_41, _42, _43) die Position
_14, _24 und _34 sind immer 0, _44 ist immer 1.

_________________
Yeah!

Das Thema was du anschneidest ist in den beiden MatheTutorial "Tutorial Objekt gedreht und dennoch nach vorne bewegt" beschrieben.
Schau doch auch nochmal da rein.

_________________
Blog: kevin-fleischer.de und fbaingermany.com