Objekt unabhängig von Rotation immer nach oben bewegen.

[Hix]

Hallo

Ich arbeite mich gerade in OpenGL ein und habe ein kleines Problem bei dem ich nicht weiterkomme. Und zwar möchte ich ein Objekt immer nach oben bewegen, auch wenn die gesamte Szene rotiert ist. Mit oben meine ich nicht entlang der y Achse, sondern immer in Richtung der obereen Bildschirmkante. Wenn ich nun die gesamte Szene um z.B. 10 Grad im Uhrzeigersinn drehe bewegt sich das Objekt nach schräg rechts oben. Ich will aber dass es sich auch dann gerade nach oben bewegt. Ich spiele nun schon seit Stunden damit herum, und irendwie ist es mir sogar peinlich deshalb nachfragen zu müssen, denn so schwer dürfte das eigentlich nicht sein. Kann mir vielleicht jemand weiter helfen?

[The_Real_Black]

Man muss die Matrizen Reihenfolge beachten ggf mehere aufteilen. Könntest du den Part vielecht Posten mit dem du dein Objekt bewegst?
Grob kann man sagen Skalieren * Rotieren * Verschieben ist die Reihenfolge für das Objekt dann muss man noch die World Matrix setzen damit alles verschoben wird.

Edit:
Rotation um Mittel Punkt: Verschieben * Rotieren

In deinen Fall: Skalieren * Rotieren(t) * Verschieben nach oben
Natürlich sollte man die Welt- und Viewmatrix auch gesetzt haben.

[Eisflamme]

Hi,

obere Bildschirmkante ist so eine Sache. Vielleicht reichst es dir aber auch schon, den y-Wert einfach zu erhöhen. glTranslatef addiert zum Positionsvektor den jeweiligen transformierten Vektor, wenn du also z.B. 90° um die y-Achse rotiert hast, ist der x-Vektor halt nicht mehr "1 0 0" (was der ersten Spalte entspricht) sondern "0 0 1" oder so ähnlich. Jdf. kannst Du Mal probieren bei der Matrix des Objektes einfach nur den y-Positionswert, also Spalte 4 Zeile 2 zu erhöhen, vll. reicht das ja schon.

Viele Grüße

[LPVOID_CH]

Das "oben" in der 3D Szene (World Space) ist nicht das gleiche "oben" des 2D Viewports (Screen Space). Kannst du bitte etwas genauer erklären was du machen willst? Was genau bewegst du bzw. was für einen Effekt willst du erreichen? Du müsstest die World Space Koordinaten zu Screen Space Koordinaten konvertieren, und dann kannst du auf dem Screen Space die Y Komponente verändern, welche sich auf deinen Bildschirm bezieht.

[eXile]

Das "oben" in der 3D Szene (World Space) ist nicht das gleiche "oben" des 2D Viewports (Screen Space).

Nein. Dazu gibt es ja gerade den Up-Vektor, wenn man seine View-Matrix gemäß der Look-At-Methode aufbaut. Meiner Meinung nach ist das Problem ganz einfach zu lösen, wenn ich denn dein Problem denn richtig verstehe:

Angenommen, du hast deine Model-Matrix M und deine View-Matrix V, und eine Translationsmatrix T, welche einfach eine Verschiebung entlang der (im jeweiligen Raum) y-Achse bewerkstelligt. Dann ist die gesuchte Model-View-Matrix einfach T*V*M, d.h. die Translation wird nach der View-Matrix (und Model-Matrix) angewendet. ;)

[Hix]

Erstmal danke dafür dass so viele bereit sind mir zu helfen. Ich versuche mal genauer zu erklären was ich machen will:

Ich habe eine Art Weltraum generiert. Also einfach ein paar Kugeln welche die Planeten darstellen und schwarzer Hintergrund. Nun möchte ich die Position der Planeten nicht im Code fix festlegen sondern einen Planeten anklicken und ihn dann mit den Pfeiltasten verschieben können. Das klappt auch wunderbar. Um nach oben und unten zu verschieben verändere ich einfach die y-Position des ausgewählten Planeten. Für vorne/hinten die z-Position und für links/rechts die x-Position.

Das funktioniert eigentlich super, aber das Problem das ich nun habe ist dass das ganze mit vielen Planeten schnell unübersichtlich wird. Z.B. wenn ein Planet den anderen verdeckt. Um den verdeckten Planeten zu sehen habe ich nun die Möglichkeit geschaffen die gesamte Szene zu rotieren. Also einfach ein glRotate das auf alle Objekte angewandt wird. Wenn ich nun z.B. die gesamte Szene um die z-Achse drehe sind die x und y Achsen nicht mehr waagrecht und senkrecht sondern schräg. Verschiebe ich nun einen Planeten nach oben wird er deshalb nicht mehr gerade nach oben sondern schräg nach oben verschoben.

