Softwaretechnologie II (Teil 1):Simulation und 3D ProgrammierungManfred ThallerWS 2012/2013

  

3D-Grafik: Mathe 

Linda Scholz

Was ist 3D Grafik?

Vektoren Matrizen Aufbau Direct3D – Zuständigkeitsbereich

Schnittstellen Ebenen Farbgebung

Zweidimensionales kartesisches Koordinatensystem

Dreidimensionales kartesisches Koordinatensystem

Darstellung dreidimensionaler Objekte

Abbildung auf dem Bildschirmdurch Projektion Bildtiefe wird vermittelt

Einsatz von Polygongrafik Verbindung von Bildpunkten zu

mehreren Dreiecken Annährung an den „perfekten“ Körper Durchschnittliche Größenordnung zur Annährung

liegt bei 10.000 Polygonen

Vektoren

Positionsvektoren Koordinaten eines Punktes

Richtungsvektor Gibt Bewegungsrichtung an In Kombination mit der Geschwindigkeit auch

Bewegungsvektoren genannt Vektorkomponenten vom Blickwinkel des

Betrachters abhängig

Rechenoperationen

Grundrechenarten zur Bewegung, Verlängerung oder Stauchung

Punktprodukt / Skalarprodukt Bestimmt Kosinus eines Winkel zwischen zwei

Richtungsvektoren Kreuzprodukt

Steht senkrecht auf den Vektoren aus denen es gebildet wurde

Rechenoperationen

Länge eines Vektors / Distanz zwischen zwei Punkten Berechnung durch Satz des Pythagoras

Normalisierte Vektoren (Richtungsvektoren) Länge 1 – pure Richtungsangabe Bewegungsvektor wird durch seine Länge geteilt Verhindert unerwartete Werte Wichtig bei Berechnung des Punktprodukts

Implementierte Klasse : tbVector3 TBVECTOR3.H

Deklaration und Inline-Methoden TBVECTOR3.CPP

Definition / Implementierung Variablen

Drei float Variablen für die Komponenten x, y, z

Programmierung einer Vektorklasse

Konstruktoren

Standardkonstruktor Kopierkonstruktor

Erwartet Referenz auf ein anderes tbVector3-Objekt Kopiert den angegeben Vektor

Konstruktor Setzt Vektorkomponenten ein

Operatoren

Arithmetische Operatoren lassen sich komponentenweise durchführen

Bsp:

inline tbVector3 operator * (const tbVector3& a,

const tbVector3& b)

{

return tbVector3(a.x * b.x, a.y * b.y, a.z * b.z);

}

Operatoren

Zuweisungsoperatoren Werden innerhalb der Klasse definiert

Vergleichsoperatoren Überprüfung zur Gleichheit bzw. Ungleichheit

zweier Vektoren

D3DVECTOR

Struktur zur Darstellung von Vektoren Wird von Direct3D verwendet Identisch mit tbVector3 Verbindung zur tbVector3 Klasse durch Casting

operator D3DVECTOR& ()

{

return *((D3DVECTOR*)(this));

}

3D Spieleprogrammierung Seite 56

Hilfsfunktionen

Vektorlänge und Quadrat der Vektorlänge tbVector3Length tbVector3LengthSq

inline float tbVector3Length(const tbVector3& v)

{

return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);

}

Hilfsfunktionen

Normalisieren eines Vektors tbVector3Normalize Teilt Vektor durch seine Länge

inline tbVector3NormalizeEX(const tbVector3& v)

{

return v / (sqrtf(v.x * v.x + v.y * v.y + v.z * v.z) + 0.0001f);

}

Wenn man nicht sicher ist ob der Vektor die Länge null hat, erreicht man durch Addition eines Kontrollwerts „sicheres“ Normalisieren

Hilfsfunktionen

Das Kreuzprodukt tbVector3Cross

inline tbVector3 tbVectorCross(const tbVector3& a,

const tbVector3& b)

