Softwaretechnologie II (Teil 1): Simulation und 3D Programmierung 3D Grafik: Mathe Softwaretechnologie II (Teil 1): Simulation und 3D Programmierung Aufbaumodul 1 WS 2014/2015 Herr Manfred Thaller Maria Wagner

Was ist eigentlich 3D Grafik?

Projection X`= x/z Y`=y/z

Polygongrafik

Vektoren Ansammlung von Werten v1 : Erste Komponente des Vektors Xv : X Komponente des Vektors V

Positionsvektoren Ort im Raum innerhalb eines Koordinatensystems Absolut vs. Relative Position

Richtungsvektoren Beschreibt Bewegungsrichtung eines Objekts Geschwindigkeit wird auch angeben  Bewegungsvektor Bsp.: Vektor (-1,0,0)  Bewegung: Einheit pro sec nach links

Rechenoperationen 1 a+b = (xa + xb ; ya + yb; za + zb) Bsp.: Ball mit Positionsvektor p und Bewegungsvektor v (t: abgelaufene Zeit) p`= p+ (v+t)

Rechenoperationen 2 Vektor mit Skalar: A . S = (xa . S; ya . S; za. S) Multiplikation eines Vektors mit einem Skalar: Verlängerung Division: Stauchung

Punktprodukt Zwei Richtungsvektoren multiplizieren: Zwischen zwei Rv den eingeschlossenen Winkel bestimmen Ergebnis = Skalar / Kosinus des Winkels Bsp.: a . b = (xa . Xb ; ya . yb; za. zb) Verwendung: Winkel 90o?  Produkt = 0

Kreuzprodukt Ergebnis ist ein neuer Vektor a x b = c c = (ya x zb - za x yb; za x xb - xa x zb; xa x yb - ya x xb )

Länge eines Vektors Bsp.: Satz des Pythagoras! Ball hat den Bewegungsvektor (3, 4, 0) Wie berechnet man die Vektorlänge? Satz des Pythagoras! |v|= Wurzel von (xv2+ yv2 + zv2 ) Verbindungsvektor | AB | = | b – a |

Programmieren einer Vektorklasse #ifdef TRIBASE_EXPORTS #define TRIBASE_API __declspec(dllexport) #else #define TRIBASE_API __declspec(dllimport) #endif tbVector3 //Name der Klasse { public: float x, y, z; //Vektorkomponenten };

Konstruktoren implementieren 1) tbVector3 () {} // tut nichts 2) tbVector3 (const tbVector3& v) : x(v.x), y(v.y), z(v.z) {} //Kopierkonstruktor 3) tbVector3 (const float vx, const float vy, const float vz) : x(v.x), y(v.y), z(v.z) // setzt angegeben Vektorkomponenten ein

Globale Operatoren Inline tbVector3 operator + (const tbVector3& a, const tbVector3& b) { return tbVector3 (a.x + b.x, a.y + b.y, a.z + b.z); } //Addition von zwei Vektoren

Zuweisungsoperatoren =, +=, -=, *=, /= Innerhalb der Klasse definiert //Zuweisung und Addition tbVector3& operator += (const tbVector3& v) { x += v.x; // Vektor v hinzuaddieren y += v.y; z += v.z; return *this; }

Vergleichsoperatoren ==; != Überprüfung der Gleichheit oder Ungleichheit zweier Vektoren // Sind a und b gleich? bool operator == tbVector3& a, tbVector3& b) { return a.x == b.x && a.y == b.y …; } (Bei Ungleichheit: eine Komponente reicht, um ungleich zu sein)

Vektorlänge Satz des Pythagoras! Inline float tbVector3Length (const tbVector3& v) { return sqrtf (v.x * v.x + v.y * v.y + v.z * v.z); // Wurzel }

Kreuzprodukt Kreuzprodukt zweier Vektoren: Neuer Richtungsvektor Inline tbVector3 tbVector3Cross (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); } Zur erinnerung: c = (ya x zb - za x yb; za x xb - xa x zb; xa x yb - ya x xb )

Minimum- und Maximumvektoren Inline tbVector3 tbVector3Min (const tbVector3& a, const tbVector3& b) { return tbVector3 (TB_MIN (a.x, b.x), TB_MIN (a.y, b.y), TB_MIN (a.z, b.z)); }

Zufallsvektoren Inline tbVector3 tbVector3Random () { return tbVector3NormalizeEx ( tbFloatRandom (-1.0f, 1.0f), tbFloatRandom (-1.0f, 1.0f), tbFloatRandom (-1.0f, 1.0f)))); }

Lineare Interpolation Positionsbestimmung eines Objekts zu einer gewissen Zeit Objekte zw. Zwei Positionen linear bewegen Interpolationsfaktor (Wert zwischen den zwei Vektoren Inline tbVector3 tbVector3InterpolateCoords ( const tbVector3& a, const tbVector3& b, const float s) { return a + s * (b-a) } Anmerkung: p = x + s*(y-x)

Doch wie ändert man das Objekt? Verschiebt, dreht man es? Fazit zu Vektoren Beschreiben: Position eines Objektes Bewegungsrichtung/Geschwindigkeit 3D Modell: Ansammlung von Punkten mit paar Zusatzinformationen Codebefehle auf Seite 63 zu sehen! Doch wie ändert man das Objekt? Verschiebt, dreht man es?

Matrizen

Operatoren

Transformation Drehungen, Verschiebungen, Vergrößerungen Positionsvektoren sind relativ zum Objektmittelpunkt Arten: Translation Skalierung Rotation Spiegelung

Vektor transformieren Vektor ( x y z )  (x y z 1) * Transformationsmatrix Ähnlich auch im Code eines Positionsvektors (s.S.85)

Translationsmatrix Position Verschiebt Vektor um einen bestimmten Verschiebungsvektor (d) Simple Vektoraddition

Skalierungsmatrix Größe Mit einem bestimmten Faktor den Vektor multiplizieren (Vergrößerung | Verkleinerung) S = Skalierungsvektor (Skalierung auf jeder Achse)

Rotationsmatrix Gleichung zur Drehung eines Punktes um den Koordinatenursprung: Es muss beachtet werden, welche Komponenten angesprochen werden x = (x * cos α) + (y * (- sin α)) y = (x * sin α) + (y * cos α)

Beispiel Ein Raumschiffmodell soll auf die Position (x1, y1, z1) gebracht werden und ein Winkel von 45 Grad um die y-Achse gedreht werden. Welche Matrizen müssen verwendet werden?

Projektionsmatrix Projektion eines dreidimensionalen Vektors auf eine Ebene (Bildschirm)

Kameramatrix

Praktischer Teil Konstruktor: 16 float Variablen: kopiert die Werte in die Matrix rein tbMatrix ( float c11, float c12, float c13, float c14, float c21, float c22, float c23, float c24, float c31, float c32, float c33, float c34, float c41, float c42, float c43, float c44) : m11(c11), m12(c12), m13(c13), m14(c14) …

Operatoren Gleich wie bei Vektoren-Operatoren, außer Multiplikation zweier Matrizen Inline tbMatrix operator * ( const tbMatrix& a, const tbMatrix& b) { return tbMatrix (b.m11 * a.m11 + b.m12 * a.m12 etc );  Jeder mit jedem

Zugriffoperatoren Wenn man auf ein Element der Matrix zurückgreifen will: tbMatrix m; //Element in Zeile1, Spalte 3 auf den Wert 17 setzen M (1,3) = 17.0f Zur Übergabe von Variablen benötigt man ein zweidimensionales Array class TRIBASE_API tbMatrix{ public: union { struct { float m11, m12, m13, m14, //Elemente der Matrix m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44; } float m[4] [4] };

Translationsmatrix tbMatrixTranslation //erwartet den Verschiebungsvektor TRIBASE_API tbMatrix tbMatrixTranslation (const tbVector3& d) { return tbMatrix ( 1.0f, 0.0f, 0.0f, d.x, 0.0f, 1.0f, 0.0f, d.y, 0.0f, 0.0f, 1.0f, d.z, 0.0f, 0.0f, 0.0f, 1.0f); }

Skalierungsmatrix // Auf allen drei Ebenen TRIBASE_API tbMatrix tbMatrixScaling (const tbVector3& s) { return tbMatrix ( s.x, 0.0f, 0.0f, 0.0f, 0.0f, s.y, 0.0f, 0.0f, 0.0f, 0.0f,s.z, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } // Auf allen drei Ebenen

Kameramatrix Translationsmatrix entgegengesetzt erzeugen Achsenvektoren der Kamera in Matrix X-Achse in erste Spalte, Y-Ache in zweite etc. Beide Matrizen multiplizieren TRIBASE_API tbMatrix tbCamera ( const tbVector3& vPos, const tbVector3& vLookAt, const tbVector3& vUp) // Kamera steht senkrecht (0,1,0) { tbVector3 vZAxis (tbVector3Normalize (vLookAt – vPos)); //z Achse berechnet // x und y Achse durch z-Produkt berechnet tbVector3 vZAxis (tbVector3Normalize (tbVector3Cross(vUp, vZAxis))); tbVector3 vZAxis (tbVector3Normalize (tbVector3Cross(vAxis, vZAxis))); }

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 Hierfür wird ursprüngliche Länge gespeichert Auch die Matrix kann man ins Logbuch schreiben tbWriteMatrixToLog

Ebenen

Ebenengleichung Flache Oberfläche im 3D Raum (endlos) Ebenengleichung: Menge der Punkte 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 +: Punkt auf der Vorderseite Ergebnis -: Punkt auf der Rückseite 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

Ebene erstellen tbVector3 a (-5.0f, -1.0f, 7.0f); tbVector3 b (1.0f, 2.0f, 8.0f); tbVector3 c (7.0f, -4.0f, 9.0f); tbPlane Plane (tbPlaneFromPoints (a,b,c)); tbWritePlaneToLog (Plane);

Hilfsfunktionen tbPlaneNormalize tbPlaneDotNormal tbPlaneDotCoord 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 tbPlaneTransform 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

RGB Farbsystem

Farbsystem 8-Bit Grafik erschwerte eine Farbgebung 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 32-Bit-Grafik 8 Bits : Transparenz

Implementierung Durch Konstruktor: tbColor c(1.0f, 0.0f, 0.0f) ; //Rot tbColor d(0.0f, 1.0f, 0.0f, 0,5f); //transparentes Grün DWORD Wert: tbColor g ((DWORD) (FF00FF80); //Violett

Fazit Vektoren Matrizen Transformationen Ebenen RGB Farbsystem

Danke für die Aufmerksamkeit!