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

Aktuelle Zeit: Mi Jul 16, 2025 19:37

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


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 9 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Corni
 Betreff des Beitrags: Problem mit Richtungsvektoren
BeitragVerfasst: Fr Jan 14, 2005 18:15 
Offline
DGL Member

Registriert: Sa Dez 13, 2003 22:48
Beiträge: 5
moin moin,

ich hab ein Problem und zwar wie ich aus 3 Winkeln meine Richtungsvektoren berechne um mich in der Welt zu bewegen.

Code:
  1.  
  2. procedure TGLFenster.RotumX(var Bx,By,Bz:T3DVector;wx:single);
  3. var b:single;
  4. begin
  5.   bz.x:=by.x*tan(wx)+bz.x;
  6.   bz.y:=by.y*tan(wx)+bz.y;
  7.   bz.z:=by.z*tan(wx)+bz.z;
  8.   b:=sqrt(bz.x*bz.x+bz.y*bz.y+bz.z*bz.z);
  9.   bz.x:=bz.x/b;
  10.   bz.y:=bz.y/b;
  11.   bz.z:=bz.z/b;
  12.   by:=self.CalcNormal(bz,bx);
  13. end;
  14.  
  15. procedure TGLFenster.Rotumy(var Bx,By,Bz:T3DVector;wy:single);
  16. var b:single;
  17. begin
  18.   bx.x:=bz.x*tan(wy)+bx.x;
  19.   bx.y:=bz.y*tan(wy)+bx.y;
  20.   bx.z:=bz.z*tan(wy)+bx.z;
  21.   b:=sqrt(bx.x*bx.x+bx.y*bx.y+bx.z*bx.z);
  22.   bx.x:=bx.x/b;
  23.   bx.y:=bx.y/b;
  24.   bx.z:=bx.z/b;
  25.   bz:=self.CalcNormal(bx,by);
  26. end;
  27.  
  28. procedure TGLFenster.Rotumz(var Bx,By,Bz:T3DVector;wz:single);
  29. var b:single;
  30. begin
  31.   by.x:=bx.x*tan(wz)+by.x;
  32.   by.y:=bx.y*tan(wz)+by.y;
  33.   by.z:=bx.z*tan(wz)+by.z;
  34.   b:=sqrt(by.x*by.x+by.y*by.y+by.z*by.z);
  35.   by.x:=by.x/b;
  36.   by.y:=by.y/b;
  37.   by.z:=by.z/b;
  38.   bx:=self.CalcNormal(by,bz);
  39. end;
  40.  


so ich denk das is der Problemteil.... :)

Tnx for Help

:shock:
Nach oben
 Profil  
Mit Zitat antworten  
La Boda
 Betreff des Beitrags:
BeitragVerfasst: Fr Jan 14, 2005 18:57 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jul 17, 2002 12:07
Beiträge: 976
Wohnort: Tübingen
Dazu haben wir ein sehr gutes Tutorial von SchodMC im Angebot: http://www.delphigl.com/script/do_show.php?name=move1&action=2

_________________
"Du musst ein Schwein sein in dieser Welt, sangen die Prinzen, das ist so 1.0. Du musst auf YouTube zeigen, dass dir dein Schweinsein gefällt, das ist leuchtendes, echtes Web 2.0."
- Hal Faber
Meine Homepage: http://laboda.delphigl.com
Nach oben
 Profil  
Mit Zitat antworten  
Corni
 Betreff des Beitrags:
BeitragVerfasst: Fr Jan 14, 2005 19:26 
Offline
DGL Member

Registriert: Sa Dez 13, 2003 22:48
Beiträge: 5
hmmm ich hab nur eine frage der rest ist mir klar und das ist auch schon im programm der fall :) und zwar wie funktioniert diese procedure ->>> RotateVector(LookVec, RotXAxis, -DegToRad(RotateX)); <<<<- ???
Nach oben
 Profil  
Mit Zitat antworten  
La Boda
 Betreff des Beitrags:
BeitragVerfasst: Fr Jan 14, 2005 19:38 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jul 17, 2002 12:07
Beiträge: 976
Wohnort: Tübingen
Hmm..bei dem Tutorial war eigentlich mal ne Demo dabei, die wird aber nicht mehr verlinkt!?
Hab ein bisschen auf meiner Festplatte gekramt und habs gefunden und mal einen Alternativlink angelegt:
http://laboda.delphigl.com/objmov_src_api.rar
Wenn du dir die Source anschaust, dürftest schon was finden :wink:

_________________
"Du musst ein Schwein sein in dieser Welt, sangen die Prinzen, das ist so 1.0. Du musst auf YouTube zeigen, dass dir dein Schweinsein gefällt, das ist leuchtendes, echtes Web 2.0."
- Hal Faber
Meine Homepage: http://laboda.delphigl.com
Nach oben
 Profil  
Mit Zitat antworten  
dmss
 Betreff des Beitrags:
BeitragVerfasst: Sa Jan 15, 2005 12:38 
Offline
DGL Member

Registriert: Sa Jan 15, 2005 12:28
Beiträge: 3
Hallo ich arbeite mit Corni zusammen und hab mal an dem Problem weitergemacht.
Der obere Vorschlag verfällt damit.
Der neue Code basiert am Matrizen Multiplikation.
Code:
  1.  
  2. procedure TOpenglwindow.setview(View:TView);
  3. var xm,ym,zm,tm:TMatrix;//TMatrix=array[0..15] of single;
  4.      {a0  a4  a8  a12
  5.       a1  a5  a9  a13
  6.       a2  a6  a10 a14
  7.       a3  a7  a11 a15}
  8. begin
  9.   self.View:=View;
  10.   self.changes:=true;
  11.   xm[0]:=1;
  12.   xm[1]:=0;
  13.   xm[2]:=0;
  14.   xm[3]:=0;
  15.   xm[4]:=0;
  16.   xm[5]:=cos(degtorad(self.View.wx));
  17.   xm[6]:=-sin(degtorad(self.View.wx));
  18.   xm[7]:=0;
  19.   xm[8]:=0;
  20.   xm[9]:=sin(degtorad(self.View.wx));
  21.   xm[10]:=cos(degtorad(self.View.wx));
  22.   xm[11]:=0;
  23.   xm[12]:=0;
  24.   xm[13]:=0;
  25.   xm[14]:=0;
  26.   xm[15]:=1;
  27.   ym[0]:=cos(degtorad(self.View.wy));
  28.   ym[1]:=0;
  29.   ym[2]:=sin(degtorad(self.View.wy));
  30.   ym[3]:=0;
  31.   ym[4]:=0;
  32.   ym[5]:=1;
  33.   ym[6]:=0;
  34.   ym[7]:=0;
  35.   ym[8]:=-sin(degtorad(self.View.wy));
  36.   ym[9]:=0;
  37.   ym[10]:=cos(degtorad(self.View.wy));
  38.   ym[11]:=0;
  39.   ym[12]:=0;
  40.   ym[13]:=0;
  41.   ym[14]:=0;
  42.   ym[15]:=1;
  43.   zm[0]:=cos(degtorad(self.View.wz));
  44.   zm[1]:=-sin(degtorad(self.View.wz));
  45.   zm[2]:=0;
  46.   zm[3]:=0;
  47.   zm[4]:=sin(degtorad(self.View.wz));
  48.   zm[5]:=cos(degtorad(self.View.wz));
  49.   zm[6]:=0;
  50.   zm[7]:=0;
  51.   zm[8]:=0;
  52.   zm[9]:=0;
  53.   zm[10]:=1;
  54.   zm[11]:=0;
  55.   zm[12]:=0;
  56.   zm[13]:=0;
  57.   zm[14]:=0;
  58.   zm[15]:=1;
  59.   wglmakecurrent(self.dc,self.hrc);
  60.   glMatrixMode(GL_MODELVIEW);
  61.   glloadidentity;
  62.   glmultmatrixf(@xm);
  63.   glmultmatrixf(@ym);
  64.   glmultmatrixf(@zm);
  65.   glgetfloatv(GL_MODELVIEW_MATRIX,@tm);
  66.   self.View.bx.x:=tm[0];
  67.   self.View.bx.y:=tm[4];
  68.   self.View.bx.z:=tm[8];
  69.   self.View.by.x:=tm[1];
  70.   self.View.by.y:=tm[5];
  71.   self.View.by.z:=tm[9];
  72.   self.View.bz.x:=tm[2];
  73.   self.View.bz.y:=tm[6];
  74.   self.View.bz.z:=tm[10];
  75. end;


