Prof. Dr. Tobias Breiner

Transkript

1

2 Eigene Geometrien Inhalt Grundlagen Dreieckslisten Dreiecksstreifen Dreieckstabellen Importer von 67

3 Grundlagen von 67

4 Grundlagen Modellierung in der virtuellen Welt (0D => D) Punktmodelle (D => D) Linienmodelle (D => D) Flächenmodelle (D => D) Volumenmodelle Fh Kempten von 67

5 Eigene Geometrien Grundlagen Flächenmodelle Flächenmodelle Flächenmodelle beschreiben die Oberflächen der virtuellen Objekte durch Vielecke (Polygone). Das Innenleben des virtuellen Objektes bleibt dagegen undefiniert. Das funktioniert so lange, wie die Kamera das Objekt nur von außen betrachtet und das Objekt intakt bleibt. von 67

6 Eigene Geometrien Grundlagen Flächenmodelle Flächenmodelle Durch die Berechnung der Interaktion zwischen Licht und Material auf der Oberfläche (Shading) entsteht eine Optische Simulation des Objektes. Da das Innenleben nicht mitberechnet wird, sind Flächenmodelle performant bei gleichzeitiger hoher visueller Qualität. Fast alle gängigen D-Werkzeuge basieren daher vornehmlich auf polygonalen Flächenmodellen. 6 von 67

7 Eigene Geometrien Grundlagen Flächenmodelle Definition Polygon Ein Polygon wird mathematisch durch eine einfache und geschlossene Folge von Kanten (Edges) in einer Ebene beschrieben, die durch je zwei Punkte definiert werden: {(p 0,p )... (p n-,p n- )} p p 0 =p 6 p p p p Fh Kempten 7 von 67

8 Eigene Geometrien Grundlagen Flächenmodelle Vorteil der Dreiecke I Ein Polygon kann beliebig viele Eckpunkte beinhalten. In Vektoria (und den meisten anderen D- Systemen) sind allerdings nur Dreiecke als Polygone erlaubt. Werden Vierecke, Fünfecke, Sechsecke, etc. benötigt, müssen diese durch mehrere Dreiecke ersetzt werden. Das ganz obige Polygon könnte man z.b. folgendermaßen aufteilen. 8 von 67

9 Eigene Geometrien Grundlagen Flächenmodelle Vorteil der Dreiecke II Indem die meisten D-Systeme sich auf Dreiecke als Polygone beschränken, wird eine Menge Ärger vermieden: Insbesonde mit Offenheit, Kreuzvernetzungen und Polygonunebenheiten durch Eckpunkte, die nicht in einer Ebene liegen. 9 von 67

10 Eigene Geometrien Grundlagen Flächenmodelle Facetten und Vertices Die von einem Polygon eingeschlossene Fläche wird als Facette (engl. Face) bezeichnet und die mit Zusatzinformationen versehenen Eckpunkte eines Polygons werden in der Computergrafik Vertices genannt (Singular: Vertex). 0 von 67

11 Eigene Geometrien Grundlagen Flächenmodelle Zusatzinformationen von Vertices Die Zusatzinformationen eines Vertex, neben seiner D-Position im Raum, unterscheiden sich von Engine zu Engine. In Vektoria sind diese konkret: - Oberflächennormale (für das Shading wichtig) - Tangente (für das POM- und Dot-Bumpmapping wichtig) - Bitangente (für das POM- und Dot-Bumpmapping wichtig) - UV-Koordinaten (geben die Position der Textur am Vertex an) (u,v) von 67

12 Eigene Geometrien Grundlagen Flächenmodelle CVertex::Init void Init ( CHVector vpos, CHVector vnormal, CHVector vtangent, CHVector vbitangent, float fu=0, float fv=0, ); Normalerweise muss die Bitangente nicht angegeben werden, sie errechnet sich mittels der Vertexnormalen und der Vertextangenten mittels dem Kreuzprodukt. In seltenen Fällen ist die Bitangente aber nicht rechtshändig orthogonal. Dann muss sie explizit mit angegeben werden. von 67