Angenommen, du hast deine Model-Matrix M und deine View-Matrix V, und eine Translationsmatrix T, welche einfach eine Verschiebung entlang der (im jeweiligen Raum) y-Achse bewerkstelligt. Dann ist die gesuchte Model-View-Matrix einfach T*V*M, d.h. die Translation wird nach der View-Matrix (und Model-Matrix) angewendet.

Tut mir leid, ich verstehe nur Bahnhof. :oops:

Ich habe mir nun gedacht ich könnte es vielleicht so machen, dass ich einen Vektor für alle Richtungen speichere (oben, hinten, rechts). Der Vektor der nach oben zeigt wäre dann am Anfang (0,-1,0). Wenn ich nun die gesamte Szene um z,B. 10 Grad um die z-Achse drehe, dann drehe ich multipliziere ich den Vektor einfach mit der Rotationsmatrix für die Drehung um -10 Grad um die z-Achse. Würde das funktionieren?

[pUnkOuter]

Du kannst auch einfach die Szene zurückdrehen, den Planeten nach oben verschieben, und die Szene wieder drehen. Wobei, nein, dann hat er sich natürlich auch schräg bewegt...

[Eisflamme]

Und ich sag immer noch. Korrigier doch einfach den Wert besagter Matrix, nachdem Du alles verrechnet hast. Das Ding geht dann sicherlich nach oben, wenn auch die Verzerrung der Projektionsmatrix nicht beachtet und damit die Schrittweite nicht in einem logisch definierten Maß von Statten geht. Das ist doch das Praktische in OGL, dass es keine Kameramatrix gibt ._.

[Hix]

Und ich sag immer noch. Korrigier doch einfach den Wert besagter Matrix, nachdem Du alles verrechnet hast. Das Ding geht dann sicherlich nach oben, wenn auch die Verzerrung der Projektionsmatrix nicht beachtet und damit die Schrittweite nicht in einem logisch definierten Maß von Statten geht. Das ist doch das Praktische in OGL, dass es keine Kameramatrix gibt ._.

Also, ehrlich gesagt verstehe ich nicht so ganz was du meinst. Wie gesagt bin ich Anfänger.

Ich definiere zuerst damit die Verschiebung

Code: Alles auswählen

gl.glTranslatef(o.getXPos(), o.getYPos(), o.getZPos());

Und zeichne dann das Objekt in den 0-Punkt. Ich hab da ja keine Matrix wo ich einen Wert ändern könnte.

[pUnkOuter]

Im Prinzip musst du dir doch nur die Rotation der Szene merken, und dann für das eine Objekt rückgängig machen, dann verschieben...oder liege ich da wieder falsch?

[Hix]

Im Prinzip musst du dir doch nur die Rotation der Szene merken, und dann für das eine Objekt rückgängig machen, dann verschieben...oder liege ich da wieder falsch?

Das war auch mein erster Gedanke, aber das funktioniert nicht. Das Objekt soll ja schon mitrotiert werden, aber wenn es dann verschoben wird eben nicht entlang der rotierten Achse.

[pUnkOuter]

Du kannst es doch nach dem Verschieben wieder zurückrotieren. Geht ja nur drum, dass es während dem Verschieben unrotiert ist, damit es gerade nach oben geht. Müsste eigentlich klappen, jedenfalls wenn meine Zeichnung stimmt.

[Hix]

Du kannst es doch nach dem Verschieben wieder zurückrotieren. Geht ja nur drum, dass es während dem Verschieben unrotiert ist, damit es gerade nach oben geht.

Eben nicht. Wenn es gerade nach oben gezeichnet wird und dann rotiert ist es ja nach dem rotieren schräg.

[Alexander Kornrumpf]

Das "oben" in der 3D Szene (World Space) ist nicht das gleiche "oben" des 2D Viewports (Screen Space). Kannst du bitte etwas genauer erklären was du machen willst? Was genau bewegst du bzw. was für einen Effekt willst du erreichen? Du müsstest die World Space Koordinaten zu Screen Space Koordinaten konvertieren, und dann kannst du auf dem Screen Space die Y Komponente verändern, welche sich auf deinen Bildschirm bezieht.

Mittlerweile ist davon auszugehen dass er ScreenSpace meint denke ich.

