Hallo, =)

ich sitze jetzt seit ein paar Tagen fest und aus meiner Suche resultierten viele Fehlversuche. Deswegen brauche ich professionelle Hilfe
In meinem Programm befindet sich ein Würfel. Dieser wird durch glRotate Manipuliert. In dieser Reihenfolge;
glRotate(x, 1, 0, 0)
glRotate(y, 0, 1, 0)
glRotate(z, 0, 0, 1)
Mein Problem ist es jetzt, dass ich wissen möchte in welche Richtungen die drei Achsen des Würfels nach der Manipulation zeigen. Es können in meinem Program maximal zwei Achsen des Würfels bewegt werden. Solange sich nur eine Achse verändert bekomme ich es auch hin, dank einfacher Rotationsberechnung, wie z.B.:



Aber wenn es eine Rotation auf der X Achse gegeben hat, haben sich die Y- und die Z-Achse des Würfels verschoben und ab da weiss ich nicht wie ich diese Verschiebung für die nächste Berechnung berücksichtigen muss. Hoffentlich habe ich es verständlich genug ausgedrückt ... hm ^^ - ich habe noch einmal ein Bild im Anhang wo ich die Problematik mit "Paint" optisch aufbereitet habe *g*

Gruß stoned4u

Gehe ich richtig in der Annahme das ich meine Matrix mit der Matrix multiplizieren muss, die aus der ersten Rotation hervorgeht? So das ich meinen Würfel in der neuen Matrix wieder von vorne sehe, ich ihn dann um die Y-Achse drehen kann und ihn dann wieder in die erste Matrix zurück multiplizieren muss? Das wird ja dann noch lustig =D aber wenn ich schon mal dabei bin dann richtig ^^ haltet mich bitte auf wenn das auch wieder nur ein Hirngespinst ist *g*

Gruß stoned4u

Wenn mich nicht alles täuscht müssten die drei achsen die ersten drei Zeilen der Matrix sein... ohne die jeweils letzte Spalte.

Wofür brauchst du das denn? Vielleicht gehts ja, ohne die Matrix zu zerpflücken...

Gruß Lord Horazont

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

@stoned4u:
Um so etwas professionell in den Griff zu kriegen, merkt man sich
a) die drei Matrizen
b) die Reihenfolge, in der sie angewendet werden.

Wenn man den Würfel wieder von vorne sehen will, macht man Folgendes:
a) man invertiert die drei Matrizen
b) man wendet sie in genau umgekehrter Reihenfolge auf das Objekt an.

Und warum sollte ich Dich aufhalten? Ich schau Dir hier so lange zu, bis es Zeit ist, die Rettung zu verständigen.

Aber wenn Dir das irgendein irrer Mathematiklehrer aufgebrummt hat, hast Du mein volles Mitleid.

Also ich hab nix gegen Matrix zerpflücken ^^ ich denke das sollte ich früher oder später eh verstehen.

Ich habe bislang einen Würfel auf den ich schaue. An der Kameraposition verändere ich nichts. Den Würfel rotiere ich durch Mausbewegungen auf der x und y Achse (zukünftig auch z) mit glRotate. Wenn mich die y Achse des Würfels dann allerdings anschaut und ich per Klick den Würfel wieder greife um ihn bewegen zu können, rotiert er nicht nach links oder rechts, sondern die sichtbare Seite dreht sich einfach nur um sich selbst. Das liegt daran das der Würfel sich auf der z Achse drehen müsste. Damit mein Program dies aber umsetzen kann, muss es wissen in welche Richtungen die Achsen des Würfels schauen.

Mir wäre schon geholfen, wenn mir jemand ein Beispiel zeigen könnte, wo ein Vertex auf einer beliebigen Achse rotiert wird. Aus den Formeln die ich bislang gefunden habe werde ich nicht schlau und ein Beispiel für eine Formel findet man so selten (in diesem Fall noch keine)...
Leuten wie mir wäre damit !!!emens!!! geholfen... aber mathematiker sind ja faule Menschen hat man mir immer wieder versichert =)

Gruß stoned4u

Hey, sooo schwarz musst Du Mathematiker aber nicht sehen.


Wenns weiter nichts ist: glRotate rotiert auf einer beliebigen Achse. glRotate arbeitet nach dem Winkel/Achse-Prinzip: der erste Wert, den Du angibt, ist der Winkel, um den das Zeug gedreht werden soll, und die drei folgenden Werte sind als Vektor zu interpretieren, der die Rotationsachse ist. Wenn Du etwas um die Achse [1/1/1] drehen willst, dann schreibst Du einfach glRotate [Winkel,1/1/1]. Rotationsachsen müssen normalerweise normalisiert (= auf die Länge 1 gebracht) werden. glRotate sollte den Vektor eigentlich selber normalisieren.