{

return tbVector3(a.y * b.z - a.z * b.y,

a.z * b.x - a.x * b.z,

a.x * b.y - a.y * b.x);

}

Hilfsfunktionen

Punktprodukt tbVector3Dot (berechnet lediglich Punktprodukt) Seite 59

tbVector3Angle rechnet Kosinuswert zusätzlich um

inline float tbVector3Angle(const tbVector3& a,

const tbVector3& b)

{

return acosf((a.x * b.x + a.y * b.y + a.z * b.z) / //Punktprodukt

sqrtf((a.x * a.x + a.y * a.y + a.z * a.z) * //Vektorlänge

(b.x * b.x + b.y * b.y + b.z * b.z)));

}

Man erhält Kosinuswert des Winkels

Durch ArcusFunktion

Hilfsfunktionen

Minimum- und Maximumvektoren Geben Minimum- bzw. Maximumvektor mehrerer

Vektoren an tbVector3Min bzw. tbVector3Max

Zufallsvektoren Liefert zufälligen normalisierten Vektor tbVector3Random Funktion für die Richtung : tbFloatRandom Einsatz für Explosionen, Rauch, etc.

Hilfsfunktionen

Lineare Interpolation Positionsbestimmung eines Objekts zu einer

gewissen Zeit Start- und Zielpunkt sind bekannt tbVector3InterpolateCoords Seite 61

Interpoliert man Normalenvektoren ist das Ergebnis nicht gleichzeitig auch ein Normalenvektor

tbVector3InterpolateNormale (Interpoliert und normalisiert)

tbVector3InterpolateNormalizeEx (Interpoliert, normalisiert und prüft ob Vektor die Länge null hat)

Hilfsfunktionen

inline tbVector3 tbVector3InterpolateNormal(const tbVector3& a,

const tbVector3& b,

const float s)

{

return tbVector3NormalizeEx(a + s * (b – a));

}

Hilfsfunktionen

Zur Überprüfung ist es hilfreich, wenn man Vektoren ins Logbuch schreibt tbWriteVector3ToLog

Übersicht der Hilfsfunktionen für Vektoren und Beispielcode auf Seite 63

Für die Arbeit mit 2D-Vektoren gibt es die Klasse tbVector2 mit 2D Funktion ähnlich zu den gerade kennengelernten

Matrizen

Matrix = rechteckige Anordnung von Zahlen

Verschiedene Menge Zeilen und Spalten

IdentitätsmatrixVerkörpert das neutrale Element

Rechenoperationen

Multiplikation von Matrizen

Spaltenanzahlvon Matrize Amuss mit Zeilenanzahlvon Matrize Bidentisch sein

Matrizen dividieren

Division durch Multiplikation mit dem Kehrwert Kehrwert ist das inverse Element – bei einer

Matrix muss es die Identitätsmatrix ergeben Invertierte Matrix bringt man durch Exponenten

-1 zum Ausdruck

Transformationen

Verschiebung Rotation Skalierung Man betrachtet Vektoren als Matrix mit Zeilen

und Spalten Man geht von absoluten Koordinaten mit dem

Objektmittelpunkt (0, 0, 0) aus

Transformationsmatrix

Transformationsmatrix verwendet 4 Spalten und 4 Zeilen

Verbleibende Zeilefüllt man mit einer 1 (w Koordinate)

Resultierende w Koordinate muss 1 sein. Ist dies nicht der Fall teilt man alle Komponenten durch sie

Transformationen

Translationsmatrix Verschiebt einen Vektor Simple Vektoraddition

Xp = xm*C11 + ym*C21 + zm*C31 + C41

Matrixelement C41 fließt „nur“ durch Addition ein Bei Yp C42 und bei Zp C43 Füllt man diese Elemente (innerhalb einer

Identitätsmatrix) aus, wird eine Translation durchgeführt

Transformation

Skalierungsmatrix Skalierung bedeutet Multiplikation eines Vektors Man nutzt die Identitätsmatrix Xo = x*Sx + y*0 + z*0 + 0 Es finden lediglich Multiplikationen der

