DGL
https://delphigl.com/forum/

glRotate, Modelview, koordinatensysteme - ich dreh' am Rad
https://delphigl.com/forum/viewtopic.php?f=21&t=6352		 Seite 1 von 1
Autor:  Doomhammer [ Mi Feb 07, 2007 18:27 ]
Betreff des Beitrags:  glRotate, Modelview, koordinatensysteme - ich dreh' am Rad
Hallo zusammen,

nach stundenlanger tüftelei steck ich fest. ich denke einfach ich hab ein brett vor dem kopf, denklockade. Hoffentlich könnte ihr s ie beseitigen!

Folgendes problem:

Ich habe Positions und Orientierungsdaten aufgenommen und möchte meine OpenGl Kamera nach diesen Daten ausrichten.
Alles gut und schön nur leider gibts ein kleinen Schönheitsfehler, der mir einen Strich durch die Rechnung macht:

Die Daten sind bezogen auf ein anderes Koordinaten system. Es ist ein rechtshändriges System , was jedoch die Z nach unten, die X Achse nach links und die Y Achse nach "hinten" hat.
Eigentlich kein Grund zu panik, dreh ichs eben in das normal karthesische von Opengl.

was ich erreichen möchte ist, dass ich die daten so benutzen kann ,als wären sie normale opengl koordinaten, so dass ich meine szene auf die normalen opengl koordinaten ausrichten kann.


Also das Koordinatensystem erst um -180° um die Z achse gedreht und dann um -90° um X gedreht. nun sind die beiden koordinatensysteme deckungsgleich..

Mein programm setzt also erstmal die modelview matrix und läd die einheitsmatrix. dann werden die beiden drehungen per glrotate nacheinander durchgeführt und schließlich noch eine translation um den 0 punkt versatz auszugleichen.

Dann kommen die Positionsdaten ins Spiel. Sie werden in eine Rotationsmatrix eingelesen und dann mit der aktuellen modelview matrix multipliziert. Danach werden noch zusätzliche Translation durchgeführt.
Achja die Objekte werden vorher in die szene geladen, also sind die vertexdaten dann relativ zum opengl urpsrung.

Meine Frage ist nun : ist das der richtige weg ?
ist die "kompensation" der koordinatensysteme richtig?
muss es vor oder nach dem multiplizieren der positions/rotationsdaten durchgeführt werden ?
muss eine kamera bewegung vorher oder hinter durchgeführt werden?
bewegt sich meine "camera" also jetzt relativ zum opengl urpsrung, wenn ich neue daten einlese?


Zur illustration hier der code

Code:
  1.  
  2. glMatrixMode( GL_MODELVIEW );
  3. glLoadIdentity();
  4.  
  5. //Koordinatensystem drehen
  6. glRotatef(-180.0f,0.0f,0.0f,.0f);
  7. glRotatef(-90.0f,1.0f,0.0f,0.0f);
  8.  
  9. // eigentliche Drehung der Kamera, aber im anderen Koordinatensystem
  10. glMultMatrixf(Matrix);
  11.  
  12. //Translation der Kamera
  13. glTranslatef(m_Position.x, m_Position.y, m_Position.z);
  14.  
  15.  


Dateianhänge:
Dateikommentar: Überführung des Koordinatensystems
steps.gif
steps.gif [ 12.49 KiB | 10472-mal betrachtet ]
Autor:  Flash [ Mi Feb 07, 2007 22:02 ]
Betreff des Beitrags: 
Das mit den Objekten hab ich gerade nicht verstanden.
Aber wenn du testen Willst ob deine Achsen richtig stehen mach einfach folgendes:

Code:
  1. glBegin(GL_LINES);
  2.   glColor3f(1,0,0); glVertex3f(1,0,0); glVertex3f(0,0,0);
  3.   glColor3f(0,1,0); glVertex3f(0,1,0); glVertex3f(0,0,0);
  4.   glColor3f(0,0,1); glVertex3f(0,0,1); glVertex3f(0,0,0);
  5. glEnd();


Dann siehst du schonmal ob die Achsen so stehen wie du dir das vorstellst.
Autor:  The-Winner [ Do Feb 08, 2007 10:07 ]
Betreff des Beitrags: 
Ein rechtshändiges system kannst du nicht durch Drehungen in ein linkshändiges überführen. Du muss eine der Achsen einfach mit -1 skalieren. Das gibt dann aber etwas Ärger beim backfaceculling.
Autor:  Doomhammer [ Do Feb 08, 2007 10:39 ]
Betreff des Beitrags: 
Mit objekten meinte ich geometrische objekte, die vorher eingeladen werden (war etwas missverständlich sorry)

vielleicht noch ein bild um mein problem zu verdeutlichen:

die cameraposition und orientierung wurde innerhalb eines anderen koordinatensystems aufgenommen.

diese daten lese ich ein und möchte sie für die kamera benutzen. Allerdings soll meine geometry relativ zu der kamera ausgerichtet werden (zb. Plane als Boden soll unten und parallel zum bildschirmrand sein).

