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

Aktuelle Zeit: Fr Jul 18, 2025 11:13

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



Ein neues Thema erstellen Auf das Thema antworten  [ 21 Beiträge ]  Gehe zu Seite 1, 2  Nächste
Autor Nachricht
 Betreff des Beitrags: Problem mit Rotationsmatrix
BeitragVerfasst: Fr Jul 29, 2005 10:49 
Offline
DGL Member

Registriert: Fr Jul 29, 2005 10:40
Beiträge: 11
Hallo Leute,
ich versuche die Matrizenrechnung von Opengl mal selbst zu machen find aber den Fehler nicht. die folgende prozedure soll die Opengl-befehle
glrotatef(wx,1,0,0);
glrotatef(wy,0,1,0);
glrotatef(wz,0,0,1);

dazu hab ich mir mal die rotationsmatrizen angeschaut und folgenden code geschrieben:

Code:
  1.  
  2. procedure TOpenglwindow.RotateVectorCPU(wx,wy,wz:single;var x1,x2,x3:Tvector);
  3.  
  4. begin
  5.   x1[0]:=1*x1[0]+0*x2[0]+0*x3[0];
  6.   x1[1]:=1*x1[1]+0*x2[1]+0*x3[1];
  7.   x1[2]:=1*x1[2]+0*x2[2]+0*x3[2];
  8.   x2[0]:=0*x1[0]+cos(degtorad(wx))*x2[0]+sin(degtorad(wx))*x3[0];
  9.   x2[1]:=0*x1[1]+cos(degtorad(wx))*x2[1]+sin(degtorad(wx))*x3[1];
  10.   x2[2]:=0*x1[2]+cos(degtorad(wx))*x2[2]+sin(degtorad(wx))*x3[2];
  11.   x3[0]:=0*x1[0]-sin(degtorad(wx))*x2[0]+cos(degtorad(wx))*x3[0];
  12.   x3[1]:=0*x1[1]-sin(degtorad(wx))*x2[1]+cos(degtorad(wx))*x3[1];
  13.   x3[2]:=0*x1[2]-sin(degtorad(wx))*x2[2]+cos(degtorad(wx))*x3[2];
  14.  
  15.   x1[0]:=cos(degtorad(wy))*x1[0]+0*x2[0]-sin(degtorad(wy))*x3[0];
  16.   x1[1]:=cos(degtorad(wy))*x1[1]+0*x2[1]-sin(degtorad(wy))*x3[1];
  17.   x1[2]:=cos(degtorad(wy))*x1[2]+0*x2[2]-sin(degtorad(wy))*x3[2];
  18.   x2[0]:=0*x1[0]+1*x2[0]+0*x3[0];
  19.   x2[1]:=0*x1[1]+1*x2[1]+0*x3[1];
  20.   x2[2]:=0*x1[2]+1*x2[2]+0*x3[2];
  21.   x3[0]:=sin(degtorad(wy))*x1[0]+0*x2[0]+cos(degtorad(wy))*x3[0];
  22.   x3[1]:=sin(degtorad(wy))*x1[1]+0*x2[1]+cos(degtorad(wy))*x3[1];
  23.   x3[2]:=sin(degtorad(wy))*x1[2]+0*x2[2]+cos(degtorad(wy))*x3[2];
  24.  
  25.   x1[0]:=cos(degtorad(wz))*x1[0]+sin(degtorad(wz))*x2[0]+0*x3[0];
  26.   x1[1]:=cos(degtorad(wz))*x1[1]+sin(degtorad(wz))*x2[1]+0*x3[1];
  27.   x1[2]:=cos(degtorad(wz))*x1[2]+sin(degtorad(wz))*x2[2]+0*x3[2];
  28.   x2[0]:=-sin(degtorad(wz))*x1[0]+cos(degtorad(wz))*x2[0]+0*x3[0];
  29.   x2[1]:=-sin(degtorad(wz))*x1[1]+cos(degtorad(wz))*x2[1]+0*x3[1];
  30.   x2[2]:=-sin(degtorad(wz))*x1[2]+cos(degtorad(wz))*x2[2]+0*x3[2];
  31.   x3[0]:=0*x1[0]+0*x2[0]+1*x3[0];
  32.   x3[1]:=0*x1[1]+0*x2[1]+1*x3[1];
  33.   x3[2]:=0*x1[2]+0*x2[2]+1*x3[2];
  34. end;
  35.  