einzelnen Komponenten statt

Transformationen

Rotationsmatrizen Gleichung zur Drehung eines Punktes um den

Koordinatenursprung: x = (x * cos α) + (y * (- sin α))

y = (x * sin α) + (y * cos α) Dieses Verfahren kann man auf die Rechnung mit

der Matrix anwenden Es muss beachtet werden, welche Komponenten

angesprochen werden

Transformationen von Richtungsvektoren

Können nicht verschoben werden (haben keine Position, beschreiben lediglich eine Richtung)

Bei einer Transformation müssen die m und n Werte vertauscht werden (transformierte invertierte Transformationsmatrix)

Transformationen

Man kann innerhalb einer Matrix mehrere Funktionen (Translation, Skalierung, Rotation) vieler Matrizen vereinen

Reihenfolge ist wichtig Skalierung Rotation Translation

Matrix als Koordinatensystem

Um eine Matrix zu erhalten die einen Punkt in ein anderes Koordinatensystem umrechnet, muss eine Translation um den Ursprung stattfinden

Um Koordinatensystemmatrix zu erhalten muss man Rotationsmatrix mit Translationsmatrix multiplizieren

Projektionsmatrix

Projektion eines dreidimensionalen Vektors auf eine Ebene (Bildschirm)

Dreiecke die vor oder hinter einer gewissen Ebene (nahe und ferne Clipping-Ebene) werden nicht mehr dargestellt Entfernung der Clipping Ebene Blickfeld des Betrachters Seitenverhältnisse des Bildes

Projektionsmatrix

Projektionsmatrize bestimmt das Sichtfeld des Betrachters

Sichtfelder – Clipping Ebenen

Kameramatrix

Virtueller Beobachter lässt sich in 3D Szene einfügen Position und Ausrichtung muss bekannt sein

- Blickpunkt der Kamera Nach-oben-Vektor –Kamerabewegung Dreht man Kamera nach links werden

Objektvektoren nach rechts bewegt Man wendet Kameramatrix vor Projektions- und

nach Transformationsmatrizen an beinhaltet eigenes Koordinatensystem

Implementierung

• Variablen der Klasse tbMatrix

• 16 float Variablen (m11 bis m44)

• Konstruktoren

• Standardkonstruktor

• Kopierkonstruktor mit Referenz auf eine andere Matrix. Kopiert die angegebene Matrix

• Konstruktor der die Werte der float-Parameter in die Matrix hineinkopiert

Operatoren

• Addition und Subtraktion sind identisch zur Vektorklasse

• Divisionsoperator invertiert rechte Matrix und multipliziert linke damit

• tbMatrixInvert

• tbMatrixTranspose

• Multiplikation ist recht komplex

Operatoren

inline tbMatrix operator * (const tbMatrix& a,

const tbMatrix& b)

{

return tbMatrix(b.m11 * a.m11 + b.m21 * a.m12 + b.m31 * a.m13 + b.m41 * a.m14,

b.m12 * a.m11 + b.m22 * a.m12 + b.m32 * a.m13 + b.m42 * a.m14,

b.m13 * a.m11 + b.m23 * a.m12 + b.m33 * a.m13 + b.m43 * a.m14,

[…]

[…]

[…] );

}

• Es lohnt sich auf vorhandene CPU-Features zurückzugreifen

Zugriffsoperatoren

• Zur Übergabe von Variablen benötigt man ein zweidimensionales Array

