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

Aktuelle Zeit: Mi Mai 15, 2024 05:59

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



Ein neues Thema erstellen Auf das Thema antworten  [ 10 Beiträge ] 
Autor Nachricht
BeitragVerfasst: Di Okt 24, 2006 10:26 
Offline
DGL Member

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

ich bin ein Nutzer von Newton.dll und wollte nun in anlehnung an diese hervoragende Physik enginge meinen Objecten auch die Möglichkeit geben eine Komplette Dreh, Positionsinfo zu erstellen.

Also in Newton gibts ne Möglichkeit die heist
Code:
  1. NewtonBodyGetMatrix(NewtonBody, @Matrix[0, 0]);
  2.  
Matrix ist dabei vom Typ
Code:
  1. TMatrix4f = Array[0..3, 0..3] Of Single;
man macht dann
Code:
  1. glMultMatrixf(@Matrix[0, 0]);

und kann sein Object Rendern und alles ist gut.

Das Functioniert wunderbar.

Also Dachte ich mir mache ich das auch
die Daten meines Objectes Habe ich nur Kriege ich sie nicht alle in die Matrix, da newton das schafft , mus es aber gehn. Ich weis nur net wie.

ich will gar nicht alles Umsetzen
nur
Code:
  1. GLTranslatef(x,y,z);
  2. Glrotatef(xr,1,0,0);
  3. Glrotatef(yr,0,1,0);
  4. Glrotatef(zr,0,0,1);
Also hab ich angefanden mal aus zu Probieren und habe auch viel rausbekommen.

die Diagonal Elemente mus ich immer auf 1 Lassen.
und Das Translatef ist auch kein Problem
Code:
  1. Matrix[0, 0] := 1; // Die Diagonalelemente müssen 1 sein
  2.     Matrix[0, 1] := 0; // Verzerren um die X - Achse
  3.     Matrix[0, 2] := 0; // Verzerren um die Y - Achse
  4.     Matrix[0, 3] := 0; // Bedeutung unbekannt
  5.     Matrix[1, 0] := 0; // Bedeutung unbekannt
  6.     Matrix[1, 1] := 1; // Die Diagonalelemente müssen 1 sein
  7.     Matrix[1, 2] := 0; // Verzerren um die Z - Achse
  8.     Matrix[1, 3] := 0; // Bedeutung unbekannt
  9.     Matrix[2, 0] := 0; // Bedeutung unbekannt
  10.     Matrix[2, 1] := 0; // Bedeutung unbekannt
  11.     Matrix[2, 2] := 1; // Die Diagonalelemente müssen 1 sein
  12.     Matrix[2, 3] := 0; // Bedeutung unbekannt
  13.     Matrix[3, 0] := x; // Die X - Position im Raum
  14.     Matrix[3, 1] := y; // Die Y - Position im Raum
  15.     Matrix[3, 2] := z; // Die Z - Position im Raum
  16.     Matrix[3, 3] := 1; // Die Diagonalelemente müssen 1 sein

Mein Problem ist das ich die Drehungen nicht Rein bekomme.

Es mus aber Gehen denn bei Newton.dll Klappt es auch , die Frage ist nur wie Geht es weis das einer von Euch ?