Du brauchst nur ein Objekt, ein gluPerspective, eine Einheits-Modelviewmatrix und ein glRotate - das genügt. Also ganz der übliche Kram denn Du bereits in Deinem Programm drin hast. Die Achse, um die Du rotieren willst, kannst Du Dir aussuchen.

In diesem Fall meinte ich ein Rechenbeispiel für die Rotation um eine beliebige Achse, also nicht um x, y oder z. Genauer: In meinem ersten Beitrag ist eine Grafik und bei 2. wurde der Würfel mit glRotate 45° auf der x Achse gedreht, dadurch haben sich die z und y Achse des - Würfels - verschoben. Ich möchte den Würfel nun um seine eigene y Achse drehen. Diese Achse liegt zwischen der eigentlichen y und der eigentlichen z Achse. Das muss ich machen um meine glRotate Vorgänge nach zu "äffen" damit ich an die neuen Koordinaten des Würfels komme um dann zu bestimmen welche Seite des Würfels nach oben sieht, welche nach rechts und welche nach vorne. =) Da ist jetzt nur noch die Sache mit der Mathematik ^^

Gruß stoned4u

Edit: Es sei noch erwähnt das ich OpenGL ES verwende und ich keine APIs ein beziehen kann, es gibt glaube ich welche die Funktionen enthalten wie RotateVektor oder GetVektor.

OffTopic: Unabhängig von deinem Problem: Bitte berichte uns ausgibig von OpenGL ES und deinen Erfahrungen damit. Auf dem Gebiet fehlen uns noch etwas die Erfahrungsträger. Gern darfst du auch deine Erkenntnisse in Wiki schreiben. Falls du also Sachen gelernt hast wie z.B. was ist schnell, was langsam, was sollte man machen, was nicht etc. dann ruhig im Forum mal einen Post abgeben. Man darf hier nicht nur Fragen, sondern auch mal solche Statements abgeben.

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

Ok aber ich bin neu in dem Bereich. Also OpenGL ES ist mein erster OpenGL Exkurs. Vorher grob DirectX.
Aber die Tutorials auf dieser Seite waren bislang alle sehr gut umzusetzen ^^

Wenn ich jetzt zusammenfassen darf, was Du willst: Du möchtest die Orientierung von Deinem Würfel wissen, also eine Antwort auf die Frage: „Wohin schaut er?“

Ich rechne das eigentlich niemals per Hand aus, daher kann ich Dir das auch nicht vorrechnen. Ich mache das so: Ich habe

*** ein Objekt, in Deinem Fall also der Würfel, und ich gebe dem Objekt
*** ein persönliches Koordinatensystem mit, in Form von 2 Vektoren mit den Namen: „Forward“ (= [0,0,1], die positive Z-Achse) und „Upward“ (= [0,1,0], die positive Y-Achse). Den dritten Vektor kann man sich immer mit dem Kreuzprodukt ausrechnen. Schlussendlich verpasse ich dem ganzen Gebilde noch eine
*** Matrix; wenn wir nur Rotation brauchen, genügt eine Matrix 3x3.

Was tun wir nun:
*** Wir erzeugen die Matrix, die sich aus einem Winkel und einer Achse ergibt
*** Dann rotieren wir den Würfel, indem wir alle Vertices des Würfels mit unserer Matrix multiplizieren. Wir brauchen daher zwei Repräsentationen des Würfels: eine rotierte und eine nicht-rotierte, denn für den nächsten Frame brauche ich ja wieder den jungfräulichen Würfel.
*** Dann rotieren wir die Vektoren Forward und Upward, indem wir sie ebenfalls mit unserer Matrix multiplizieren. Wieder brauchen wir eine rotierte und eine nicht rotierte Version.

In welche Richtung der Würfel schaut, wird in einem solchen System immer durch den rotierten „Forward“-Vektor angegeben.

Was noch geklärt werden muss: wie komme ich zu einer Routine, die mir eine solche Matrix erstellen kann? Also ich habe natürlich eine. Die Geometry.pas scheint keine zu haben, aber im Internet gibts das, z.B. hier: http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToMatrix/index.htm


