Trigonometrische Funktionen Runtime - Library - Funktionen sin oder cos auf Berechnung von double ausgelegt Einfache Genauigkeit float durch funktionale.

Trigonometrische Funktionen

• Runtime - Library - Funktionen sin oder cos auf Berechnung von double ausgelegt

• Einfache Genauigkeit float durch funktionale gleichwertige Funktionen sinf, cosf, tanf, atanf

• Konstante π wird durch D3DX_PI repräsentiert

Vektoren• In C: • 3D - Vektor als struct mit drei Koordinatenwerten

x, y, z:typedef struct _D3DVECTOR

{

float x;

float y;

float z;

}

D3DVECTOR;

-> Koordinaten eines Vektor v über v.x, v.y, v.z ansprechbar

• In c++: verschiedene Konstruktoren und überladene Operatoren

typedef struct D3DXVECTOR3: public D3DVECTOR{public:D3DXVECTOR3 () {}; // erzeugt uninitialisierten VektorD3DXVECTOR3 ( CONST FLOAT *); /* initialisiert Vektor aus Array

von Gleitkommazahlen */D3DXVECTOR3 (CONST D3DVECTOR& ); /* Copy - Konstruktor: Vektor

aus Vektor */D3DXVECTOR3 ( FLOAT x, FLOAT y, FLOAT z); /* Initialisierung mit

3 Einzelwerten */

operator FLOAT* (); /*Vektor auf Array von Gleitkommazahlen casten*/

operator CONST FLOAT* () const; /* damit jede Koordinate über Index ansprechbar */

D3DXVECTOR3& operator += (CONST D3DXVECTOR3&); //Addition Vektoren v+= w */

D3DXVECTOR3& operator -= (CONST D3DXVECTOR3&);// SubtraktionD3DXVECTOR3& operator *= (FLOAT);/* Multiplikation Vektor v *= s

(Skalar)*/D3DXVECTOR3& operator /= (FLOAT);/* Division Vektor v /= s

(Skalar)*/

D3DXVECTOR3 operator + () const; // Vorzeichen +vD3DXVECTOR3 operator - () const; // Vorzeichen -v

D3DXVECTOR3 operator + (CONST D3DXVECTOR3&) const;// Addition zweier Vektoren u = v + wD3DXVECTOR3 operator - (CONST D3DXVECTOR3&) const;// Subtraktion zweier Vektoren u = v - w

D3DXVECTOR3 operator * (FLOAT) const; // u = v*s (Skalar)D3DXVECTOR3 operator / (FLOAT) const; // u = v/s (Skalar)

friend D3DXVECTOR3 operator * (FLOAT, CONST struct D3DXVECTOR3&); // u = s (Skalar) * v

BOOL operator == (CONST D3DXVECTOR3& ) const;// Test auf Gleichheit zweier Vektoren u == vBOOL operator != (CONST D3DXVECTOR3& ) const;// Test auf Ungleichheit u!=v}D3DXVECTOR3, // ist ein 3D - Vektor*LPD3DXVECTOR3; // ist ein Zeiger auf einen 3D - Vektor

Vektorfunktionen-> Addition von zwei Vektoren

D3DXVECTOR3* D3DXVec3Add

(D3DVECTOR3* pOut, CONST D3DVECTOR3* pV1, CONST D3DVECTOR3* pV2)

( Zeiger auf Ergebnisvektor, ersten Summanden, zweiten Summanden )

- *pOut wird als Funktionsergebnis über return zurück gegeben

- Alternativ: Out = V1 + V2

-> Subtraktion ist in Parametersignatur identisch

D3DXVECTOR3* D3DXVec3Subtract

(D3DVECTOR3* pOut, CONST D3DVECTOR3* pV1, CONST D3DVECTOR3* pV2)

( Zeiger auf Ergebnisvektor, erster Operand, zweiter Operand )

-> Skalieren, dh Multiplizieren des Vektors mit einer Zahl

D3DXVECTOR3* D3DXVec3Scale (D3DXVECTOR3* pOut, CONST D3DXVECTOR3* pV, FLOAT s)

( Zeiger auf Ergebnisvektor, skalierenden Vektor, Skalierungsfaktor)

- alternativ: Out = s * V

-> Skalarprodukt von Vektoren

FLOAT D3DXVec3Dot (CONST D3DXVECTOR3* pV1, CONST D3DXVECTOR3* pV2)

(Erster Eingabevektor, zweiter Eingabevektor)

-> Länge eines Vektors

FLOAT D3DXVec3Length (CONST D3DXVECTOR3* pV)

(Zeiger auf Vektor, dessen Länge gesucht)

-> Längenvergleiche zwischen Vektoren

- Längenquadrate der Vektoren berechnen ist effizienter, da kein Wurzel ziehenFLOAT D3DXVecLengthSq (CONST D3DXVECTOR3* pV)(Vektor, dessen Längenquadrat gesucht)

-> Vektorkreuzprodukt- zwei Vektoren: a x b

D3DXVECTOR3* D3DXVecCross (D3DXVECTOR3* pOut, CONST D3DXVECTOR3* pV1, CONST D3DXVECTOR3* pV2)

(Ergebnis, erster Operand, zweiter Operand)

-> lineare Interpolation Out= (1-s)V1 + V2

D3DXVECTOR3* D3DXVec3Lerp (D3DXVECTOR3* pOut, CONST D3DXVECTOR3* pV1, CONST D3DXVECTOR3* pV2, FLOAT s)

(Ergebnis, erster Operand, zweiter Operand, Interpolationsfaktor)

-> jeweils kleinste x, y, z - Koordinatenwerte zweier Vektoren zu neuem Vektor zusammen fassen, Minimum der beiden Eingabewerte

D3DXVECTOR3* D3DXVec3Minimize (D3DXVECTOR3* pOut, CONST D3DXVECTOR3* pV1, CONST D3DXVECTOR3* pV2)

(Ergebnisvektor, erster Operand, zweiter Operand)

-> Maximum äquivalent berechnenD3DXVECTOR3* D3DXVec3Maximize (D3DXVECTOR3* pOut,

CONST D3DXVECTOR3* pV1, CONST D3DXVECTOR3* pV2)

-> normalisierter Vektor - gleiche Richtung wie Ursprungsvektor, aber Länge 1- Berechnung: Division durch seine Länge

D3DXVECTOR3* D3DXVec3Normalize (D3DXVECTOR3* pOut, CONST D3DXVECTOR3* pV)

(Ergebnisvektor, Eingabevektor)

Matrizen• 4 x 4 Matrizen - zunächst wieder einfache C Datenstrukturtypedef struct _D3DMATRIX{union // Union, in der zwei Interpretationen der Matrix{ struct{ float _11, _12, _13, _14; //als einzeln benannte Felderfloat _21, _22, _23, _24;float _31, _32, _33, _34;float _41, _42, _43, _44;};float m [4][4];// als zweidimensionaler Array// übereinander gelegt sind -> Felder von Matrix mat// können direkt mat._32 oder über Index mat.m [3][2]}; // angesprochen werden} D3DMATRIX;

typedef struct D3DMXMATRIX : public D3DMATRIX

{

Public:

D3DXMATRIX () {}; // ohne Initialwerte

D3DXMATRIX (CONST FLOAT *); // über Array von Werten

D3DXMATRIX (CONST D3DXMATRIX&); // über andere Matrix

D3DXMATRIX (FLOAT _11, FLOAT _12, FLOAT _13, FLOAT _14,

FLOAT _21, FLOAT _22, FLOAT _23, FLOAT _24,

FLOAT _31, FLOAT _32, FLOAT _33, FLOAT _34,

FLOAT _41, FLOAT _42, FLOAT _43, FLOAT _44,);

// Initialisierung über Einzelwerte

FLOAT& operator () (UINT Row, UINT Col);

FLOAT operator () (UINT Row, UINT Col) const;

// Überladen Operator () -> Zugriff auf Felder der

// Matrix mat über mat (3,2)

// im ersten Fall sind Werte durch Referenz veränderbar

operator FLOAT* (); // Cast Operatoren

operator CONST FLOAT* () const;// Matrix als Array

D3DXMATRIX& operator *= (CONST D3DXMATRIX& );

//Multiplikation zweier Matrizen m*=n

D3DXMATRIX& operator += (CONST D3DXMATRIX& );

// Addition zweier Matrizen m+=n

D3DXMATRIX& operator -= (CONST D3DXMATRIX& );

// Subtraktion zweier Matrizen m-=n

D3DXMATRIX& operator *= (FLOAT);

// Multiplikation Matrix m *=s (Skalar)

D3DXMATRIX& operator /= (FLOAT);

// Division einer Matrix durch Skalar m/=s

D3DXMATRIX operator + () const;

// Vorzeichen +m

D3DXMATRIX operator - () const;

// Vorzeichen -m

D3DXMATRIX operator * (CONST D3DXMATRIX&) const;

//Multiplikation zweier Matrizen m = n1 *n2

D3DXMATRIX operator + (CONST D3DXMATRIX&) const;

// Addition zweier Matrizen m = n1+ n2

D3DXMATRIX operator - (CONST D3DXMATRIX&) const;

// Subtraktion zweier Matrizen m = n1 - n2

D3DXMATRIX operator * (FLOAT) const;

// Multiplikation Matrix * Skalar m = n*s

D3DXMATRIX operator / (FLOAT) const;

// Division Matrix / Skalar m = n/s

friend D3DXMATRIX operator * (FLOAT, CONST D3DXMATRIX&);

// Multiplikation Skalar, Matrix m = s*n

BOOL operator == (CONST D3DXMATRIX&) const;

// Test auf Gleichheit zweier Matrizen m == n

BOOL operator != (CONST D3DXMATRIX&) const;

// Test auf Ungleichheit m!=n }

D3DXMATRIX, // Datentyp: eine 4x4 Matrix

*LPD3DXMATRIX; // Datentyp: Zeiger auf 4x4 Matrix

Matrizenfunktionen-> Einheitsmatrix erzeugen- häufig als Initialwert verwendet, macht gar nichts wenn auf Vektor / MatrixD3DXMATRIX* D3DXMatrixIdentity (D3DXMATRIX* pOut)(Zeiger auf Ergebnismatrix wird über return zurück

gegeben)

-> Berechnung der Umkehrmatrix- manche Matrixoperationen lassen sich rückgängig machen, so etwa die

Drehung, z.B. Drehung um die z-Achse- Allgemeine Matrix zur Drehung um z-Achse sowie für deren umgekehrte

Drehung ergibt Einheitsmatrix -> M * M-1 = E

D3DXMATRIX* D3DXMatrixInverse (D3DXMATRIX* pOut, FLOAT* pDeterminant, CONST D3DXMATRIX*pM)

(Zeiger auf Ergebnismatrix, berechnende Determinante, invertierende Matrix)

- wenn nicht invertierbar: Rückgabewert 0- Determinante: wenn ungleich 0, ist die Matrix invertierbar

-> Multiplikation, Produkt zweier MatrizenD3DXMATRIX* D3DXMatrixMultiply (D3DXMATRIX*pOut, CONST

D3DXMATRIX* pM1, CONST D3DXMATRIX* pM2)(Zeiger auf Ergebnismatrix, erste, zweite

Eingabematrix)- pOut wird zurück gegeben

-> Rotationen um eine der drei KoordinatenachsenD3DXMATRIX* D3DXMatrixRotationX (D3DXMATRIX*pOut, FLOAT

Angle)D3DXMATRIX* D3DXMatrixRotationY (D3DXMATRIX*pOut, FLOAT

Angle)D3DXMATRIX* D3DXMatrixRotationZ (D3DXMATRIX*pOut, FLOAT

Angle)(Ergebnismatrix, Rotationswinkel)- Vektor gegen den Uhrzeigersinn in bestimmtem Winkel- Beliebige Achse:D3DXMATRIX* D3DXMatrixRotationAxis (D3DXMATRIX*pOut,

CONST D3DXVECTOR3* pV, FLOAT Angle)- Vektor angeben, der Drehachse bilden soll

-> Matrix, die Vektoren um Winkel in alle drei Koordinatenrichtungen kippt

- Yaw: Rechts - Links - Drehen- Pitch: Auf - Ab- Roll: Rechts - Links - NeigenD3DXMATRIX* D3DXMatrixRotationYawPitchRoll (D3DXMATRIX*

pOut, FLOAT Yaw, FLOAT Pitch, FLOAT Roll)

-> Matrix in x,y,z Richtung skalieren

D3DXMATRIX* D3DXMatrixScaling (D3DXMATRIX* pOut, FLOAT sx, FLOAT sy, FLOAT sz)

(Ergebnis, Skalierungsfaktor in x,y,z - Richtung)

-> Translation oder Verschiebung

D3DXMATRIX* D3DXMatrixTranslation (D3DXMATRIX* pOut, FLOAT x, FLOAT y, FLOAT z)

(Ergebnis, Verschiebung in x,y,z - Richtung)

-> Erzeugung von Projektionsmatrizen- Matrix für orthogonale Projektion in z-Richtung in einem linkshändischen

KoordinatensystemD3DXMATRIX* D3DXMatrixOrthoLH (D3DXMATRIX* pOut, FLOAT

w, FLOAT h, FLOAT zn, FLOAT zf)(Zeiger auf Ergebnismatrix, Breite des Sichtfensters, Höhe des Sichtfensters,

Abstand zur nahen Begrenzungsebene, Abstand zur fernen Begrenzungsebene)

-> perspektivische ProjektionD3DXMATRIX* D3DXMatrixPerspectiveLH (D3DXMATRIX* pOut,

FLOAT w, FLOAT h, FLOAT zn, FLOAT zf) (Ergebnismatrix, Breite des Sichtfensters, Höhe des Sichtfensters, Abstand zur

nahen Begrenzungsebene, Abstand zur fernen Begrenzungsebene)

-> für eine perspektivische Projektion über Ansichtsverhältnis und Blickwinkel

D3DXMATRIX* D3DXMatrixPerspectiveFovLH (D3DXMATRIX* pOut, FLOAT fovy, FLOAT Aspect, FLOAT zn, FLOAT zf)

(Ergebnismatrix, Blickfeldwinkel, Ansichtsverhältnis, Abstand zur nahen Begrenzungsebene, Abstand zur fernen Begrenzungsebene)

-> Szene aus bestimmter Position betrachten, damit ist bestimmte Bewegung im Raum verbunden

D3DXMATRIX* D3DXMatrixLookAtLH (D3DXMATRIX* pOut, CONST D3DXVECTOR3* pEye, CONST D3DXVECTOR3* pAt, CONST D3DXVECTOR3* pUp)

(Zeiger auf Ergebnismatrix, Standpunkt Betrachter, Blickpunkt Betrachter, Richtungsvektor, der angibt, wo für Betrachter „oben“ ist)

Vektor - Matrizenfunktionen

• Multiplizieren eines Vektors mit einer Matrix:D3DXVec3TransformNormal

D3DCVec3TransformCoord

- beide Funktionen ermöglichen Multiplikation eines dreidimensionalen Vektors mit 4x4 Matrix

- Wir wollen mit 3D Vektoren arbeiten, müssen aber aus technischen Gründen mit in der vierten Koordinate mit 1 ergänzten 4D Vektoren arbeiten

D3DXVec3TransformNormal- Matrix wird durch Ignorieren der vierten Spalte und vierten Zeile

zurecht geschnitten- Dann Multiplikation des 3D - Eingabevektors mit Matrix

D3DXVECTOR3* D3DXVec3TransformNormal ( D3DXVECTOR3* pOut, CONST D3DXVECTOR3* pV, CONST D3DXMATRIX* pM)

(Zeiger auf Ergebnisvektor, multiplizierenden Vektor, Matrix)

- Ergebnis ist nur bei Dreh- oder Skalierungsmatrix korrekt, Verschiebung: ein Verschiebevektor wird in letzter Zeile und Spalte ignoriert

D3DXVECTOR3* D3DXVec3TransformCoord (D3DXVECTOR3* pOut, CONST D3DXVECTOR3* pV, CONST D3DXMATRIX* pM)

( Zeiger auf Ergebnisvektor, auf den zu multiplizierenden Vektor, auf Matrix)

- fehlende vierte Koordinate des Vektors wird mit 1 ergänzt

- Eignet sich für Verschiebung

- Multiplikation mit kompletter 4x4 Matrix

- Dann Rückskalierung: die ersten drei Koordinaten werden durch den Wert der vierten Koordinate dividiert

- Bei Drehungen, Skalierungen, Translationen hat Rückskalierung keinen Effekt -> auch hier korrekte Ergebnisse

- Vierte Koordinate nach Multiplikation ignoriert

- Ergebnis: 3D Vektor

Modellierung dreidimensionaler Objekte• Statt Punktwolke in 3D Szenarien: digitales Drahtgitter, auch

genannt Mesh• Besteht aus Vielzahl von Eck- und Knotenpunkten (Vertices)• Ein Vertex ist ein Vektor mit x, y, z - Koordinate• Zusätzlich: Angabe der Punkte, die zusammen eine Fläche bilden -

> Aufstellung aller Flächen bzw Faces• Fläche hat immer Vorderseite und Rückseite und wird durch

Aufzählung ihrer Eckpunkte im Uhrzeigersinn bei Blick auf Vorderseite beschrieben

• Folien zum „Bekleben“: Texturen in bmp oder jpg Format -> Information über Klebepunkte

• Für jeden Eckpunkt muss man festlegen, welche Stelle der Textur an ihm anzukleben ist

• Textur wird entsprechend gestreckt oder gestaucht -> Textur Mapping

• Material: Textur mit Materialeigenschaften

• In DirectX: Mesh als Datenstruktur

• Dateiformat für Meshes: x-Format .x

• Erstellung über 3D Modeller