Bei der modelview matrix geht es ja um die relative position von camera und geometry (oder ?)

Da die geometry bei der initialisierung eingeladen wird und sich auch nicht verändert, macht es ja sinn , die matrix zu zu verändern, dass mit hilfe der aufgenommenen daten und der korrekturmatrix , die geometry wieder "richtig erscheint", d.h. nicht gedreht ,etc.

Jetzt ist meine Frage: wie muss die Korrektur matrix aussehen, also es müssten ja 2 Rotationen sein. Wann muss die Korrektur durchgeführt werden? Meine Cameradaten bestehen aus Orientierung (Quaternionen) und XYZ-Positionsdaten (ich rechne die Quaternionen in eine Rotationsmatrix um und füge per glTranslate die Position hinzu) , danach sollte doch die Korrektur stattfinden ??


@The-Winner: es sind beide rechtshändrige systeme, also sollte nur rotation und translation ausreichen

@Flash: wie helfen mir die achsen weiter? ich probiers auf jeden fall mal aus ;)
Achja, Dein programm aus dem rotationstutorial funktioniert bei mir nicht richtig: das fenster ist so skaliert, dass nur ein bruchteil der rechten einagebfelder zu sehen sind, es ändert sich auch nicht ,wenn ich es größer skaliere, leider kann ich somit keine eingaben machen...

€dit: also nochmal zur translation: die kamera wird z.b. um die Y achse verschoben , was allerdings die Y achse des ursprünglichen Systems ist und nicht die normale opengl Y-Achse darstellt. (Wäre ja in dem Fall die negative Z-Achse).

Wenn ich die Korrekturmatrix mit den Daten multipliziere, dann sollte es doch "richtig" sein oder ?

Dateianhänge:
Dateikommentar: Kamera im Ziel und Ursprünglichen Koordinatensystem
camera.gif
camera.gif [ 4.91 KiB | 10447-mal betrachtet ]
Autor:  dj3hut1 [ Do Feb 08, 2007 13:59 ]
Betreff des Beitrags: 
Hallo Doomhammer,

du musst bei Matrizenoperationen wie z.B. glRotate und glTranslate auf die Reihenfolge deiner Operationen achten (Jeder dieser Befehle ist eine Matrizenmultiplikation).
Die Operationen die zuerst vor dem Vertex stehen, werden zuerst ausgeführt, du musst also von unten nach oben denken...

Wenn du dein System z.B. zuerst 180° um die Z-Achse drehen willst, sollten deine Befehle so aussehen :

Code:
  1. //Koordinatensystem drehen
  2. glRotatef(-90.0f,1.0f,0.0f,0.0f);
  3. glRotatef(-180.0f,0.0f,0.0f,1.0f);
  4.  


Viele Grüße
dj3hut1
Autor:  Doomhammer [ Fr Feb 09, 2007 10:51 ]
Betreff des Beitrags: 
danke dj3hut1, das war der entscheidene tipp für mich... irgendwie gehe ich immer von einem camera-objekt aus und nicht einfach von einer transformationsmatrix... wenn man allerdings vom vertex als startpunkt ausgeht, kann man dann einfach die transformation zurückführen....

ich bin über die funktion gluLookAt im wiki gesolpert, ist eigentlich ja genau das was ich haben möchte, position angeben und fertig.

Der zweite parameter ist der Centerpoint. Leider habe ich nur den ein quaternion zu verfügung für die orientierung im raum.
Ist es dann möglich mit hilfe der definition : CenterX - EyeX, CenterX mit EyeX + sichtvektor der kamer zu definiren, dann würde ja EyeX wegfallen und man bekäme den sichtvektor , der durch das quaternion mutlipliziert mit der Z-Achse gebildet wird.

den up vektor berechne ich mit hilfe des quaternion und der Y achse..

bin ich da auf dem richtigen weg oder gibts ne andere möglichkeit ?

edit: kann man mit multmatrix auch vektoren multiplizieren oder muss ich das per hand machen ?

€dit2: okay habsm al per hand gemacht , code sieht so aus

