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

Aktuelle Zeit: Mi Jul 09, 2025 13:53

Foren-Übersicht » Programmierung » Allgemein
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 12 Beiträge ] 
Autor Nachricht
 Betreff des Beitrags: 2d Physik-Engine
BeitragVerfasst: Fr Mai 05, 2006 14:50 
Offline
DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710
Ich habe gerade die Arbeiten an meinem lange geplanten 2d game
begonnen. jetzt stellt sich die frage der physik, ich wollte einige
physikalische features einbauen, damit das game net alzu langweilig wird.
wie mache ich das am besten ?
da das ein tiefer einschnitt in das spiel ist, habe ich bisher auch net alzu viel.

schonmal vielen dank ;)

mfg


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 14:58 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Nun, wenn du hier im Forum nach Physik fragst, dann bekommst du vermutlich immer diese Antwort:

Guck dir doch mal "Newton" an. Das ist eine freie Physikengine, die alles mögliche kann.

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 15:20 
Offline
DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710
ja, aber die frage geht ja in richtung 2d, newton ist doch sicherlich 3d spezifisch. bei 2d ließe sich da sicherlich mehr performance rausholen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 15:34 
Offline
Forenkatze
Benutzeravatar

Registriert: Mi Okt 22, 2003 18:30
Beiträge: 1945
Wohnort: Närnberch
Programmiersprache: Scala, Java, C*
ja sicherlich. Auch wenn man prinzipiell eine 3D-Physik-Engine genausogut für 2D nehmen kann (und das wird auch ab und zu gemacht *g*), ist eine reine 2D-Physik-Engine performance-mäßig natürlich besser. Falls du nur so Sachen wie Kollisionsabfrage benötigst, kannst du ja mal nen Blick in die Links hier riskieren. Dort ist iirc eine 2D-Physik-Engine gelistet bzw. Units, die AABB-Kollisionen und solche Sachen berechnen ;)

_________________
"Für kein Tier wird so viel gearbeitet wie für die Katz'."


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 15:51 
Offline
DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710
das einzige was ich gefunde habe waren bsp-trees, ist das die richtige anlaufstation für 2d ?
ich hab mal von einer library für kollisionsdetektion gehört die sehr schnell sein soll, aber
einfachheit geht mir dann vor performance, also gucke ich mir mal newton an ;)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 18:37 
Offline
DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710
gibt es irgendwo tutorials für einfache physikalische simulationen zu newton ?


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 18:49 
Offline
Ernährungsberater
Benutzeravatar

Registriert: Sa Jan 01, 2005 17:11
Beiträge: 2068
Programmiersprache: C++
Schau mal hier: http://newton.delphigl.de/


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 18:55 
Offline
DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710
die demos habe ich schon längst, ich habe ja auch nach einem tutorial gefragt ;)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 19:22 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Am besten nach Verlet Integration googlen. Das ist sehr einfach zu programmieren.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Mai 05, 2006 19:23 
Offline
DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710
ich hab mich auch schonmal schlau gemacht, das schwerste scheinen ja die kollisionsabfragen zu sein, der rest ist ne menge formelzeuch mit dem man eigentlich klarkommen sollte ;)