Im Prinzip musst du dir doch nur die Rotation der Szene merken, und dann für das eine Objekt rückgängig machen, dann verschieben...oder liege ich da wieder falsch?

Wenn mich nicht alles täuscht wäre das nur richtig wenn er WorldSpace meinen würde. Was erklären würde warum es nicht den von ihm gewünschtehn Effekt hat.

Das ist doch das Praktische in OGL, dass es keine Kameramatrix gibt ._.

Huh?

[pUnkOuter]

Wenn du Worldspace meinst, dann sollte das folgende richtig sein:

Also, vielleicht irre ich mich ja völlig, ist schon eine Weile her, dass ich direkt mit OGL Befehlen Zeug rumgeschoben habe, aber du beginnst ja immer mit der Identitätsmatrix, also am Ursprung, und ohne Rotation. Dann machst du jeweils ein glPushMatrix, glTranslate, platzierst den Planeten, glPopMatrix, glPushMatrix, glTranslate, platzierst den nächsten Planeten, usw. Schliesslich rotierst du noch die gesamte Szene mit glRotate, machst die Projektion und zeichnest dann.

Um die aktuelle Position der Planeten zu bekommen, musst du den Vektor, den du im glTranslate benutzt hast, natürlich auch rotieren. Das heisst, du wirst nicht darum herum kommen, selber ein wenig mit Vektoren und Matrizen zu rechnen. Nehmen wir mal an, du hättest also die Position der Planeten nach der Szenenrotation. Wenn du nun einen gerade nach oben bewegen willst, so machst du einfach ein glPushMatrix, glTranslate zu seiner Position, glRotate in die andere Richtung in die du die Szene gedreht hast (Eigenrotation), verschiebst ihn nach oben, rotierst ihn wieder in die korrekte Richtung (Eigenrotation rückgängig) und machst am Schluss ein glPopMatrix, und erst DANN die Projektion. Der Planet bewegt sich dann nicht schräg, weil du vor der Aktion den Nullpunkt an seine Position setzt.

[Hix]

Was ich meine ist, dass es sich am Bildschirm nach oben bewegen soll. So wie sich die kleinen Bläschen in der Wasserflasche immer nach oben bewegen, egal in welche Richtung man die Flasche dreht.

Also, vielleicht irre ich mich ja völlig, ist schon eine Weile her, dass ich direkt mit OGL Befehlen Zeug rumgeschoben habe, aber du beginnst ja immer mit der Identitätsmatrix, also am Ursprung, und ohne Rotation. Dann machst du jeweils ein glPushMatrix, glTranslate, platzierst den Planeten, glPopMatrix, glPushMatrix, glTranslate, platzierst den nächsten Planeten, usw. Schliesslich rotierst du noch die gesamte Szene mit glRotate, machst die Projektion und zeichnest dann.

Genau so mache ich es.

Um die aktuelle Position der Planeten zu bekommen, musst du den Vektor, den du im glTranslate benutzt hast, natürlich auch rotieren. Das heisst, du wirst nicht darum herum kommen, selber ein wenig mit Vektoren und Matrizen zu rechnen. Nehmen wir mal an, du hättest also die Position der Planeten nach der Szenenrotation. Wenn du nun einen gerade nach oben bewegen willst, so machst du einfach ein glPushMatrix, glTranslate zu seiner Position, glRotate in die andere Richtung in die du die Szene gedreht hast (Eigenrotation), verschiebst ihn nach oben, rotierst ihn wieder in die korrekte Richtung (Eigenrotation rückgängig) und machst am Schluss ein glPopMatrix, und erst DANN die Projektion. Der Planet bewegt sich dann nicht schräg, weil du vor der Rückrotation den Nullpunkt an seine Position setzt.

Dann bewegt er sich ja trotzdem schräg. Wenn ich ein rotate nach dem glTranslate zwischen dem PushMatrix und PopMatrix mach dreht er sich ja nur um die eigene Achse.

Ich glaube an Hand einer Skizze ist am einfachsten zu erklären was ich will:

Ist die Szene wie in 1 nicht rotiert passt alles. Ist sie wie in 2 rotiert bewegt sich der Planet schräg und nicht nach oben. In so einem Fall soll er sich wie in 3 dargestellt bewegen.

edit:
Hier nochmal wie ich meine Transaltionen und Rotationen aufgebaut habe:

Code: Alles auswählen