13 Eigene Geometrien Grundlagen Flächenmodelle Drehrichtung der Facetten Es ist wichtig, dass die Vertices in einem rechtshändigen System auch rechtsdrehend vernetzt sind (mathematisch positive Rotation, wenn man das Objekt von Außen betrachtet) v v v 0 v und nicht linksdrehend, sonst zeigt die Flächennormale der Facette nach innen. v v 0 von 67

14 Eigene Geometrien Grundlagen Flächenmodelle Polygonnetze Normalerweise wird eine Oberfläche nicht durch einzelne isolierte Polygone definiert, sondern durch Polygonnetze. Hier können sich verschiedene Facetten ein- und denselben Vertex teilen. V In diesem Beispiel teilen sich die Facetten F, F, F und F den Vertex V. V6 V6 Diese Vertexredundanzen lassen sich zur Renderbeschleunigung und zur Speicherplatzreduzierung ausnutzen. F V F V0 F V F F F0 F0 F F F6 V V von 67

15 Eigene Geometrien Grundlagen Flächenmodelle Streifen (Strips) Die Vertexredundanzen kann man u.a. durch Streifen bzw. engl. Strips vermeiden. Hier wird das Polygonnetz implizit durch die Reihenfolge der Vertices definiert. Bei Dreiecksstreifen (Triangle Strips) definieren immer drei aufeinanderfolgende Vertices eine neue Facette. V0,V,V => F V,V,V => F V,V,V => F V,V,V => F V0 V F V F F V V F V von 67

16 Eigene Geometrien Grundlagen Flächenmodelle Fans Die Vertexredundanzen können bei speziellen Geometrien auch durch Fans eliminiert werden. Fans beschreiben eine Menge von Polygonen, die sich einen zentralen Vertex teilen. Bei Triangle Fans gibt der erste Vertex den Zentralvertex an, die nachfolgenden Vertices die restlichen Vertices der adjazenten Facetten. In diesem Beispiel teilen sich die Facetten F0 bis F den zentralen Vertex V0. Die Anwendungsgebiete von Fans sind sehr eng begrenzt, die Performanzvorteile marginal und die Struktur so inflexibel, dass Fans in modernen D-Systemen für gewöhnlich nicht mehr angeboten werden, z.b. werden sie ab DirectX 0, OpenGL.0, Vektoria V, etc. nicht mehr unterstützt. F F V F0 F F V0 F 6 von 67

17 Eigene Geometrien Grundlagen Tabellen (Indexed Face Sets) Spezielle Tabellen, auch Indexed Face Sets genannt, sind die flexibelste und meist genutzte Möglichkeit zur Vermeidung von Vertexredundanzen. Hier wird jeder Vertex einmal in einer Vertextabelle aufgelistet und mit einer Facettentabelle beliebig oft referenziert. Vertextabelle Facettentabelle V0 V X Y Z V A V B V C V F0 F V F F V F0 V V V.0.. V V V V F0 0 F F F 7 von 67

18 Eigene Geometrien Grundlagen Flächenmodelle Erzeugung polygonaler Geometrien Neben den parametrisierten Erzeugung von geometrischen Primitiven (Kugel, Quader, Tetraeder, Quad, ) gibt es die Möglichkeit, eigene geometrische Flächenmodelle zu erstellen. Die Möglichkeit zur Erzeugung eigener Geometrien bieten nicht alle Szenegrafen bzw. Game- oder D-Engines. In Vektoria gibt es mehere Möglichkeiten zur Erzeugung eigener polygonaler Geometrien, u.a.: Dreieckslisten per CGeoTriangleList, Dreiecksstreifen per CGeoTriangleStrip, Dreieckstabellen per CGeoTriangleTable 8 von 67