so der code funktioniert fast. nur die Koordinaten von x3 werden falsch berechnet. ich find aber seit 2 tagen den fehler nicht.
Also wenn jamand mal Muse dazu hat wäre es schön wenn mir jemand helfen könnte . Danke

ps.: meine 3*3Matrizen:

vektoren:
x1[0],x1[1],x1[2]
x2[0],x2[1],x2[2]
x3[0],x3[1],x3[2]
und die Rotationsmatrizen (c=cos,s=sin):
um X:
1,0,0
0,c,s
0,-s,c

um Y.
c,0,-s
0,1,0
s,0,c

um Z

c,s,0
-s,c,0
0,0,1

so und nu hab ich alles der reihe nach multipliziert.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 11:07 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Nov 13, 2004 11:00
Beiträge: 229
Wohnort: Steinhude
iirc müssten die rotationsmatrizen eigentlich so aussehen:

X
1,0,0
0,c,-s
0,s,c

Y
c,0,-s
0,1,0
s,0,c

Z
c,-s,0
s,c,0
0,0,1


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 11:26 
Offline
DGL Member

Registriert: Fr Jul 29, 2005 10:40
Beiträge: 11
ja müssten sie aber ich sag mal so viel die rotationsmatrix von mir und die von opengl is gleich (das ist 100%ig sicher) und trotzdem gibt es NUR bei x3 abweichungen ich hoffe ich kann damit etwas klarheit in das problem bringen . Aber trotzdem danke für die antwort


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 11:32 
Offline
DGL Member

Registriert: Fr Jul 29, 2005 10:40
Beiträge: 11
also ich hab jetzt sogar extra alles umgestellt und die vorgeschlagenen matrizen genommen der code sieht nun so aus:
Code:
  1.  
  2. procedure TOpenglwindow.RotateVectorCPU(wx,wy,wz:single;var x1,x2,x3:Tvector);
  3.  
  4. begin
  5.   x1[0]:=1*x1[0]+0*x2[0]+0*x3[0];
  6.   x1[1]:=1*x1[1]+0*x2[1]+0*x3[1];
  7.   x1[2]:=1*x1[2]+0*x2[2]+0*x3[2];
  8.   x2[0]:=0*x1[0]+cos(degtorad(wx))*x2[0]-sin(degtorad(wx))*x3[0];
  9.   x2[1]:=0*x1[1]+cos(degtorad(wx))*x2[1]-sin(degtorad(wx))*x3[1];
  10.   x2[2]:=0*x1[2]+cos(degtorad(wx))*x2[2]-sin(degtorad(wx))*x3[2];
  11.   x3[0]:=0*x1[0]+sin(degtorad(wx))*x2[0]+cos(degtorad(wx))*x3[0];
  12.   x3[1]:=0*x1[1]+sin(degtorad(wx))*x2[1]+cos(degtorad(wx))*x3[1];
  13.   x3[2]:=0*x1[2]+sin(degtorad(wx))*x2[2]+cos(degtorad(wx))*x3[2];
  14.  
  15.   x1[0]:=cos(degtorad(wy))*x1[0]+0*x2[0]+sin(degtorad(wy))*x3[0];
  16.   x1[1]:=cos(degtorad(wy))*x1[1]+0*x2[1]+sin(degtorad(wy))*x3[1];
  17.   x1[2]:=cos(degtorad(wy))*x1[2]+0*x2[2]+sin(degtorad(wy))*x3[2];
  18.   x2[0]:=0*x1[0]+1*x2[0]+0*x3[0];
  19.   x2[1]:=0*x1[1]+1*x2[1]+0*x3[1];
  20.   x2[2]:=0*x1[2]+1*x2[2]+0*x3[2];
  21.   x3[0]:=-sin(degtorad(wy))*x1[0]+0*x2[0]+cos(degtorad(wy))*x3[0];
  22.   x3[1]:=-sin(degtorad(wy))*x1[1]+0*x2[1]+cos(degtorad(wy))*x3[1];
  23.   x3[2]:=-sin(degtorad(wy))*x1[2]+0*x2[2]+cos(degtorad(wy))*x3[2];
  24.  
  25.   x1[0]:=cos(degtorad(wz))*x1[0]-sin(degtorad(wz))*x2[0]+0*x3[0];
  26.   x1[1]:=cos(degtorad(wz))*x1[1]-sin(degtorad(wz))*x2[1]+0*x3[1];
  27.   x1[2]:=cos(degtorad(wz))*x1[2]-sin(degtorad(wz))*x2[2]+0*x3[2];
  28.   x2[0]:=sin(degtorad(wz))*x1[0]+cos(degtorad(wz))*x2[0]+0*x3[0];
  29.   x2[1]:=sin(degtorad(wz))*x1[1]+cos(degtorad(wz))*x2[1]+0*x3[1];
  30.   x2[2]:=sin(degtorad(wz))*x1[2]+cos(degtorad(wz))*x2[2]+0*x3[2];
  31.   x3[0]:=0*x1[0]+0*x2[0]+1*x3[0];
  32.   x3[1]:=0*x1[1]+0*x2[1]+1*x3[1];
  33.   x3[2]:=0*x1[2]+0*x2[2]+1*x3[2];
  34. end;