verlet integration hab ich jetzt nichts gescheites auf deutsch gefunden und naja einen englisch dokumentieren c++ code, aber bei physik ist es schon schwer genug das ganze auf deutsch zu verstehen. und auf deutsch hab ich mal wieder nichts gefunden :(

Absolut hilfreich fände ich ein kleines beispiel, kA einfach eine kiste die fix steht und eine die obendrauf fällt, mehr brauche ich auch nicht, das ganze dann in 2d, wäre sehr sehr nett, wenn einer sowas als demo mal machen könnte.

mfg


nach ein wenig gefriemel hab ich den einen sdl code in delphi zum laufen bekommen (mit forms):
Code:
  1.  
  2. unit UMain;
  3.  
  4. interface
  5.  
  6. uses
  7.   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  8.   Dialogs, DGLOpenGL, NewtonImport, Textures, AppEvnts;
  9.  
  10. type
  11.   TVector3f = record
  12.     X,Y,Z : Single;
  13.    end;
  14.   TMatrix4f = array[0..3, 0..3] of Single;
  15.   TNewtonBox = class
  16.     NewtonBody : PNewtonBody;
  17.     Matrix: TMatrix4f;
  18.     Size: TVector3f;
  19.     constructor Create(pSize, pPosition : TVector3f; pMass : Single);
  20.     procedure Render;
  21.   end;
  22.  
  23. var
  24.  Rotation: Single;
  25.  NewtonWorld: PNewtonWorld;
  26.  NewtonBox: array of TNewtonBox;
  27.  AccTimeSlice: Single;
  28.  TimeLastFrame: Cardinal;
  29.  
  30. type
  31.   TMainForm = class(TForm)
  32.     ApplicationEvents1: TApplicationEvents;
  33.     procedure FormCreate(Sender: TObject);
  34.     procedure IdleHandler(Sender: TObject; var Done: Boolean);
  35.     procedure FormDestroy(Sender: TObject);
  36.   private
  37.     StartTime, TimeCount, FrameCount, Frames, DrawTime: Cardinal;
  38.     procedure SetupGL;
  39.     procedure Init;
  40.     procedure Render;
  41.     procedure ErrorHandler;
  42.   public
  43.     DC: HDC;
  44.     RC: HGLRC;
  45.   end;
  46.  
  47. var
  48.   MainForm: TMainForm;
  49.  
  50. implementation
  51.  
  52. {$R *.dfm}
  53.  
  54. function V3(pX, pY, pZ: Single): TVector3f;
  55. begin
  56.   Result.x := pX;
  57.   Result.y := pY;
  58.   Result.z := pZ;
  59. end;
  60.  
  61. procedure ForceAndTorqueCallback(const body: PNewtonBody); cdecl;
  62. var
  63.   Mass: Single;
  64.   Inertia: TVector3f;
  65.   Force: TVector3f;
  66. begin
  67.   NewtonBodyGetMassMatrix(Body, @Mass, @Inertia.x, @Inertia.y, @Inertia.z);
  68.   Force := V3(0, -9.8 * Mass, 0);
  69.   NewtonBodyAddForce(Body, @Force.x);
  70. end;
  71.  
  72. constructor TNewtonBox.Create(pSize, pPosition: TVector3f; pMass: Single);
  73. var
  74.   Inertia: TVector3f;
  75.   Collision: PNewtonCollision;
  76. begin
  77.   Size := pSize;
  78.   Collision  := NewtonCreateBox(NewtonWorld, pSize.x, pSize.y, pSize.z, nil);
  79.   NewtonBody := NewtonCreateBody(NewtonWorld, Collision);
  80.   NewtonReleaseCollision(NewtonWorld, Collision);
  81.   Inertia.x := pMass * (pSize.y * pSize.y + pSize.z * pSize.z) / 12;
  82.   Inertia.y := pMass * (pSize.x * pSize.x + pSize.z * pSize.z) / 12;
  83.   Inertia.z := pMass * (pSize.x * pSize.x + pSize.y * pSize.y) / 12;
  84.   NewtonBodySetMassMatrix(NewtonBody, pMass, Inertia.x, Inertia.y, Inertia.z);
  85.   NewtonBodyGetMatrix(NewtonBody, @Matrix[0,0]);
  86.   Matrix[3,0] := pPosition.x;
  87.   Matrix[3,1] := pPosition.y;
  88.   Matrix[3,2] := pPosition.z;
  89.   NewtonBodySetMatrix(NewtonBody, @Matrix[0,0]);
  90.   NewtonBodySetForceAndTorqueCallBack(NewtonBody, ForceAndTorqueCallBack);
  91. end;
  92.  
  93. procedure TNewtonBox.Render;
  94. begin
  95.   NewtonBodyGetMatrix(NewtonBody, @Matrix[0,0]);
  96.   glPushMatrix;
  97.    glMultMatrixf(@Matrix[0,0]);
  98.    glScalef(Size.x / 2, Size.y / 2, Size.z / 2);
  99.  
  100.    glBegin(GL_QUADS);
  101.     glNormal3f(0, 0, 1);
  102.      glVertex3f( -1, -1,  1);
  103.      glVertex3f(  1, -1,  1);
  104.      glVertex3f(  1,  1,  1);
  105.      glVertex3f( -1,  1,  1);
  106.     glNormal3f(0, 0, -1);
  107.      glVertex3f( -1, -1, -1);
  108.      glVertex3f( -1,  1, -1);
  109.      glVertex3f(  1,  1, -1);
  110.      glVertex3f(  1, -1, -1);
  111.     glNormal3f(0, 1, 0);
  112.      glVertex3f( -1,  1, -1);
  113.      glVertex3f( -1,  1,  1);
  114.      glVertex3f(  1,  1,  1);
  115.      glVertex3f(  1,  1, -1);
  116.     glNormal3f(0, -1, 0);
  117.      glVertex3f( -1, -1, -1);
  118.      glVertex3f(  1, -1, -1);
  119.      glVertex3f(  1, -1,  1);
  120.      glVertex3f( -1, -1,  1);
  121.     glNormal3f(1, 0, 0);
  122.      glVertex3f(  1, -1, -1);
  123.      glVertex3f(  1,  1, -1);
  124.      glVertex3f(  1,  1,  1);
  125.      glVertex3f(  1, -1,  1);
  126.     glNormal3f(-1, 0, 0);
  127.      glVertex3f( -1, -1, -1);
  128.      glVertex3f( -1, -1,  1);
  129.      glVertex3f( -1,  1,  1);
  130.      glVertex3f( -1,  1, -1);
  131.    glEnd;
  132.    
  133.   glPopMatrix;
  134. end;
  135.  
  136. procedure InitNewton;
  137. var
  138.   TmpV: TVector3f;
  139.   i: Integer;
  140. begin
  141.   NewtonWorld := NewtonCreate(nil, nil);
  142.   SetLength(NewtonBox, 1);
  143.   NewtonBox[0] := TNewtonBox.Create(V3(10, 0.5, 10), V3(0, -2, 0), 0);
  144.   for i := 0 to 9 do
  145.   begin
  146.    SetLength(NewtonBox, Length(NewtonBox) + 1);
  147.    NewtonBox[High(NewtonBox)] := TNewtonBox.Create(V3(1, 1, 1), V3(0, 3 + i * 1.1, 0), 10);
  148.    TmpV := V3(Random(5), Random(5), Random(5));
  149.    NewtonBodySetOmega(NewtonBox[High(NewtonBox)].NewtonBody, @TmpV.x);
  150.   end;
  151. end;
  152.  
  153. procedure TMainForm.Render;
  154. var
  155.   i: Integer;
  156. begin
  157.   AccTimeSlice := AccTimeSlice + (GetTickCount-TimeLastFrame);
  158.   TimeLastFrame := GetTickCount;
  159.  
  160.   glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
  161.  
  162.   glMatrixMode(GL_MODELVIEW);
  163.   glLoadIdentity;
  164.  
  165.   gluPerspective(45.0, ClientWidth / ClientHeight, 1, 1000);
  166.  
  167.   glTranslatef(0, 0, -15);
  168.   glRotatef(15, 1, 0, 0);
  169.   glRotatef(45, 0, 1, 0);
  170.  
  171.   if Length(NewtonBox) > 0 then
  172.     for i := 0 to High(NewtonBox) do
  173.       NewtonBox[i].Render;
  174.  
  175.   SwapBuffers(DC);
  176.  
  177.   Rotation := Rotation + 0.1;
  178.   if Rotation > 360 then
  179.     Rotation := Rotation - 360;
  180.  
  181.   while AccTimeSlice > 12 do
  182.   begin
  183.     NewtonUpdate(NewtonWorld, (12 / 1000));
  184.     AccTimeSlice := AccTimeSlice - 12;
  185.   end;
  186. end;
  187.  
  188. procedure TerminateApplication;
  189. var
  190.   i: Integer;
  191. begin
  192.   if Length(NewtonBox) > 0 then
  193.     for i := 0 to High(NewtonBox) do
  194.       NewtonBox[i].Free;
  195.   NewtonDestroy(NewtonWorld);
  196. end;
  197.  
  198. procedure TMainForm.IdleHandler(Sender: TObject; var Done: Boolean);
  199. begin
  200.   StartTime := GetTickCount;
  201.   Render;
  202.   DrawTime := GetTickCount - StartTime;
  203.   Inc(TimeCount, DrawTime);
  204.   Inc(FrameCount);
  205.  
  206.   if TimeCount >= 1000 then
  207.   begin
  208.     Frames := FrameCount;
  209.     TimeCount := TimeCount - 1000;
  210.     FrameCount := 0;
  211.     MainForm.Caption := InttoStr(Frames) + ' FPS';
  212.     ErrorHandler;
  213.   end;
  214.  
  215.   Done := false;
  216. end;
  217.  
  218. procedure TMainForm.ErrorHandler;
  219. begin
  220.   if glGetError <> GL_NO_ERROR then
  221.     MainForm.Caption := gluErrorString(glGetError);
  222. end;
  223.  
  224. procedure TMainForm.SetupGL;
  225. begin
  226.   glClearColor(0.0, 0.0, 0.0, 0.0);
  227.   glEnable(GL_DEPTH_TEST);
  228.   glEnable(GL_CULL_FACE);
  229. end;
  230.  
  231. procedure TMainForm.Init;
  232. begin
  233.   TimeLastFrame := GetTickCount;
  234.   InitNewton;
  235. end;
  236.  
  237. procedure TMainForm.FormCreate(Sender: TObject);
  238. begin
  239.   DC := GetDC(Handle);
  240.   if not InitOpenGL then Application.Terminate;
  241.   RC := CreateRenderingContext(DC, [opDoubleBuffered], 32, 24, 0, 0, 0, 0);
  242.   ActivateRenderingContext(DC, RC);
  243.   SetupGL;
  244.   Init;
  245. end;
  246.  
  247. procedure TMainForm.FormDestroy(Sender: TObject);
  248. begin
  249.   DeactivateRenderingContext;
  250.   DestroyRenderingContext(RC);
  251.   ReleaseDC(Handle, DC);
  252. end;
  253.  
  254. Initialization
  255.   Randomize;
  256.  
  257. end.
  258.  

das problem ist jetzt, dass ja jede box gleich gezeichnet wird, kann ich irgendwie eine box anders färben ?


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Sa Mai 06, 2006 15:33 
Offline
DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710
ich bin jetzt wieder am anfang, mein versuch eine eigene kleine physik engine zu schreiben.
gibt es irgendwo deutsche anlaufstellen, tutorials, irgendetwas womit man sich das nötige erarbeiten kann.
ich habe einige englische seiten gefunden auf denen das nur schwach und praxisfern erklärt wird.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Mai 09, 2006 02:38 
Offline
DGL Member

Registriert: So Sep 26, 2004 05:57
Beiträge: 190
Wohnort: Linz
Seth hat geschrieben:
ich habe einige englische seiten gefunden auf denen das nur schwach und praxisfern erklärt wird.

Also wenn du englisch halbwegs beherrschst, dann solltest du das mit dem "deutsche tutorials, ..." weg lassen weil du prinzipiell eher mehr in englisch (oder zumindest in englisch oder deutsch :-) ) finden wirst.

Ein nicht ganz so praxisfernes Tutorial (in englisch) findet sich beispielsweise hier:
http://www.harveycartel.org/metanet/tutorials.html

Aber generell ist Gamedev.net auch immer eine recht gute (jedoch häufig eher theoretische) Anlaufstelle für solche Dinge.


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


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 5 Gäste


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:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.011s | 14 Queries | GZIP : On ]