19 Eigene Geometrien Grundlagen Flächenmodelle Flächenmodellklassen in Vektoria kann sein Triangle Lists CGeoTriangleList Geometrie CGeo kann sein Triangle Table CGeoTriangleTable Triangle Strip CGeoTriangleStrip Besteht aus einzelnen Dreieckspolygonen => für unzusammenhängende oder kantige Strukturen mit wenigen Polygonen geeignet Besteht aus einer Serie von Vertices, die ein Dreieckspolygonnetz definieren. => Für runde, zusammenhängende Strukturen geeignet. Besteht aus Vertexund Indextabelle (Indexed Face Set). => meist beste Wahl (vermeidet Vertexredundanzen) 9 von 67

20 Kapitel Kapitel Dreieckslisten 0 von 67

21 Eigene Geometrien Dreieckslisten kann sein Triangle Lists CGeoTriangleList Geometrie CGeo Triangle Strip CGeoTriangleStrip kann sein Triangle Table CGeoTriangleTable Besteht aus einzelnen Dreieckspolygonen => für unzusammenhängende oder kantige Strukturen mit wenigen Polygonen geeignet Besteht aus einer Serie von Vertices, die ein Dreieckspolygonnetz definieren. => Für runde, zusammenhängende Strukturen geeignet. Besteht aus Vertexund Indextabelle (Indexed Face Set). => meist beste Wahl (vermeidet Vertexredundanzen) von 67

22 Dreieckslisten Triangle Lists Pro und Cons Vorteile: Einfacher als Triangle Strips und Triangle Tables. Auch für kantige und/oder unzusammenhängende Geometrien verwendbar. Nachteile: Etwas Langsamer als Triangle Strips und Triangle Tables, da redundante Vertices mehrfach aufgelistet werden. Im Folgenden ein Beispiel, wie man mit Hilfe von Triangle Lists einen Einheitswürfel erzeugen kann. von 67

23 Dreieckslisten Allgemeines Vorgehen bei Triangle Lists Vertices erzeugen CVertex::Init( ) Vertices zu Polygonen vernetzen CGeoTriangleList::AddVertex( ) Dreiecksliste initialisieren CGeoTriangleList::Init(); Die initialisierte Triangle List kann man wie eine normale Geometrie verwenden. von 67

