Prinzip von TFormPoint

Übersicht BlitzBasic Beginners-Corner

Neue Antwort erstellen

TheProgrammer

Betreff: Prinzip von TFormPoint

BeitragDi, Nov 28, 2006 20:23
Antworten mit Zitat
Benutzer-Profile anzeigen
Hi!

Ich hoffe, dieses Thema passt hier rein, denn ich brauche die Funktion TFormPoint für B+.

Gegeben ist eine Koordinate, die umgerechnet werden soll von einem Objekt (Position, Skalierung und Rotation sind gegeben) auf die globale Welt.

Nach dem Prinzip:
Code: [AUSKLAPPEN]
TFormPoint(x#,y#,z#,   posX#,posY#,posZ#, sclX#,sclY#,sclZ#, pitch#,yaw#,roll#)


Ein Ansatz für die Formeln, die angewendet werden, würde mir schon reichen.


Ich hoffe, ihr könnt mir dabei helfen und bitte um schnelle Antwort. Wink

Mfg
TheProgrammer
aktuelles Projekt: The last day of human being

lucifer

BeitragDi, Nov 28, 2006 20:59
Antworten mit Zitat
Benutzer-Profile anzeigen
Dazu musst du den Positions Vektor mit der WorldMatrix des Objektes mulitplizieren.

Die Matrix Elemente 41,42 und 43 füllst du einfach mit den X-,Y-,Z-Werten. Die SkalirungsWerte kommen in die Elemente 11,22,33. Die Rotations wird dann schon etwas komplizierter. Dazu würde ich 3 Matrizen aufstellen, für jede Achse eine.

Die Matrix für die Rotation um die X-Achse bildest du so:
Die Elmente 22,33 füllst du mit cos(alpha), das Element 23 mit -sin(alpha) und das Element 32 mit sin(alpha).

Die Matrix für die Rotation um die Y-Achse bildest du so:
Die Elmente 11,33 füllst du mit cos(alpha), das Element 13 mit sin(alpha) und das Element 31 mit sin(alpha).

Die Matrix für die Rotation um die Z-Achse bildest du so:
Die Elmente 11,22 füllst du mit cos(alpha), das Element 21 mit sin(alpha) und das Element 12 mit sin(alpha).

Diese 3 Matrizen mutliplizierts du dann miteinander und das Ergebnis davon dann mit der davor aufgestellten Translations- und Skalirungsmatrix.
Das Ergebnis davon dann mit dem Positionsvektor und du solltest das ergebnis haben.
Aktuelles Projekt:
Demonspawn
RPG

TheProgrammer

BeitragDi, Nov 28, 2006 21:02
Antworten mit Zitat
Benutzer-Profile anzeigen
Hm, mit Matrizen kenn ich mich leider nicht so aus. Wie würde das jetzt Formel-mäßig aussehen? Was genau stellen solche Matrix-Elemente dar?
aktuelles Projekt: The last day of human being
 

Dreamora

BeitragDi, Nov 28, 2006 21:24
Antworten mit Zitat
Benutzer-Profile anzeigen
Ein Matrixelement ist eine Float.

Wie das aussehen würde, wäre etwas der Art:

neuesX# = altesX * irgendwas + altesY * irgendwasAnderes

und das gleiche für Y

Entsprechende Formeln findest du in den entsprechenden Mathetutorials.


~VERSCHOBEN~

falsches Board
Dreamora
Ihr findet die aktuellen Projekte unter Gayasoft und könnt mich unter @gayasoft auf Twitter erreichen.

TheProgrammer

BeitragDi, Nov 28, 2006 22:39
Antworten mit Zitat
Benutzer-Profile anzeigen
Hm, hab mir mal die Beschreibungen auf Wikipedia, Robsite und Blitzbase.de durchgelesen. Dabei ist folgender Code rausgekommen, der sehr viel Schreibarbeit verlangt hat ^^:

Code: [AUSKLAPPEN]
Function BPlus_TFormPoint(x#,y#,z#,  posx#,posy#,posz#, sclx#,scly#,sclz#, pitch#,yaw#,roll#)

   ; POSITION + SKALIERUNG
   ; | SX      0       0       0 |
   ; | 0       SY      0       0 |
   ; | 0       0       SZ      0 |
   ; | X       Y       Z       1 |


   ; PITCH
   ; | 1       0       0       0 |
   ; | 0       cos(a)  sin(a)  0 |
   ; | 0       -sin(a) cos(a)  0 |
   ; | 0       0       0       1 |
   
   ; YAW
   ; | cos(a)  0       -sin(a) 0 |
   ; | 0       1       0       0 |
   ; | sin(a)  0       cos(a)  0 |
   ; | 0       0       0       1 |
   
   ; ROLL
   ; | cos(a)  sin(a)  0       0 |
   ; | -sin(a) cos(a)  0       0 |
   ; | 0       0       1       0 |
   ; | 0       0       0       1 |

   ; Pos + Scale
   e_m11# = sclx#        : e_m12# = 0            : e_m13# = 0            : e_m14# = 0
   e_m21# = 0            : e_m22# = scly#        : e_m23# = 0            : e_m24# = 0
   e_m31# = 0            : e_m32# = 0            : e_m33# = sclz#        : e_m34# = 0
   e_m41# = posx#        : e_m42# = posy#        : e_m43# = posz#        : e_m44# = 1
   
   
   ; Pitch
   p_m11# = 1            : p_m12# = 0            : p_m13# = 0            : p_m14# = 0
   p_m21# = 0            : p_m22# = Cos(pitch#)  : p_m23# = Sin(pitch#)  : p_m24# = 0
   p_m31# = 0            : p_m32# = -Sin(pitch#) : p_m33# = Cos(pitch#)  : p_m34# = 0
   p_m41# = 0            : p_m42# = 0            : p_m43# = 0            : p_m44# = 1
   
   ; Yaw
   y_m11# = Cos(yaw#)    : y_m12# = 0            : y_m13# = -Sin(yaw#)   : y_m14# = 0
   y_m21# = 0            : y_m22# = 1            : y_m23# = 0            : y_m24# = 0
   y_m31# = Sin(yaw#)    : y_m32# = 0            : y_m33# = Cos(yaw#)    : y_m34# = 0
   y_m41# = 0            : y_m42# = 0            : y_m43# = 0            : y_m44# = 1
   
   ; Roll
   r_m11# = Cos(roll#)   : r_m12# = Sin(roll#)   : r_m13# = 0            : r_m14# = 0
   r_m21# = -Sin(roll#)  : r_m22# = Cos(roll#)   : r_m23# = 0            : r_m24# = 0
   r_m31# = 0            : r_m32# = 0            : r_m33# = 1            : r_m34# = 0
   r_m41# = 0            : r_m42# = 0            : r_m43# = 0            : r_m44# = 1
   
   
   ; Winkel multiplizieren
   w_m11# = p_m11#*y_m11# + p_m12#*y_m21# + p_m13#*y_m31# + p_m14#*y_m41#
   w_m12# = p_m11#*y_m12# + p_m12#*y_m22# + p_m13#*y_m32# + p_m14#*y_m42#
   w_m13# = p_m11#*y_m13# + p_m12#*y_m23# + p_m13#*y_m33# + p_m14#*y_m43#
   w_m14# = p_m11#*y_m14# + p_m12#*y_m24# + p_m13#*y_m34# + p_m14#*y_m44#
   
   w_m21# = p_m21#*y_m11# + p_m22#*y_m21# + p_m23#*y_m31# + p_m24#*y_m41#
   w_m22# = p_m21#*y_m12# + p_m22#*y_m22# + p_m23#*y_m32# + p_m24#*y_m42#
   w_m23# = p_m21#*y_m13# + p_m22#*y_m23# + p_m23#*y_m33# + p_m24#*y_m43#
   w_m24# = p_m21#*y_m14# + p_m22#*y_m24# + p_m23#*y_m34# + p_m24#*y_m44#
   
   w_m31# = p_m31#*y_m11# + p_m32#*y_m21# + p_m33#*y_m31# + p_m34#*y_m41#
   w_m32# = p_m31#*y_m12# + p_m32#*y_m22# + p_m33#*y_m32# + p_m34#*y_m42#
   w_m33# = p_m31#*y_m13# + p_m32#*y_m23# + p_m33#*y_m33# + p_m34#*y_m43#
   w_m34# = p_m31#*y_m14# + p_m32#*y_m24# + p_m33#*y_m34# + p_m34#*y_m44#
   
   w_m41# = p_m41#*y_m11# + p_m42#*y_m21# + p_m43#*y_m31# + p_m44#*y_m41#
   w_m42# = p_m41#*y_m12# + p_m42#*y_m22# + p_m43#*y_m32# + p_m44#*y_m42#
   w_m43# = p_m41#*y_m13# + p_m42#*y_m23# + p_m43#*y_m33# + p_m44#*y_m43#
   w_m44# = p_m41#*y_m14# + p_m42#*y_m24# + p_m43#*y_m34# + p_m44#*y_m44#


   w2_m11# = w_m11#*r_m11# + w_m12#*r_m21# + w_m13#*r_m31# + w_m14#*r_m41#
   w2_m12# = w_m11#*r_m12# + w_m12#*r_m22# + w_m13#*r_m32# + w_m14#*r_m42#
   w2_m13# = w_m11#*r_m13# + w_m12#*r_m23# + w_m13#*r_m33# + w_m14#*r_m43#
   w2_m14# = w_m11#*r_m14# + w_m12#*r_m24# + w_m13#*r_m34# + w_m14#*r_m44#
   
   w2_m21# = w_m21#*r_m11# + w_m22#*r_m21# + w_m23#*r_m31# + w_m24#*r_m41#
   w2_m22# = w_m21#*r_m12# + w_m22#*r_m22# + w_m23#*r_m32# + w_m24#*r_m42#
   w2_m23# = w_m21#*r_m13# + w_m22#*r_m23# + w_m23#*r_m33# + w_m24#*r_m43#
   w2_m24# = w_m21#*r_m14# + w_m22#*r_m24# + w_m23#*r_m34# + w_m24#*r_m44#
   
   w2_m31# = w_m31#*r_m11# + w_m32#*r_m21# + w_m33#*r_m31# + w_m34#*r_m41#
   w2_m32# = w_m31#*r_m12# + w_m32#*r_m22# + w_m33#*r_m32# + w_m34#*r_m42#
   w2_m33# = w_m31#*r_m13# + w_m32#*r_m23# + w_m33#*r_m33# + w_m34#*r_m43#
   w2_m34# = w_m31#*r_m14# + w_m32#*r_m24# + w_m33#*r_m34# + w_m34#*r_m44#
   
   w2_m41# = w_m41#*r_m11# + w_m42#*r_m21# + w_m43#*r_m31# + w_m44#*r_m41#
   w2_m42# = w_m41#*r_m12# + w_m42#*r_m22# + w_m43#*r_m32# + w_m44#*r_m42#
   w2_m43# = w_m41#*r_m13# + w_m42#*r_m23# + w_m43#*r_m33# + w_m44#*r_m43#
   w2_m44# = w_m41#*r_m14# + w_m42#*r_m24# + w_m43#*r_m34# + w_m44#*r_m44#
   
   ; Positionen hinzu multiplizieren

   o_m11# = w2_m11#*e_m11# + w2_m12#*e_m21# + w2_m13#*e_m31# + w2_m14#*e_m41#
   o_m12# = w2_m11#*e_m12# + w2_m12#*e_m22# + w2_m13#*e_m32# + w2_m14#*e_m42#
   o_m13# = w2_m11#*e_m13# + w2_m12#*e_m23# + w2_m13#*e_m33# + w2_m14#*e_m43#
   o_m14# = w2_m11#*e_m14# + w2_m12#*e_m24# + w2_m13#*e_m34# + w2_m14#*e_m44#
   
   o_m21# = w2_m21#*e_m11# + w2_m22#*e_m21# + w2_m23#*e_m31# + w2_m24#*e_m41#
   o_m22# = w2_m21#*e_m12# + w2_m22#*e_m22# + w2_m23#*e_m32# + w2_m24#*e_m42#
   o_m23# = w2_m21#*e_m13# + w2_m22#*e_m23# + w2_m23#*e_m33# + w2_m24#*e_m43#
   o_m24# = w2_m21#*e_m14# + w2_m22#*e_m24# + w2_m23#*e_m34# + w2_m24#*e_m44#
   
   o_m31# = w2_m31#*e_m11# + w2_m32#*e_m21# + w2_m33#*e_m31# + w2_m34#*e_m41#
   o_m32# = w2_m31#*e_m12# + w2_m32#*e_m22# + w2_m33#*e_m32# + w2_m34#*e_m42#
   o_m33# = w2_m31#*e_m13# + w2_m32#*e_m23# + w2_m33#*e_m33# + w2_m34#*e_m43#
   o_m34# = w2_m31#*e_m14# + w2_m32#*e_m24# + w2_m33#*e_m34# + w2_m34#*e_m44#
   
   o_m41# = w2_m41#*e_m11# + w2_m42#*e_m21# + w2_m43#*e_m31# + w2_m44#*e_m41#
   o_m42# = w2_m41#*e_m12# + w2_m42#*e_m22# + w2_m43#*e_m32# + w2_m44#*e_m42#
   o_m43# = w2_m41#*e_m13# + w2_m42#*e_m23# + w2_m43#*e_m33# + w2_m44#*e_m43#
   o_m44# = w2_m41#*e_m14# + w2_m42#*e_m24# + w2_m43#*e_m34# + w2_m44#*e_m44#
   
   
   Print o_m11#
   Print o_m12#
   Print o_m13#
   Print o_m14#
   Print
   Print o_m21#
   Print o_m22#
   Print o_m23#
   Print o_m24#
   Print
   Print o_m31#
   Print o_m32#
   Print o_m33#
   Print o_m34#
   Print
   Print o_m41#
   Print o_m42#
   Print o_m43#
   Print o_m44#

End Function


Könnt ihr mir sagen, ob das vom Prinzip her so richtig aufgestellt ist? Und was soll ich dann noch mit der Produkt-Matrix machen?

Mfg
TheProgrammer
aktuelles Projekt: The last day of human being

StepTiger

BeitragDi, Nov 28, 2006 22:45
Antworten mit Zitat
Benutzer-Profile anzeigen
ziemlich lang, oder?

Code: [AUSKLAPPEN]
Function turn(obj,wink#,sx#,sy#,sz#,richt=0)
   
   tx#=EntityX#(obj,1)
   ty#=EntityY#(obj,1)
   tz#=EntityZ#(obj,1)
   
   x#=tx#-sx#
   y#=ty#-sy#
   z#=tz#-sz#
   
   a#=wink#
   
   If richt=0
      nx#=x#
      ny#=Cos#(a#) * y# - Sin#(a#) * z#
      nz#=Sin#(a#) * y# + Cos#(a#) * z#
   ElseIf richt=1
      nx#=x#*Cos#(a#)+z#*Sin#(a#)
      ny#=y#
      nz#=-x#*Sin#(a#)+z#*Cos#(a#)
   ElseIf richt=2
      nx#=x#*Cos#(a#)-y#*Sin#(a#)
      ny#=x#*Sin#(a#)+y#*Cos#(a#)
      nz#=z#
   EndIf
   
   x#=nx#+sx#
   y#=ny#+sy#
   z#=nz#+sz#
   
   PositionEntity obj,x#,y#,z#
   
End Function

abgesehen davon, dass der code nur objekte um andere dreht, ist es sehr gut möglich, das ganze auf vertices umzusetzen
Noch gestern standen wir am Abgrund, doch heute sind wir schon einen Schritt weiter.
Computer:
AMD Sempron 3000+; ATI Radeon 9800 Pro; 512 MB DDR RAM 400Mhz; Asus E7N8X-E Deluxe; Samsung 200GB HD 5.4ns acces t
Gewinner: BP Code Compo #2
Π=3.141592653589793238...<--- und das aus dem kopf Laughing
Seit der Earthlings-Diskussion überzeugter Fleisch(fr)esser.

TheProgrammer

BeitragDi, Nov 28, 2006 23:33
Antworten mit Zitat
Benutzer-Profile anzeigen
Habs mal auf deine Weise probiert. Kommt aber irgendwie immernoch net das richtige raus.. Ich werd hier gleich verrückt. ^^

Code: [AUSKLAPPEN]
Graphics3D 800,600,0,2

obj = CreatePivot()
PositionEntity obj,-5,5,-6
ScaleEntity obj,45,3,5
RotateEntity obj,184,45,7


TFormPoint(0,0,2,obj,0)
BPlus_TFormPoint(0,0,2, -5,5,-6, 45,3,5, 184,45,7)

Print
Print "B3D: "+TFormedX()+","+TFormedY()+","+TFormedZ()

FreeEntity obj
WaitKey()
End



Function BPlus_TFormPoint(posx#,posy#,posz#,  px#,py#,pz#, sclx#,scly#,sclz#, pitch#,yaw#,roll#)
   
   a# = pitch#
   
   x#=posx#:y#=posy#:z#=posz#

   nx#=x#
   ny#=Cos#(a#) * y# - Sin#(a#) * z#
   nz#=Sin#(a#) * y# + Cos#(a#) * z#
   
   x# = nx#:y# = ny#:z# = nz#
   a# = yaw#

   nx#=x#*Cos#(a#)+z#*Sin#(a#)
   ny#=y#
   nz#=-x#*Sin#(a#)+z#*Cos#(a#)
   
   x# = nx#:y# = ny#:z# = nz#
   a# = roll#

   nx#=x#*Cos#(a#)-y#*Sin#(a#)
   ny#=x#*Sin#(a#)+y#*Cos#(a#)
   nz#=z#

   nx# = nx# * sclx#
   ny# = ny# * scly#
   nz# = nz# * sclz#
   
   nx# = nx# + px#
   ny# = ny# + py#
   nz# = nz# + pz#
   
   Print nx#
   Print ny#
   Print nz#

End Function


Woran liegt es jetzt schonwieder?

Mfg
TheProgrammer
aktuelles Projekt: The last day of human being

Vertex

BeitragMi, Nov 29, 2006 0:59
Antworten mit Zitat
Benutzer-Profile anzeigen
Code: [AUSKLAPPEN]
Global gTempVector.TVector, gTempMatrix.TMatrix

gTempVector = New TVector
gTempMatrix = New TMatrix

Type TVector
   Field X#
   Field Y#
   Field Z#
   Field W#
End Type

Type TMatrix
   Field AA#, AB#, AC#, AD#
   Field BA#, BB#, BC#, BD#
   Field CA#, CB#, CC#, CD#
   Field DA#, DB#, DC#, DD#
End Type

Function MatrixIdentity(M.TMatrix)
   M\AA = 1.0 : M\AB = 0.0 : M\AC = 0.0  : M\AD = 0.0
   M\BA = 0.0 : M\BB = 1.0 : M\BC = 0.0  : M\BD = 0.0
   M\CA = 0.0 : M\CB = 0.0 : M\CC = 1.0  : M\CD = 0.0
   M\DA = 0.0 : M\DB = 0.0 : M\DC = 0.0  : M\DD = 1.0
End Function

Function MatrixRotate(M.TMatrix, Pitch#, Roll#, Yaw#)
   Local SinX#, SinY#, SinZ#
   Local CosX#, CosY#, CosZ#

   SinX = Sin(Pitch) : SinY = Sin(Yaw) : SinZ = Sin(Roll)
   CosX = Cos(Pitch) : CosY = Cos(Yaw) : CosZ = Cos(Roll)

   M\AA = CosY*CosZ
   M\AB = CosY*SinZ
   M\AC = -SinY
   M\AD = 0.0

   M\BA = SinX*SinY*CosZ - CosX*SinZ
   M\BB = SinX*SinY*SinZ + CosX*CosZ
   M\BC = SinX*CosY
   M\BD = 0.0

   M\CA = CosX*SinY*CosZ + SinX*SinZ
   M\CB = CosX*SinY*SinZ - SinX*CosZ
   M\CC = CosX*CosY
   M\CD = 0.0

   M\DA = 0.0
   M\DB = 0.0
   M\DC = 0.0
   M\DD = 1.0
End Function

;Function MatrixRotateEx(M.TMatrix, Angle#, X#, Y#, Z#)
;   Local C#, S#, RLength#
;
;   C = Cos(Angle)
;   S = Sin(Angle)
;
;   ; Normalize Vector
;   RLength = 1.0/Sqr(X*X + Y*Y + Z*Z)
;   X = X*RLength
;   Y = Y*RLength
;   Z = Z*RLength
;
;   M\AA = X*X*(1.0 - C) + C
;   M\AB = Y*X*(1.0 - C) + Z*S
;   M\AC = X*Z*(1.0 - C) - Y*S
;   M\AD = 0.0
;   
;   M\BA = X*Y*(1.0 - C) - Z*S
;   M\BB = Y*Y*(1 - C) + C
;   M\BC = Y*Z*(1.0 - C) + X*S
;   M\BD = 0.0
;
;   M\CA = X*Z*(1.0 - C) + Y*S
;   M\CB = Y*Z*(1.0 - C) - X*S
;   M\CC = Z*Z*(1.0 - C) + C
;   M\CD = 0.0
;   
;   M\DA = 0.0
;   M\DB = 0.0
;   M\DC = 0.0
;   M\DD = 1.0
;End Function

Function MatrixTranslate(M.TMatrix, X#, Y#, Z#)
   M\AA = 1.0 : M\AB = 0.0 : M\AC = 0.0  : M\AD = 0.0
   M\BA = 0.0 : M\BB = 1.0 : M\BC = 0.0  : M\BD = 0.0
   M\CA = 0.0 : M\CB = 0.0 : M\CC = 1.0  : M\CD = 0.0
   M\DA = X   : M\DB = Y   : M\DC = Z    : M\DD = 1.0
End Function

Function MatrixScale(M.TMatrix, X#, Y#, Z#)
   M\AA = X   : M\AB = 0.0 : M\AC = 0.0  : M\AD = 0.0
   M\BA = 0.0 : M\BB = Y   : M\BC = 0.0  : M\BD = 0.0
   M\CA = 0.0 : M\CB = 0.0 : M\CC = Z    : M\CD = 0.0
   M\DA = 0.0 : M\DB = 0.0 : M\DC = 0.0  : M\DD = 1.0
End Function

Function MatrixMatrixMultiply(X.TMatrix, Y.TMatrix, R.TMatrix)
   gTempMatrix\AA = X\AA*Y\AA + X\AB*Y\BA + X\AC*Y\CA + X\AD*Y\DA
   gTempMatrix\AB = X\AA*Y\AB + X\AB*Y\BB + X\AC*Y\CB + X\AD*Y\DB
   gTempMatrix\AC = X\AA*Y\AC + X\AB*Y\BC + X\AC*Y\CC + X\AD*Y\DC
   gTempMatrix\AD = X\AA*Y\AD + X\AB*Y\BD + X\AC*Y\CD + X\AD*Y\DD

   gTempMatrix\BA = X\BA*Y\AA + X\BB*Y\BA + X\BC*Y\CA + X\BD*Y\DA
   gTempMatrix\BB = X\BA*Y\AB + X\BB*Y\BB + X\BC*Y\CB + X\BD*Y\DB
   gTempMatrix\BC = X\BA*Y\AC + X\BB*Y\BC + X\BC*Y\CC + X\BD*Y\DC
   gTempMatrix\BD = X\BA*Y\AD + X\BB*Y\BD + X\BC*Y\CD + X\BD*Y\DD

   gTempMatrix\CA = X\CA*Y\AA + X\CB*Y\BA + X\CC*Y\CA + X\CD*Y\DA
   gTempMatrix\CB = X\CA*Y\AB + X\CB*Y\BB + X\CC*Y\CB + X\CD*Y\DB
   gTempMatrix\CC = X\CA*Y\AC + X\CB*Y\BC + X\CC*Y\CC + X\CD*Y\DC
   gTempMatrix\CD = X\CA*Y\AD + X\CB*Y\BD + X\CC*Y\CD + X\CD*Y\DD

   gTempMatrix\DA = X\DA*Y\AA + X\DB*Y\BA + X\DC*Y\CA + X\DD*Y\DA
   gTempMatrix\DB = X\DA*Y\AB + X\DB*Y\BB + X\DC*Y\CB + X\DD*Y\DB
   gTempMatrix\DC = X\DA*Y\AC + X\DB*Y\BC + X\DC*Y\CC + X\DD*Y\DC
   gTempMatrix\DD = X\DA*Y\AD + X\DB*Y\BD + X\DC*Y\CD + X\DD*Y\DD

   R\AA = gTempMatrix\AA : R\AB = gTempMatrix\AB : R\AC = gTempMatrix\AC : R\AD = gTempMatrix\AD
   R\BA = gTempMatrix\BA : R\BB = gTempMatrix\BB : R\BC = gTempMatrix\BC : R\BD = gTempMatrix\BD
   R\CA = gTempMatrix\CA : R\CB = gTempMatrix\CB : R\CC = gTempMatrix\CC : R\CD = gTempMatrix\CD
   R\DA = gTempMatrix\DA : R\DB = gTempMatrix\DB : R\DC = gTempMatrix\DC : R\DD = gTempMatrix\DD
End Function

Function MatrixVectorMultiply(A.TMatrix, B.TVector, R.TVector)
   gTempVector\X = A\AA*B\X + A\AB*B\Y + A\AC*B\Z + A\AD*B\W
   gTempVector\Y = A\BA*B\X + A\BB*B\Y + A\BC*B\Z + A\BD*B\W
   gTempVector\Z = A\CA*B\X + A\CB*B\Y + A\CC*B\Z + A\CD*B\W
   gTempVector\W = A\DA*B\X + A\DB*B\Y + A\DC*B\Z + A\DD*B\W

   R\X = gTempVector\X
   R\Y = gTempVector\Y
   R\Z = gTempVector\Z
   R\W = gTempVector\W
End Function

Function TFormPoint2(Point.TVector, SX#, SY#, SZ#, Pitch#, Yaw#, Roll#, TX#, TY#, TZ#, Result.TVector)
   Local Scale.TMatrix, Rotate.TMatrix, Translate.TMatrix
   Local Modelview.TMatrix

   Scale     = New TMatrix
   Rotate    = New TMatrix
   Translate = New TMatrix
   Modelview = New TMatrix

   MatrixScale(Scale, SX#, SY#, SZ#)
   MatrixRotate(Rotate, Pitch#, Yaw#, Roll#)
   MatrixTranslate(Translate, TX#, TY#, TZ#)

   MatrixMatrixMultiply(Scale, Rotate, Modelview)
   MatrixMatrixMultiply(Modelview, Translate, Modelview)

   MatrixVectorMultiply(Modelview, Point, Result)

   Delete Scale
   Delete Rotate
   Delete Translate
   Delete Modelview
End Function

Global Point.TVector, Result.TVector

Point  = New TVector
Result = New TVector

Point\X = 0.0
Point\Y = 0.0
Point\Z = 0.0
Point\W = 1.0
TFormPoint2(Point, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, Result)

Print Result\X
Print Result\Y
Print Result\Z
Print Result\W

WaitKey
End


Sorry, werde mich mal die Tage nochmal drum kümmern, damit das Lauffähig wird. Die Matrizen sind schonmal OK von mir.

Blitz3D wird im Hintergrund denke mal mit Quaternions arbeiten, so, dass die MatrixRotate Funktion nicht 1 zu 1 stimmt (dazu siehe MatrixRotateEx) es kann Gimballock auftreten(wie auch in allen Codes zuvor)

mfg olli
vertex.dreamfall.at | GitHub

Vertex

BeitragMi, Nov 29, 2006 9:26
Antworten mit Zitat
Benutzer-Profile anzeigen
Code: [AUSKLAPPEN]
Function MatrixVectorMultiply(A.TMatrix, B.TVector, R.TVector)
   gTempVector\X = A\AA*B\X + A\BA*B\Y + A\CA*B\Z + A\DA*B\W
   gTempVector\Y = A\AB*B\X + A\BB*B\Y + A\CB*B\Z + A\DB*B\W
   gTempVector\Z = A\AC*B\X + A\BC*B\Y + A\CC*B\Z + A\DC*B\W
   gTempVector\W = A\AD*B\X + A\BD*B\Y + A\CD*B\Z + A\DD*B\W

   R\X = gTempVector\X
   R\Y = gTempVector\Y
   R\Z = gTempVector\Z
   R\W = gTempVector\W
End Function


die alte mit der ersetzen, dann dürfte es klappen. Habe bisher die Rotation nicht probiert, Scale und Translate funktionieren aber.

mfg olli
vertex.dreamfall.at | GitHub

TheProgrammer

BeitragMi, Nov 29, 2006 18:46
Antworten mit Zitat
Benutzer-Profile anzeigen
Vielen Dank für die Mühe. Very Happy

Aber irgendwas stimmt da noch nicht...

Code: [AUSKLAPPEN]

Graphics3D 320,240,0,2

Include "tforming.bb"

; B2D
Point  = New TVector
Result = New TVector

Point\X = 0.0
Point\Y = 0.0
Point\Z = 2.0
Point\W = 1.0
TFormPoint2(Point, 1.0, 1.0, 2.0, 90.0, 45.0, 0.0, 1.0, 2.0, 3.0, Result)

Print "B2D: "+Result\X+","+Result\Y+","+Result\Z

Delete point
Delete result


; B3D
piv = CreatePivot()
PositionEntity piv,1,2,3
ScaleEntity piv,1,1,2
RotateEntity piv,90,45,0

TFormPoint 0,0,2, piv,0

Print "B3D: "+TFormedX()+","+TFormedY()+","+TFormedZ()



WaitKey
End


Die Werte weichen immernoch voneinander ab. Sad

Mfg
Theprogrammer
aktuelles Projekt: The last day of human being

Neue Antwort erstellen


Übersicht BlitzBasic Beginners-Corner

Gehe zu:

Powered by phpBB © 2001 - 2006, phpBB Group