Hallo Alle Zusammen,
Danke erst mal für eure Hinweise ich versuche diese mal auf zu arbeiten
Deine Landschaft sieht genial aus, hast du die mit OpenGL gemacht ?
Danke für die Blumen, natürlich ist das OpenGL. Das ist auch Recht unspektakulär gemacht ist einfach nur ein Trianglestrip im Wireframe Mode Ohne Wireframe sieht es noch nicht so gut aus, weil mein Textur erzeugungsalgorithmus 1:1 skalliert (das kriege ich besser hin aber vorerst reicht es)
- Vorschau2.png (101.89 KiB) 3689 mal betrachtet
Die Frage ist wie gut soll die Simulation sein.
Das ist ein Spass Projekt, in der Regel fange ich irgendwie an und iteriere dann so lange bis ich entweder nicht mehr weiter weis oder es gut genug aussieht.
=> gerade bin ich noch in der Phase, das man sieht das es unrealistisch ist. Ich würde ganz gerne wenigstens soweit kommen dass es halbwegs glaubwürdig wirkt *g*.
Kannst du was dazu schreiben, wie stellst du die Lage im Raum dar? Ist nämlich nicht ganz einfach, wenn man die Position in absoluten Koordinaten mitführen möchte, was in der Simulation ja nötig ist.
Ja das war zu Anfangs etwas Kniffelig, vor allem weil ich auch noch die Richtung der Z-Achse gedreht habe (ein Rein Persöhnliches Feature hat nichts mit der Mathe zu tun).
Wenn man aber mal weis wie es geht ist es echt einfach und das will ich euch natürlich nicht vor enthalten (wie es dazu kam, kann man hier nachlesen:
https://delphigl.com/forum/viewtopic.php?f=30&t=11700 )
Zur Mathematik ein paar Details:
In OpenGL gibt es keinen Unteschied zwischen Welt Koordinaten und Kamera Koordinaten (deswegen heist es auch ModelView Matrix)
=> entweder man bewegt die Welt um die Kamera oder die Kamera um die Welt, macht keinen Unterschied, außer das eben alles Negativ wird.
Ich Rendere also meine Welt in Absolut Koordinaten und Drehe vorher die Kamera:
Code: Alles auswählen
Procedure TForm1.OpenGLControl1Paint(Sender: TObject);
Var
Delta, t: uint64;
Begin
If Not Initialized Then Exit;
// Render Szene
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
t := GetTickCount64();
delta := t - fLastTick;
fLastTick := t;
fDrone.Move(delta);
fDrone.Render(); // Die Drohne besteht im Prinzip nur aus einer sich Bewegenden Kamera
fmap.Render();
OpenGLControl1.SwapBuffers;
End;
Der Fürs Rendern Relevante Teil ist dann wie Folgt:
Code: Alles auswählen
Procedure TCam.CamToOpenGL();
Begin
If fCamAngle <> 0 Then Begin
glRotatef(-fCamAngle, 1, 0, 0);
End;
glMultMatrixf(@fMatrix);
End;
Man Beachte den "CAMAngle" dieser ist unabhängig, das ist deswegen so weil ich damit eine für alle Berechnungen "unsichtbare" Rotation der Kamera machen kann (siehe CAM-Angle on Real Drone
).
FMatrix ist also das Ding das das Geheimnis macht. In der Mathematik nennt man so ein Ding Basiswechselmatrix
=> Das Ding Rechnet also Weltkoordinaten in Kamerakoordinaten um.
Will ich nun die Kamera drehen kann ich das entweder von Hand Berechnen, oder lasse es OpenGL machen und das geht dann so:
Code: Alles auswählen
Procedure TCam.Roll(Angle: Single);
Begin
glPushMatrix();
glLoadIdentity();
glRotatef(-Angle, 0, 0, 1);
glMultMatrixf(@fMatrix);
glGetFloatv(GL_MODELVIEW_MATRIX, @fMatrix);
glPopMatrix();
End;
Ich habe auch eine eigene Mathe Library die das genauso machen kann, nur so geht es halt "schneller"
Man kann so auch die Kamera bewegen:
Code: Alles auswählen
Procedure TCam.StrafeUpWay(delta: Single);
Begin
glPushMatrix();
glLoadIdentity();
glTranslatef(0, -delta, 0);
glMultMatrixf(@fMatrix);
glGetFloatv(GL_MODELVIEW_MATRIX, @fMatrix);
glPopMatrix();
End;
Der bisherige Code hat auch so funktioniert => die Kamera wird aus sicht dieser nach Oben Versetzt.
=> Dieses Verfahren hat aber 2 Nachteile
1. Ich kann die Physik nicht sauber rein Rechnen
2. Ich weis nicht wo ich bin
das 2. ist, wenn man die Eigenschaften der Matrix Kennt leicht zu erledigen, man braucht nur die Inverse Matrix und kann so Kamera Koordinaten wieder zurück Rechnen in Absolute:
Code: Alles auswählen
Function TCam.GetPosition: TVector3;
Var
m: TMatrix4x4;
v, p: TVector4;
Begin
v := v4(fMatrix[3, 0], fMatrix[3, 1], fMatrix[3, 2], 0); // Die Position in Kamera-Space
m := TransposeMatrix(fMatrix); // Da es sich um eine Ortohonalmatrix Handelt ist die Inverse die Transponierte
p := m * v; // Rückprojektion der Kamera Position in das Absolute Koordinatensystem
result := v3(-p.x, -p.y, -p.z); // Typconvertierung
End;
Und damit kann man dann auch "leicht" das 1. Lösen. Denn Wenn meine Drohne Gas gibt muss ich ja wissen wie sich die Beschleunigung in Absolut Koordinaten Auswirkt und das geht ganz einfach wenn für V nicht die Werte Aus der Matrix nimmt sondern
Result wird dann zu den Nach Achsen Separierten Anteilen umgerechnet
.
So viel zur Mathematik, wem das nicht Reicht einfach noch mal Konkreter Nachfragen
.
So nun aber zu meinen Themen:
Folgendes habe ich gemacht und es schaut schon mal deutlich besser aus (leider kann ich hier keine Filme hochladen, sonst könntet ihr es auch sehen *g*).
- Driften geht schon
- Achtung wer den Code Nachvollziehen Will bei mir ist x nach Links, y nach Oben und z nach Vorne
Code: Alles auswählen
Const
Gravity = 9.8 / 10; // Die musste ich doch drastisch "kürzen"
Throttle: Single = Gravity * 2; // Die Drohne muss stärker als die Gravitation sein, sonst fliegt sie nicht (Typisch ist normalerweise Faktor 4-8)
Procedure TDrone.MoveAcro();
Var
f: Single;
Begin
// Throttle
f := Input.Throttle(); // [-1..1]
If fPropMode = pmNormal Then Begin // Normal Fliegen
f := (f + 1) / 2; //Umrechnen nach [0..1]
fActualForce := fActualForce + fcam.ConvertCamCoordToWorldCoord(V3(0, -Throttle * f, 0));
End
Else Begin // Inverted Flugmodus
fActualForce := fActualForce + fcam.ConvertCamCoordToWorldCoord(V3(0, -Throttle * f, 0));
End;
// Yaw
fcam.Yaw(Turn * Input.Yaw());
// Roll
fcam.Roll(Turn * Input.Roll());
// Pitch
fcam.Pitch(Turn * Input.Pitch());
If assigned(Map) Then Begin
// Schwerkraft
fActualForce := fActualForce + v3(0, -Gravity, 0);
End;
End;
Procedure TDrone.Move(Delta_ms: Integer);
Var
p: TVector3;
Begin
If Not assigned(Input) Then exit;
fActualForce := v3(0, 0, 0);
Case fFlightMode Of
fmAcro: MoveAcro();
fmArcade: MoveArcade();
End;
fVelocity := fVelocity + fActualForce * Delta_ms / 1000;
p := fCam.Position;
p := p + fVelocity;
fcam.Position := p;
// Kollisionen ..
If assigned(Map) Then Begin
If fCam.CollideWithGround(map.GetHeightAtPosition(p.x, p.z)) Then Begin
fVelocity := v3(0, 0, 0);
End;
End;
End;
=> Es fehlt also noch der Luftwiderstand, wie mache ich das ?
=> Es fehlt noch die Geschwindigkeitsbegrenzung (das dürfte doch dann der Luftwiderstand erledigen)?
=> Es fehlt noch die Masse der Drohne (oder macht man das in dem man einfach Throttle anpasst)?
-\
-/ So siehts schon mal deutlich besser aus, ich musste G aber um Faktor 10 Reduzieren und auch mein Throttle ist irgendwie nur geraten
.
Verein
Links
Suche