und trotzdem is das problem wie erst ...

Ich find den Fehler einfach ne 'grumml'


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 11:38 
Offline
DGL Member

Registriert: Fr Jul 29, 2005 10:40
Beiträge: 11
ich muss nochma reinquatschen also die matrizen müssten doch eigentlich so aussehen:

X
1,0,0
0,c,-s
0,-s,c

Y
c,0,s
0,1,0
-s,0,c

Z
c,-s,0
s,c,0
0,0,1

zumindest laut turorial und ich mein das funktioniert ja soweit auch wenn man das alles mit Glmultmatrix macht aber ich möchte das gerne eben auch ma so machen :D


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 13:12 
Offline
DGL Member

Registriert: Mo Dez 20, 2004 08:58
Beiträge: 442
Wohnort: Mittweida (Sachsen)
Code:
  1.   TGLMatrix=Record
  2.     Case Boolean of
  3.       True: (A: Array[0..15] of GLDouble);
  4.       False: (M: Array[0..3,0..3] of GLDouble);
  5.     // ATTENTION OpenGL stores Column-leading
  6.     // first index is Column, second is Row
  7.     // e.g.: 1st col, 3rd row would be [0,2] not [2,0]
  8.   End;
  9.   TGLVector=Record
  10.    Case Integer Of
  11.     0: (X: GLDouble;
  12.         Y: GLDouble;
  13.         Z: GLDouble);
  14.     1: (Width: GLDouble;
  15.         Depth: GLDouble;
  16.         Height: GLDouble);
  17.     2: (RotX: GLDouble;
  18.         RotY: GLDouble;
  19.         RotZ: GLDouble);
  20.   End;
  21. //______________________________________________________________________________
  22. Procedure TGLBaseGraphic.SetRotation(_oRotation: TGLVector);
  23. Var
  24.   cx,cy,cz,sx,sy,sz: double;
  25. Begin
  26.   oRotation:=_oRotation;
  27.   cx:=Cos(DegToRad(360-oRotation.RotX));
  28.   cy:=Cos(DegToRad(360-oRotation.RotY));
  29.   cz:=Cos(DegToRad(360-oRotation.RotZ));
  30.   sx:=Sin(DegToRad(360-oRotation.RotX));
  31.   sy:=Sin(DegToRad(360-oRotation.RotY));
  32.   sz:=Sin(DegToRad(360-oRotation.RotZ));
  33.   oMatrix.M[0,0]:=cy*cz;
  34.   oMatrix.M[0,1]:=sx*sy*cz+cx*sz;
  35.   oMatrix.M[0,2]:=sx*sz-cx*sy*cz;
  36.   oMatrix.M[1,0]:=-cy*sz;
  37.   oMatrix.M[1,1]:=cx*cz-sx*sy*sz;
  38.   oMatrix.M[1,2]:=cx*sy*sz+sx*cz;
  39.   oMatrix.M[2,0]:=sy;
  40.   oMatrix.M[2,1]:=-sx*cy;
  41.   oMatrix.M[2,2]:=cx*cy;
  42.   ChangeWorld;
  43. End;
  44.  

