Gravitationssimulator

[dizzy]

Ein Zitat aus diesem Thread:

Zitat von gmarts:

[...] Lad dir mal TVGenial runter und klicke dann mit der rechten Maustaste auf das Logo(links oben) ...dabei Shift+Alt gedrückt halten. Dann öffnet sich ein Gravitationssimulator. ..Tolle Sache um mit dem Chaos zu spielen.

Hatte mir das Dingen mal runtergeladen und es hat richtig Spaß gemacht damit rumzufummeln .
Noch mehr Spaß hat es gemacht, als ich meinen Klon davon funktionstüchtig hatte .

Und hier ist er! Erstmal ohne Soßen, da die im Moment echt nicht ansehnlich sind. Absolut quick'n'dirty mit massig globalen Variablen und reichlich "OneChar"-Bezeichnern *schäm*.
Falls aber Intersse daran besteht, mach ich den QT mal etwas lesbarer.

Viel Spaß damit!

[ibp]

... kannst du dir ja selber erklären aus masse und zentrifugalkraft

[maximov]

Zitat von ibp:

Zitat von maximov:

Ich nehme mal an dass du die berechnung iterativ machst...geht ja auch vermutlich nicht anders. Was ähnliches wollte ich auch mal machen, nur sollte es ein stabiles planeten system werden. Aber durch die iteration haben sich die ungenauigkeiten auf addiert und der mond fiel immer auf die erde

.. ist doch richtig, die masse von planeten erhöht sich doch ständig, damit kann das ganze system nicht stabil bleiben, da ja die zentrifugalkraft gleich bleibt, also erhöht sich somit auch die anziehungskraft der körper, folge ...

In meinem programm hatte ich aber konstante massen, die genau auf erde und mond eingestellt waren...aber das is ein anderes thema

[OnTopic]
Irgendwie hat das prog probleme mit dem start und abbrechen buttons bzw. beenden!

[dizzy]

Huch! Danke für die vielen Kommentare! Werde den Source dann mal a) noch optimieren (ja da ist noch einiges Potential ) und b) Ordentlich schreiben... Aber nicht vor Freitag/Samstag, da ich erst Fr. irgendwann wieder nach Hause komme wo ich Delphi hab *entzuuuug*.


Ja, das Teil arbeitet rein Iterativ und ist quasi rundenbasiert. Es gibt ein Objekt GravEngine das ein Array von Partikelobjekten hält. Die Methode GravEngine.NextStep führt auf "einen Schlag" die Bewegung aller Partikel aus, nachdem vorher die Kollisionen bereinigt wurden. Auch die Richtung und Geschwindigkeit werden als Quatum behandelt, d.h. zu einem Zeitpunkt werden sämtliche Änderungen errechnet und dann in einem Rutsch ausgeführt. Dadurch wird das einigermaßen Stabil. Ich habs auch schon geschafft, dass das eine oder andere Partikelchen eine (scheinbar) stabile Ellipsenbahn um eine große Masse einnimmt! Ist aber nicht zu häufig, da die Ränder ja als Banden fungieren. Hier wird's dann die Option geben, dass die enfliehenden Partikel verschwinden - gute Idee!

Eine feste stationäre Masse wäre auch eine feine Sache! Wird gemacht

@maximov: Die Masse "pennt"
Und was meinst du mit "durchcyceln" ?

@FlorianH: Jupp, hab ich leider zu spät gesehen. -> ToDo

@Rackergen2: Nö . Ist halt etwas Vektorrechnung gepaart mit 1/r²

@maximov(2): Die Sache mit den Buttons ist die: [Start] startet eine Schleife mit einem Application.ProcessMessages. Pause beendet diese Schleife nicht, sondern nimmt nur den Berechnungsblock raus, so dass nurnoch das ProcesssMessages geloopt wird. Erst der Stop-Button beendet die äusserste Schleife, und erst jetzt lässt sich das Programm schließen bzw. tut es das wenn vorher irgendwann das X gedrückt wurde. Diese etwas wenig elegante Methode habe ich gewählt, da ich irgendwie keine Lust auf Threads hatte
So in etwa ists:

Delphi-Quellcode:

procedure onBtnStartClick(Sender: TObject);
begin
  aborted := false;
  paused := false;

  while not aborted do
  begin
    if not paused then
    begin
      MacheRechnungUndZeichne;
    end;
    Application.Processmessages;
  end;
end;

und die Buttons schalten jeweils nur die Flags.

\\edit: Ach ja! Ne DirectX-Version gibt es quasi schon. Halt an Stelle von Graphics32 nen DirectDraw-Image... Aber der Vorteil ist absolut minimal, da G32 schon sehr fix ist, und die reine Darstellung Kleinkram ist. Zumal DirectDraw nativ kein Zeichnen von antialiasten Linien (Richtungsvektoren) mitbringt, und es wird noch die Option "Motionblur" geben - nur wie in nem anderen Thread bereits geschrieben kann DD selbst DAS nicht von Hause aus. Dafür muss man auf Direct3D zurückgreifen, und das ist mir für so einen kleinen Effekt zu heftig.


Schicken Gruß,
bis die Tage,
dizzy

[maximov]

Zitat von dizzy:

@maximov: Die Masse "pennt"
Und was meinst du mit "durchcyceln" ?

Du kennst doch das spiel 'Asteroids' (das mit den felsbrocken im welt raum, die man zerschiessen kann)? Wenn ein fels oben verschwindet, dann kommt er von unter wieder rein. Das könnte lustige effekte geben. Geil wär auch, wenn man auf grosse massen schiessen könnte und diese dann zerfallen.

Zitat:

@maximov(2): Die Sache mit den Buttons ist die: [Start] startet eine Schleife mit einem Application.ProcessMessages. Pause beendet diese Schleife nicht, sondern nimmt nur den Berechnungsblock raus, so dass nurnoch das ProcesssMessages geloopt wird. Erst der Stop-Button beendet die äusserste Schleife, und erst jetzt lässt sich das Programm schließen bzw. tut es das wenn vorher irgendwann das X gedrückt wurde. Diese etwas wenig elegante Methode habe ich gewählt, da ich irgendwie keine Lust auf Threads hatte

Threads würd ich auf nicht machen, da hast du nur sychronisations-kosten. Aber du kannst ganz leicht das application.OnIdle event nutzen:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin
...
  Application.OnActivate := AppActivate;
  Application.OnDeactivate := AppDeactivate; 
end;

procedure TForm1.GameFrame(Sender: TObject; var Done: Boolean);
begin
  MacheRechnungUndZeichne;
  Done := false;
end;

procedure TForm1.AppActivate(Sender: TObject);
begin 
    application.OnIdle := GameFrame;                                 
end;


procedure TForm1.AppDeactivate(Sender: TObject);
begin
  application.OnIdle := nil;
end;

Und wenn du zu anderen apps wechselst, dann wird der game loop ausser kraft gesetz.

Zitat:

\\edit: Ach ja! Ne DirectX-Version gibt es quasi schon. Halt an Stelle von Graphics32 nen DirectDraw-Image... Aber der Vorteil ist absolut minimal, da G32 schon sehr fix ist, und die reine Darstellung Kleinkram ist. Zumal DirectDraw nativ kein Zeichnen von antialiasten Linien (Richtungsvektoren) mitbringt, und es wird noch die Option "Motionblur" geben - nur wie in nem anderen Thread bereits geschrieben kann DD selbst DAS nicht von Hause aus. Dafür muss man auf Direct3D zurückgreifen, und das ist mir für so einen kleinen Effekt zu heftig.

Nicht wenn man 'ne fertige render engine hat ...leider hab ich momentan dafür keine zeit. Aber is so ja auch geil

[dizzy]