das Problem ist blos das sich manchmal (ich finde keinen Grund dafür) sich die Achsen vertauschen und ich irgend wo in der Welt herumspaziere. Die Richtungsvektoren müssten eigentlich richtig berechnet werden.
Hier mal der Code für das Keydown event:
Code:
  1.  
  2. class procedure TProcdummy.Keydown(Sender: TObject; var Key: Word; Shift: TShiftState);
  3. var view:TView;
  4.     l:TInputline;
  5. begin
  6.   //if (sender as TGLFenster).mode=2 then
  7.   //begin
  8.   if key=(sender as TGLFenster).tastenbelegung[0] then //vorwärts
  9.   begin
  10.     view:=(sender as TGLFenster).getview;
  11.     view.x:=view.x-view.bz.x;
  12.     view.y:=view.y-view.bz.y;
  13.     view.z:=view.z-view.bz.z;
  14.     (sender as TGLFenster).setview(view);
  15.   end;
  16.   if key=(sender as TGLFenster).tastenbelegung[1] then //rückwärts
  17.   begin
  18.     view:=(sender as TGLFenster).getview;
  19.     view.x:=view.x+view.bz.x;
  20.     view.y:=view.y+view.bz.y;
  21.     view.z:=view.z+view.bz.z;
  22.     (sender as TGLFenster).setview(view);
  23.   end;
  24.   if key=(sender as TGLFenster).tastenbelegung[2] then //links
  25.   begin
  26.     view:=(sender as TGLFenster).getview;
  27.     view.x:=view.x-view.bx.x;
  28.     view.y:=view.y-view.bx.y;
  29.     view.z:=view.z-view.bx.z;
  30.     (sender as TGLFenster).setview(view);
  31.   end;
  32.   if key=(sender as TGLFenster).tastenbelegung[3] then //rechts
  33.   begin
  34.     view:=(sender as TGLFenster).getview;
  35.     view.x:=view.x+view.bx.x;
  36.     view.y:=view.y+view.bx.y;
  37.     view.z:=view.z+view.bx.z;
  38.     (sender as TGLFenster).setview(view);
  39.   end;
  40.   if key=(sender as TGLFenster).tastenbelegung[4] then //hoch
  41.   begin
  42.     view:=(sender as TGLFenster).getview;
  43.     view.x:=view.x+view.by.x;
  44.     view.y:=view.y+view.by.y;
  45.     view.z:=view.z+view.by.z;
  46.     (sender as TGLFenster).setview(view);
  47.   end;
  48.   if key=(sender as TGLFenster).tastenbelegung[5] then //runter
  49.   begin
  50.     view:=(sender as TGLFenster).getview;
  51.     view.x:=view.x-view.by.x;
  52.     view.y:=view.y-view.by.y;
  53.     view.z:=view.z-view.by.z;
  54.     (sender as TGLFenster).setview(view);
  55.   end;
  56.   //end;
  57. end;
  58.  


So ich hoffe ihr könnt einen Fehler entdecken. Wir suchen jetzt schon ne ganze Weile und so langsam bin ich mit meinem Latein am Ende.
Als Danke im Voraus :shock:
Nach oben
 Profil  
Mit Zitat antworten  
La Boda
 Betreff des Beitrags:
BeitragVerfasst: Sa Jan 15, 2005 12:50 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jul 17, 2002 12:07
Beiträge: 976
Wohnort: Tübingen
Also ich würde euch empfehlen, die Geometry.pas in dem oben geposteten Sourcen anzuschauen. Dort wird ja praktisch dasselbe gemacht, und es ist auch schon optimiert. Habs mir selber mal angeschaut, die Rotate-Funktion schaut prinzipiell so aus:
Code:
  1. procedure RotateVector(var vector : TVector; const axis : TAffineVector; angle: Single);
  2. var
  3.    rotMatrix : TMatrix4f;
  4. begin
  5.    rotMatrix:=CreateRotationMatrix(axis, Angle);
  6.    vector:=VectorTransform(vector, rotMatrix);
  7. end;