Zuletzt geändert von Corpsman am Di Okt 24, 2006 19:57, insgesamt 2-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Okt 24, 2006 10:43 
Offline
DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)
Ich biete Dir mal einen Auszug aus meinem Code an, allerdings ertellt dieser eine Rotation um einen Vektor, d.h. die Matrix beinhaltet gleichzeitig (in dieser Reihenfolge) Rotation um x, y und z Achse. Quasi Drei Rotationen hintereinander, als würdest Du erst um x, dann um y und dann um z rotieren und diese Matritzen gleich miteinander multiplizieren.
Code:
  1.  
  2. //Typedefs
  3. TGLMatrix=Record
  4.     Case Boolean of
  5.       True: (A: Array[0..15] of GLDouble);
  6.       False: (M: Array[0..3,0..3] of GLDouble);
  7.     // ATTENTION OpenGL stores Column-leading
  8.     // first index is Column, second is Row
  9.     // e.g.: 1st col, 3rd row would be [0,2] not [2,0]
  10.   End;
  11.  
  12.   TGLVector=Record
  13.    Case Integer Of
  14.     0: (X: GLDouble;
  15.         Y: GLDouble;
  16.         Z: GLDouble);
  17.     1: (Width: GLDouble;
  18.         Depth: GLDouble;                                    
  19.         Height: GLDouble);
  20.     2: (Tilt: GLDouble;
  21.         Roll: GLDouble;
  22.         Pan: GLDouble);
  23.   End;
  24. //hier Berechnung der Rotationsmatrix
  25. Function VecToRotationMatrix(_oAxis: TGLVector;
  26.                              _dRotation: GLDouble): TGLMatrix;
  27. Var
  28.   c: Double;
  29.   s: Double;
  30. Begin
  31.   c:=cos(_dRotation);
  32.   s:=sin(_dRotation);
  33.   Result.M[0,0]:=c + (1-c)*sqr(_oAxis.X);
  34.   Result.M[0,1]:=(1-c)*_oAxis.X*_oAxis.Y + s*_oAxis.Z;
  35.   Result.M[0,2]:=(1-c)*_oAxis.Z*_oAxis.X - s*_oAxis.Y;
  36.   Result.M[0,3]:=0;
  37.  
  38.   Result.M[1,0]:=(1-c)*_oAxis.X*_oAxis.Y - s*_oAxis.Z;
  39.   Result.M[1,1]:=c + (1-c)*sqr(_oAxis.Y);
  40.   Result.M[1,2]:=(1-c)*_oAxis.Y*_oAxis.Z + s*_oAxis.X;
  41.   Result.M[1,3]:=0;
  42.  
  43.   Result.M[2,0]:=(1-c)*_oAxis.Z*_oAxis.X + s*_oAxis.Y;
  44.   Result.M[2,1]:=(1-c)*_oAxis.Y*_oAxis.Z - s*_oAxis.X;
  45.   Result.M[2,2]:=c + (1-c)*sqr(_oAxis.Z);
  46.   Result.M[2,3]:=0;
  47.  
  48.   Result.M[3,0]:=0;
  49.   Result.M[3,1]:=0;
  50.   Result.M[3,2]:=0;
  51.   Result.M[3,3]:=1;
  52. End;
  53.  

hier sind sozusagen gleich alle Achsen verwurstet.
[edit]hab gelogen. erst wird um die Z-Achse Rotiert, dann um die (verdrehte) X-Achse, als letztes um die (2x verdrehte) Y-Achse. Das ist insofern wichtig, da die Multiplikation von Matritzen nicht dem Kommutativgesetz unterliegt. Diese Reihenfolge schien mir für mein Projekt am Sinnvollsten, da ich hauptsächlich um Z rotiert habe[/edit]
[edit2] Du kannst die Rotationsreihenfolge dennoch ändern, indem du Dir erst eine Rotationsmatrix um ey geben lässt, diese verarbeitest, dann eine um ez und so weiter[/edit2]

_________________
Manchmal sehen Dinge, die wie Dinge aussehen wollen, mehr wie Dinge aus, als Dinge.
<Esmerelda Wetterwax>
Es kann vorkommen, dass die Nachkommen trotz Abkommen mit ihrem Einkommen nicht auskommen und umkommen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Okt 24, 2006 11:24 
Offline
DGL Member

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

Da ich immer nur

Code:
  1.  
  2. Gltranslatef(x,y,0);
  3. glrotatef(angle,0,0,1);
  4.  


machen mus brauche ich mir um die Kommutativität ja keine sorgen machen.

So dann werde ich mal versuchen deinen Code zu verstehn \";)\"

[edit]

Ich stelle fest es geht nicht \":(\"

hab das ganze nu so gemacht

also ich Drehe immer nur um Z

