Softwaretechnologie II (Teil 1): Simulation und 3D Programmierung

Präsentation zum Thema: "Softwaretechnologie II (Teil 1): Simulation und 3D Programmierung"—  Präsentation transkript:

1 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

2 Was ist eigentlich 3D Grafik?

3

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

5 Polygongrafik

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

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

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

9 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)

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

11 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

12 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 )

13 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 |

14 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 };

15 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

16 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

17 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; }

18 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)

19 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 }

20 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 )

21 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)); }

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

23 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)

24 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?

25 Matrizen

26 Operatoren

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

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

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

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

31 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 α)

32 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?

33 Projektionsmatrix Projektion eines dreidimensionalen Vektors auf eine Ebene (Bildschirm)

34 Kameramatrix

35 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) …

36 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

37 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] };

38 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); }

39 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

40 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))); }

41 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

42 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

43 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

44 Ebenen

45 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

46 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

47 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

48 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);

49 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

50 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

51 RGB Farbsystem

52 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

53 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

54 Fazit Vektoren Matrizen Transformationen Ebenen RGB Farbsystem

55 Danke für die Aufmerksamkeit!