class TRIBASE_API tbMatrix{public:

union{

struct {

float m11, m12, m13, m14, //Elemente der Matrixm21, m22, m23, m24,m31, m32, m33, m34,m41, m42, m43, m44;

}float m[4] [4]; //Zweidimensionales Array

};[…]

Zugriffsoperatoren

• Durch Überladen des „()“-Operators der tbMatrix-Klasse kann man Elemente einzeln ansprechen

class TRIBASE_API tbMatrix{public:

[…] //Zugriffsoperatorenfloat& operator () (int iRow, int iColumn) {return m[iRow - 1] [iColumn - 1];}float operator () (int iRow, int iColumn) const {return m[iRow - 1] [iColumn - 1];}};

tbMatrix m; //Matrixelemente lassen sich einzeln verändernm(1, 3) = 100.0f; m(2, 1) = -50.0f;

float f = m(1, 2); // zur allgemeinen Abfrage

Implementierung

• Identitätsmatrix und Translationsmatrix lassen sich leicht erzeugen

TRIBASE_API tbMatrix tbMatrixTranslation (const tbVector3& v){

return tbMatrix (1.0f, 0.0f, 0.0f, 0.0f,

0.0f, 1.0f, 0.0f, 0.0f,

0.0f, 0.0f, 1.0f, 0.0f,

v.x, v.y, v.z, 1.0f);

• Identitätsmatrix wird durch tbMatrixIdentity erzeugt, in dem man die ersten drei Zeichen der letzten Zeile auf 0.0f setzt.

Implementierung

• Rotationsmatrix

• Man kann Rotation für alle Achsen separat vornehmen Seite 79-80

• tbMatrixRotationX

• tbMatrixRotationY

• tbMatrixRotationZ

• Sinus- und Kosinuswerte müssen nur einmal berechnet werden.

Implementierung

• Rotation um alle drei Achsen

TRIBASE_API tbMatrix tbMatrixRotation (const tbVector3& v)

{

return tbMatrixRotationZ(v.z) * tbMatrixRotationX(v.x) * tbMatrixRotationY(v.y);

}

• Rotation um eine beliebige Achse ebenfalls möglich Seite 81

• tbMatrixRotationAxis

Implementierung

• Skalierungsmatrix

TRIBASE_API tbMatrix tbMatrixScaling (const tbVector3& v)

{

return tbMatrix(v.x, 0.0f, 0.0f, 0.0f,

0.0f, v.y, 0.0f, 0.0f,

0.0f, 0.0f, v.z, 0.0f,

0.0f, 0.0f, 0.0f, 1.0f);

}

Weitere Hilfsfunktionen

• tbMatrixAxes

• Man übergibt Achsenvektoren zur Berechnung der Achsenmatrix

• Ausgabe der Ausrichtung eines Objekts

• tbMatrixDet

• Bestimmt Determinante einer Matrix

• tbMatrixInvert

• Invertiert angegebene Matrix

• tbMatrixTranspose

• Transponiert eine Matrix

Weitere Hilfsfunktionen

• tbMatrixcamera

• Kameramatrix berechnen durch Positionsvektor vPos, Richtungsvektor vLookAt und „Nach-Oben-Vektor“ vUp für Kameradrehung

• Translationsmatrix wird entgegengesetzt der Kameraposition erzeugt

• Achsenvektoren der Kamera in eine Matrix eintragen

• Beide multiplizieren und man erhält die Kameramatrix

• tbMatrixProjection

• Erzeugt eine Projektionsmatrix

Weitere Hilfsfunktionen

• tbVector3TransformCoords

• Positionsvektor mit Matrix multiplizieren

• W-Koordinate wird für den Fall einer Projektion geprüft

• tbVector3TransformNormal

• Richtungsvektor mit Matrix multiplizieren

• Transponierte invertierte Matrix wird benötigt

• Transformierter Vektor soll selbe Länge wie Originalvektor erhalten

• Hierfür wird ursprüngliche Länge gespeichert

Hilfsfunktionen

Auch die Matrix kann man ins Logbuch schreiben tbWriteMatrixToLog

Übersicht der Hilfsfunktionen für Matrizen und Beispielcode auf Seite 87

Für die Transformation von 2D-Vektoren gibt es die Funktionen tbVector2TransformNormal und tbVector2TransformCoords

Ebenen

Ebenengleichung

• Bestimmt die Menge der Punkte aus denen eine Ebene besteht

• Stützvektor

• Liegt in der Ebene

• Normalenvektor

• Steht senkrecht auf der Ebene

• Verbindet man einen Punkt mit dem Stützvektor muss der Verbindungsvektor senkrecht zum Normalenvektor stehen

Lage eines Punktes

• Durch Ebenengleichung lässt sich herausfinden ob ein Punkt auf der Ebene liegt (Ergebnis null)

• Ist das Ergebnis positiv, liegt der Punkt auf der Vorderseite (sichtbaren Seite) einer Ebene

• Ist das Ergebnis negativ, liegt der Punkt auf der Rückseite (nicht sichtbaren Seite) einer Ebene

• Ergebnis der Ebenengleichung wird mit Normalenvektor dividiert um Entfernung des Punktes zu der Ebene herauszufinden.

Implementierung

• tbPlane

• Vier Variablen (Fließkommazahlen) a, b, c und d

• Zusätzlich eine tbVector3-Variable n (Normalenvektor)

• Kopierkonstruktor

• Leerer Konstruktor

• Konstruktor der vier float-Werte erwartet

• Konstruktor, der tbVector3-Wert und einen float-Wert erwartet

• Operatoren gibt es nicht

Hilfsfunktionen

• tbPlaneNormalize

• Normalisiert Ebenen

• tbPlaneDotNormal

• Punktprodukt aus einem Vektor und dem Normalenvektor aus der Ebene

• tbPlaneDotCoord

• Soll Punkt in Ebenengleichung einsetzen und das Ergebnis zurückliefern

• tbPointPlaneDistance

• Distanz eines Produkts zur Ebene

Hilfsfunktionen

• tbPlaneFromPointNormal

• Erwartet einen Punkt und einen Normalenvektor und liefert die Ebene

• tbPlaneTransform

• Man kann auch Ebenen mit Matrizen transformieren

• tbWritePlaneToLook

• Schreibt eine Ebene in die Logbuchdatei

• Übersicht der Hilfsfunktionen und Beispielcode auf Seite 94

RGB-Farbsystem

• Ehemalige 8-Bit Grafik erschwerte eine ausgewogene Farbgebung

RGB-Farbsystem

• 16-Bit-Grafik

• Darstellung eines Pixels basierte auf dem RGB-System

• 16 Bits aufgeteilt in 5 Rotanteile, 6 Grünanteile und 5 Blauanteile

• 24-Bit-Grafik gefolgt von 32-Bit-Grafik

• Bei 32 Bits bleiben 8 Bits für Farbinformationen wie Transparenz

RGB-Farbsystem

• Die vier Komponenten betrachtet man jeweils als ein Byte

• Bei Direct3D ist es auch möglich Fließkommazahlen (float-Wert) für die einzelnen Farbkomponenten zu verwendet

Implementierung

• Klasse tbColor

• Vier float-Variablen (r, g, b und a – Alpha)

• Konstruktoren:

tbColor a(); //kein Parameter

tbColor b(0.5f); //Fließkommazahl r,g,b bekommen den Wert

tbColor c(0.0f, 1.0f, 0.0f, 0.5f); //float-Werte

tbColor d((BYTE) (0), 255, 0, 128); //Byte-Werte

tbColor e((DWORD) (0xFF00FF80)); //DWORD-Wert

Operatoren

• Addition ergibt additive Mischung zweier Farben

• Multiplikation

• mit positivem Wert über 1 hellt auf

• Mit positivem Wert unter 1 dunkelt ab

Casting

• Farbe in ein DWORD-Wert verwandeln

tbColor Red(1.0f, 0.0f, 0.0f);

DWORD dwRed = (DWORD) (Red); //Casting verwenden

Red = tbColor(dwRed); //Konstruktor verwenden

Weitere Hilfsfunktionen

• tbColorNegate

• Berechnen des Negativs

• tbColorBrightness

• Berechnung der Helligkeit

• tbColorRandom

• Erzeugt Zufallsfarbe

Diese und weitere auf Seite 97