CreateRotationMatrix:
Code:
  1. function CreateRotationMatrix(Axis: TAffineVector; Angle: Single): TMatrix; register;
  2. var
  3.    cosine, sine, one_minus_cosine : Single;
  4. begin
  5.    SinCos(Angle, Sine, Cosine);
  6.    one_minus_cosine:=1 - cosine;
  7.    NormalizeVector(Axis);
  8.  
  9.    Result[X, X]:=(one_minus_cosine * Sqr(Axis[0])) + Cosine;
  10.    Result[X, Y]:=(one_minus_cosine * Axis[0] * Axis[1]) - (Axis[2] * Sine);
  11.    Result[X, Z]:=(one_minus_cosine * Axis[2] * Axis[0]) + (Axis[1] * Sine);
  12.    Result[X, W]:=0;
  13.  
  14.    Result[Y, X]:=(one_minus_cosine * Axis[0] * Axis[1]) + (Axis[2] * Sine);
  15.    Result[Y, Y]:=(one_minus_cosine * Sqr(Axis[1])) + Cosine;
  16.    Result[Y, Z]:=(one_minus_cosine * Axis[1] * Axis[2]) - (Axis[0] * Sine);
  17.    Result[Y, W]:=0;
  18.  
  19.    Result[Z, X]:=(one_minus_cosine * Axis[2] * Axis[0]) - (Axis[1] * Sine);
  20.    Result[Z, Y]:=(one_minus_cosine * Axis[1] * Axis[2]) + (Axis[0] * Sine);
  21.    Result[Z, Z]:=(one_minus_cosine * Sqr(Axis[2])) + Cosine;
  22.    Result[Z, W]:=0;
  23.  
  24.    Result[W, X]:=0;
  25.    Result[W, Y]:=0;
  26.    Result[W, Z]:=0;
  27.    Result[W, W]:=1;
  28. end;

VectorTransform:
Code:
  1. function VectorTransform(const V: TVector; const M: TMatrix) : TVector; register;
  2. begin
  3.    if vSIMD=1 then begin
  4.       asm
  5.         db $0F,$0E               /// femms
  6.  
  7.         db $0F,$6F,$00           /// movq        mm0,[eax]
  8.         db $0F,$6F,$48,$08       /// movq        mm1,[eax+8]
  9.         db $0F,$6F,$22           /// movq        mm4,[edx]
  10.         db $0F,$6A,$D0           /// punpckhdq   mm2,mm0
  11.         db $0F,$6F,$6A,$10       /// movq        mm5,[edx+16]
  12.         db $0F,$62,$C0           /// punpckldq   mm0,mm0
  13.         db $0F,$6F,$72,$20       /// movq        mm6,[edx+32]
  14.         db $0F,$0F,$E0,$B4       /// pfmul       mm4,mm0
  15.         db $0F,$6F,$7A,$30       /// movq        mm7,[edx+48]
  16.         db $0F,$6A,$D2           /// punpckhdq   mm2,mm2
  17.         db $0F,$6A,$D9           /// punpckhdq   mm3,mm1
  18.         db $0F,$0F,$EA,$B4       /// pfmul       mm5,mm2
  19.         db $0F,$62,$C9           /// punpckldq   mm1,mm1
  20.         db $0F,$0F,$42,$08,$B4   /// pfmul       mm0,[edx+8]
  21.         db $0F,$6A,$DB           /// punpckhdq   mm3,mm3
  22.         db $0F,$0F,$52,$18,$B4   /// pfmul       mm2,[edx+24]
  23.         db $0F,$0F,$F1,$B4       /// pfmul       mm6,mm1
  24.         db $0F,$0F,$EC,$9E       /// pfadd       mm5,mm4
  25.         db $0F,$0F,$4A,$28,$B4   /// pfmul       mm1,[edx+40]
  26.         db $0F,$0F,$D0,$9E       /// pfadd       mm2,mm0
  27.         db $0F,$0F,$FB,$B4       /// pfmul       mm7,mm3
  28.         db $0F,$0F,$F5,$9E       /// pfadd       mm6,mm5
  29.         db $0F,$0F,$5A,$38,$B4   /// pfmul       mm3,[edx+56]
  30.         db $0F,$0F,$D1,$9E       /// pfadd       mm2,mm1
  31.         db $0F,$0F,$FE,$9E       /// pfadd       mm7,mm6
  32.         db $0F,$0F,$DA,$9E       /// pfadd       mm3,mm2
  33.  
  34.         db $0F,$7F,$39           /// movq        [ecx],mm7
  35.         db $0F,$7F,$59,$08       /// movq        [ecx+8],mm3
  36.         db $0F,$0E               /// femms
  37.       end
  38.    end else begin
  39.       Result[X]:=V[X] * M[X, X] + V[Y] * M[Y, X] + V[Z] * M[Z, X] + V[W] * M[W, X];
  40.       Result[Y]:=V[X] * M[X, Y] + V[Y] * M[Y, Y] + V[Z] * M[Z, Y] + V[W] * M[W, Y];
  41.       Result[Z]:=V[X] * M[X, Z] + V[Y] * M[Y, Z] + V[Z] * M[Z, Z] + V[W] * M[W, Z];
  42.       Result[W]:=V[X] * M[X, W] + V[Y] * M[Y, W] + V[Z] * M[Z, W] + V[W] * M[W, W];
  43.    end;
  44. end;
  45.  