EDIT: was aus dem oben Gesagten klar ersichtlich sein sollte: Ich brauche die beiden Vektoren gar nicht. Es reicht, wenn ich meine Matrix habe. Wenn ich mich bei der Erstellung der Matrix an die OpenGL-Konventionen halte, dann brauch ich auch keine rotierte Version des Würfels im Hauptspeicher erzeugen. Ich übergeben dann nur meinen unrotierten Würfel an OpenGL und werfe die Matrix hinterher mit glMultmatrix. Die rotierten Positionen des Würfel weiß ich jetzt nicht, aber wenn ich sie brauchen sollte, kann ich sie mit jederzeit erzeugen, weil ich meine Matrix ja immer noch habe. Man kommt also letztendlich zu dem Schluss, dass neben dem (unrotierten) Modell nur die Matrix nötig ist, um alle Dinge in Erfahrung bringen zu können, die man braucht.

Ich versteh zwar nicht das was Traude vorgeschlagen hat, aber wenn es nur um die Achsen geht, kann man wirklich einfach die Achsen ohne die Transformation mit der Matrix nach der Transformation multiplizieren und schon sind sie gedreht.

Also in der Art:

Ich glaube ich kann dem folgen =P und ich vermute das ist ein leichterer Weg als mein jetziger - auch erstmal danke für den Link. Das werde ich mir noch genauer ansehen. Jetzt beschäftige ich mich gerade noch mit der Rotation um eine beliebige Achse, denn ich glaube das verstehe ich jetzt auch langsam und wäre ja doof dann aufzuhören ^^ darum mache ich das noch mal bis zum Ende. Ich melde mich aufjedenfall wenn es was neues gibt oder ich mich an den anderen Lösungsweg mache =)

Hier nochmal gute Links falls hier in Zukunft wer vorbei kommt der nach Rotation um beliebige Achsen auf diesen Thread gestoßen ist:
http://www.mi.fh-wiesbaden.de/~schwan/Vorlesungen/GenCG/Skripte/GenCGUS2.pdf
http://stud-in.fh-swf.de/Friedrich.Huber/documents/Formelsammlung%20Computergrafik.pdf

Gruß stoned4u

@Schläfer:
Das ist witzig: Du sagst, Du verstehst nicht was ich sage, aber Du machst dann genau das Gleiche wie ich. Die Matriix, die OpenGL drin hat wird ja auch irgendwie erzeugt, das ist ja nix Mystisches. Das ist ja das Tolle an OpenGL: dass es so logisch ist. Und das bedeutet auch, dass ich mir die Matrix, die gefordert ist, auch selber machen kann.

Und ihr beide macht wiederum genau das, was im DGL Tutorial: "Tutorial Objekt gedreht und dennoch nach vorne bewegt" und "Tutorial Objekt immer um eigene Achse drehen" steht.

@Stoned: bei uns in den Links findest du noch das CompGeo Script. Das ist ziemlich gut, und kann auch als Nachschlagewerk dienen.

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

@Traude / @Schläfer
Ok so habe ich es jetzt gelöst! Und hierzu schonmal eine Anmerkung zum OpenGL ES eine Matrix Multiplikation sieht dort wie folgt aus:



(Ich schreibe in ObjC)

OpenGL ES stellt
eine Matrix in einem
ein Dimensionalen
Array da,

0 4 8 12
1 5 9 13
2 6 10 14
3 7 11 15

deswegen konnte ich die Tutorials nur mit Fehlern versuchen zu verstehen... schwierig ^^ sollte ich mich wohl drum kümmern mit einer Anmerkung

=============

Nun habe ich ein anderes Problem ^^ aber es geht immer noch um Rotationen, zur Not verzichte ich aber erstmal auf dieses "Feature". Folgendes:
Mein Würfel wird ja in dieser Reihenfolge gedreht X, Y, Z. In meinem Beispiel jetzt einmal um jeweils 90°.
Noch immer ist meine Kamera am selben Punkt wie sonst. So wie der Würfel nun vor mir "steht"
möchte ich ihn aber noch ein weiteres mal um seine X Achse drehen. Da meine Rotations-Reihenfolge aber
X, Y, Z ist, wird die erneute X Rotation ja mit zu der ersten gezählt (X, Y, Z sind globale Variablen)
und jeder weiss nun wie unerwartet die Bewegung des Würfels wird ... =D

Muss ich nun einen Rechenweg finden der X, Y, Z so umrechnet das am Ende die gewünschte Drehung resultiert?
Oder geht dies auch über Matrizen?
Oder lasse ich es lieber? ^^

Ich zerbreche mir schon mal den Kopf =)

EDIT: Ich nehme an, wenn ich die X Achse manipulieren möchte muss ich mich auf Y oder Z konzentrieren und lediglich dort addieren/subtrahieren ich versuchs mal ^^