Code:
  1.  
  2. Function Telement.GetOpenGlMatrix: TMatrix4f;
  3.  
  4. Type
  5.   TGLMatrix = Record
  6.  
  7.     Case Boolean Of
  8.  
  9.       True: (A: Array[0..15] Of single);
  10.  
  11.       False: (M: Array[0..3, 0..3] Of single);
  12.  
  13.       // ATTENTION OpenGL stores Column-leading
  14.  
  15.       // first index is Column, second is Row
  16.  
  17.       // e.g.: 1st col, 3rd row would be [0,2] not [2,0]
  18.  
  19.   End;
  20.  
  21.   TGLVector = Record
  22.  
  23.     Case Integer Of
  24.       0: (X: single;
  25.         Y: single;
  26.         Z: single);
  27.       1: (Width: single;
  28.         Depth: single;
  29.         Height: single);
  30.       2: (Tilt: single;
  31.         Roll: single;
  32.         Pan: single);
  33.   End;
  34.   //hier Berechnung der Rotationsmatrix
  35.   Function VecToRotationMatrix(_oAxis: TGLVector;
  36.     _dRotation: single): TGLMatrix;
  37.   Var
  38.     c: Double;
  39.     s: Double;
  40.   Begin
  41.     c := cos(_dRotation);
  42.     s := sin(_dRotation);
  43.     Result.M[0, 0] := c + (1 - c) * sqr(_oAxis.X);
  44.     Result.M[0, 1] := (1 - c) * _oAxis.X * _oAxis.Y + s * _oAxis.Z;
  45.     Result.M[0, 2] := (1 - c) * _oAxis.Z * _oAxis.X - s * _oAxis.Y;
  46.     Result.M[0, 3] := 0;
  47.     s := 0;// ich Drehe ja nur um Z
  48.     c := 0;// ich Drehe ja nur um Z
  49.     Result.M[1, 0] := (1 - c) * _oAxis.X * _oAxis.Y - s * _oAxis.Z;
  50.     Result.M[1, 1] := c + (1 - c) * sqr(_oAxis.Y);
  51.     Result.M[1, 2] := (1 - c) * _oAxis.Y * _oAxis.Z + s * _oAxis.X;
  52.     Result.M[1, 3] := 0;
  53.  
  54.     Result.M[2, 0] := (1 - c) * _oAxis.Z * _oAxis.X + s * _oAxis.Y;
  55.     Result.M[2, 1] := (1 - c) * _oAxis.Y * _oAxis.Z - s * _oAxis.X;
  56.     Result.M[2, 2] := c + (1 - c) * sqr(_oAxis.Z);
  57.  
  58.     Result.M[2, 3] := 0;
  59.     Result.M[3, 0] := 0;
  60.     Result.M[3, 1] := 0;
  61.     Result.M[3, 2] := 0;
  62.     Result.M[3, 3] := 1;
  63.   End;
  64. Var
  65.   b: TGLMatrix;
  66.   d: TGLVector;
  67.   i, j: integer;
  68. Begin
  69.   d.x := x;
  70.   d.y := y;
  71.  
  72.   b := VecToRotationMatrix(d, Angle * 180 / pi);
  73.  
  74.   For i := 0 To 2 Do
  75.     For j := 0 To 2 Do
  76.       result[i, j] := b.m[i, j];
  77.  
  78.       //body.Angle * 180 / pi
  79.         //  Es Fehlt noch die Berücksichtigung der Drehungen
  80.           {  glLoadIdentity;
  81.             glTranslatef(B.body.centerofmass.x, B.body.centerofmass.y, 0);
  82.             glRotatef(B.body.Angle * 180 / pi, 0, 0, 1);}
  83.  
  84.  
  85. End;
  86.  


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Okt 24, 2006 12:57 
Offline
DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)
Also ich weiss nixht, wo Du x und y hernimmst, aber wenn Du um Z rotieren willst, musst du den Achsenvektor mit 0,0,1 angeben, also d.x:=0, d.y:=0,d.z:=1.
Desweiteren gibt Dir meine Funktion die fertige Rotationsmatrix wieder, diese musst Du dann einfach mit der aktuell gesetzten OpenGL-Matrix multiplizieren. Für eventuelle Scherungen musst Du natürlich eine eigene Matrix erzeugen und getrennt anwenden (Translationen kannst Du gleich in diese Matrix einbauen, da sie ja nur die letzte Spalte beeinflussen).
Falls Angle in Grad ist, musst Du natürlich durch 180 teilen und mal pi nehmen, nicht andersherum.
p.s. erst jetzt entdeckt: In der Funktion darfst Du Sin und Cos NICHT null setzen, da durch die Verwurstung der drei Rotationen die z-Rotation alle Elemente, die gesetzt werden beinflusst.

_________________
Manchmal sehen Dinge, die wie Dinge aussehen wollen, mehr wie Dinge aus, als Dinge.
<Esmerelda Wetterwax>
Es kann vorkommen, dass die Nachkommen trotz Abkommen mit ihrem Einkommen nicht auskommen und umkommen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Okt 24, 2006 16:04 
Offline
DGL Member

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

Also x, y, und Angle sind variablen der Klasse TElement.

x,y die Position, und Angle die Rotation um die Z-Achse

Da ich 2D - Graphiken mache Reicht mir das vollkommen aus.

Leider geht es so aber nicht.

