Vertex Layout

Transcription

Vertex Layout

Bachelor Praktikum:
Echtzeitgraphik in C++ und DirectX10
computer graphics & visualization
Diese Woche...
• Abschluss der C++‐Einführung:
– Objektorientierung in C++
– Datentypen‐Umwandlung
– Präprozessor
• Einführung in DirectX
–
–
–
–
Übertragung von Geometrie‐Daten an die GPU
Festlegung der Topologie von Primitiven
Rendern der Daten
DXUT
3D Praktikum SS2009 – Echtzeitgraphik in C++ und DirectX10
K. Bürger, R. Fraedrich, Prof. Dr. Westermann computer graphics & visualization
struct
• eigentlich nur ein anderer Name für class, außer dass standardmäßig alle Elemente public statt private sind.
• struct wird daher vorwiegend für zusammen‐gesetzte Typen verwendet.
• Beispiel:
– struct Farbe {
unsigned char r; unsigned char g;
unsigned char b;
}
…
Farbe f(255,255,0);
f.r = 0;
Vererbungslehre und Verwandtes
• Vererbung funktioniert wie in Java, nur die Syntax ist
etwas anders:
– class SuperClass {
public:
void foo();
};
class SubClass : public SuperClass {
public:
void bar();
};
Dynamisches und statisches Binden
• Im Gegensatz zu Java werden in C++ generell statisch
gebunden:
void foo();
};
void foo();
};
…
SubClass a;
SuperClass *p = &a;
p‐>foo();
// SuperClass::foo() wird aufgerufen
Dynamisches und statisches Binden
• Wenn die Funktion dynamisch zur Laufzeit ausgewählt
werden soll, muss man die Funktion als virtual deklarieren:
virtual void foo();
};
virtual void foo();
};
…
SubClass a;
SuperClass *p = &a;
p‐>foo();
// SubClass::foo() wird aufgerufen
Abstrakte Klassen
• Darüber hinaus kann man eine Funktion pure virtual deklarieren, d.h. die Funktion wird von der Klasse
nicht implementiert:
– virtual void foo() = 0;
• In diesem Fall kann von der Klasse keine Instanz
erzeugt werden. In diesem Fall spricht man von einer
abstrakten Klasse.
• Davon abgeleitete Klassen sind ebenfalls abstrakt, sofern sie nicht alle pure virtual Funktionen
implementieren.
Mehrfachvererbung
• Im Gegensatz zu Java ist in C++ Mehrfach‐Vererbung
möglich:
– class Foo {
public:
int a;
}
Bar
Foo
class Bar {
public:
int b;
}
FooBar
class FooBar : public Foo, public Bar {…};
→ FooBar verfügt sowohl über a als auch über b!
Überladen von Operatoren
• Ein weiterer Vorteil von C++ ist, dass Operatoren überladen werden können:
– class Vec3 {
…
// subscript‐operator
float &operator[](int k);
// Addition
Vec3 operator+(const Vec3 &v) const;
…
}
…
Vec3 v1(1,2,3);
Vec3 v2(2,3,4);
Vec3 v3 = v1 + v2;
v3[2] = 0;
// Anwendung des +‐Operators
// Anwendung des []‐Operators
Templates (Generische Programmierung)
• Templates sind „Programmgerüste“, die eine vom Datentyp unabhängige Programmierung ermöglichen.
• Beispiel:
– template<typename T>
T getMax(T a, T b) {
if (a < b)
return b;
else
return a;
}
float x = 1.0f;
float y = 1.1f;
float m = getMax<float>(x, y);
Standard Template Library (STL)
• Das Ganze geht auch mit Klassen.
• Beispiel sind die Template‐Klassen der STL:
– vector<T>
– list<T>
– u.v.m.
(dynamisch wachsendes lineares "Feld„)
(doppelt verkettete Liste)
• Beispiel:
– vector<int> v;
v.push_pack(42);
cout << v.size() << endl;
cout << v[0] << endl;
v.pop_pack();
// fügt 42 am Ende hinzu
// liefert die Anzahl der Elemente
// [] liefert das erste Element
// entfernt das letzte Element;
• Das aber nur als kurzer Einblick…
Datentyp‐Umwandlungen in C++
• Implizite Typumwandlung
– in C++ können fundamentale Datentypen in einer
verblüffenden Anzahl von Möglichkeiten ineinander
umgewandelt werden.
– i.d.R. geben Compiler eine Warnung aus, wenn durch die Typumwandlung Information verloren gehen kann.
• Beispiele: double → float, float → int, int → short, etc.
• Hinweis:
– Diese Warnungen sollten niemals ignoriert werden!
– Stattdessen solltet ihr mit einer expliziten Typwandlung das gewünschte Verhalten herbeiführen.
• Explizite Typwandlung (Teil 1)
– Konvertierung verwandter Typen (static_cast)
• Beispiel:
– float f = 3.14f;
int i = static_cast<int> ( f ); // konvertiert 3.14 in 3
– Konvertierung nicht verwandter Typen (reinterpret_cast)
• Beispiel:
– char rawData[256];
…
// hier werden die Rohdaten aus einer Datei gelesen
…
// da wir sicher wissen, dass es sich um int‐Werte handelt:
int *data = reinterpret_cast<int*>(rawData);
• Explizite Typwandlung (Teil 2)
– Konvertierung mit Prüfung zur Laufzeit (dynamic_cast)
• Beispiel:
– void Foo(CBase *b) {
if ( dynamic_cast<CDerived*> ( b ) != NULL)
cout << “b IS of class CDerived!”;
else
cout << “b is NOT of class CDerived!”
}
– Konvertierung zur Entfernung des const‐Qualifiers (const_cast)
• Ganz böse… deswegen kein Beispiel ;‐)
• Es gibt noch weitere Arten wie man casten kann:
• Beispiel:
– float f=3.1415f;
– int i=(int)f;
– int j=int(f);
// Gleitkomma‐Literale mit dem Suffix f oder F
// sind vom Typ float, ansonsten vom Typ double
// C‐style cast
// function‐style cast
• Diese Casts führen jede Konvertierung durch, die als Kombination aus static_cast, reinterpret_cast und const_cast ausgedrückt werden können.
• Üblich zur Konvertierung von integrierten Datentypen
(um das umständliche „static_cast“ zu vermeiden)
• Bei anderen Typumwandlungen kann die Mächtigkeit dieser Operationen und die Unauffälligkeit der Schreibweise leicht zu Fehlern führen und sollten daher vermieden werden.
Präprozessor: Compiler‐Direktiven
• Der Präprozessor wird vor dem Compiler‐Aufruf automatisch gestartet und bearbeitet den Quellcode durch Einfügen, Löschen und Ersetzen von Text.
• Präprozessor‐Befehle fangen mit # an.
• Häufigstes Beispiel:
– Einfügen einer Header‐Datei aus dem aktuellen Verzeichnis:
#include „MyClass.h“
#include „util/MyUtility.h“
– Einfügen einer Header‐Datei aus dem Include‐Verzeichnis des Compilers:
#include <iostream>
Präprozessor: Bedingte Übersetzung
• Mit Hilfe des Präprozessors kann man auch Macros
definieren, z.B.:
#define DEBUG
#define PI 3.14159
// ohne Wert
// mit Wert
• Macros ohne Wert werden für bedinge Übersetzung verwendet, z.B.:
#ifdef DEBUG
cout << „PI is defined as “ << PI;
#endif
• darüber hinaus gibt es auch #else und #ifndef
(„if not defined“)
Präprozessor: include‐Guards
• Beispiel:
<iostream>
– In den Headern “Foo.h” und “Bar.h” wird
<iostream> inkludiert und eine Datei “FooBar.h”
inkludiert wiederum diese beiden Header.
– Da Klassen, Funktionen und Variablen nur einmal
deklariert werden dürfen, führt dies zu einem
Compiler‐Fehler.
Foo.h
Bar.h
FooBar.h
• Um dies zu verhindern, verwendet man Macros und bedingte Übersetzung.
Präprozessor: include‐Guards
• Beispiel “FooBar.h”:
#ifndef FOO_BAR_H
#define FOO_BAR_H
// Um Namenskonflikten zu verhindern wählt
// man das Macro abhängig vom Klassennamen
class Foobar {
…
};
#endif
• Anmerkung: denselben Zweck erfüllt die Präprozessor Direktive
#pragma once, allerdings gehört sie nicht zum Standard von C++!
„Fixed Function Pipeline“
• Für diese Woche nur so viel:
– Input: Geometrische Primitive
– Output: Bild wird auf Bildschirm ausgegeben
• Überblick:
–
–
–
–
Übertragung von Geometrie‐Daten an die GPU
Topologie der Primitive festlegen
Rendern der Daten
DXUT
Rendering Pipeline
User / Driver
Vertex Stream
Transform & Lighting
Fragment Stream
Texturing
Vertex Stage
Rasterisierer
Pixel Stage
Blending/Ops
Texture
0 1
Texture
Texture
2 3
Texture
Direct3D 10 Pipeline
• Die Pipeline besteht aus:
– Programmierbaren Einheiten
• Vertex Shader
• Geometrie Shader
• Pixel Shader
Input
Assembler
Vertex
Shader
Geometry
Shader
Stream
Output
– Fixed‐Function Einheiten
•
•
•
•
Input Assembler
Stream Output
Setup / Rasterizer
Output Merger
Memory
Setup /
Rasterizer
Pixel
Shader
Output
Merger
Input Assembler
• Aufgabe:
– Vertex Daten lesen/erzeugen
• Input:
– Vertex Buffer + Index Buffer
• Output:
– Vertices mit Attributen und Indices pro Vertex, Primitiv und Objekt
• Steuerbar durch:
– IASetVertexBuffers/SetIndexBuffer
– IASetInputLayout
– IASetPrimitiveTopology
Vertex Buffer
Input
Assembler
Index Buffer
Vertex
Shader
Texture/Buffer
Geometry
Shader
Texture/Buffer
Stream
Output
Texture/Buffer
Setup /
Rasterizer
Memory
Pixel
Shader
Texture/Buffer
Output
Merger
Depth
Color
Input Assembler
Input Layout:
• Position (float3 – slot 0)
• Normal (float3 – slot 0)
• Farbe (float 3 – slot 1)
Vertex Buffer:
Input
Assembler
Primitive Topology:
Triangle List
Slot 0:
3F A4 91 8C 7A 42 B9 6F 73 E9 37 FF … Slot 1:
2E 94 BB 6C 5A 47 F9 FE 26 C7 4A 72 … Index Buffer:
0 4 8 0 1 3 5 3 6 10 2 4 3 7 5 2 14 8 23 11 9 4 … Output (Vertices):
• Position 3F A4 91 8C 7A 42
• Normal 89 6F 73 E9 37 FF
• Farbe 2E 94 BB 6C 5A 47
•Vertex ID:
0
•Primitive ID:
0
Input Assembler (IA)
Die Input Assembler Einheit ist dafür verantwortlich der restlichen Pipeline
Geometriedaten (z.b Linien, Dreiecke) zur Verfügung zu stellen.
•
Sie liest benutzergefüllte Speicherblöcke und
– weiß anhand des gesetzten Input Layout wie diese Daten zu interpretieren sind
– erstellt daraus eine Menge von geometrischen Primitiven, abhängig vom gesetzten
Primitivtyp (D3D10_PRIMITIVE_TOPOLOGY )
– Stellt die assemblierten Primitive den folgenden Pipeline Einheiten zur Verfügung
•
Die elementare Einheit sind dabei Eckpunkte, die verschiedenste
Eigenschaften haben können (z.B. Position, Farbe, Normale, …)
•
Die Input Assembler Einheit errechnet weiterhin zusätzliche sogenannte
„system generated values“ für jedes Primitiv und stellt sie den folgenden
Shader Einheiten zur Verfügung (z.b SV_VertexID, SV_PrimitiveID, ...)
Vertex Layout
• Vertices können verschiedene Attribute haben:
–
–
–
–
Position
Normale
Farbe(n)
Textur‐Koordinat(en)
• Ein Vertex‐Layout definiert wie die Attribute im Speicher abgelegt werden. Meistens wird das Vertex‐
Layout durch ein struct repräsentiert:
– struct SimpleVertex
{
D3DXVECTOR3 Pos;
D3DXVECTOR4 Color; };
// Position
// Farbe (RGBA)
Vertex Layout
• Mit Hilfe des Vertex Layouts definiert man die Eingabedaten für die GPU:
SimpleVertex vertices[] = {
{ D3DXVECTOR3( ‐1.0f, 1.0f, ‐1.0f ), D3DXVECTOR4( 0.0f, 0.0f, 1.0f, 1.0f ) },
{ D3DXVECTOR3( 1.0f, 1.0f, ‐1.0f ), D3DXVECTOR4( 0.0f, 1.0f, 0.0f, 1.0f ) },
Einzelne
Vertices
{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR4( 0.0f, 1.0f, 1.0f, 1.0f ) },
{ D3DXVECTOR3( ‐1.0f, 1.0f, 1.0f ), D3DXVECTOR4( 1.0f, 0.0f, 0.0f, 1.0f ) },
};
Position
Farbe
• Bei einem statische angelegten Array kann man die Anzahl der Elemente berechnen:
UINT numVertices = sizeof(vertices) / sizeof(vertices[0]);
Input Layout
• Das Vertex Layout ist die Repräsentation der Daten im Hauptspeicher.
• Der GPU werden die Daten aber als „Rohdaten“ in einem Buffer übergeben.
• Damit die GPU die Daten richtig interpretieren kann müssen wir daher ein Input‐Layout definieren.
• Das struct D3D10_INPUT_ELEMENT_DESC dient dazu ein einzelnes Vertex‐Attribut zu beschreiben.
Input Layout
• D3D10_INPUT_ELEMENT_DESC hat folgende Felder:
Felder
Bedeutung
SemanticName
Name des Elements (muss mit dem Namen im Shader übereinstimmen)
SemanticIndex
Index der dafür genutzt werden kann, mehrfach den selben semantischen Namen zu verwenden.
Format
Datentyp des Elements (DXGI_FORMAT).
InputSlot
Ganzzahl, die beschreibt von welchem Input Slot die Daten für dieses Element gelesen werden sollen. In DX10 ist es möglich auf, dass die GPU auf mehrere Vertex Buffer simultan zugreift.
AlignedByteOffset
Offset vom Beginn eines jeden Vertex zu diesem Element. D3D10_APPEND_ALIGNED_ELEMENT kann zur automatischen Bestimmung des Offset genutzt werden (sofern die Reihenfolge der Elemente im Vertex Layout und Input Layout übereinstimmen).
InputSlotClass
D3D10_INPUT_PER_VERTEX_DATA oder D3D10_INPUT_PER_INSTANCE_DATA
InstanceDataStepRate
Anzahl der Instanzen für die dieselben Daten genutzt werden sollen.
0 für D3D10_INPUT_PER_VERTEX_DATA.
Input Layout
• Definitions‐Beispiel:
D3D10_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 }, };
UINT numElements = sizeof(layout) / sizeof(layout[0]);
• Zum Erstellen braucht man zusätzlich die Input Signature der kompilierten Effect Technique:
D3D10_PASS_DESC PassDesc;
g_pTechnique‐>GetPassByIndex( 0 )‐>GetDesc( &PassDesc );
if( FAILED( g_pd3dDevice‐>CreateInputLayout( layout, numElements,
PassDesc.pIAInputSignature, PassDesc.IAInputSignatureSize, &g_pVertexLayout )))
return FALSE;
• Verwenden kann man das Input Layout anschließend mit:
g_pd3dDevice‐>IASetInputLayout( g_pVertexLayout );
Vertex Buffer
• Damit weiß die GPU wie die Daten zu interpretieren sind. Was noch fehlt sind die Daten an sich.
• Dafür müssen wir einen Vertex Buffer auf der GPU anlegen und ihn mit unseren Daten füllen.
• Dafür benötigen wir zwei Strukturen:
– D3D10_BUFFER_DESC zur Beschreibung des Buffers
– D3D10_SUBRESOURCE_DATA zur Übergabe der Daten
Vertex Buffer
• Beispiel:
// Create and fill description
D3D10_BUFFER_DESC bd;
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof( SimpleVertex ) * numVertices;
bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
// Define initial data
D3D10_SUBRESOURCE_DATA InitData;
InitData.pSysMem = vertices;
// Create Buffer
if( FAILED( g_pd3dDevice‐>CreateBuffer( &bd, &InitData, &g_pVertexBuffer ) ) )
return FALSE;
// Set vertex buffer
UINT stride = sizeof( SimpleVertex );
UINT offset = 0;
g_pd3dDevice‐>IASetVertexBuffers( 0, 1, &g_pVertexBuffer, &stride, &offset );
Primitive Topology
• Jetzt verfügt die GPU über die Vertex‐Daten und weiß auch wie sie zu interpretieren sind.
• Was noch fehlt ist, welche geometrischen Primitive wir mit den Daten beschreiben.
2
4
0
1
5
3
• Beispiele:
–
–
–
–
D3D10_PRIMITIVE_TOPOLOGY_POINTLIST
D3D10_PRIMITIVE_TOPOLOGY_LINELIST
D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP
D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST
2
4
0
1
2
5
3
4
0
2
1
3
5
4
0
1
3
• Festlegen können wir die aktuelle Topologie mit:
D3D10_PRIMITIVE_TOPOLOGY pt = D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP;
g_pd3dDevice‐>IASetPrimitiveTopology( pt );
5
Rendern (Draw)
• Wenn Input Layout, Vertex Buffer und die Primitve
Topology gesetzt sind, können wir eine Effect
Technique anwenden und Daten „zeichnen“:
// Render D3D10_TECHNIQUE_DESC techDesc; g_pTechnique‐>GetDesc( &techDesc ); for( UINT p = 0; p < techDesc.Passes; ++p ) {
g_pTechnique‐>GetPassByIndex( p )‐>Apply(0);
g_pd3dDevice‐>Draw( 3, 0 ); // DrawIndexed
}
Anzahl der zu
zeichnenden Vertices
Index des ersten
Vertex
Index Buffer
• Das Anlegen funktioniert wie beim Vertex Buffer:
// Create data for the index buffer
DWORD indices[] = {
Einzige
3,1,0,
2,1,3,
};
UINT numInd = sizeof(indices) / sizeof(indices[0]); // Create and fill description
D3D10_BUFFER_DESC bd;
bd.Usage = D3D10_USAGE_DEFAULT;
bd.ByteWidth = sizeof( DWORD ) * numInd;
bd.BindFlags = D3D10_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
// Define initial data
D3D10_SUBRESOURCE_DATA InitData;
InitData.pSysMem = indices;
// Create Buffer
hr = g_pd3dDevice‐>CreateBuffer( &bd, &InitData, &g_pIndexBuffer );
if( FAILED(hr) )
return hr;
// Set index buffer
g_pd3dDevice‐>IASetIndexBuffer( g_pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
Ausnahme
Rendern (DrawIndexed)
• Beim Rendern ändert sich lediglich der Draw‐Befehl:
…
g_pd3dDevice‐>DrawIndexed( 6 , 0 , 0 );
…
Anzahl der zu
zeichnenden Indizes
Index des ersten
Vertex
Erster zu zeichnender
Index
Hinweis: Der letzte Parameter kann auch negativ sein.
Effect Techniques
• In DirectX legt man mit Hilfe einer Effect Technique
den Abauf der Rendering‐Pipeline fest.
• Gespeichert werden Effect Techniques und deren „Details“ in einem separaten Effect‐File (mehr dazu nächste Woche).
• Mit der Funktion D3DX10CreateEffectFromFile
kann man ein Effekt‐Objekt laden.
• Mit der Member‐Funktion GetTechniqueByName
kann man anschließend einen Pointer auf eine einzelne Effect Technique bekommen.
DXUT
• Die DirectX Utility Library (DXUT) dient dazu die Verwendung der Windows‐ und Direct3D‐APIs zu
vereinfachen.
• Hilfe bietet DXUT unter anderem beim
–
–
–
–
Erstellen von Fenstern
Erstellen von einem Direct3D Device
Handling von Device und Window Events
usw.
DXUT
• Der Umgang mit DirectX und Windows wird mit Hilfe
von Callback‐Funktionen geregelt:
– DXUTSetCallbackD3D10DeviceCreated :
Hier wird alles initialisiert, was nicht von der Größe des Fensters abhängt.
– DXUTSetCallbackD3D10SwapChainResized :
Hier wird alles initialisiert, was von der Größe des Fensters abhängt.
– DXUTSetCallbackD3D10SwapChainReleasing :
Hier muss alles freigegeben werden, was in OnSwapChainResized erstellt wurde.
– DXUTSetCallbackD3D10DeviceDestroyed :
Hier muss alles freigegeben werden, was in OnDeviceCreated erstellt wurde.
– DXUTSetCallbackD3D10FrameRender :
Hier wird die Szene gerendert.
DXUT
• Fortsetzung der Callback‐Funktionen:
– DXUTSetCallbackFrameMove :
Für Direct3D‐unabhängige Aktualisierung der Szene pro Frame vor dem Rendern.
– DXUTSetCallbackMsgProc :
Für das Handling von Window Messages.
– DXUTSetCallbackKeyboard :
Für das Handling von Keyboard‐Eingaben.
– DXUTSetCallbackDeviceChanging :
Wird vor dem Erstelln vom Direct3D Device aufgerufen und kann somit dessen Einstelungen ändern.
DXUT
• Zusätzliche Features:
– Kamera‐Klassen
• CFirstPersonCamera
(„First Person“)
• CModelViewerCamera („Third Person“)
– Graphical User Interface
– Rendern von Text
– Device Settings Dialog
Speicherfreigabe (DXUT)
• Auch auf der GPU immer daran denken, Speicher wieder freizugeben, wenn man ihn nicht mehr braucht (z.B. für Buffer, Input Layout, usw.).
• Unter DXUT geht das mit SAFE_RELEASE( Pointer ).
• Wenn beim Beenden des Programms Objekte noch nicht freigegeben wurden, erscheint im Debug‐Modus vom Visual Studio folgende Meldung:
Referenzen
•
The DirectX Software Development Kit
http://msdn.microsoft.com/en‐us/library/bb219737.aspx
•
Direct3D 10 Graphics (Programming Guide, Reference, Tutorials, Samples)
•
DXUT Programming Guide
•
DXUT Reference
•
HLSL Programming Guide
http://msdn.microsoft.com/en‐us/library/bb509635(VS.85).aspx
•
HLSL Reference
http://msdn.microsoft.com/en‐us/library/bb509638(VS.85).aspx

Vertex Layout

Transcription

Similar documents

Jennifer Rieke | SS2009 | Markenanalyse »smart