Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Mo Sep 28, 2020 09:27

Foren-Übersicht » Programmierung » Mathematik-Forum
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 7 Beiträge ] 
Autor Nachricht
BeitragVerfasst: So Apr 26, 2020 07:29 
Offline
DGL Member

Registriert: Mo Jun 12, 2006 14:47
Beiträge: 75
Programmiersprache: Object FPC
Hallo miteinander,

ich bin gerade dabei einen kleinen Drohnensimulator zu schreiben (Acro Modus).

Eine Drohne im Acro modus fliegt sich wie folgt: Drehung um alle Achsen(Yaw, Roll, Pitch), und Throttle (Bewegung nach Oben, aus sicht der Kamera)

Nun habe ich folgenden Code zum Rendern:

Code:
  1.  
  2.   glClearColor(0.0, 0.0, 0.0, 0.0);
  3.   glClear(GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT);
  4.   glLoadIdentity();
  5.   fCam.Move();
  6.   fCam.CamToOpenGL();
  7.   RenderScene();
  8.   OpenGLControl1.SwapBuffers;
  9.  


Da ich die Kamera ständig drehen muss habe ich die Rotation und Translation in 2 Separate Schritte aufgeteilt (das erstpart bei jeder Rotation das subtrahieren der Position und danach wieder addieren)

Code:
  1.  
  2. Procedure TCam.Roll(Angle: Single); // Rotation um die Achse die in den Monitor hinein zeigt
  3. Begin
  4.   glPushMatrix;
  5.   glLoadIdentity();
  6.   glRotatef(-Angle, 0, 0, 1); // Yaw, und Pitch sind analog haben nur diesen Vector anders
  7.   glMultMatrixf(@fMatrix);
  8.   glGetFloatv(GL_MODELVIEW_MATRIX, @fMatrix);
  9.   glPopMatrix;
  10. End;
  11.  


Gerendert wird das ganze dann via:

Code:
  1. Procedure TCam.CamToOpenGL();
  2. Begin
  3.   glMultMatrixf(@fMatrix);
  4.   glTranslatef(-Fposition.x, -Fposition.y, -Fposition.z);  // Die Camera Bewegung ist ja Relativ zur Scene und deswegen Negativ
  5. End;


Mein Problem ist nun Throttle (Bewegung aus sicht der Kamera nach Oben):

Code:
  1.  
  2. Procedure TCam.StrafeUpWay(delta: Single);
  3. Var
  4.   v: TVector4;
  5. Begin
  6.   v := v4(0, delta, 0, 0);
  7.   v := fMatrix * v;
  8.   Fposition.x := Fposition.x + v.x;
  9.   Fposition.y := Fposition.y + v.y;
  10.   Fposition.z := Fposition.z + v.z;
  11. End;
  12.  


Der oben gezeigt Code funktioniert ganz gut wenn ich "Waagrecht" fliege, sobald ich aber die Kamera Kippe z.b 90° Roll, dann sollte ich ja, wenn ich beschleunige immer noch Relativ nach oben und Absolut nach Rechts/Links fliegen.
Je Länger ich fliege (also je mehr Rotationen ich gemacht habe) desto wilder wird das Ergebnis => Sprich die Kamera bewegt sich z.B. nach Links obwohl sie nach oben sollte. Manchmal sogar in mehrere Achsen.

Die Blickrichtung wird dabei aber immer Korrekt und meinen Erwartungen entsprechend gerendert, daher gehe ich davon aus, dass meine Rotationsmatrix korrekt ist.

Wie also kann ich StrafeUpWay korrekt implementieren ?
Nochmal:
Wenn ich meine Kamera an einer Bestimmten Position habe und in eine Bestimmte Richtung Blicke, wie berechne ich die Absolute Positionsänderung, wenn ich Relativ zur Kamera nach Oben möchte ?

Diese Frage habe ich ebenfalls auf MathePlanet gestellt.

_________________
Try my 3D-Game (new Version 2) Balanced2 v2.02
or See my other Stuff at http://www.Corpsman.de


Zuletzt geändert von Corpsman am Mi Apr 29, 2020 05:30, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Apr 26, 2020 10:35 
Offline
Ernährungsberater
Benutzeravatar

Registriert: Sa Jan 01, 2005 17:11
Beiträge: 2023
Programmiersprache: C++
Du verrechnest die Matrix zweimal:
In CamToOpenGL() passt du erst die Matrix an und führst dann deine Translation durch. Dadurch erfolgt die Translation schon im System der Kamera und nicht mehr absolut.
Bei StrafeUpWay() hast du deine Translation ja schon mit der Matrix "korrigiert".

Meine Empfehlung an der Stelle ist es Rotation und Translation nicht zu trennen sondern immer in der kombinierten 4x4 Matrix zu arbeiten. Dann kannst du entscheiden ob die nächste Änderung (als 4x4 Matrix, z.B. eine einfache Translation oder auch Rotationen) auf die aktuelle Matrix draufgerechnet werden soll (Multiplikation von Rechts) oder ob sie vor der aktuellen Matrix statt finden soll (Multiplikation von Links).