Code:
  1.  
  2.     q.CreateMatrix(Matrix);
  3.  
  4.  
  5.     //Z-Vector
  6.     glVector Vector_Z;
  7.     Vector_Z.i = 0;
  8.     Vector_Z.j = 0;
  9.     Vector_Z.k = 1;
  10.     Vector_Z.l = 1;
  11.  
  12.     //Y-Vector
  13.     glVector Vector_Y;
  14.     Vector_Y.i = 0;
  15.     Vector_Y.j = 1;
  16.     Vector_Y.k = 0;
  17.     Vector_Y.l = 1;
  18.  
  19.  
  20.     //Calculates the Vector through the camera = Matrix * (0/0/1)
  21.     m_DirectionVector.i = Matrix[0]*Vector_Z.i + Matrix[4]*Vector_Z.j + Matrix[8]*Vector_Z.k + Matrix[12]*Vector_Z.l;
  22.     m_DirectionVector.j = Matrix[1]*Vector_Z.i + Matrix[5]*Vector_Z.j + Matrix[9]*Vector_Z.k + Matrix[13]*Vector_Z.l;
  23.     m_DirectionVector.k = Matrix[2]*Vector_Z.i + Matrix[6]*Vector_Z.j + Matrix[10]*Vector_Z.k + Matrix[14]*Vector_Z.l;
  24.     m_DirectionVector.l = Matrix[3]*Vector_Z.i + Matrix[7]*Vector_Z.j + Matrix[11]*Vector_Z.k + Matrix[15]*Vector_Z.l;
  25.  
  26.     //Point of interest
  27.     m_Center.x = m_DirectionVector.i + m_Position.x;
  28.     m_Center.y = m_DirectionVector.j + m_Position.x;
  29.     m_Center.z = m_DirectionVector.k + m_Position.x;
  30.  
  31.     //Calculates the Up-Vector = Matrix * (0/1/0)
  32.     m_UpVector.i = Matrix[0]*Vector_Y.i + Matrix[4]*Vector_Y.j + Matrix[8]*Vector_Y.k + Matrix[12]*Vector_Y.l;
  33.     m_UpVector.j = Matrix[1]*Vector_Y.i + Matrix[5]*Vector_Y.j + Matrix[9]*Vector_Y.k + Matrix[13]*Vector_Y.l;
  34.     m_UpVector.k = Matrix[2]*Vector_Y.i + Matrix[6]*Vector_Y.j + Matrix[10]*Vector_Y.k + Matrix[14]*Vector_Y.l;
  35.     m_UpVector.l = Matrix[3]*Vector_Y.i + Matrix[7]*Vector_Y.j + Matrix[11]*Vector_Y.k + Matrix[15]*Vector_Y.l;
  36.  
  37.     glMatrixMode( GL_MODELVIEW );
  38.     glLoadIdentity();
  39.  
  40.     gluLookAt(m_Position.x, m_Position.y, m_Position.z, m_Center.x, m_Center.z, m_Center.z, m_UpVector.i, m_UpVector.j, m_UpVector.k);
  41.  
  42.  


Muss ich nach der multiplikation der des Direction vektors bzw up vektors nochmal durch das 4te element teilen oder nicht ?
Autor:  dj3hut1 [ Fr Feb 09, 2007 11:56 ]
Betreff des Beitrags: 
Hallo,

kann es sein, dass du mit q.CreateMatrix(Matrix) schon die richtige Transformationsmatrix aus deinem Quaternion erzeugst?
Wenn ja, dann brauchst du gluLookAt nicht mehr, sondern dein Code würde dann so aussehen :

Code:
  1. glMatrixMode( GL_MODELVIEW );
  2. glLoadIdentity();
  3.  
  4. q.CreateMatrix(Matrix);
  5.  
  6. glMultMatrix(Matrix);
  7. ...


Ist nur die Frage, ob die Elemente in 'Matrix' dann richtig angeordnet sind, wenn nicht musst du die Matrix möglicherweise transponieren (Zeilen und Spalten vertauschen)

Viele Grüße
dj3hut1
Autor:  Doomhammer [ Fr Feb 09, 2007 12:00 ]
Betreff des Beitrags: 
Hi,

ich habe die klassen aus dem NeHe Tutorial http://nehe.gamedev.net/data/lessons/le ... mera_Class . Hier wird direkt damit multipliziert.

aber wie sieht das aus mit der translation ? demnach müsste die ja nachher kommen, damit sie vorher ausgeführt wird?

Code:
  1.  
  2. glMatrixMode( GL_MODELVIEW );
  3. glLoadIdentity();
  4.  
  5. q.CreateMatrix(Matrix);
  6.  
  7. glMultMatrix(Matrix);
  8. glTranslatef(m_Position.x, m_Position.y, m_Position.z);
  9.  


arghjs irgendwie hab ich echt ne hinrblockade.. aber eigentlich sollte der code ja das gleiche machen !?
Autor:  Pellaeon [ Sa Feb 10, 2007 12:46 ]
Betreff des Beitrags: 
Doomhammer hat geschrieben:
aber wie sieht das aus mit der translation ? demnach müsste die ja nachher kommen, damit sie vorher ausgeführt wird?
[


Jo so funktioniert das. Bei Matrizen ist die Reihenfolge wichtig, in der du Multiplizierst A * B = B * A trifft hier nur in Ausnahmefällen zu
Matrix R -> Rotation
Matrix T -> Translation
Vektor P -> Punkt

sagen wir du willst erst de Punkt verschieben udn dann rotieren, also
T * P = TP
R * TP = neuerP

können wir auch schreiben als

R * ( T * P) = (R * T) * P = R * T * P = neuerP

Da wir die Matrix von links multiplizieren, ergibt sich beim normalen Aufschreiben der Matrizen halt die umgekehrte Reihenfolge.
Seite 1 von 1 Alle Zeiten sind UTC + 1 Stunde
Powered by phpBB® Forum Software © phpBB Group
https://www.phpbb.com/