Hallo!

Ich habe eine Frage die auf Anhieb simpel aussieht, bei der Umsetzung dann aber doch wesentlich komplizierter ist als erwartet. Ich hätte gerne eine User/Kamera-Steuerung mit der man sich völlig frei im Raum bewegen kann und zwar im Stile eines Flugsimulators bzw. Descent. Also völlig freie Drehung um alle drei Achsen; Vorwärts- und Seitwärtsbewegung in die Richtung in die man schaut. Das Problem ist, dass sich in jedem Schritt alle drei Drehwinkel (also um x-, y- und z-Achse) ändern können und da sehe ich dann vor lauter sin's und cos's nicht mehr was ich mache.
Solange man den Benutzer in der Bewegung auf eine Ebene beschränkt ist ja noch alles ganz einfach, aber wenn man davon ausgeht dass man irgendwie schräg in der Luft hängt, dann um die eigene Achse rotiert und nach oben "fliegt", wird's chaotisch...

Eine Idee wäre, alles über Matrizen zu machen, aber dann kommt man in das Problem dass bei jeder Usereingabe die Matrix mit einer neuen Matrix multipliziert werden muss was dann mit der Dauer mit Sicherheit zu sehr unschönen Effekten führt (Verzerrung?).

Hat jemand schon einmal so etwas programmiert und kann es zur Verfügung stellen? Oder hat jemand einen heissen Tipp wie man so etwas am geschicktesten anstellt?

Quaternionen verwenden - oder doch auf Matrizen zurückgreifen und diese alle paar Frames zu normalisieren und die Achsen normal aufeinander stellen, damit diese nicht degenerieren:

_________________
Viel Spaß beim Programmieren,
Mars
http://www.basegraph.com/

Quaternionen sind hier die eleganteste Art die Orientierung zu speichern, weil sie die 3 Achsenvektoren sehr kompakt speichern. Wenn man sich z.B. nach rechts oder links dreht, dreht man sich nicht um die normale Achse sondern um den Achsenvektor, den man als oben definiert hat. Bei den anderen Rotationen ist es ähnlich.

So kann man Quaternionen erstellen:

Ein Quaternion q=(x,y,z,w) erstellt man aus einer Achse a und einem Drehwinkel w folgendermaßen:

q=(a.x*sin(w/2),a.y*sin(w/2),a.z*sin(w/2),cos(w/2))

Zwei Quaternionen q1,q2 multipliziert man folgendermaßen:

q3=q1*q2=
(q1.w*q2.w-q1.x*q2.x-q1.y*q2.y-q1.z*q2.z,
q1.w*q2.x+q1.x*q2.w+q1.y*q2.z-q1.z*q2.y,
q1.w*q2.y+q1.y*q2.w+q1.z*q2.x-q1.x*q2.z,
q1.w*q2.z+q1.z*q2.w+q1.x*q2.y-q1.y*q2.x)

Für das Rendern konvertiert man das Quaternion dann in eine Matrix in OpenGL Reihenfolge:

(1-2*(q.y*q.y+q.z*q.z),2*(q.x*q.y-q.z*q.w),2*(q.x*q.z+q.y*q.w),0,2*(q.x*q.y+q.z*q.w),1-2*(q.x*q.x+q.z*q.z),2*(q.y*q.z-q.x*q.w),0,2*(q.x*q.z-q.y*q.w),2*(q.y*q.z+q.x*q.w),1-2*(q.x*q.x+q.y*q.y),0,0,0,0,0)


Eine sehr viel einfachere Möglichkeit ist, direkt die OpenGL Matrizen zu benutzen und die Matrix nicht bei jedem Frame neuzusetzen, sondern bei Bewegungen immer nur mit glRotate zu drehen und mit glTranslate zu verschieben.

Vielen Dank für die Antworten, das hilft mir schon deutlich weiter.

Schau mal bei den Tutorials vorbei. Hab mal was zu dem Thema verfasst...

_________________
Und was würdest Du tun, wenn Du wüsstest, dass morgen Dein letzter Tag auf dieser Erde ist?