Und etwas OT: Wenn du das Matrixhandling im Griff hast, kannst du dann auch direkt auf OpenGL 3.0 und größer wechseln. Dort ist (aus meiner Sicht) nur der Ort wo die Matrix berechnet wird geändert. Und zwar aus OpenGL raus in die Hand des Benutzers.

_________________
Steppity,steppity,step,step,step! :twisted:
❆ ❄ ❄ ❄ ❅ ❄ ❆ ❄ ❅ ❄ ❅ ❄ ❅ ❄ ❄
❄ ❄ ❄ ❅ ❄ ❄ ❄ ❅ ❄ ❄ ❆ ❄ ❄


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Apr 26, 2020 15:01 
Offline
DGL Member

Registriert: Mo Jun 12, 2006 14:47
Beiträge: 75
Programmiersprache: Object FPC
Hallo i0n0s,

Danke für deine Hinweise ich habe meinen Code nun wie folgt umgeschrieben:
Code:
  1.  
  2. Procedure TCam.CamToOpenGL();
  3. Begin
  4.   glMultMatrixf(@fMatrix);
  5. End;
  6.  
  7. Procedure TCam.StrafeUpWay(delta: Single);
  8. Begin
  9.   glPushMatrix;
  10.   glLoadIdentity();
  11.   glTranslatef(0, -delta, 0);
  12.   glMultMatrixf(@fMatrix);
  13.   glGetFloatv(GL_MODELVIEW_MATRIX, @fMatrix);
  14.   glPopMatrix;
  15. End;
  16.  


Damit kann ich nun 1a die Kamera bewegen, was nun aber nicht mehr geht ist
- Setzen der Position Absolut (außer die Rotatsionsmatrix ist = Einheitsmatrix)
- Gravitation durch Verschiebung Absolut
=> Also alles was nicht Relativ zu meinem Kamerasystem ist.

Code:
  1.  
  2. Procedure TCam.Translate(x, y, z: Single);
  3. Begin
  4.   fMatrix[3, 0] := fMatrix[3, 0] - x;
  5.   fMatrix[3, 1] := fMatrix[3, 1] - y;
  6.   fMatrix[3, 2] := fMatrix[3, 2] - z;
  7. End;  
  8.  
  9. Procedure TCam.SetPosition(x, y, z: Single);
  10. Begin
  11.   fMatrix[3, 0] := -x;
  12.   fMatrix[3, 1] := -y;
  13.   fMatrix[3, 2] := -z;
  14. End;  
  15.  
  16. Function TCam.GetPosition: TVector3;
  17. Begin
  18.   result := v3(-fMatrix[3, 0], -fMatrix[3, 1], -fMatrix[3, 2]);
  19. End;
  20.  


Wie mache ich das nun ?
Nochmal:
Wenn ich eine Matrix Habe die mein Kamerasystem dreht und Verschiebt, wie kann ich daraus die Absolut Position Ermitteln / verändern ?
Und ich brauche auch die Absolute Position, damit ich sie später gegen meine Welt "Kollidieren" kann.

Deinen Hinweis auf das OT verstehe ich nicht, ich nutze DGLOpenGL.pas für "OpenGL 4.6"

_________________
Try my 3D-Game (new Version 2) Balanced2 v2.02
or See my other Stuff at http://www.Corpsman.de


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Apr 26, 2020 15:09 
Offline
DGL Member

Registriert: Mo Jun 12, 2006 14:47
Beiträge: 75
Programmiersprache: Object FPC
Ok ich habe Translate ersetzt durch:

Code:
  1.  
  2. Procedure TCam.Translate(x, y, z: Single);
  3. Begin
  4.   glPushMatrix();
  5.   glLoadIdentity();
  6.   glMultMatrixf(@fMatrix);
  7.   glTranslatef(-x, -y, -z);
  8.   glGetFloatv(GL_MODELVIEW_MATRIX, @fMatrix);
  9.   glPopMatrix();
  10. End;
  11.  


Und nun scheint die Schwerkraft zu funktionieren, auch wenn ich nicht genau verstehe, was der Unterschied zwischen dem "Händischen" und dem Rechnen via OpenGL ist.

Damit Bleibt nur noch die Frage, wie Bekomme ich die Position meiner Kamera Heraus, wenn diese wild Verdreht ist ?

_________________
Try my 3D-Game (new Version 2) Balanced2 v2.02
or See my other Stuff at http://www.Corpsman.de


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Apr 26, 2020 15:28 
Offline
Ernährungsberater
Benutzeravatar

Registriert: Sa Jan 01, 2005 17:11
Beiträge: 2023
Programmiersprache: C++
Die glTranslate ist eine Multiplikation der aktuellen Matrix mit:
Code:
  1. 1 0 0 x
  2. 0 1 0 y
  3. 0 0 1 z
  4. 0 0 0 1