Das Ganze arbeitet also nicht recht anders als das von dmss, vergleicht das mal. Ich bin zu faul 8)

_________________
"Du musst ein Schwein sein in dieser Welt, sangen die Prinzen, das ist so 1.0. Du musst auf YouTube zeigen, dass dir dein Schweinsein gefällt, das ist leuchtendes, echtes Web 2.0."
- Hal Faber
Meine Homepage: http://laboda.delphigl.com
Nach oben
 Profil  
Mit Zitat antworten  
Tomok
 Betreff des Beitrags:
BeitragVerfasst: Sa Jan 15, 2005 16:42 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jul 16, 2003 15:20
Beiträge: 198
Der Hauptunterschied ist, so wie ich dass sehe, dass VectorTransform 3DNow nutzt und dadurch in etwa doppelt so schnell sein wird, wie die reine Delphi version.
Nach oben
 Profil  
Mit Zitat antworten  
dmss
 Betreff des Beitrags:
BeitragVerfasst: Mo Jan 17, 2005 15:55 
Offline
DGL Member

Registriert: Sa Jan 15, 2005 12:28
Beiträge: 3
Aber einen Fehler bei ''dmss'' könnt ihr also nicht entdecken. Die Geschwindigkeit ist zwar bedenkenswert aber mir geht es erstmal hauptsächlich darum, warum die Achsen bei mir manchmal vertauscht sind. Es ist gut möglich das die Art in ''Geometry.pas'' besser ist, aber bis jetzt versuche ich so viel als möglich selbst zu coden. Und darum wärs mir lieb wenn einer den Fehler finden könnte, oder mir versichern könnte das mein Code 100 %-ig richtig ist. :shock:

Also vielen Dank für eure Mühe bis jetzt und weiterhin.
Nach oben
 Profil  
Mit Zitat antworten  
dmss
 Betreff des Beitrags:
BeitragVerfasst: Mo Jan 17, 2005 16:09 
Offline
DGL Member

Registriert: Sa Jan 15, 2005 12:28
Beiträge: 3
Ha Ha (ich muss jetzt über den Fehler selber lachen), die Berechnung ist richtig, aber bei OpenGl läuft ja die Z-Achse nach vorn. Ich hab also beim Keydown-Event nur bei der Addition des Richtungsvektors den Z-Anteil mit falschen Vorzeichen gehabt.

Also kurzer Hand das Vorzeichen getauscht. Und tata es geht.

Also ich dank euch nochmals für die Mühe.
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 9 Beiträge ] 
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 23 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.010s | 14 Queries | GZIP : On ]