Das Bild ist total verzerrt, sieht aus wie wenn es Rechts unten ein schwarzes Loch hätte was alles ansaugt ;)

Code:
  1.  
  2. Function Telement.GetOpenGlMatrix: TMatrix4f;
  3.  
  4. Type
  5.   TGLMatrix = Record
  6.  
  7.     Case Boolean Of
  8.  
  9.       True: (A: Array[0..15] Of single);
  10.  
  11.       False: (M: Array[0..3, 0..3] Of single);
  12.  
  13.       // ATTENTION OpenGL stores Column-leading
  14.  
  15.       // first index is Column, second is Row
  16.  
  17.       // e.g.: 1st col, 3rd row would be [0,2] not [2,0]
  18.  
  19.   End;
  20.  
  21.   TGLVector = Record
  22.  
  23.     Case Integer Of
  24.       0: (X: single;
  25.         Y: single;
  26.         Z: single);
  27.       1: (Width: single;
  28.         Depth: single;
  29.         Height: single);
  30.       2: (Tilt: single;
  31.         Roll: single;
  32.         Pan: single);
  33.   End;
  34.   //hier Berechnung der Rotationsmatrix
  35.   Function VecToRotationMatrix(_oAxis: TGLVector;
  36.     _dRotation: single): TGLMatrix;
  37.   Var
  38.     c: Double;
  39.     s: Double;
  40.   Begin
  41.     c := cos(_dRotation);
  42.     s := sin(_dRotation);
  43.     Result.M[0, 0] := c + (1 - c) * sqr(_oAxis.X);
  44.     Result.M[0, 1] := (1 - c) * _oAxis.X * _oAxis.Y + s * _oAxis.Z;
  45.     Result.M[0, 2] := (1 - c) * _oAxis.Z * _oAxis.X - s * _oAxis.Y;
  46.     Result.M[0, 3] := 0;
  47.  
  48.     Result.M[1, 0] := (1 - c) * _oAxis.X * _oAxis.Y - s * _oAxis.Z;
  49.     Result.M[1, 1] := c + (1 - c) * sqr(_oAxis.Y);
  50.     Result.M[1, 2] := (1 - c) * _oAxis.Y * _oAxis.Z + s * _oAxis.X;
  51.     Result.M[1, 3] := 0;
  52.  
  53.     Result.M[2, 0] := (1 - c) * _oAxis.Z * _oAxis.X + s * _oAxis.Y;
  54.     Result.M[2, 1] := (1 - c) * _oAxis.Y * _oAxis.Z - s * _oAxis.X;
  55.     Result.M[2, 2] := c + (1 - c) * sqr(_oAxis.Z);
  56.  
  57.     Result.M[2, 3] := 0;
  58.     Result.M[3, 0] := 0;
  59.     Result.M[3, 1] := 0;
  60.     Result.M[3, 2] := 0;
  61.     Result.M[3, 3] := 1;
  62.   End;
  63. Var
  64.   b: TGLMatrix;
  65.   d: TGLVector;
  66.   i, j: integer;
  67. Begin
  68.   d.x := 0;
  69.   d.y := 0;
  70.   d.z := 1;
  71.   b := VecToRotationMatrix(d, Angle);
  72.   For i := 0 To 2 Do
  73.     For j := 0 To 2 Do
  74.       result[i, j] := b.m[i, j];
  75.   Result[3, 0] := x; // Die X - Position im Raum
  76.   Result[3, 1] := y; // Die Y - Position im Raum
  77.   Result[3, 2] := 0; // Die Z - Position im Raum
  78. end;


Zum Initialisieren von OpenGL mache ich for jedem rendern übrigens:

Code:
  1.  
  2.   Hig := GlPanel.Height / GlPanel.Width * 20;
  3.   glClear(GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT);
  4.   glMatrixMode(GL_PROJECTION);
  5.   glLoadIdentity;
  6.   glOrtho(0, 20, 0, Hig, 0, 1);
  7.   glMatrixMode(GL_MODELVIEW);
  8.   glLoadIdentity;
  9.  


Damit sehe ich dann einen auschnitt der 20 Längeneinheiten Breit ist.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Okt 24, 2006 18:18 
Offline
DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)
Ohne Informationen, was Du mit Deiner Result-Variable machst, kann ich nur Kaffeesatz lesen. Sprich: etwas Code, was mit der Matrix passier und evtl. nen Screenshot wäre toll :wink:

