Upload
friedrich-wragge
View
109
Download
1
Embed Size (px)
Citation preview
3D Grafik: Mathe
Softwaretechnologie II (Teil 1): Simulation und 3D ProgrammierungAufbaumodul 1WS 2014/2015
Herr Manfred ThallerMaria Wagner
Was ist eigentlich 3D Grafik?
Projection
X`= x/zY`=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)
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)
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 = cc = (ya x zb - za x yb; za x xb - xa x zb; xa x yb - ya x xb )
Länge eines Vektors
• Bsp.: – Ball hat den Bewegungsvektor (3, 4, 0)
• Wie berechnet man die Vektorlänge?
Satz des Pythagoras!• |v|= Wurzel von (xv
2+ yv2 + zv
2 )• 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)
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 MatrizenInline 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 setzenM (1,3) = 17.0f
• Zur Übergabe von Variablen benötigt man ein zweidimensionales Arrayclass 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
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
Kameramatrix1. Translationsmatrix entgegengesetzt erzeugen2. Achsenvektoren der Kamera in Matrix
1. X-Achse in erste Spalte, Y-Ache in zweite etc.
3. 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 berechnettbVector3 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• 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
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:1. tbColor c(1.0f, 0.0f, 0.0f) ; //Rot
tbColor d(0.0f, 1.0f, 0.0f, 0,5f); //transparentes Grün2. DWORD Wert:
tbColor g ((DWORD) (FF00FF80); //Violett
Fazit
• Vektoren• Matrizen
– Transformationen• Ebenen• RGB Farbsystem
Danke für die Aufmerksamkeit!