ich hoffe, das hilft

_________________
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: Fr Jul 29, 2005 13:20 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Apr 25, 2005 17:51
Beiträge: 464
kann mir denken warum dein x3 nicht stimmt:

du berechnest in den ersten beiden Schritten x1 und x2, diese sind nun VERÄNDERT!!!
Für die Berechnung brauchst du aber immer die Ursprungsdaten der benutzten Matrizen. Du musst also Puffern, damit die schon neu berechneten Daten nicht benutzt werden und das jeweils vor jeder eigenständigen Multiplikation.

Ach ja wenn du langeweile hast: schreib dir lieber ne Klasse Matrix dafür und hau den Code nicht einfach so in dei Methode deiner Klasse. :-)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 14:34 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Wenn du dich dann auch für die anderen Transformationen der Matrizen interessierst dann guck mal unter: Links->General->CompGeo. Das könnte dir helfen.

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


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 16:56 
Offline
DGL Member

Registriert: Fr Jul 29, 2005 10:40
Beiträge: 11
Vielen dank erstma für die rege Beteiligung :D ich häng jetzt erstma an der Umsetzung...werd mich wieder melden wenn ich weitere Probleme hab :D


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 17:40 
Offline
DGL Member

Registriert: Fr Jul 29, 2005 10:40
Beiträge: 11
Also ich muss jetzt nochma reinhacken:

ich habe 3 Berechnungsvarianten (tm,xm,ym,zm sind 4*4 -Matrizen):
1.
Code:
  1.  
  2. glloadidentity;
  3. glrotatef(wx,1,0,0);
  4. glrotatef(wy,0,1,0);
  5. glrotatef(wz,0,0,1);
  6. glgetfloatv(GL_MODELVIEW_MATRIX,@tm);
  7. x1[0]:=tm[0];
  8. x1[1]:=tm[4];
  9. x1[2]:=tm[8];
  10. x2[0]:=tm[1];
  11. x2[1]:=tm[5];
  12. x2[2]:=tm[9];
  13. x3[0]:=tm[2];
  14. x3[1]:=tm[6];
  15. x3[2]:=tm[10];
  16.  

2.
Code:
  1.  
  2.  
  3. xm[0]:=1;
  4.   xm[1]:=0;
  5.   xm[2]:=0;
  6.   xm[3]:=0;
  7.   xm[4]:=0;
  8.   xm[5]:=cos(degtorad(wx));
  9.   xm[6]:=sin(degtorad(wx));
  10.   xm[7]:=0;
  11.   xm[8]:=0;
  12.   xm[9]:=-sin(degtorad(wx));
  13.   xm[10]:=cos(degtorad(wx));
  14.   xm[11]:=0;
  15.   xm[12]:=0;
  16.   xm[13]:=0;
  17.   xm[14]:=0;
  18.   xm[15]:=1;
  19.   ym[0]:=cos(degtorad(wy));
  20.   ym[1]:=0;
  21.   ym[2]:=-sin(degtorad(wy));
  22.   ym[3]:=0;
  23.   ym[4]:=0;
  24.   ym[5]:=1;
  25.   ym[6]:=0;
  26.   ym[7]:=0;
  27.   ym[8]:=sin(degtorad(wy));
  28.   ym[9]:=0;
  29.   ym[10]:=cos(degtorad(wy));
  30.   ym[11]:=0;
  31.   ym[12]:=0;
  32.   ym[13]:=0;
  33.   ym[14]:=0;
  34.   ym[15]:=1;
  35.   zm[0]:=cos(degtorad(wz));
  36.   zm[1]:=sin(degtorad(wz));
  37.   zm[2]:=0;
  38.   zm[3]:=0;
  39.   zm[4]:=-sin(degtorad(wz));
  40.   zm[5]:=cos(degtorad(wz));
  41.   zm[6]:=0;
  42.   zm[7]:=0;
  43.   zm[8]:=0;
  44.   zm[9]:=0;
  45.   zm[10]:=1;
  46.   zm[11]:=0;
  47.   zm[12]:=0;
  48.   zm[13]:=0;
  49.   zm[14]:=0;
  50.   zm[15]:=1;
  51.   glMatrixMode(GL_MODELVIEW);
  52.   glloadidentity;
  53.   glmultmatrixf(@xm);
  54.   glmultmatrixf(@ym);
  55.   glmultmatrixf(@zm);
  56.   glgetfloatv(GL_MODELVIEW_MATRIX,@tm);
  57.   x1[0]:=tm[0];
  58.   x1[1]:=tm[4];
  59.   x1[2]:=tm[8];
  60.   x2[0]:=tm[1];
  61.   x2[1]:=tm[5];
  62.   x2[2]:=tm[9];
  63.   x3[0]:=tm[2];
  64.   x3[1]:=tm[6];
  65.   x3[2]:=tm[10];
  66.  