_________________
Manchmal sehen Dinge, die wie Dinge aussehen wollen, mehr wie Dinge aus, als Dinge.
<Esmerelda Wetterwax>
Es kann vorkommen, dass die Nachkommen trotz Abkommen mit ihrem Einkommen nicht auskommen und umkommen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Okt 24, 2006 19:54 
Offline
DGL Member

Registriert: Mo Jun 12, 2006 14:47
Beiträge: 75
Programmiersprache: Object FPC
Code:
  1.  
  2. Procedure TWorldelement.render;
  3. Var
  4.  Matrix: TMatrix4f;
  5. Begin
  6.  glPushMatrix;
  7.  matrix := body.GetOpenGlMatrix;
  8.  glMultMatrixf(@Matrix[0, 0]);
  9.  body.render;
  10.  glpopmatrix;
  11. End;
  12.  


Wobei body eine Lokace Varaible von TWorldelement ist und vom Typ TElement.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Okt 25, 2006 07:22 
Offline
DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)
Fällt mir jetzt nix Ungewöhnliches dran auf, ausser, dass, falls Du keine Verschachtelungen der Elemente hast, du diese Matrix einfach als Projektionsmatrix setzen kannst.
Falls Du allerdings Verschachtelungen hast und Du ein 'schwarzes Loch' Phänomen beobachtest, kanns noch daran Liegen, dass die Rotationen/Verscheibungen der einzelnen Elemente nicht relativ zum übergeordneten, sondern zur Welt angegeben sind. Dann musst Du in jedem Fall diese Matrix einfach setzen und nicht mit der aktuellen multiplizieren.

_________________
Manchmal sehen Dinge, die wie Dinge aussehen wollen, mehr wie Dinge aus, als Dinge.
<Esmerelda Wetterwax>
Es kann vorkommen, dass die Nachkommen trotz Abkommen mit ihrem Einkommen nicht auskommen und umkommen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Okt 25, 2006 13:46 
Offline
DGL Member

Registriert: Mo Jun 12, 2006 14:47
Beiträge: 75
Programmiersprache: Object FPC
Juhu es funktioniert.

Habe heute mit einem MatheStudenten gesprochen , der hat es mir erklärt.

Und ein bischen Nicht deterministisches Raten Ergaben dann :
Code:
  1. Function TElement.GetOpenGlMatrix: TMatrix4f;
  2. Var
  3.   c: extended;
  4.   s: extended;
  5. Begin
  6.   SinCos(angle, s, c);
  7.   Result[0, 0] := c;
  8.   Result[0, 1] := s;
  9.   Result[0, 2] := 0;
  10.   Result[0, 3] := 0;
  11.   Result[1, 0] := -s;
  12.   Result[1, 1] := c;
  13.   Result[1, 2] := 0;
  14.   Result[1, 3] := 0;
  15.   Result[2, 0] := 0;
  16.   Result[2, 1] := 0;
  17.   Result[2, 2] := c + (1 - c);
  18.   Result[2, 3] := 0;
  19.   Result[3, 0] := x; // Die X - Position im Raum
  20.   Result[3, 1] := y; // Die Y - Position im Raum
  21.   Result[3, 2] := 0; // Die Z - Position im Raum
  22.   Result[3, 3] := 1;
  23. End;


Und das Functioniert wunderbar :)

Es geht halt deswegen weil ich nur um Z drehe und dann sehr viele 0en reinkommen ;)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Okt 25, 2006 14:55 
Offline
DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)
Kannst ja spaseshalber mal meine Matrix nehmen und die Formeln mit x=0 und y=0 vereinfachen. Dann sollte eigentlich die Matrix von dem Mathe-Studenten rauskommen. Wenn nicht, hab ich was falsch gemacht.
Ich hab quasi jeweils ne Rotation um x,y und z genommen und die resultierenden Matritzen multiliziert.
Dadurch ergeben sich dann diese Formeln. Wenn man die Reihenfolge der Multiplikation ändert, ergeben sich ganz andere Formeln für die einzelnen Elemente. Meine Berechnung ist also nur eine von sechs möglichen Kombinationen.

_________________
Manchmal sehen Dinge, die wie Dinge aussehen wollen, mehr wie Dinge aus, als Dinge.
<Esmerelda Wetterwax>
Es kann vorkommen, dass die Nachkommen trotz Abkommen mit ihrem Einkommen nicht auskommen und umkommen.


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


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 2 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.030s | 19 Queries | GZIP : On ]