Wenn wir uns jetzt das Ergebnis für x betrachten ist das:
Code:
  1. a_{11} * x + a_{12} * y + a_{13} * z + x' * 1

x' ist die vorherige X-Position. Und die a_{ij} hat du bei deinem Translate einfach ignoriert.

Les dir bitte mal im Tutorial Matrix den Abschnitt "Auswirkungen von Matrixmanipulationen - oder "Wie positioniere ich meine Objekte richtig?"" und dann das Kombinieren der Operationen an.
Wenn du auf Matrizen arbeitest, kannst du sie nur noch über Matrizenmultiplikationen verändern.

Und es mag erstmal etwas kompliziert klingen, aber dahinter steht die bisherige Logik von glTranslate.
Ein Beispiel:
glTranslate(1, 0, 0);
glRotate(90, 0, 0, 1);
glTranslate(1, 0, 0);

Jetzt stehe ich ja nicht bei (2, 0, 0) sondern bei (1, 1, 0) [Vorzeichenfehler bitte ignorieren *hust*].
Mit dem glRotate werden Werte außerhalb der Diagonalen gesetzt und die nächste Translation kombiniert Werte.

_________________
Steppity,steppity,step,step,step! :twisted:
❆ ❄ ❄ ❄ ❅ ❄ ❆ ❄ ❅ ❄ ❅ ❄ ❅ ❄ ❄
❄ ❄ ❄ ❅ ❄ ❄ ❄ ❅ ❄ ❄ ❆ ❄ ❄


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: So Apr 26, 2020 20:10 
Offline
DGL Member

Registriert: Mo Jun 12, 2006 14:47
Beiträge: 75
Programmiersprache: Object FPC
Intuitiv war mir das ja schon klar deswegen hab ich das Translate ja durch die OpenGL variante ersetzt. Danke für den Hinweis, werde mir den Artikel noch genauers ansehen.

Offen Bleibt die Frage wie ich die Absolut Koordinaten meiner Kamera herausbekomme.

Ich dachte daran die Achsen Einheitsvektoren durch die Rotationsmatrix zu jagen (jeden Einzeln), dann müsste ich nur noch die Linearkombination finden welche dann die Position der fMatrix [3,0] -- [3,2] ergibt, gibts da nen "Eleganten" Trick dafür oder ist mein Ansatz unsinn ?

Alternativ dachte ich auch schon daran fMatrix zu invertieren dann könnte man ja ebenfalls [3,0] -- [3,2] zurück transformieren. Aber eine Matrizen invertierung zu Rechnen wird wahrscheinlich komplizierter sein wie die erste Variante ..

_________________
Try my 3D-Game (new Version 2) Balanced2 v2.02
or See my other Stuff at http://www.Corpsman.de


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mo Apr 27, 2020 12:06 
Offline
DGL Member

Registriert: Mo Jun 12, 2006 14:47
Beiträge: 75
Programmiersprache: Object FPC
Wenn man mal weiß wie es geht ist es einfach hier die Auflösung:

Notwendig ist die Inverse Matrix von fmatrix um die Weltkoordinaten zu Berechnen. Da meine Fmatrix eine sogenannte Orthogonalmatrix ist reicht es hier diese zu transponieren um sie zu invertieren (das spart richtig viel Rechenzeit).

Code:
  1.  
  2. Function TCam.GetPosition: TVector3;
  3. Var
  4.   m: TMatrix4x4;
  5.   v, p: TVector4;
  6. Begin
  7.   v := v4(fMatrix[3, 0], fMatrix[3, 1], fMatrix[3, 2], 0); // Die Position in Kamera-Space
  8.   m := TransposeMatrix(fMatrix); // Da es sich um eine Ortohonalmatrix Handelt ist die Inverse die Transponierte
  9.   p := m * v;// Rückprojektion der Kamera Position in das Absolute Koordinatensystem
  10.   result := v3(-p.x, -p.y, -p.z);
  11. End;
  12.  


Und die Kollision mit dem Boden ist dann auch ein Kinderspiel:

Code:
  1.  
  2. Procedure TCam.ApplyGravity(Delta: single);
  3. Begin
  4.   Translate(0, -delta, 0);
  5. End;
  6.  
  7. Procedure TCam.CollideWithGround(GroundLevel: Single);
  8. Var
  9.   absPos: TVector3;
  10. Begin
  11.   absPos := GetPosition();
  12.   If absPos.y < GroundLevel Then Begin // Wir können nicht Tiefer wie Groundlevel, also wieder nach Oben schieben
  13.     Translate(0, absPos.y - GroundLevel, 0);
  14.   End;
  15. End;
  16.  
  17.  

_________________
Try my 3D-Game (new Version 2) Balanced2 v2.02
or See my other Stuff at http://www.Corpsman.de


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 7 Beiträge ] 
Foren-Übersicht » Programmierung » Mathematik-Forum


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.025s | 16 Queries | GZIP : On ]