gl.glTranslatef(x, y, z);
            gl.glRotatef(xrot, 1.0f, 0.0f, 0.0f);
            gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);
            gl.glRotatef(zrot, 0.0f, 0.0f, 1.0f);

            for(alle objekte o){
                  gl.glPushMatrix();
	          gl.glTranslatef(o.getXPos(), o.getYPos(), o.getZPos());
		  gl.glRotatef(xRotP, 1.0f, 0.0f, 0.0f);
		  gl.glRotatef(yRotP, 0.0f, 1.0f, 0.0f);
		  gl.glRotatef(zRotP, 0.0f, 0.0f, 1.0f);  
                      //objekt erstellen                  
                  gl.glPopMatrix();
           }

Die ersten translate und rotate Methoden verschieben und rotieren die gesamte Szene (oder eben die Kamera je nachdem wie man das sehen will) und die in der for Schleife immer ein einzelnes Objekt.

[pUnkOuter]

Nein, darum rotierst du ihn ja um die Szenenrotation zurück, damit der dann nach oben geht, nicht mehr schräg. Sieht man ja in deinem Bild gut, einfach nach Bild 2 die Eigenrotation des Planeten auf die negative Szenenrotation stellen, dann zeigt der Vektor wieder gerade nach oben.

[Hix]

Nein, darum rotierst du ihn ja um die Szenenrotation zurück, damit der dann nach oben geht, nicht mehr schräg. Sieht man ja in deinem Bild gut, einfach nach Bild 2 die Eigenrotation des Planeten auf die negative Szenenrotation stellen, dann zeigt der Vektor wieder gerade nach oben.

Wenn ich dich richtig verstehe meinst du folgendes: Wenn ich die gesamte Szene um 10 Grad auf der Z Achse drehe (also im oben geposteten Code wäre zrot=10), dann soll ich den Planeten um -10 Grad um die eigene Achse drehen (also zRotP=-10). Dann bewegt sich der Planet aber dennoch schief, nur steht er gerade. Ich wills aber genau umgekehrt. Er soll wie in Punkt 2 und 3 schief stehen sich aber dennoch gerade nach oben bewegen.

[Alexander Kornrumpf]

Dein Problem ist dass du nicht weißt wo "oben" ist, oder?

Also Entweder du bewegst den Planeten entlang des Up Vektors der Kamera was automatisch "im Bild nach oben" bedeutet, oder wenn du keine Kamera in dem Sinne hast, kannst du es machen wie Eisflamme es für den Fall beschrieben hat. Vielleicht gubt es auch noch andere Varianten, aber das scheinen mir die einfachsten zu sein.

[Hix]

Dein Problem ist dass du nicht weißt wo "oben" ist, oder?

Genau so ist es.

Also Entweder du bewegst den Planeten entlang des Up Vektors der Kamera was automatisch "im Bild nach oben" bedeutet,

Das habe ich schon versucht, aber ich scheitere daran den Up Vektor zu berechnen. Habe einen Vektor 0,1,0 genommen und darauf alle Rotationen angewandt. Rausgekommen ist aber nur Blödsinn. Gibt es nicht irgendeine Möglichkeit den Up irgendwie aus der View Matrix auszulesen?

oder wenn du keine Kamera in dem Sinne hast, kannst du es machen wie Eisflamme es für den Fall beschrieben hat. Vielleicht gubt es auch noch andere Varianten, aber das scheinen mir die einfachsten zu sein.

Leider habe ich immer noch nicht verstanden was er gemeint hat.

[Alexander Kornrumpf]

http://www.gamedev.net/community/forums ... _id=497918

[Hix]

http://www.gamedev.net/community/forums ... _id=497918

Für etwas derart simples brauche ich 2 Tage. Ich muss wirklich noch viel lernen :lol:

Falls jemand mal das gleiche Problem hat und auf diesen Thread stößt poste ich noch wie man den Up Vektor genau ausließt:

Code: Alles auswählen

Vector v = new Vector();
double mvmatrix[] = new double[16];
gl.glGetDoublev(GL.GL_MODELVIEW_MATRIX, mvmatrix, 0);
v.x=mvmatrix[4];
v.y=mvmatrix[5];
v.z=mvmatrix[6]; 

Vielen Dank für eure Hilfe!

edit: Eine kleine Frage hab ich dann doch noch. Wenn ich den Up Vektor wie oben beschrieben auslese zeigt der Vektor nur dann nach oben wenn ich die x Koordinate mit -1 multipliziere. Weiß jemand warum?

[TGGC]

Ich glaube die Fehlen mathematische Grundlagen, die du erstmal nachholen solltest. Vielleicht mal entsprechendes Buch dazu kaufen/ leihen.