und schließlich 3.

Code:
  1.  
  2. procedure TOpenglwindow.RotateVectorCPU(wx,wy,wz:single;var x1,x2,x3:Tvector);
  3.  
  4. begin
  5.   x1[0]:=1*x1[0]+0*x2[0]+0*x3[0];
  6.   x1[1]:=1*x1[1]+0*x2[1]+0*x3[1];
  7.   x1[2]:=1*x1[2]+0*x2[2]+0*x3[2];
  8.   x2[0]:=0*x1[0]+cos(degtorad(wx))*x2[0]-sin(degtorad(wx))*x3[0];
  9.   x2[1]:=0*x1[1]+cos(degtorad(wx))*x2[1]-sin(degtorad(wx))*x3[1];
  10.   x2[2]:=0*x1[2]+cos(degtorad(wx))*x2[2]-sin(degtorad(wx))*x3[2];
  11.   x3[0]:=0*x1[0]+sin(degtorad(wx))*x2[0]+cos(degtorad(wx))*x3[0];
  12.   x3[1]:=0*x1[1]+sin(degtorad(wx))*x2[1]+cos(degtorad(wx))*x3[1];
  13.   x3[2]:=0*x1[2]+sin(degtorad(wx))*x2[2]+cos(degtorad(wx))*x3[2];
  14.  
  15.   x1[0]:=cos(degtorad(wy))*x1[0]+0*x2[0]-sin(degtorad(wy))*x3[0];
  16.   x1[1]:=cos(degtorad(wy))*x1[1]+0*x2[1]-sin(degtorad(wy))*x3[1];
  17.   x1[2]:=cos(degtorad(wy))*x1[2]+0*x2[2]-sin(degtorad(wy))*x3[2];
  18.   x2[0]:=0*x1[0]+1*x2[0]+0*x3[0];
  19.   x2[1]:=0*x1[1]+1*x2[1]+0*x3[1];
  20.   x2[2]:=0*x1[2]+1*x2[2]+0*x3[2];
  21.   x3[0]:=sin(degtorad(wy))*x1[0]+0*x2[0]+cos(degtorad(wy))*x3[0];
  22.   x3[1]:=sin(degtorad(wy))*x1[1]+0*x2[1]+cos(degtorad(wy))*x3[1];
  23.   x3[2]:=sin(degtorad(wy))*x1[2]+0*x2[2]+cos(degtorad(wy))*x3[2];
  24.  
  25.   x1[0]:=cos(degtorad(wz))*x1[0]-sin(degtorad(wz))*x2[0]+0*x3[0];
  26.   x1[1]:=cos(degtorad(wz))*x1[1]-sin(degtorad(wz))*x2[1]+0*x3[1];
  27.   x1[2]:=cos(degtorad(wz))*x1[2]-sin(degtorad(wz))*x2[2]+0*x3[2];
  28.   x2[0]:=sin(degtorad(wz))*x1[0]+cos(degtorad(wz))*x2[0]+0*x3[0];
  29.   x2[1]:=sin(degtorad(wz))*x1[1]+cos(degtorad(wz))*x2[1]+0*x3[1];
  30.   x2[2]:=sin(degtorad(wz))*x1[2]+cos(degtorad(wz))*x2[2]+0*x3[2];
  31.   x3[0]:=0*x1[0]+0*x2[0]+1*x3[0];
  32.   x3[1]:=0*x1[1]+0*x2[1]+1*x3[1];
  33.   x3[2]:=0*x1[2]+0*x2[2]+1*x3[2];
  34. end;