24 Dreieckslisten - Einheitswürfel mit Triangle Lists Benötigte Variablen im Header class CGeoUnitCube : public CGeoTriangleList { public: // In den Konstruktor wird alles reingeschrieben: CGeoUnitCube(void); // der Destruktor kann erst einmal leer bleiben: ~CGeoUnitCube(void); }; // Pro Würfelseite brauche ich Vertices. // Ein Würfel hat 6 Seiten. // Also brauche ich * 6 = Vertices // (Acht Vertices miteinander zu teilen ist keine // gute Idee, da die Normalen, Tangenten und // Bitangenten pro Seite anders sind): CVertex m_avertex[]; von 67

25 Dreieckslisten - Einheitswürfel mit Triangle Lists Benötigte Variablen im Header CGeoUnitCube :: CGeoUnitCube(void) { } // // Hier in den Konstruktorkörper kommt der Code der folgenden Seiten rein. Damit wird der Einheiswürfel gleich am Anfang mit den richtigen Vertices und Polygonen aufgebaut. CGeoUnitCube :: ~CGeoUnitCube(void) { } Der Destruktor kann erst einmal leer bleiben von 67

26 Dreieckslisten - Einheitswürfel mit Triangle Lists Nummerierung der Vorderseite y v z v 0 x v v 6 von 67

27 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der Vorderseite // Zuerst muss die Seite Z Plus gebaut werden: m_avertex[0].init( // Vertex 0 von Seite Z+: CHVector(+.0f,+.0f,+.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente 0.0f,.0f); // UV-Koordinaten m_avertex[].init( // Vertex von Seite Z+: CHVector(-.0f,+.0f,+.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente.0f,.0f); // UV-Koordinaten m_avertex[].init( // Vertex von Seite Z+: CHVector(+.0f,-.0f,+.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente 0.0f, 0.0f); // UV-Koordinaten 7 von 67

28 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der Vorderseite m_avertex[].init( // Vertex von Seite Z+: CHVector(-.0f,-.0f,+.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente.0f, 0.0f); // UV-Koordinaten // Jetzt haben wir die Vertices der Vorderseite // definiert, wir müssen noch die Vertices // zu Dreieckspolygonen vernetzen: //. Dreieck auf der Z+-Seite: AddVertex(&m_avertex[0]); AddVertex(&m_avertex[]); AddVertex(&m_avertex[]); //. Dreieck auf der Z+-Seite: AddVertex(&m_avertex[]); AddVertex(&m_avertex[]); AddVertex(&m_avertex[]); Auf rechtshändige Drehrichtung achten! Auf rechtshändige Drehrichtung achten! 8 von 67

29 Dreieckslisten - Einheitswürfel mit Triangle Lists Nummerierung der Rückseite y v v z x v 7 v6 9 von 67

30 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der Rückseite // Dann muss die Seite Z Minus gebaut werden: m_avertex[].init( // Vertex von Seite Z-: CHVector(+.0f,+.0f,-.0f), // Position CHVector( 0.0f, 0.0f,-.0f), // Normale CHVector(.0f, 0.0f, 0.0f), // Tangente 0.0f,.0f); // UV-Koordinaten m_avertex[].init( // Vertex von Seite Z-: CHVector(-.0f,+.0f,-.0f), // Position CHVector( 0.0f, 0.0f,-.0f), // Normale CHVector(.0f, 0.0f, 0.0f), // Tangente.0f,.0f); // UV-Koordinaten m_avertex[6].init( // Vertex 6 von Seite Z-: CHVector(+.0f,-.0f,-.0f), // Position CHVector( 0.0f, 0.0f,-.0f), // Normale CHVector(.0f, 0.0f, 0.0f), // Tangente 0.0f, 0.0f); // UV-Koordinaten 0 von 67

31 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der Rückseite m_avertex[7].init( // Vertex 7 von Seite Z -: CHVector(-.0f,-.0f,-.0f), // Position CHVector( 0.0f, 0.0f,-.0f), // Normale CHVector(.0f, 0.0f, 0.0f), // Tangente.0f, 0.0f); // UV-Koordinaten // Jetzt haben wir die Vertices der Hinterseite // definiert, wir müssen nun noch die Vertices zu // Dreieckspolygonen vernetzen: //. Dreieck auf der Z Minus-Seite: AddVertex(&m_avertex[]); AddVertex(&m_avertex[6]); AddVertex(&m_avertex[]); //. Dreieck auf der Z Minus-Seite: AddVertex(&m_avertex[]); AddVertex(&m_avertex[6]); AddVertex(&m_avertex[7]); Auf rechtshändige Drehrichtung achten! Auf rechtshändige Drehrichtung achten! von 67

32 Dreieckslisten - Einheitswürfel mit Triangle Lists Nummerierung auf der rechten Seite y v 9 z v 8 v 0 v x von 67

33 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der rechten Seite // Seite X Plus: m_avertex[8].init( // Vertex 8 von Seite X+: CHVector(+.0f,+.0f,+.0f), // Position CHVector(.0f, 0.0f, 0.0f), // Normale CHVector( 0.0f,.0f, 0.0f), // Tangente.0f, 0.0f); // UV-Koordinaten m_avertex[9].init( // Vertex 9 von Seite X+: CHVector(+.0f,+.0f,-.0f), // Position CHVector(.0f, 0.0f, 0.0f), // Normale CHVector(0.0f,.0f, 0.0f), // Tangente.0f,.0f); // UV-Koordinaten m_avertex[0].init( // Vertex 0 von Seite X+: CHVector(+.0f,-.0f,+.0f), // Position CHVector(.0f, 0.0f, 0.0f), // Normale CHVector( 0.0f,.0f, 0.0f), // Tangente 0.0f, 0.0f); // UV-Koordinaten von 67

34 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der rechten Seite m_avertex[].init( // Vertex von Seite X+: CHVector(+.0f,-.0f,-.0f), // Position CHVector(.0f, 0.0f, 0.0f), // Normale CHVector( 0.0f,.0f, 0.0f), // Tangente 0.0f,.0f); // UV-Koordinaten // Jetzt haben wir die Vertices der rechten Seite // definiert, wir müssen nun noch die Vertices zu // Dreieckspolygonen vernetzen: //. Dreieck auf der X Plus-Seite: AddVertex(&m_avertex[8]); AddVertex(&m_avertex[0]); AddVertex(&m_avertex[9]); //. Dreieck auf der X Plus-Seite: AddVertex(&m_avertex[9]); AddVertex(&m_avertex[0]); AddVertex(&m_avertex[]); von 67

35 Dreieckslisten - Einheitswürfel mit Triangle Lists Nummerierung auf der linken Seite v y v z v v x von 67

36 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der linken Seite // Seite X Minus: m_avertex[].init ( // Vertex von Seite X-: CHVector(-.0f,+.0f,+.0f), // Position CHVector(-.0f, 0.0f, 0.0f), // Normale CHVector( 0.0f,.0f, 0.0f), // Tangente.0f,.0f); // UV-Koordinaten m_avertex[].init ( // Vertex von Seite X-: CHVector(-.0f,+.0f,-.0f), // Position CHVector(-.0f, 0.0f, 0.0f), // Normale CHVector( 0.0f,.0f, 0.0f), // Tangente.0f,0.0f); // UV-Koordinaten m_avertex[].init( // Vertex von Seite X-: CHVector(-.0f,-.0f,+.0f), // Position CHVector(-.0f, 0.0f, 0.0f), // Normale CHVector( 0.0f,.0f, 0.0f), // Tangente 0.0f,.0f); // UV-Koordinaten 6 von 67

37 Dreieckslisten - Einheitswürfel mit Triangle Lists Aufbau der linken Seite m_avertex[].init( // Vertex von Seite X-: CHVector(-.0f,-.0f,-.0f), // Position CHVector(-.0f, 0.0f, 0.0f), // Normale CHVector( 0.0f,.0f, 0.0f), // Tangente 0.0f, 0.0f); // UV-Koordinaten // Jetzt haben wir die Vertices der linken Seite // definiert, wir müssen nun noch die Vertices zu // Dreieckspolygonen vernetzen: //. Dreieck auf der linken Seite: AddVertex(&m_avertex[]); AddVertex(&m_avertex[]); AddVertex(&m_avertex[]); //. Dreieck auf der linken Seite: AddVertex(&m_avertex[]); AddVertex(&m_avertex[]); AddVertex(&m_avertex[]); 7 von 67

38 Dreieckslisten - Einheitswürfel mit Triangle Lists Übung: Ober- und Unterseite Das Prinzip sollte jetzt klar geworden sein, es fehlen aber noch Ober- und Unterseite. Diese Aufgabe bleibt Ihnen überlassen. y Oberseite z x 8 von 67

39 Dreieckslisten - Einheitswürfel mit Triangle Lists Initialisierung der Triangle List Nachdem Ober- und Unterseite erstellt wurden, kommt der letzte Befehl im Konstruktor. Mit CTriangleList::Init werden die Polygondaten an die Grafikkarte übergeben und damit einie eigene Geometrie erzeugt: CGeoTriangleList::Init(); Die Klasse kann nun so vertwendet werden, als wäre sie eine normale Geometrie, man inkluded sie und schreibt im Header: CGeoUnitCube m_zgunitcube; Die Variable m_zgunitcube muss natürlich noch an ein geeignetes Placement geadded werden und eventuell per SetMaterial mit einem Material versehen werden: m_zp.addgeo(&m_zgunitcube); m_zgunitcube.setmaterial(pmaterial); 9 von 67

40 Dreieckslisten - Einheitswürfel mit Triangle Lists Ausgabe Einheitswürfel 0 von 67

41 Kapitel Kapitel Dreiecksstreifen von 67

42 Dreiecksstreifen CGeoTriangleStrips kann sein Triangle Lists CGeoTriangleList Geometrie CGeo Triangle Strip CGeoTriangleStrip kann sein Triangle Table CGeoTriangleTable Besteht aus einzelnen Dreieckspolygonen => für unzusammenhängende oder kantige Strukturen mit wenigen Polygonen geeignet Besteht aus einer Serie von Vertices, die ein Dreieckspolygonnetz definieren. => Für runde, zusammenhängende Strukturen geeignet. Besteht aus Vertexund Indextabelle (Indexed Face Set). => meist beste Wahl (vermeidet Vertexredundanz) von 67

43 Dreiecksstreifen Pro und Cons von Triangle Strips Vorteile: Shader können etwas schneller mit Triangle Strips umgehen (Faustregel ca. 0% schneller) Nachteile: Komplizierter als Triangle Lists und Triangle Tables Nur schwer kantige Strukturen erzeugbar Keine unzusammenhängenden Strukturen erzeugbar von 67

44 Dreiecksstreifen Quad durch Triangle Strips Im Folgenden ein Beispiel, wie man mittels Triangle Strips ein Quad erzeugen kann. Ein Quad ist eine rechteckige Fläche im Raum, bestehend aus zwei Dreieckspolygonen von 67

45 Dreiecksstreifen Eigenen Quad mit Triangle Strips (/) // Im Header der Game-Klasse brauchen wir eine // Instanz eines Dreiecks-Strips: CGeoTriangleStrip m_zgtrianglestrip; // In der CGame::Init() erfolgt die Erzeugung der // Geometrie: // Erst die Vertices initalisieren: m_avertex[0].init( // Vertex : CHVector(-,-,0,), // Position CHVector(0,0,,0), // Normale CHVector(,0,0,0), // Tangente 0.0F, 0.0f // UV-Koordinaten ); von 67

46 Dreiecksstreifen Eigenen Quad mit Triangle Strips (/) m_avertex[].init( // Vertex : CHVector(+,-,0,), // Position CHVector(0,0,,0), // Normale CHVector(,0,0,0), // Tangente.0F, 0.0f // UV-Koordinaten ); m_avertex[].init( // Vertex : CHVector(-,+,0,), // Position CHVector(0,0,,0), // Normale CHVector(,0,0,0), // Tangente 0.0F,.0f // UV-Koordinaten ); 6 von 67

47 Dreiecksstreifen Eigenen Quad mit Triangle Strips (/) m_avertex[].init( // Vertex : CHVector(+,+,0,), // Position CHVector(0,0,,0), // Normale CHVector(,0,0,0), // Tangente.0F,.0f, // UV-Koordinaten ); // Die Vertices gehören zum Triangle Strip: for(int i=0;i<;i++) { m_zgtrianglestrip.addvertex(&m_avertex[i]); m_zgtrianglestrip.addindex(i); } 7 von 67

48 Dreiecksstreifen Eigenen Quad mit Triangle Strips (/) // Initialisiere den Triangle Strip: m_zgtrianglestrip.init(); // Mappe Material auf das Rechteck: m_zgtrianglestrip.setmaterial(&m_material); // und nun kannst Du Deinen eigenen persönlichen Triangle Strip benutzen, wie eine ganz normale Geometrie: m_placement.addgeo(& m_zgtrianglestrip); 8 von 67

49 Dreiecksstreifen Ergebnis: Eigener Quad 9 von 67

50 Dreiecksstreifen Übung Erzeugen Sie einen Pfeiler mit Hilfe von Triangle Strips! Freiwillige Zusatzaufgabe für die schnellen Nerds: Erzeugen Sie eine Prozedur, die parametrisiert dorische und ionische Pfeiler erzeugt! 0 von 67

51 Kapitel Kapitel Dreieckstabellen von 67

52 Polygonale Flächenmodelle Dreieckstabellen kann sein Triangle Lists CGeoTriangleList Geometrie CGeo Triangle Strip CGeoTriangleStrip kann sein Triangle Table CGeoTriangleTable Besteht aus einzelnen Dreieckspolygonen => für unzusammenhängende oder kantige Strukturen mit wenigen Polygonen geeignet Besteht aus einer Serie von Vertices, die ein Dreieckspolygonnetz definieren. => Für runde, zusammenhängende Strukturen geeignet. Besteht aus Vertexund Indextabelle (Indexed Face Set). => meist beste Wahl (vermeidet Vertexredundanzen) von 67

53 Dreieckstabellen Vorgehen bei CGeoTriangleTables Vertices erzeugen CVertex::Init( ) Vertex-Tabelle erzeugen CGeoTriangleTable::AddVertex( ) Facetten-Tabelle erzeugen CGeoTriangleTable::AddIndex(..) Dreieckstabelle initialisieren CGeoTriangleTable::Init(); Die initialisierte Dreieckstabelle kann man wie eine normale Geometrie verwenden. von 67

54 Dreieckstabellen Beispiel: Fünfeck in XY-Ebene V Vertextabelle Facettentabelle V0 F F V X Y Z V V V V A V B V C F0 0 F 0 F 0 V F0 V V V Wird mit AddVertex() befüllt Wird mit AddIndex() befüllt. Jeweils drei aufeinanderfolgende Aufrufe bilden eine Dreiecksbeschreibung. von 67

55 Dreieckstabellen Eigenes Fünfeck mittels CGeoTriangleTable Benötigte Variablen im Header (/) class CGeoPentagon : public CGeoTriangleTable { public: // In den Konstruktor wird alles reingeschrieben: CGeoPentagon(void); // der Destruktor kann erst einmal leer bleiben: ~CGeoPentagon(void); }; // Für ein Fünfeck brauche ich natürlich // fünf Vertices. CVertex m_avertex[]; von 67

56 Dreieckstabellen Eigenes Fünfeck mit Triangle Tables (/) // Zuerst muss die Seite Z Plus gebaut werden: m_avertex[0].init( // Vertex 0 von Seite Z+: CHVector(+0.0f,+0.8f, 0.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente 0.0f,.0f); // UV-Koordinaten m_avertex[].init( // Vertex von Seite Z+: CHVector(-0.f,+0.0f, 0.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente.0f,.0f); // UV-Koordinaten m_avertex[].init( // Vertex von Seite Z+: CHVector(+.f,-0.0f, 0.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente 0.0f, 0.0f); // UV-Koordinaten 6 von 67

57 Dreieckstabellen Eigenes Fünfeck mit Triangle Tables (/) m_avertex[].init( // Vertex von Seite Z+: CHVector(-.f,-0.8f, 0.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente.0f, 0.0f); // UV-Koordinaten m_avertex[].init( // Vertex von Seite Z+: CHVector(-0.7f,-.f, 0.0f), // Position CHVector( 0.0f, 0.0f,.0f), // Normale CHVector(-.0f, 0.0f, 0.0f), // Tangente.0f, 0.0f); // UV-Koordinaten // Jetzt haben wir die Vertices definiert und fügen sie nacheinander der Vertextabelle hinzu: for(int i = 0; i<; ++i) AddVertex(&m_avertex[i]); 7 von 67

58 Dreieckstabellen Eigenes Fünfeck mit Triangle Tables (/) // Wir erzeugen nun die Facettenliste, indem wir für jede // Facette nacheinander ihre drei Vertices per AddIndex // aufrufen: //. Dreieck F0: AddIndex(0); AddIndex(); AddIndex(); //. Dreieck F: AddIndex(0); AddIndex(); AddIndex(); //. Dreieck F: AddIndex(0); AddIndex(); AddIndex(); Auf rechtshändige Drehrichtung achten! 8 von 67

59 Dreieckstabellen Eigenes Fünfeck mit Triangle Tables (/) // Am Schluss müssen wir den Triangle Table // initialisieren: Init(); // Man kann natürlich den Triangle Table auch noch mit // einem Material versehen: SetMaterial(&m_material); // Nun kann man die Klasse CGeoPentagon verwenden, // wie eine ganz normale Gemetrie und eine // diesbezügliche Instanz per AddGeo an ein // Placement hängen. 9 von 67

60 Kapitel Kapitel Importer 60 von 67

61 Importer Wavefront-Import (OBJ-Dateien) In der Game.h: CGeo * m_pzg; CFileWavefront m_filewavefront; In der Game.cpp / Init-Methode: m_pzg = m_filewavefront.loadgeo( myfile.obj"); Blender invertiert die UV-Maps, daher müssen Sie beim Importieren den dafür extra angelegten Invertierungsflag setzen, also:.loadgeo( myfile.obj, true); Importieren Sie mit Blender oder Maya erstellte D- Geometrien am besten mit diesem Importer, das bringt die schönsten Ergebnisse! 6 von 67

62 Importer Blender-Import In der Game.h: Achtung, Nr.! Bisher ist es nur möglich, Blender Files von -Bit Blender-Versionen zu importieren! Achtung, Nr.! Es wird immer nur das allererste Mesh aus einem Blender-File importiert! CGeo * m_pzg; CFileBlender m_fileblender; In der Game.cpp / Init-Methode: m_pzg = m_fileblender.loadgeo( myfile.blend"); 6 von 67

63 Importer D Studio Max-Import In der Game.h: CGeo * m_pzg; CFileDS m_fileds; In der Game.cpp / Init-Methode: m_pzg = m_fileds.loadgeo( myfile.ds"); 6 von 67

64 Importer XD-Import Achtung, Nr.! XD-Files enthalten für gewöhnlich weder Normalenvektoren noch UV-Koordinaten! Diese Daten werden daher von Vektoria heuristisch abgeschätzt. Die meisten importierten Meshes werden daher vom Shading und von der Texturierung her etwas seltsam aussehen. Achtung, Nr.! Es wird immer nur das allererste Mesh aus einem XD-File importiert! In der Game.h: CGeo * m_pzg; CFileXD m_filexd; In der Game.cpp / Init-Methode: m_pzg = m_filexd.loadgeo( myfile.xd"); 6 von 67

65 Tipp Prozedural topp, modelliert flopp (/) Ziehen Sie möglichst eine in Vektoria prozedural erzeugte Geometrie bzw. eine vorgefertigte Vektoria- Primitivengeometrie einer importierten Geometrie vor! Die Gründe dafür sind:.) Prozedural erzeugte Geometrien sind sparsamer hinsichtlich der Vertices und genauer durchdacht..) Prozeduren können möglicherweise wiederverwendet werden..) Tangenten- und Bitangentenkoordinaten für das Bumpmapping werden in Modellierungsprogrammen oft nicht gut generiert und wenn doch, meist nicht exportiert..) Beim Importieren können Fehler auftreten Achtung! Die Form einer einmal erzeugten Geometrie kann danach nur noch schwer verändert werden! 6 von 67

66 Tipp Prozedural topp, modelliert flopp (/) Materialartefakte durch fehlende Tangenten und Bitangenten. UtahTeapot, per OBJ-Datei importiert. UtahTeapot, prozedural erzeugt. 66 von 67

67 Game Over Danke für Ihr Interesse! Copyright: ; Tobias.Breiner@D-Generation.de 67 von 67