OnIdle nutzen so wie du schreibst klingt mal nach einer richtig guten Idee , so werd ich's umfrickeln! Cool!
Und das Cyclen ist mir getz auch klar. Klingt auch fein, da muss dan mal ne Auswahlkiste rein mit allem möglich was man mit sonnem Partikel machen kann wenns abhaut


Bis die Tage,
dizzy

[dizzy]

Jetzt endlich bin ich so weit. Hier der ganze Quatsch - mit Soße

Mit eine Klitzekleinigkeit bin ich noch etwas unzufrieden, nämlich der Anzeige der Raumverzerrung insbesondere bei großen Massen. Da kommt es leider noch etwas zu "Raumfaltung" die nicht sein dürfte. Aber es sieht trotzdem ganz nett aus, und mir sind die Ideen ausgegangen wie man das ändern könnte. Nun wurscht, dast Ding ist ganz schick geworden (es sind zur oberen Version ein paar Features dazugekommen).
Sicherlich könnte man an der einen oder anderen Stelle performanter Proggen, aber mir reicht's so wie es ist


Nochmals viel Spaß damit!
gruss,
dizzy

\\Nachtrag: Um den Source zu kompilieren braucht ihr die Graphics32 Library. Wie es mit Delphi < 7 aussieht weiss ich net.

\\edit: UPDATE! Die Version von gestern Nacht hat noch ein Feature, nämlich ein Speicherleck beim Beenden. -> fixed
Die Berechnung der Partikel benötigt jetzt nicht mehr unnötigerweise (n^2 - n) Rechenschritte, sondern nur noch (n^2 + n)/2 (Dreieickszahlen). Durch Luckies Nachfragen ists mir erst aufgefallen...

[Luckie]

Delphi-Quellcode:

function VectorLength(v: TVector): double;
asm
  fld  v.x;
  fmul v.x;
  fld  v.y;
  fmul v.y;
  faddp;
  fsqrt;
  fstp result;
// In Delphi-Language:
//  result := sqrt(sqr(v[0])+sqr(v[1]));
end;

Optimiert hier der Delphi Compiler so schlecht?

Nachtrag: Bei sehr vielen Partikeln leidet die Performance doch recht stark.

[dizzy]

Zitat von Luckie:

Optimiert hier der Delphi Compiler so schlecht?

Nuja, rein subjektiv war der asm-Code merklich schneller. Also hab ich ihn gelassen (war eigentlich nur testweise) .
\\edit: Da fällt mir auf: Der Delphi-Code ist sogar mitlerweile falsch . TVector war mal ein Array. Mittlerweile ists ein record mit TVector.x und TVector.y *hüstel*.

Zitat von Luckie:

Nachtrag: Bei sehr vielen Partikeln leidet die Performance doch recht stark.

Das ist ja gerade das Problem einer solchen Simulation. Jeder Partikel wirkt auf jeden anderen, und umgekehrt. Es muss also wirklich jeder Partikel durchlaufen werden, und gegen jeden weiteren verrechnet.
Es sind immer (n^2 - n) (n = Partikelanzahl) Verrechnungsschritte nötig, die ihrerseits nochmal diverse Divisionen und weitere Rechnungen beinhalten. Da schlägt natürlich jeder Partikel mehr sehr stark zu Buche. Lässt man zusätzlich noch das Gitter anzeigen, werden weitere solche Schleifen durchlaufen, da jeder Gitterpunkt ähnlich wie die Partikel gegen jeden vorhandenen Partikel verrechnet werden muss. Ich finde dafür ist die Simulation sogar noch recht fix .

Nachti!
dizzy

[TeronG]

Echt Spitze die Soße
giebts das auch als Screensaver??

[dizzy]

Noch nicht. Aber ist sicherlich recht schnell machbar, da man ja nur auf Fullscreen umfrickeln muss, und statt .exe .scr schreiben

btw: gibt nen Update