so und 1. und 2. liefern die gleichen ergebnisse nur bei 3. gibts es bei x3 Abweichungen
so und das mit dem verändert das haut ja nich hin weil ja meine vergleichswerte auch durch aufeinander folgende multiplikationen entstehen ... hmm es muss irgend einen Fehler bei 3. geben :(


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 18:49 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Apr 25, 2005 17:51
Beiträge: 464
Zitat:
x3[0]:=0*x1[0]+sin(degtorad(wx))*x2[0]+cos(degtorad(wx))*x3[0];
x3[1]:=0*x1[1]+sin(degtorad(wx))*x2[1]+cos(degtorad(wx))*x3[1];
x3[2]:=0*x1[2]+sin(degtorad(wx))*x2[2]+cos(degtorad(wx))*x3[2];


x1,x2 und auch x3 berechnen sich aus der Eingangs(!!!!!!!!!!!!!!!)-Matrix.
Dort was ich rauskopiert habe verwendest du x1 und x2, diese enthalten aber schon die Werte der (Teil-)Ergebnis(!!!!!!)-Matrix, wurde also VERÄNDERT, du brauchst aber die Ausgangswerte.

Siehe Post von Sidorion, auch er puffert die Werte der Eingangsmatrix.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 19:48 
Offline
DGL Member

Registriert: Fr Jul 29, 2005 10:40
Beiträge: 11
gut aber warum stimmen dann die werte von x2 da benutz ich ja auch die VERÄNDERTEN Werte von x1 ?


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 20:16 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Apr 25, 2005 17:51
Beiträge: 464
beim ersten geht x1 mit Faktor 0 ein da spielt das keine Rolle, bei den anderen kA, weis deine Zahlen nicht kann Zufall sein, aber wie schon gesagt speicher dir die alten Werte.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Fr Jul 29, 2005 21:43 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Nov 13, 2004 11:00
Beiträge: 229
Wohnort: Steinhude
bei der ersten routation veränderst also x1 nicht.
bei der zweiten wid zwar x1 verändert, aber x2 nicht.
bei der 3. würde ich dann auf zufall tippen, vll. kürzt sich da auch was raus, habs jetz nicht nachgerechnet


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Sa Jul 30, 2005 01:00 
Offline
DGL Member

Registriert: Do Apr 08, 2004 16:55
Beiträge: 516
Lasst doch mal das umwandeln in Gradmas, und Rechnet lieber mit dem Bogenmas( 2 PI = 360° )!

Zitat:
x3[0]:=0*x1[0]+sin(degtorad(wx))*x2[0]+cos(degtorad(wx))*x3[0];
x3[1]:=0*x1[1]+sin(degtorad(wx))*x2[1]+cos(degtorad(wx))*x3[1];
x3[2]:=0*x1[2]+sin(degtorad(wx))*x2[2]+cos(degtorad(wx))*x3[2];


Soll das eine 0 sein die dort vor x1 steht? Ehrlichgesagt kann man dann glaube ich die Operation weglassen, den mit 0 Zu Multiplizieren gibt immer 0!

_________________
Shareholder und Leitender Entwickler bei Pipedream-Games.

Zitat: Siehst du diesen Park da unten? Jeden Tag lernen sich darin Menschen kennen und verlassen einander. Und du hast dein ganzes Leben Zeit darin zu gehen.


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 21 Beiträge ]  Gehe zu Seite 1, 2  Nächste
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

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