Displacement Mapping

Transkript

1 Displacement Mapping Studienarbeit Vorgelegt von Ruth-Maria Recker Institut für Computervisualistik Arbeitsgruppe Computergraphik Betreuer: Dipl.-Inform. Thorsten Grosch Prüfer: Prof. Dr.-Ing. Stefan Müller Januar 2006

2 Inhaltsverzeichnis 1 Einleitung 5 2 GPU Programmierung Entwicklung der GPU Fixed-Function-Pipeline Programmierbare Graphik-Pipeline Vertex-Prozessor Fragment-Prozessor Cg Bump Mapping Blinn-Bump Mapping Normal Mapping Normal-Maps Berechnung des Texture Space Beleuchtung Anwendung von Bump Mapping Parallax Mapping Idee von Parallax Mapping Parallax Mapping mit Offset Limiting Anwendung von Parallax Mapping Displacement Mapping Idee von Displacement Mapping View-dependent Displacement Mapping Per-Pixel Displacement Mapping Erstellung einer Distance-Map Rendern des Bildes mit Per-Pixel Displacement Mapping Der Vertex-Shader Der Fragment-Shader Selbstverschattung Filterung Anwendung von Per-Pixel Displacement Mapping i

3 6 Die Beispielszene Modellierung der Szene VRML Ergebnisse 44 8 Fazit und Ausblick 51 ii

4 Abbildungsverzeichnis 2.1 Fixed-Function-Pipeline [6] Programmierbare Graphik-Pipeline [6] Vertex-Prozessor [10] Fragment-Prozessor [10] Einfaches Vertex-Programm Einfaches Fragment-Programm Idee des Bump Mapping [1] Konvertierung eines Height-Fields in eine Normal-Map Ergebnis des Bump Mappings Parallax Mapping [15] Berechnung des Offset-Vektors [15] Berechnung des Offsets-Vektors mit Offset Limiting [15] Ergebnis des Parallax Mappings Idee von Displacement Mapping [3] Displacements mit View-dependent Displacement Mapping [14] Krümmung der Oberfläche [14] Undersampling [5] Oversampling [5] Sphere Tracing [4] Erstellung einer 2D-Distance-Map [4] Selbstverschattung [14] Ohne Filterung Mipmapping und Anisotrope Filterung Ergebnis des Displacement Mappings: Steine Ergebnis des Displacement Mappings: Text Modellierte Beispielszene Gerenderte Beispielszene Vergleich der verschiedenen Verfahren Ergebnisse des Displacement Mappings im Detail Gullideckel iii

5 1 Einleitung In immer mehr Bereichen kommen heutzutage dreidimensionale computergenerierte Szenen zum Einsatz. Dies ist insbesondere in der Film- sowie der Computerspieleindustrie zu beobachten. Aber auch weitere Einsatzgebiete wie beispielsweise Virtual Reality sind möglich. Bei der Generierung der 3D-Szenen liegt das Hauptaugenmerk auf einer möglichst realitätsgetreuen Darstellung der Szene. Neben der korrekten Simulation des Lichtes tragen auch die verwendeten Materialien einen wichtigen Teil zur Darstellungsqualität der Szene bei. Ein wichtiger Aspekt bei den Materialien ist die Simulation der Oberflächenstruktur. In der Realität existieren so gut wie keine vollkommen glatten Oberflächen. Selbst Metall- und Plastikmaterialien besitzen feine, auf den ersten Blick kaum sichtbare Strukturen, welche jedoch einen wichtigen Teil zum Erscheinungsbild des Objektes beitragen. Fehlen diese Strukturen, so verliert das Objekt einen Teil seiner Realitätsnähe, da das Licht nun anders von der Oberfläche reflektiert wird und dem Objekt so ein anderes Aussehen verleiht. Da es zu aufwendig ist, sehr feine Strukturen auszumodellieren, werden häufig Verfahren zur Simulation dieser Strukturen eingesetzt. Doch auch bei verhältnismäßig groben Strukturen der Oberfläche ist eine Ausmodellierung der einzelnen Strukturen oft zu aufwendig. Durch den Einsatz geeigneter Verfahren, wie beispielsweise Bump Mapping oder Displacement Mapping, läßt sich der Aufwand zur Generierung der Szene reduzieren. Darüberhinaus ermöglichen viele der eingesetzten Verfahren eine Simulation der Oberflächenstruktur ohne die Generierung neuer Dreiecke. Die Reduzierung der Renderzeit sowie des Speicherverbrauchs wird als enormer Vorteil dieser Verfahren angesehen. So werden zum Beispiel in Computerspielen Szenen mit Hilfe dieser Verfahren mit detailreichen Oberflächen versehen und lassen sich dennoch in Echtzeit darstellen. In dieser Studienarbeit werden verschiedene Verfahren zur Verbesserung der Oberflächenstruktur vorgestellt, die zur Implementierung auf moderner Graphik-Hardware geeignet sind. Dabei liegt der Schwerpunkt auf dem Displacement Mapping. Nach einer kurzen Einführung in die GPU Programmierung sowie in die hier verwendete Sprache Cg wird das Bump Mapping vorgestellt. Im Anschluß daran wird ein weiteres Verfahren zur Verbesserung der Oberflächenstruktur, das Parallax Mapping, erläutert. Das nächste Kapitel beschäftigt sich mit Displacement Mapping sowie dessen Einsatzmöglichkeiten. Zum Vergleich der einzelnen Verfahren dient eine Beispielszene, deren Erstellung im nächsten Kapitel vorgestellt wird. Darüberhinaus wird hier auch der Import der Szene in die eigene Anwendung erläutert. Die Ergebnisse des Vergleichs hinsichtlich Speicherverbrauch, Renderzeit und Darstellungsqualität werden zum Schluß vorgestellt. 5

6 2 GPU Programmierung 2.1 Entwicklung der GPU Während früher die CPU noch alleine für die Berechnung der gesamten Darstellung zuständig war, gewann die Graphik-Hardware in den letzten Jahren zunehmend an Bedeutung. Die moderne Graphik-Hardware ist mittlerweile in ihrer Leistungsfähigkeit soweit entwickelt, dass sie die meisten Berechnungen zur Darstellung einer komplexen 3D-Szene übernehmen kann. Vor der Entwicklung der ersten GPUs 1 ermöglichte nur eine spezielle Graphik- Hardware von Firmen wie Silicon Graphics (SGI) oder Evans & Sutherland Konzepte wie Vertex-Transformationen oder Texture Mapping. Diese Hardware war allerdings durch ihren hohen Preis für den Massenmarkt nicht erschwinglich und wurde ausschließlich in speziellen Workstations eingesetzt. Dies änderte sich erst Mitte der 90iger Jahre mit der Entwicklung der ersten 3D-Chips für PCs. Unterstützt durch eine starke Entwicklung der Computerspieleindustrie kamen in immer kürzeren Abständen neue 3D-Chips auf den Markt. Seit 2001 gibt es auch die ersten programmierbaren Graphikchips, zum Beispiel von ATI und NVIDIA. Diese Graphikchips ermöglichten erstmals die Programmierung des Vertex-Prozessors. Mit später entwickelten Graphikchips kam auch die Möglichkeit der Programmierung des Fragment Prozessors hinzu. 2.2 Fixed-Function-Pipeline Im Computer entworfene 3D-Modelle müssen gerendert werden, damit sie auf dem Bildschirm in 2D dargestellt werden können. Während des Rendering-Vorgangs durchlaufen die Objekte eine sogenannte Rendering-Pipeline, welche die zur Umrechnung nötigen Schritte durchführt. Ursprünglich war die Funktionalität der einzelnen Stufen dieser Rendering-Pipeline genau festgelegt, deshalb spricht man hier von einer Fixed- Function-Pipeline. In der Abbildung 2.1 können die verschiedenen Schritte der Pipeline nachvollzogen werden. 1 Graphics Processing Unit 6

7 2.2 Fixed-Function-Pipeline 3D Application or Game 3D API: OpenGL or Direct3D CPU - GPU Boundary GPU Front End Vertex Transformation Primitive Assembly Rasterization Fragment Texturing & Coloring Raster Operations Frame Buffer Abbildung 2.1: Fixed-Function-Pipeline [6] Die Eingabedaten, welche üblicherweise aus einer 3D-Anwendung oder einem 3D- Computerspiel stammen, werden zur Steuerung der 3D-API 2 verwendet. Man unterscheidet heute im Allgemeinen bei den 3D-APIs zwischen Direct3D und OpenGL. Bei Direct3D handelt es sich um einen Bestandteil von DirectX, entwickelt und betreut von Microsoft. Der Standard OpenGL entstand aus dem IRIS GL, entwickelt von Silicon Graphics (SGI). Heute wird die OpenGL-Spezifikation vom OpenGL Architecture Review Board (ARB) betreut. Während OpenGL plattformunabhängig ist, läuft Direct3D lediglich auf Windows Plattformen. Mit Hilfe der Methoden einer 3D-API können 3D- Objekte gerendert werden. Dazu werden die in der 3D-Anwendung aufgerufenen Befehle von der 3D-API umgesetzt. Der GPU Front-End erhält über den Graphikkartentreiber die entsprechenden Befehle von der 3D-API und steuert dementsprechend die Umsetzung der Befehle auf der Grafikhardware. In der nächsten Stufe, der Vertex Transformation, wird ein Vertex mit Hilfe mathematischer Operationen von Objektkoordinaten in Clip-Koordinaten umgerechnet. Außerdem kann die Beleuchtung des Vertex berechnet werden. Die transformierten Vertices werden in der Primitive-Assembly Stufe zu Geometrie- Primitiven, wie zum Beispiel Dreiecken, Linien oder Punkten, zusammengefasst. In der anschließenden Rasterisierungsstufe werden nun die geometrischen Primitive gegen das View Frustum sowie eventuell gegen vorher definierte Clipping Planes geclippt. Darüberhinaus werden beim Backface Culling diejenigen Polygone, deren Vorderseiten vom Betrachter abgewandt sind, verworfen. Die übrig gebliebenen Polygone können nun rasterisiert werden. Bei der Rasterisierung werden die geometrischen Primitive in ein 2D-Bild umgerechnet. Hierbei werden die Positionen derjenigen Fragmente bestimmt, die ein geometrisches Primitiv im 2D-Bild einnimmt. Außerdem wird bei der Rasterisierung die Farbe und ein Depth-Wert für jedes Fragment durch Interpolation bestimmt. Innerhalb der nächsten Stufe in der Rendering Pipeline, Fragment Texturing und Coloring, wird die endgültige Farbe eines Fragments festgelegt. Dies geschieht durch Kombination der interpolierten Farbe aus den Vertices mit der zum Fragment gehörenden Texturfarbe, sofern eine Textur angelegt wurde. 2 Application Programming Interface 7

8 2.3 Programmierbare Graphik-Pipeline Bevor das Fragment an den Frame-Buffer gesendet werden kann, muß es noch eine Reihe von Tests bestehen. Zu diesen Rasteroperationen gehören der Scissor-Test, der Alpha-Test, der Stencil-Test und der Depth-Test. Besteht ein Fragment einen dieser Tests nicht, so wird es verworfen. Andernfalls wird noch eine Blending-Operation und eine Dithering-Operation durchgeführt. Anschließend kann das fertige Fragment an den Frame-Buffer gesendet werden. 2.3 Programmierbare Graphik-Pipeline 3D API Commands 3D Application or Game 3D API: OpenGL or Direct3D CPU - GPU Boundary GPU Command & Data Stream GPU Front End Vertex Index Stream Primitive Assembly Assembled Polygons, Lines & Points Rasterization & Interpolation Pixel Location Stream Raster Operations Pixel Updates Frame Buffer Pretransformed Vertices Programmable Vertex Processor Transformed Vertices Rasterized Pretransformed Fragments Programmable Fragment Processor Transformed Fragments Abbildung 2.2: Programmierbare Graphik-Pipeline [6] Mittlerweile besteht in den modernen GPUs die Möglichkeit, bestimmte Stufen der Fixed-Function-Pipeline durch programmierbare Abschnitte zu ersetzen. Bei den programmierbaren Abschnitten handelt es sich um den Vertex-Prozessor und den Fragment-Prozessor. Die Abbildung 2.2 zeigt die programmierbare Pipeline mit den Abschnitten für den Vertex- und den Fragment-Prozessor. Durch die Verwendung des Vertex- bzw. des Fragment-Prozessors ist der Programmierer nicht auf die festgelegte Funktionalität einer Fixed-Function-Pipeline beschränkt, sondern kann die vorhandenen Funktionen noch um seine eigenen Funktionen ergänzen. Somit hat er mehr Möglichkeiten, die Darstellung seiner gewählten Szene zu beeinflußen. Da alle Berechnungen im Vertex- und im Fragment-Programm direkt auf der GPU erfolgen, welche solche Berechnungen schneller als die CPU ausführen kann, ist es möglich, viel Zeit einzusparen. 8

9 2.4 Vertex-Prozessor 2.4 Vertex-Prozessor Durch den Vertex-Prozessor, Abbildung 2.3, wird die Stufe der Vertex-Transformationen in der Rendering-Pipeline ersetzt. Dabei lädt der Vertex-Prozessor zuerst die Attribute für jeden Vertex, wie zum Beispiel Position, Farbe und Texturkoordinaten. Anschließend führt er alle im Vertex-Programm angegebenen Instruktionen auf dem Vertex aus. Dabei kann er eine begrenzte Anzahl von mathematischen Operationen verwenden, wie zum Beispiel Addition, Subtraktion, Multiplikation und Division aber auch Operationen wie Skalarprodukt, Kreuzprodukt, Minimum und Maximum sind möglich. Die Geforce 6 Serie [10] beinhaltet bis zu 6 Vertex-Pipelines. Jede der Vertex-Verarbeitungseinheiten basiert auf der MIMD-Architektur 3. Dabei hat jeder Prozessor eine eigene Kopie der durchzuführenden Verarbeitungsschritte und kann so unterschiedliche Operationen auf unterschiedlichen Datenströmen ausführen. Input Vertex Data Vertex Texture Fetch fp32 Scalar Unit fp32 Vector Unit Texture Cache Branch Unit Primitive Assembly Vertex Processor Viewport Processing To Setup Abbildung 2.3: Vertex-Prozessor [10] Die im Vertex-Prozessor enthaltene Scalar-Verarbeitungseinheit und die Vector-Verarbeitungseinheit arbeiten parallel. Sämtliche Operationen werden dabei mit einer fp32 4 Genauigkeit pro Komponente ausgeführt. Die GeForce 6 Serie erlaubt erstmals auch Texturzugriffe im Vertex-Prozessor. Es besteht eine Zugriffsmöglichkeit auf den Textur- Zwischenspeicher, welcher mit dem Fragment-Prozessor geteilt wird. Außerdem existiert ein sogenannter Vertex-Zwischenspeicher. Hier wird der Vertex vor und nach der Verarbeitung gespeichert. Der Vorteil dieses Speichers ist, dass ein 3 Multiple Instruction, Multiple Data 4 32-bit floating point 9

10 2.5 Fragment-Prozessor doppelt auftretender Vertex nicht zweimal bearbeitet werden muss. Beim zweiten Auftreten des Vertex kann hier einfach das schon berechnete Ergebnis aus dem Vertex- Zwischenspeicher verwendet werden. 2.5 Fragment-Prozessor Durch den Fragment-Prozessor 2.4 wird die Stufe der Fragment-Texturierung der Fixed- Function-Pipeline ersetzt. Der Fragment-Prozessor führt auf den übergebenen Fragmenten die im Fragment-Programm spezifizierten Instruktionen aus. So kann im Fragment-Programm zum Beispiel die Beleuchtung des Fragments berechnet werden. Außerdem besteht die Möglichkeit, dem Fragment einen Texturwert zuzuweisen. Zum Schluß wird im Fragment-Programm die endgültige Farbe des Fragments bestimmt. Texture Data Input Fragment Data Floating-Point Texture Processor fp32 Shader Unit1 Texture Cache fp32 Shader Unit2 Branch Processor Fog ALU Fragment Processor Output Shaded Fragments Abbildung 2.4: Fragment-Prozessor [10] Der Fragment-Prozessor der GeForce 6 Serie ist ein SIMD 5 Prozessor, was bedeutet, dass eine Anweisung für mehrere Fragmente gleichzeitig bearbeitet werden kann. Dazu verfügt die Geforce 6 Serie über bis zu 16 Fragment-Pipelines. 5 Single Instruction, Multiple Data 10

11 2.6 Cg Wie der Vertex-Prozessor hat auch der Fragment-Prozessor Zugriff auf einen Textur- Zwischenspeicher. Die GeForce 6 Serie unterstützt dabei die Filterung von fp16 6 Texturen. Der Fragment-Prozessor hat zwei fp32 Shader Units pro Pipeline. Die zu verarbeitenden Fragmente werden durch diese beiden Shader Units sowie den Branch Prozessor geschickt, bevor sie die Pipeline erneut zur Ausführung der nächsten Instruktion durchlaufen. Im letzten Schritt der Fragment-Pipeline kann Nebel in fixed-point precision hinzugefügt werden, ohne dass die Performance dadurch beeinträchtigt wird. 2.6 Cg Nach der Entwicklung der ersten programmierbaren Graphikkarten war es natürlich auch erforderlich, eine Sprache bereitzustellen, die für die Programmierung dieser Graphikkarten eingesetzt werden kann. Zunächst wurde zur Programmierung der GPU die Low-Level Sprache Assembler verwendet. Neben dem Vorteil, dass die gesamte Kontrolle über den Code beim Programmierer lag, hatte Assembler auch einige Nachteile. Assembler-Programme sind aufgrund ihrer Syntax oft schwer zu lesen. Außerdem wächst die Codelänge schon bei wenigen Instruktionen sehr schnell an. Dies war der Grund, weshalb sich Assembler auf Dauer in der Graphikprogrammierung nicht durchsetzen konnte. Im Jahr 2001 wurde deshalb von NVIDIA eine neue High-Level Sprache entwickelt: Cg [6], wobei Cg für C for graphics steht. Cg zeichnet sich zunächst durch seine hohe Portabilität aus. Diese Sprache kann auf verschiedenen Plattformen wie Windows, Linux und Mac OS X gleichermaßen eingesetzt werden. Darüberhinaus ist der Programmierer frei in der Wahl der API. Er kann sowohl OpenGL als auch DirextX verwenden. Um das Cg-Programm später auf der GPU einsetzen zu können, muß der Programmierer noch sogenannte Vertex- und Fragment-Profile wählen. Durch die Wahl von geeigneten Profilen werden die zur Verfügung stehenden Features für ein Cg-Programm entsprechend der gewählte 3D-API und GPU begrenzt. Profile können in die eigene Anwendung eingebunden werden. Werden zum Beispiel das Vertex-Profil vp40 sowie das Fragment-Profil fp40 gewählt, so können die Befehle der 3D-API OpenGL von Cg verwendet werden. Da Cg eine High-Level Sprache ist, zeichnet sie sich durch eine übersichtlichere Programmstruktur aus, als es bei Assembler der Fall ist und ist deshalb auch wesentlich einfacher zu lesen. Schon der Name Cg deutet auf die Nähe zur Programmiersprache C hin. Tatsächlich basiert die Syntax und Semantik von Cg auf C. Die Syntax von Cg wurde jedoch um Vektor- und Matrix-Datentypen sowie Texturtypen ergänzt. Außerdem stellt Cg dem Programmierer verschiedene Funktionen zur Verfügung. Dazu gehören zum Beispiel die Funktion dot, welche das Skalarprodukt berechnet, und die Funktion cross, welche die Berechnung des Kreuzproduktes übernimmt. Sowohl Vertex- als auch Fragment-Programme basieren auf dem Stream-Prinzip. Das bedeutet, dass das entsprechende Cg-Programm für jeden Vertex aus dem Vertex-Stream 6 16-bit floating point 11

12 2.6 Cg beziehungsweise jedes Fragment aus dem Fragment-Stream einzeln aufgerufen wird. Die Struktur eines Cg-Programms läßt sich wie folgt beschreiben: <return-type> <program-name> (<parameters>) [: <semantic-name>] Hierbei sind der Programmname und die Parameter des Programms genauso zu interpretieren wie in C auch. Der Rückgabewert des Cg-Programms muß nicht zwangsläufig aus einem einzelnen Wert bestehen. Mit Hilfe von Ausgabe-Strukturen oder Out- Parametern kann ein Cg-Programm auch mehrere Werte zurückliefern. Die Rückgabewerte des Vertex-Programms werden anschließend an das Fragment-Programm weitergeleitet und können dort verwendet werden. In Cg-Programmen kann man im Anschluß an einen Parameter eine Semantik festlegen, welche in einem Profil definiert ist. Eine mögliche Semantik ist zum Beispiel POSITION oder COLOR. Mit diesen semantischen Bindungen kann einerseits einem Vertex-Programm mitgeteilt werden, wie die übergebenen Parameter interpretiert werden sollen und gleichermaßen kann man so auch dem Fragment-Programm sagen, wie es die vom Vertex-Programm übergebenen Parameter behandeln soll. In der Abbildung 2.5 wird ein Beispiel für ein einfaches Vertex-Programm dargestellt. Dieses Programm bekommt für jeden Vertex eine Position und eine Farbe übergeben. Mit Hilfe der Ausgabevariablen, gekennzeichnet durch out, werden die Werte für die Position und die Farbe an das Fragment-Programm weitergeleitet. Das entsprechende Fragment-Programm, dargestellt in Abbildung 2.6, erhält die Farbe vom Vertex- Programm und fügt diese Farbe dem Fragment hinzu. [16] void VertexProgram( float4 position : POSITION, float4 color : COLOR, uniform float4x4 modelviewproj, out float4 oposition : POSITION, out float4 ocolor : COLOR) { oposition = mul(modelviewproj, position); ocolor = color; } void VertexProgram( float4 position : POSITION, float4 color : COLOR, uniform float4x4 modelviewproj, { } out float4 oposition : POSITION, Abbildung 2.5: Einfaches Vertex-Programm out float4 ocolor : COLOR) oposition = mul(modelviewproj, position); ocolor = color; void FragmentProgram( float out f { ocolor = color; } void FragmentProgram( float4 color : COLOR, out float4 ocolor : COLOR) { ocolor = color; } Abbildung 2.6: Einfaches Fragment-Programm 12

13 3 Bump Mapping In unserer Umwelt beobachten wir im Allgemeinen keine völlig glatten Oberflächen, sondern häufig Oberflächen, welche eine feine Struktur aufweisen, wie zum Beispiel Strukturen im Stein und Holz aber auch feinere Strukturen in Metalloberflächen. Diese Strukturen können wir unseren modellierten Objekten hinzufügen, um ihnen dadurch ein realistischeres Aussehen zu verleihen. Ein möglicher Ansatz wäre es, die Detailstrukturen in der Geometrie auszumodellieren. Neben der Tatsache, dass dies viel Modellierungsaufwand bedeuten würde, benötigt man auch zum Rendern einer Szene mit zusätzlicher Geometrie deutlich mehr Zeit und hat einen höheren Speicherverbrauch. Ein anderer Ansatz besteht in der Simulation der Detailstrukturen mit Hilfe von einem Verfahren, genannt Bump Mapping, welches allein durch eine Veränderung der Beleuchtung eines Objektes Strukturen auf der Oberfläche simulieren kann, ohne zusätzliche Geometrie zu erzeugen. 3.1 Blinn-Bump Mapping James F. Blinn hat das Verfahren Bump Mapping bereits 1978 erfunden und in seinem Paper Simulation of Wrinkled Surfaces [1] veröffentlicht. Sein Ansatz arbeitet mit einem Height-Field, einem Graustufenbild, dessen Grauwerte für Höhenangaben stehen. Für das Verfahren [9] benötigen wir eine Oberfläche, auf der Bump Mapping simuliert werden soll. Diese Oberfläche P wird durch eine bivariate Vektor-Funktion P (u, v) beschrieben. Die Oberflächen-Normale in einem Punkt auf der Oberfläche P ist wie folgt beschrieben: N(u, v) = P (u, v) u P (u, v) v Außerdem existiert eine bivariate Skalar-Funktion F (u, v). F kann dabei geometrisch als ein Height-Field interpretiert werden, mit dem die Beleuchtung der originalen Oberfläche so verändert werden kann, dass eine Struktur erkennbar ist. Die für die Struktur benötigte Höhenangabe erhält man aus dem Height-Field-Image, die Richtung der Höhenveränderung wird durch die Normale N(u, v) angegeben. Kombiniert man die originale Oberfläche P und das Height-Field F, so erhält man eine neue Oberfläche P (u, v), die definiert ist durch: (3.1) P N(u, v) (u, v) = P (u, v) + F (u, v) N(u, v) (3.2) 13

14 3.1 Blinn-Bump Mapping Die neue Oberfläche P enthält jetzt die Struktur. Die Idee dieses Verfahrens wird in Abbildung 3.1 dargestellt. Abbildung 3.1: Idee des Bump Mapping [1] Für eine Simulation der Oberfläche P in einem Shader benötigt man die Normale dieser Oberfläche. Dabei wird die Normale beschrieben durch: N (u, v) = P (u, v) u P (u, v) v Die Bestimmung der Normalen erfordert zunächst die Bildung der partiellen Ableitungen der neuen Oberfläche. (3.3) P u P v = (P + F (N/ N )) u = (P + F (N/ N )) v = P u + F ( N u N = P v + F v ( N N ) ( N N + F u ) + F ( N N v ) ) (3.4) (3.5) Unter der Annahme, dass der Wert von F vernachlässigbar klein ist, läßt sich eine Approximation dieser Gleichungen finden, welche um den letzten Term reduziert ist. Daraus ergibt sich nun die Normale N : N = P u P v + F u ( ) N P v + N ( F P v u N) + N F F u v (N N) N 2 (3.6) 14

15 3.2 Normal Mapping Der letzte Term dieser Gleichung wird hierbei Null und man erhält schließlich die Normale N, welche durch Addition der Normalen der originalen Oberfläche mit einem Offset Vektor D erzeugt wird. N = N + D (3.7) D = F ( N P ) F u v v ( N P ) u (3.8) 3.2 Normal Mapping Blinn-Bump Mapping liefert für Offline-Anwendungen sehr gute Ergebnisse. Bei Echtzeitanwendungen sind jedoch andere Verfahren dem Blinn-Bump Mapping, welches durch seine aufwändigen Berechnungen eine hohe Rechenzeit erfordert, vorzuziehen. Hierfür eignet sich zum Beispiel das Normal Mapping, ein Verfahren welches auf der Verwendung einer so genannten Normal-Map mit vorberechneten Normalen basiert. Im Gegensatz zum Blinn-Bump Mapping werden bei diesem Verfahren die originalen Normalen nicht durch Berechnung verändert, sondern sie werden komplett durch die Normalen aus der Normal-Map ersetzt Normal-Maps Normal-Maps sind im RGB-Format angelegt. Somit werden die Normalen als Vektoren abgespeichert, wobei die Komponenten x, y, z jeweils den Farben rot, grün und blau entsprechen. Normal-Maps können automatisch aus Height-Field-Images erstellt werden. Um die Normalen aus einem Height-Field berechnen zu können, muß zunächst die erste partielle Ableitung des Height-Field-Images F in horizontaler und vertikaler Richtung berechnet werden: ( ) F (u, v) F (u, v) F (u, v) = (F u (u, v), F v (u, v)) =, (3.9) u v Mit den beiden Ableitungen kann nun die Normale N in normalisierter Form für die Normal-Map berechnet werden. N = F u(u, v), F v (u, v), 1 Fu (u, v) 2 + F v (u, v) (3.10) Normalen besitzen im Gegensatz zu Farbvektoren eine Richtung. Der Wertebereich einer Normalen liegt deshalb im Bereich [-1,1]. Bevor die Normalen in einer RGB- Textur, deren Wertebereich [0,1] entspricht, gespeichert werden können, müssen sie bezüglich des Bereichs komprimiert werden. Dies geschieht mit folgender Funktion: F arbvektor = 0.5 N ormalvektor + 0.5; (3.11) 15

16 3.3 Berechnung des Texture Space Der Farbvektor kann anschließend in der Normal-Map gespeichert werden. Zur Verwendung der Normalen bei der Beleuchtung ist eine Dekompression des Vektors aus der Normal-Map notwendig. Normalvektor = 2 (F arbvektor 0.5); (3.12) (a) Height-Field (b) Normal-Map Abbildung 3.2: Konvertierung eines Height-Fields in eine Normal-Map 3.3 Berechnung des Texture Space Bei der Beleuchtung eines Objektes werden nun statt der originalen Vertex-Normalen die Normalen aus der Normal-Map verwendet. Diese Normalen befinden sich im sogenannten Texture Space, oder auch Tangent Space genannt. Somit sind sie zunächst noch von einem konkreten Objekt unabhängig und können für jedes beliebige Objekt verwendet werden. Für eine korrekte Berechnung der Beleuchtung ist es erforderlich, dass sich der Lichtvektor, der Blickvektor und die Normale in einem Koordinatensystem befinden. Üblicherweise konvertiert man hierzu sowohl den Blickvektor als auch den Lichtvektor in den Texture Space. Diese Umrechnung erfordert neben der Normalen die Kenntnis zweier anderer Vektoren, der Tangente und der Binormalen. Die drei Vektoren stehen dabei in folgendem Verhältnis: Binormale = N ormale T angente (3.13) N ormale = T angente Binormale (3.14) T angente = Binormale N ormale (3.15) Jeder Vertex des zu beleuchtenden triangulierten Objekts besitzt eine 3D Position und eine 2D Texturkoordinate. Die Kombination dieser beiden Vektoren ergibt einen 16

17 3.3 Berechnung des Texture Space 5D Vektor, der die Punkte v 0, v 1 und v 2 des Dreiecks beschreibt: v 0 = x 0, y 0, z 0, s 0, t 0 (3.16) v 1 = x 1, y 1, z 1, s 1, t 1 (3.17) v 2 = x 2, y 2, z 2, s 2, t 2 (3.18) Alle diese Koordinaten liegen in der Ebene des gleichen Dreiecks. Deshalb ist es möglich, folgende Ebenengleichungen aufzustellen: A 0 x + B 0 s + C 0 t + D 0 = 0 (3.19) A 1 y + B 1 s + C 1 t + D 1 = 0 (3.20) A 2 z + B 2 s + C 2 t + D 2 = 0 (3.21) Für jede dieser drei Gleichungen können nun die Koeffizienten A, B, C und D berechnet werden. A 0, B 0, C 0 = x 0, s 0, t 0 x 1, s 1, t 1 x 0, s 0, t 0 x 2, s 2, t 2 (3.22) D 0 = A 0, B 0, C 0 x 0, s 0, t 0 (3.23) A 1, B 1, C 1 = y 0, s 0, t 0 y 1, s 1, t 1 y 0, s 0, t 0 y 2, s 2, t 2 (3.24) D 1 = A 1, B 1, C 1 y 0, s 0, t 0 (3.25) A 2, B 2, C 2 = z 0, s 0, t 0 z 1, s 1, t 1 z 0, s 0, t 0 z 2, s 2, t 2 (3.26) D 2 = A 2, B 2, C 2 z 0, s 0, t 0 (3.27) Anschließend kann man diese Gleichungen so umformen, dass x, y, und z in Abhängigkeit von s und t ausgedrückt werden. Mit den folgenden Gleichungen können die 2D Positionen im Texture Space in ihre entsprechenden 3D Positionen im Object Space umgewandelt werden. x = B 0s C 0 t D 0 A 0 (3.28) y = B 1s C 1 t D 1 A 1 (3.29) z = B 2s C 2 t D 2 A 2 (3.30) 17

18 3.4 Beleuchtung Von jeder dieser drei Gleichungen kann jetzt die partielle Ableitung nach s und t gebildet werden. Aus diesen partiellen Ableitungen lassen sich folgende Gleichungen für die Tangente und die Binormale aufstellen: x T angente = s, y s, z = B 0, B 1, B 2 (3.31) s A 0 A 1 A 2 x Binormale = t, y t, z = C 0, C 1, C 2 (3.32) t A 0 A 1 A 2 Mit der so berechneten Tangente und Binormalen sowie der Vertex-Normalen lassen sich der Lichtvektor L und der Blickvektor V in den Texture Space konvertieren: 3.4 Beleuchtung L T BN = T x T y T z B x B y B z N x N y N z L x L y L z (3.33) Mit der Normalen aus der Normal-Map sowie dem konvertierten Lichtvektor und Blickvektor kann nun die Beleuchtung des Fragments durchgeführt werden. Dabei wird die diffuse Beleuchtung nach dem Lambert Modell berechnet. D = diffus M (N L) (3.34) Die diffuse Materialfarbe wird durch diffus M, die Normale durch N und der Lichtvektor durch L beschrieben. Die spekulare Beleuchtung hingegen wird nach dem Blinn- Phong Modell berechnet. S = specular M (N H) shininess (3.35) H = L + V (3.36) Hierbei handelt es sich bei specular M um die spekulare Materialfarbe. Der Halbvektor H ist der Vektor, welcher in der Mitte zwischen dem Lichtvektor L und dem Blickvektor V liegt. Der spekulare Exponent shininess kann in Abhängigkeit von den Materialeigenschaften gewählt werden. 3.5 Anwendung von Bump Mapping Die Technik des Bump Mappings läßt sich relativ einfach und effizient implementieren und ermöglicht so einen verbesserten Tiefeneindruck der Texturen eines Objektes. Im Allgemeinen eignet sich Bump Mapping gut zur Darstellung von detailreichen Strukturen mit geringer Amplitude. So kann Bump Mapping zum Beispiel zur Darstellung 18

19 3.5 Anwendung von Bump Mapping von feinen Details in Leder-, Kunststoff- oder Metallmaterialien ideal eingesetzt werden. Spätestens bei Betrachtung der Kanten eines Objektes, insbesondere bei Strukturen mit höherer Amplitude, wird allerdings deutlich, dass es sich bei Bump Mapping nur um eine Simulation handelt, da Bump Mapping keine Silhouetten darstellen kann. Darüberhinaus werden weder Selbstverdeckung und Schatten noch Parallax Effekte mit der verwendeten Bump Mapping Technik dargestellt. Dies schwächt den Realitätseindruck des Ergebnisses sicherlich ab. Trotzdem ist Bump Mapping eine Verbesserung im Vergleich zu dem normalen Texture Mapping. Der mit Hilfe von Bump Mapping zu erzielende Tiefeneffekt ohne große Einbußen bei der Geschwindigkeit und dem Speicherverbrauch der Applikation rechtfertigt sicherlich den Einsatz von Bump Mapping in Computerspielen. In Abbildung 3.3 ist die Anwendung von Bump Mapping auf die Textur von einer Steinmauer sowie auf eine Hauttextur zu sehen. Das Beispiel der Steinmauer wird auch noch zum Vergleich der Darstellung von Bump Mapping mit Parallax und Displacement Mapping dienen. (a) Steine (b) Haut Abbildung 3.3: Ergebnis des Bump Mappings 19

20 4 Parallax Mapping 4.1 Idee von Parallax Mapping Die Idee von Parallax Mapping wurde zuerst von Tomomichi Kaneko [13] im Jahr 2001 veröffentlicht. Im Gegensatz zu Bump Mapping, welches bei einer Veränderung der Betrachtungsrichtung flach und somit teilweise unrealistisch wirkt, berücksichtigt Parallax Mapping die Verschiebung von Teilen der Oberfläche relativ zueinander bei einem Wechsel der Position des Betrachters, die sogenannte Parallaxe, und erreicht damit einen höheren Realitätsgrad. Terry Welsh veröffentlichte im Jahr 2004 eine Technik [15], mit der Parallax Mapping unter Nutzung moderner GPUs verwendet werden kann. Außerdem ergänzte er seinen Ansatz durch Offset Limiting, um so bestimmte Artefakte von Parallax Mapping zu vermindern. Im folgenden soll der Ansatz von Welsh erläutert werden. reale Oberfläche A B Auge Polygon aktuelle Texturkoordinate korrigierte Texturkoordinate Abbildung 4.1: Parallax Mapping [15] Bei Verwendung einer Technik wie Normal Mapping können wir durch Ersetzung der Normalen, wie im Kapitel Bump Mapping beschrieben, eine strukturierte Oberfläche simulieren. Allerdings wirkt die entstandene Oberfläche aus verschiedenen Betrachtungswinkeln dennoch zu flach. In der Abbildung 4.1 ist die Ursache dieses Problems dargestellt. Der Sehstrahl vom Auge trifft auf unser Polygon. Somit greifen wir mit der aktuellen Texturkoordinate auf die zu verwendenden Texturen sowie auf die Normal-Map zu. Durch die Berechnungen beim Bump Mapping Verfahren ergibt sich ein Punkt A auf unserer simulierten Oberfläche. Der Punkt A ist jedoch nicht korrekt. Wir können sehen, dass der Sehstrahl bereits in Punkt B auf unsere zu simulierende Oberfläche treffen würde. Für eine korrekte Simulation der Oberfläche müssen wir also die aktuelle Texturkoordinate dahingehend korrigieren, dass sich durch Anwen- 20

21 4.1 Idee von Parallax Mapping dung des Bump Mapping Verfahrens auf die korrigierte Texturkoordinate der Punkt B ergibt. Beim Parallax Mapping wird genau diese Korrektur der Texturkoordinaten vorgenommen, so dass durch diese Technik die Parallaxe, welche sich ergibt wenn wir die unebene Oberfläche aus verschiedenen Positionen betrachten, simuliert wird. Als Voraussetzung zur Durchführung von Parallax Mapping benötigen wir die gegebenen Texturkoordianten, einen Höhenwert aus einem Height-Field-Image und einen Blickvektor von der Oberfläche zum Auge, wobei dieser Blickvektor sich im Texture Space befinden muß. Die zugrunde liegende Idee bei der Berechnung der neuen Texturkoordinate ist, wie in Abbildung 4.2 dargestellt, die alte Texturkoordinate durch einen berechneten Offset-Vektor zu verschieben. Der Offset-Vektor verläuft dabei parallel zum Polygon, nämlich vom Punkt A auf der zu simulierenden Oberfläche direkt oberhalb von P in Richtung des Blickvektors. Height Map A Offset Auge Polygon P T_old T_new Abbildung 4.2: Berechnung des Offset-Vektors [15] Zur Berechnung des Offset-Vektors muß als erstes der Blickvektor in einen normalisierten Blickvektor V konvertiert werden. Die zur Bestimmung der Struktur erforderliche Höhe h an der aktuellen Texturkoodinate T old kann dem Height-Field-Image entnommen werden. Welsh verwendet zusätzlich noch einen Skalierungsfaktor s und einen Bias-Wert b um die Werte aus dem Height-Field-Image, die im Wertebereich [0,1] liegen, in einen geeigneteren Wertebereich in Abhängigkeit von der zu texturierenden Fläche zu konvertieren. Dabei wird die Höhe h um den Skalierungsfaktor s skaliert, um die Textur an die Größe der zu texturierenden Fläche anzupassen. Durch den Bias b wird das Height- Field so verschoben, dass der mittlere Höhenwert des Height-Fields in der Oberflächenebene liegt. Die neue Höhe h sb berechnet sich wie folgt: b = 0.5 s (4.1) h sb = h s + b (4.2) Unter diesen Voraussetzungen kann nun der Offset-Vektor V parallel zur Oberfläche 21

22 4.2 Parallax Mapping mit Offset Limiting des Polygons berechnet werden. Durch Addition des Offset-Vektors zur alten Texturkoordinate erhält man schließlich die neue Texturkoodinate T new. V offset = h sb V x,y /V z (4.3) T new = T old + V offset (4.4) Mit Hilfe dieser neu berechneten Texturkoordinate kann nun auf die verschiedenen Texturen, wie die Normal-Map und die reguläre Color-Map, zugegriffen werden. 4.2 Parallax Mapping mit Offset Limiting Height Map A Offset Auge Polygon P T_old T_new Abbildung 4.3: Berechnung des Offsets-Vektors mit Offset Limiting [15] Normales Parallax Mapping hat das Problem, dass bei flachen Betrachtungswinkeln der Oberfläche Artefakte auftreten können. Die Berechnung der Verschiebung beim normalen Parallax Mapping erfolgt unter der Annahme, dass die Höhe h an der Position mit der neuen Texturkoordinate T new der Höhe an der Position mit der alten Texturkoordinate T old entspricht. Jedoch trifft man diesen Fall in der Realität äußerst selten an. Bei einer Oberfläche variiert die Höhe der Struktur in der Regel in kurzen Abständen voneinander. Schaut der Betrachter die Oberfläche aus einem relativ steilen Betrachtungswinkel an, so ergibt sich durch die Berechnung auch nur eine geringe Verschiebung der Texturkoordinate. Hierbei ist also mit einer fast identischen Höhe an der Position der neuen Texturkoordinate zu rechnen. Die Annahme einer gleichen Höhe führt jedoch dann zu Problemen bei der Berechnung der Parallaxe, wenn man die Oberfläche aus einem flachen Winkel betrachtet. Durch die Berechnung ergibt sich in diesem Fall ein großer Offset-Vektor, der zur Verschiebung der Texturkoordinate dient. Je weiter die neue Texturkoordinate von der alten Texturkoordinate entfernt ist, desto höher ist auch die Wahrscheinlichkeit, dass an der Position der neuen Texturkoordinate eine andere Höhe eingetragen ist als an der Position der alten Texturkoordinate. Da dies in der Berechnung jedoch bisher nicht berücksichtigt wurde, kann sich die Oberfläche für den 22

23 4.3 Anwendung von Parallax Mapping Betrachter als ein Durcheinander von verschiedenen Pixelwerten ohne klar erkennbare Struktur darstellen. Zur Korrektur dieses Problems hat Welsh das Parallax Mapping um ein Offset Limiting erweitert. Die Idee dabei besteht darin, eine zu weite Verschiebung der Texturkoordinaten zu verhindern und damit gleichzeitig eine bessere Garantie dafür zu liefern, dass sich der Height-Wert an der Position der neuen Texturkoordinaten nicht wesentlich von dem Height-Wert an der Position der alten Texturkoordinate unterscheidet. Mit dieser Technik können die Artefakte, wie sie beim normalen Parallax Mapping auftreten, verringert werden. Konkret erreicht Welsh dies, indem er die maximale Verschiebung der Texturkoordinate auf eine Länge von h sb begrenzt. Dies wird in der Abbildung 4.3 dargestellt. V offset = h sb V x,y (4.5) T new = T old + V offset (4.6) Die Wahl eines anderen Wertes zur Begrenzung der Verschiebung der Texturkoordinate wäre auch möglich, da es sich bei diesem Ansatz von Parallax Mapping lediglich um eine Approximation der Parallaxe handelt. Es hat sich allerdings herausgestellt, dass sich durch Verwendung des h sb -Wertes gute Ergebnisse erzielen lassen, was den Einsatz dieses Wertes rechtfertigt. Welsh reduziert somit durch seinen Offset Limiting Ansatz den Fehler, der bei der Berechnung der Parallaxe bei flachen Betrachtungswinkeln entsteht. 4.3 Anwendung von Parallax Mapping Bei Parallax Mapping handelt es sich, genauso wie beim Bump Mapping, um eine sehr schnelle Technik. Die Anzahl der Instruktionen im Vertex- bzw. Fragment-Programm ist bei Parallax Mapping im Vergleich zu Bump Mapping nur geringfügig angestiegen. Parallax Mapping hat allerdings den entscheidenden Vorteil, dass es die Darstellung von Parallax Effekten ermöglicht und dadurch einen realistischeren Eindruck der simulierten Strukturen beim Betrachter hervorruft. Bei sehr flachen Betrachtungswinkeln erscheint die simulierte Geometrie jedoch auch mit der Technik des Parallax Mapping als zu flach. Darüberhinaus handelt es sich bei Parallax Mapping nur um eine Approximation der tatsächlichen Strukturen. Auffallend sind hierbei auch stufenähnliche Artefakte, die sich teilweise erkennen lassen, wenn die Fläche aus einem flachen Winkel betrachtet wird. Eine Ursache der Artefakte ist sicherlich die Wahl eines zu großen Offset-Vektors. Dieses Problem läßt sich durch Wahl eines geeigneten s-parameters in Abhängigkeit von der Größe der zu texturierenden Fläche relativ gut korrigieren. Parallax Mapping eignet sich jedoch aufgrund der approximierten Berechnung der neuen Texturkoordinaten genauso wie das Bump Mapping nicht zur Darstellung hochfrequenter Strukturen mit hoher Amplitude. Auch Selbstverdeckung und -verschattung 23

24 4.3 Anwendung von Parallax Mapping lassen sich mit dieser Technik nicht darstellen. Die Abbildung 4.4 zeigt die Anwendung des Parallax Verfahrens auf dieselbe Steinstruktur, die bereits zur Darstellung von Bump Mapping verwendet wurde. Abbildung 4.4: Ergebnis des Parallax Mappings 24

25 5 Displacement Mapping 5.1 Idee von Displacement Mapping Displacement Mapping ist ein weiteres Verfahren, Oberflächen um detailliertere Strukturen zu ergänzen. Das bereits vorgestellte Parallax Mapping ermöglicht nur die Darstellung von gröberen Strukturen mit niedriger Frequenz, während es zur Simulation von großen Verschiebungen und Selbstverdeckung ungeeignet ist. Mit Displacement Mapping hingegen läßt sich eine weitaus bessere Darstellung dieser genannten Fälle erreichen. So ist es mit Displacement Mapping sogar möglich, schwierige Fälle, wie Text, gut darzustellen. Man unterscheidet zwei Arten des Displacement Mappings. Zunächst wäre das echte Displacement Mapping zu nennen. Displacement Mapping wurde in dieser Form zum ersten Mal 1984 von Cook [2] beschrieben. Hierbei werden die Informationen über die Struktur der darzustellenden Oberfläche einem Height-Field F (u, v) entnommen. Mit dem aus dem Height-Field gewonnenen Höhenwert h wird nun jeder Vertex (x, y, z) der Originaloberfläche P (u, v) entlang seiner Normalen ˆN(u, v) um eben diesen Höhenwert verschoben. Voraussetzung für dieses Verfahren ist die detailliertere Unterteilung des zugrunde liegenden Meshes an den entsprechenden Stellen. Die Geometrie eines Objektes wird hierbei also verändert. Die Abbildung 5.1 stellt diesen Zusammenhang dar. P' N' neue Oberfläche alte Oberfläche h P ^ N Abbildung 5.1: Idee von Displacement Mapping [3] P (u, v) = P (u, v) + F (u, v) ˆN(u, v) (5.1) 25

26 5.2 View-dependent Displacement Mapping ˆN(u, v) = N(u, v) N(u, v) Obwohl durch die echte Veränderung der Geometrie optimale Ergebnisse im Aussehen der Objekte erzielt werden und auch schwierige Fälle gut dargestellt werden können, bringt diese Vorgehensweise leider einen Nachteil mit sich. Durch die Erzeugung von zusätzlichen Vertices bei der Unterteilung des Meshes erhöht sich auch die notwendige Rechenleistung sowie der Speicherverbrauch. Aus diesem Grunde ist echtes Displacement Mapping zum Einsatz in einer Echtzeitapplikation wenig geeignet. Eine gute Alternative bietet ein Displacement Mapping Verfahren, welches die Geometrie eines Objektes nicht verändert, sondern, ähnlich wie bei Bump Mapping und Parallax Mapping, die strukturierte Oberfläche nur simuliert. Der Vorteil des Displacement Mapping Verfahrens gegenüber den beiden anderen genannten Verfahren liegt in der genaueren Bestimmung des Schnittpunkt von Oberfläche und Blickvektor. Daraus ergibt sich eine bessere Visualisierung der zusätzlichen Merkmale der Oberfläche. Möglich wird diese genauere Schnittpunktbestimmung durch den Einsatz des Ray- Tracing Verfahrens. (5.2) 5.2 View-dependent Displacement Mapping Das View-dependent Displacement Mapping von Wang et al [14] ist eines derjenigen Verfahrens, welches pixelorientiert arbeitet. Anders als beim klassischen Displacement Mapping von Cook, berechnet dieses Verfahren nicht die Abstände entlang der Normalen, sondern mißt den Abstand einer Referenzoberfläche entlang der Blickrichtung zu der zu simulierenden Oberfläche. Letztere wird hierbei durch ein Height-Field repräsentiert. 26

27 5.2 View-dependent Displacement Mapping Blickrichtung V Referenzoberfläche Height- Field h P P' d l Abbildung 5.2: Displacements mit View-dependent Displacement Mapping [14] Für mehrere mögliche Blickrichtungen V, ausgedrückt in sphärischen Koordinaten (Θ, φ), wird ein Punkt P auf der Referenzoberfläche mit den Texturkoordinaten (x, y) auf den entsprechenden Punkt P der zu simulierenden Oberfläche projiziert. Dieser Vorgang wird für alle Punkte der Referenzoberfläche durchgeführt. Der Punkt P besitzt dabei die Texturkoordinaten (x, y ). Da P für verschiedene Blickrichtungen V natürlich auf verschiedene Punkte P auf der zu simulierenden Oberfläche projiziert wird, ist der zu speichernde Abstand d abhängig von x, y, Θ, φ. Darüberhinaus beeinflußt auch die Krümmung c der Oberfläche den projizierten Punkt P. Dieser Zusammenhang wird in Abbildung 5.3 dargestellt. V1 V 0 V1 V 0 V 2 V 2 V 3 V 3 V n V n P P P' 3 P' n P' 3 P' n P' 0 P' 1 P' 2 P' 0 P' 1 P' 2 Abbildung 5.3: Krümmung der Oberfläche [14] Die Funktion zur Bestimmung der Abstände der Referenzoberfläche zu der zu simulierenden Oberfläche hängt also von fünf Werten ab: x, y, Θ, φ, c. Deshalb werden die 27

28 5.3 Per-Pixel Displacement Mapping berechneten Abstände für jeden gefundenen Schnittpunkt in einer fünf-dimensionalen Map abgespeichert. Wird kein Schnittpunkt gefunden, so wird 1 in die Map eingetragen. Durch die fünf-dimensionale Map ergibt sich allerdings eine hohe Datenmenge, die es zu bewältigen gilt. Verwendet man zum Beispiel ein Height-Field mit einer Auflösung von 128x128, 32x8 Blickrichtungen sowie 16 Krümmungswerten so benötigt die Map 64 MB Speicherplatz. Außerdem stellt die hohe Dimensionalität der Map ein weiteres Problem dar, weil die Graphikhardware im Allgemeinen auf eine geringere Dimension beschränkt ist. Deshalb werden die Daten mit SVD 1 aufgeteilt und komprimiert. Mit Hilfe von SVD lässt sich die Dimension reduzieren. Dabei entstehen zwei Maps mit niedrigerer Dimensionalität. Zum Rendern des Bildes wird die Map im Fragment-Shader wieder dekomprimiert und ausgelesen. So kann der in der Map gespeicherte vorberechnete Abstand nun zur Verschiebung der Texturkoordinaten eingesetzt werden. Durch die fünf Dimensionen der Map ist bei diesem Verfahren allerdings ein hoher Aufwand im Vorverarbeitungsschritt sowie ein allgemein erhöhter Speicherbedarf zu erwarten. 5.3 Per-Pixel Displacement Mapping Ein anderes Verfahren, welches pixelorientiert arbeitet, ist das Per-Pixel Displacement Mapping with Distance Functions von William Donnely [4]. Anders als beim Viewdependent Displacement Mapping wird hier die Technik des Ray-Tracings nicht im Vorverarbeitungsschritt sondern direkt im Fragment-Shader eingesetzt. Mit Hilfe von Ray-Tracing soll bestimmt werden, für welchen Teil des Bildes welcher Teil der Geometrie sichtbar ist. Normalerweise wird dabei ein Strahl vom Betrachter durch die Geometrie geschickt und in regelmäßigen Abständen abgetastet, um den Schnittpunkt des Strahls mit der Geometrie zu bestimmen. In diesem speziellen Fall von Displacement Mapping muss man das Height-Field in regelmäßigen Abständen abtasten, um den Schnittpunkt mit der zu simulierenden Geometrie zu finden, da die Höhenwerte in dem Height-Field die Geometrie simulieren. Hierbei tritt allerdings das Problem des Undersamplings auf. Sofern die Abstände, in denen abgetastet wird, weiter als einen Texel voneinander entfernt sind, läßt sich nicht mehr sicherstellen, dass jeder mögliche Schnittpunkt gefunden wird. Durch die so verpassten Schnittpunkte können Lücken in der gerenderten Geometrie entstehen und Aliasing Effekte auftreten. Die Abbildung 5.4 zeigt den Effekt von Undersampling. Die grau schattierte Geometrie wird hierbei vollständig verpasst. Die triviale Lösung wäre sicherlich, die Abstände der Abtastung zu verringern. Das so erzwungene Oversampling 5.5 stellt allerdings eine Lösung dar, die mit zu hohen Kosten verbunden ist. Darüberhinaus gibt es nicht unbedingt einen einheitlichen Samplingabstand, der für alle Teile der zu simulierenden Geometrie geeignet ist. Vielmehr müssen die wählbaren Abstände in jeder Region neu festgelegt werden, je nachdem wie die zu simulierende Geometrie beschaffen ist. 1 singular-value decomposion 28

29 5.3 Per-Pixel Displacement Mapping p1 p0 p2 p3 p4 Abbildung 5.4: Undersampling [5] p7 p6 p5 p4 p3 p2 p1 p0 Abbildung 5.5: Oversampling [5] Eine gute Lösung zu diesem Problem stellt die Verwendung des Konzepts von Sphere Tracing von John Hart [8] dar. Sphere Tracing ist eine geeignete Methode zum Rendern von implicit surfaces unter Verwendung des geometrischen Abstands. Die Idee des Sphere Tracings wird in Abbildung 5.6 dargestellt. Hierbei wird ein Strahl vom Punkt p 0 aus losgeschickt. Ziel ist es, den nächsten Abstand zu der Geometrie zu finden. Da die Richtung des nächsten Abstandes nicht festgelegt ist, bietet sich hierfür eine Kugel an. Um den Abstand zu bestimmen, wird der Radius der Kugel so lange vergrößert, bis ein Schnittpunkt zwischen der Kugel und der Geometrie gefunden wurde. In diesem Fall stellt p 1 nun den Schnittpunkt zwischen Kugel und Strahl dar, nachdem der Schnittpunkt zwischen Kugel und Geometrie gefunden wurde. Ausgehend von p 1 kann dieser Vorgang nun so lange wiederholt werden und neue Punkte p i erzeugt werden, bis der Strahl tatsächlich die Geometrie trifft. Dies ist in diesem Beispiel beim Punkt p4 der Fall. Deutlich ist zu erkennen, dass in p4 der Radius einer neuen Kugel den Wert Null annehmen würde. Der Algorithmus konvergiert für diesen Fall. Insgesamt sind in dem gezeigten Beispiel also vier Abtastungen ausreichend, um sicherzustellen, dass kein Schnittpunkt verpasst wird oder ein zu hohes Maß an 29

30 5.3 Per-Pixel Displacement Mapping Abtastungen die Rechenzeit erhöht. p0 p2 p1 p4 p3 Abbildung 5.6: Sphere Tracing [4] Dieses Konzept wird zur Berechnung einer Distance-Map im Fall von Displacement Mapping genutzt. Dabei wird für jeden Punkt p im Texture-Space und eine Oberfläche S eine Funktion wie folgt definiert: dist(p, S) = min {d(p, q) : q in S} (5.3) Diese Funktion liefert als Ergebnis die kleinste Distanz von dem Punkt p zur Oberfläche S. Diese Distanz kann nun in einer drei-dimensionalen Distance-Map abgespeichert werden. Das genaue Vorgehen zur Erstellung einer Distance-Map wird im nächsten Kapitel erläutert. Mit Hilfe der in der Distance-Map abgespeicherten Distanzen können wir die Abtastung des Height-Fields optimieren. Dabei existiert ein Strahl mit einem Ausgangspunkt p 0 und einer normalisierten Richtung d. Nun kann der neue Punkt auf dem Strahl, an dem auch das Height-Field abgetastet werden muss, durch folgende Berechnung bestimmt werden: p 1 = p 0 + dist(p 0, S) d (5.4) Ausgehend von der Bedingung, dass p 0 außerhalb der Geometrie liegt, liegt auch p 1 außerhalb der Geometrie. Durch eine iterative Anwendung der Gleichung 5.4 und eine geeignete Anzahl der Iterationen kann der endgültige Schnittpunkt des Strahls mit der Geometrie bestimmt werden. Mit diesem genauen Schnittpunkt läßt sich die darzustellende Oberfläche viel genauer simulieren als es beispielsweise beim Parallax Mapping, welches nur eine Approximation des Schnittpunktes berechnet, der Fall ist. 30

31 5.4 Erstellung einer Distance-Map 5.4 Erstellung einer Distance-Map Die Berechnung der Distance-Map im 3D basiert auf dem 4SED Algorithmus von Danielsson [11] zur Berechnung einer 2D-Distance-Map. Dieser Algorithmus hat einen Aufwand von O(n), wobei n die Anzahl der Pixel in der 2D-Map ist. Um den Algorithmus im 3D nutzen zu können, wird er noch entsprechend erweitert D Height-Field 2D Distance Map Abbildung 5.7: Erstellung einer 2D-Distance-Map [4] Zunächst ist es erforderlich, die zu erstellende 3D-Distance-Map zu initialisieren. Die Initialisierung erfolgt in Abhängigkeit von dem gewählten Height-Field F. Die 3D- Distance-Map sei im folgenden mit D bezeichnet. Die 3D-Distance-Map wird nun in z-richtung durchlaufen. Ist der aktuelle z-wert kleiner als der Höhenwert, der in dem Height-Field eingetragen ist, so wird die Distance-Map an dieser Stelle mit 0 initialisiert. Die Höhenwerte des Height-Fields bilden so die zu simulierende strukturierte Oberfläche. Der Vorstellung nach befinden sich also alle Voxel, die einen kleineren z- Wert als den Höhenwert des Height-Fields an der entsprechenden Position haben, unterhalb der zu simulierenden strukturierten Oberfläche. Ihre Distanz ist somit immer 0. Ist der Höhenwert aus dem Height-Field jedoch größer als der z-wert an der aktuellen Position in der Distance-Map, so wird an dieser Stelle der Distance-Map zur Initialisierung eine maximale Distanz Z eingetragen. for a l l x for a l l y for a l l z D( x, y, z ) = ( 0, 0, 0 ) i f z <= F ( x, y ) D( x, y, z ) = (Z, Z, Z) i f z > F ( x, y ) Listing 5.1: Initialization [11] [4] Im Anschluß an die Initialisierung der notwendigen Bereiche mit der maximalen Distanz kann nun in einem ersten Scan-Schritt begonnen werden, die richtigen Distanzen von jedem Voxel in der 3D-Distance-Map zur simulierten Oberfläche zu berechnen. Das Verfahren prüft hierbei, wie weit jeder Voxel der Distance-Map, sowohl in x-, in y- als 31

32 5.4 Erstellung einer Distance-Map auch in z-richtung von der simulierten Oberfläche entfernt ist. Die berechneten Distanzen werden in jedem Voxel der Distance-Map für alle drei Richtungen eingetragen. Im folgenden Pseudo-Code sei die Breite des Height-Fields durch width und die Länge des Height-Fields durch height bezeichnet. Außerdem existiert eine wählbare Tiefe depth der Distance-Map. Ohne diesen selbst gewählten Tiefenwert würde automatisch eine Distance-Map angelegt, deren Tiefe dem maximal möglichen Höhenwert im Height-Field entspricht. Da das Height-Field im Prinzip ein Graustufenbild ist, wäre die übliche Tiefe der Distance-Map 255. Eine Distance-Map dieser Größe ist jedoch aufgrund des großen Speicherverbrauchs problematisch. Deshalb reduziert man die Tiefe, wobei sich der Wert 16 relativ gut eignet. for z =1,2,... depth for y =0,1,... height 1 D( x, y, z ) = min ( D( x, y, z ), D( x, y, z 1) + ( 0, 0, 1 ) ) for y = 1, 2,... height 1 for x = 0, 1,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x, y 1, z ) + ( 0, 1, 0 ) ) for x = 1, 2,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x 1, y, z ) + ( 1, 0, 0 ) ) for x = width 2, width 3,... 0 D( x, y, z ) = min ( D( x, y, z ), D( x +1, y, z ) + ( 1, 0, 0 ) ) for y = height 2, height 3,... 0 for x = 0, 1,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x, y+1, z ) + ( 0, 1, 0 ) ) for x = 1, 2,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x 1, y, z ) + ( 1, 0, 0 ) ) for x = width 2, width 3,... 0 D( x, y, z ) = min ( D( x, y, z ), D( x +1, y, z ) + ( 1, 0, 0 ) ) Listing 5.2: First Picture Scan [11] [4] Nach diesem ersten Durchlauf erhält man bereits Distanzen für jede der drei möglichen Richtungen. Allerdings stimmen diese Distanzen nur für die gerade gewählte z- Richtung. Um die vollständig richtigen Distanzen zu berechnen, muss die Distance- 32

33 5.4 Erstellung einer Distance-Map Map noch einmal in der anderen z-richtung durchlaufen werden. Dies geschieht im folgenden zweiten Scan-Schritt. for z=depth 2, depth 3,... 0 for y =0,1,... height 1 D( x, y, z ) = min ( D( x, y, z ), D( x, y, z +1) + ( 0, 0, 1 ) ) for y = 1, 2,... height 1 for x = 0, 1,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x, y 1, z ) + ( 0, 1, 0 ) ) for x = 1, 2,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x 1, y, z ) + ( 1, 0, 0 ) ) for x = width 2, width 3,... 0 D( x, y, z ) = min ( D( x, y, z ), D( x +1, y, z ) + ( 1, 0, 0 ) ) for y = height 2, height 3,... 0 for x = 0, 1,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x, y+1, z ) + ( 0, 1, 0 ) ) for x = 1, 2,... width 1 D( x, y, z ) = min ( D( x, y, z ), D( x 1, y, z ) + ( 1, 0, 0 ) ) for x = width 2, width 3,... 0 D( x, y, z ) = min ( D( x, y, z ), D( x +1, y, z ) + ( 1, 0, 0 ) ) Listing 5.3: Second Picture Scan [11] [4] for z = 0, 1,... depth for y = 0, 1,... height 1 for x = 0, 1,... width 1 value= length (D( x, y, z ) ) i f ( value > depth ) value = depth D( x, y, z ) = value Listing 5.4: Final Distance-Map [4] Für die Berechnung der Distance-Map mit Hilfe des Algorithmus war es notwendig jeweils drei Distanz-Werte in jedem Voxel zu speichern. So konnte konkret die jeweilige Distanz in x- in y- und in z-richtung ermittelt werden. Da der verwendete 33

34 5.5 Rendern des Bildes mit Per-Pixel Displacement Mapping Ansatz auf Sphere-Tracing beruht, reicht es für die finale 3D-Textur, in der die Distanz- Informationen gespeichert werden, nur einen Wert je Voxel abzuspeichern. Dieser Distanz-Wert entspricht dem Radius der Kugel von der aktuellen Position zum nächstgelegenen Punkt auf der zu simulierenden Oberfläche. 5.5 Rendern des Bildes mit Per-Pixel Displacement Mapping Der Vertex-Shader Der Vertex-Shader für das Displacement Mapping ist hauptsächlich für die Transformation bestimmter Vektoren in den Texture-Space zuständig. Anders als beim Normal Mapping wird beim Displacement Mapping zusätzlich zum Lichtvektor auch der Blickvektor in den Texture-Space konvertiert. Notwendig ist dies, weil der Blickvektor als Richtung des Strahls verwendet wird, welcher im Texture-Space zur Bestimmung des Schnittpunkts mit der Geometrie verwendet wird. Darüberhinaus wird ein Skalierungsfaktor s verwendet, welcher umgekehrt proportional zu der zu erwartenden Tiefe der Struktur ist. Somit kann die Stärke des Displacement-Effekts an die Größe der verwendeten zu texturierenden Fläche angepasst werden. Erreichen läßt sich dieser Effekt konkret durch Multiplikation der z-komponente des Blickvektors im Texture-Space mit dem genannten Faktor s Der Fragment-Shader Im Fragment-Shader wird als erstes die Richtung des Strahls, in diesem Fall des Blickvektors, normalisiert. Hierbei reicht eine einfache Normalisierung auf die Länge von eins jedoch noch nicht aus. Es ist zu beachten, dass die Abstände in der Distance-Map in Pixeln gespeichert werden, der Blickvektor jedoch in der Einheit von Texturkoordinaten angegeben ist. Üblicherweise hat man die Tiefe der Distance-Map auf einen niedrigeren Wert als die Breite und Höhe der Map beschränkt, zum Beispiel auf 16. So stellt man sicher, dass die Rechenzeit und der Speicherverbrauch nicht zu stark ansteigt. Gleichzeitig erhält man dadurch jedoch auch unterschiedliche Einheiten für den Blickvektor und die Distance-Map. Da der Blickvektor jedoch in einem späteren Ray- Marching Schritt zum Abtasten der Distance-Map zum Einsatz kommen soll, muss er in der Einheit der Distance-Map angegeben werden. Um dies zu erreichen, benötigt man den folgenden Normalisierungsfaktor: N ormalisierungsf aktor = depth/width depth/height 1 (5.5) Die verwendeten Größenangaben beziehen sich auf die Distance-Map. Durch Multiplikation des Normalisierungsfaktors mit dem Blickvektor erhält man einen Blickvektor, welcher in der Einheit der Distance-Map angegeben ist. Dieser Vektor kann nun für das folgende Ray-Marching verwendet werden. 34

35 5.5 Rendern des Bildes mit Per-Pixel Displacement Mapping Mit Hilfe des Ray-Marchings soll der Schnittpunkt des Blickvektors mit der zu simulierenden Geometrie gefunden werden. Zunächst wird die Distance-Map am Startpunkt des Strahls abgefragt. Der so erhaltene Wert, distance, ist der Abstand, in dem garantiert keine Schnittpunkte des Strahls mit der Geometrie vorliegen. Geht man den normalisierten Strahl, offset, um den angegeben Abstand entlang, so erhält man einen neuen Punkt außerhalb der Geometrie. Ausgehend von diesem Punkt kann das beschriebene Verfahren nun iterativ durchgeführt werden. Dabei nähert man sich in immer kürzer werdenden Intervallen dem Schnittpunkt des Strahls mit der Geometrie immer weiter an. Ist der Schnittpunkt gefunden, so konvergiert das Verfahren. Voraussetzung dafür ist die Wahl einer geeigneten Anzahl an Iterationen. for ( i n t i = 0 ; i < NUM ITERATIONS ; i ++) { f l o a t d i s t a n c e = f1tex3d ( distancetex, texcoord ) ; texcoord += d i s t a n c e o f f s e t ; } Listing 5.5: Ray-Marching [4] Mit den Texturkoordinaten des so gefundenen Schnittpunktes können wir die Normale aus der Normal-Map auslesen und zur Beleuchtung verwenden. In die Beleuchtungsberechnung wird auch ein Term für die Selbstverschattung mit einbezogen. Dieser Term besagt, ob das zu beleuchtende Fragment von einem anderen Teil der simulierten Geometrie verdeckt wird. Ist dies der Fall, so wird das Fragment entsprechend abgedunkelt Selbstverschattung Die Selbstverschattung ist eine geeignete Möglichkeit, den bereits erzielten Tiefeneindruck noch zu unterstützen und damit den allgemeinen Realitätsgrad der simulierten Oberfläche zu erhöhen. Das bisher vorgestellte Verfahren des Displacement Mappings läßt sich um eine Berechnung zur Erzeugung von Selbstverschattung ergänzen. In der Abbildung 5.8 wird das Verfahren der Selbstverschattung dargestellt. Die Idee der Selbstverschattung besteht darin, einen Test durchzuführen, der ergibt, ob der neu berechnete Punkt P auf der simulierten Oberfläche Licht von der Lichtquelle erhält oder im Schatten anderer simulierter Geometrie liegt. 35

36 5.5 Rendern des Bildes mit Per-Pixel Displacement Mapping Eye EVec Light Referenzoberfläche Height- Field P h Offset L L' LVec P' Abbildung 5.8: Selbstverschattung [14] Zur Durchführung dieses Test ist es erforderlich, den Lichtvektor auf Schnittpunkte mit der simulierten Geometrie zu testen. Dazu muss zunächst die Texturkoordinate für den Schnittpunkt L des Lichtvektors LV ec mit der originalen Geometrie bestimmt werden. Ähnlich wie beim Parallax Mapping kann diese Texturkoordinate durch Addition eines Offset-Vektors zur Texturkoordinate der aktuellen Position P in der simulierten Geometrie berechnet werden. Für diese Berechnung ist es erforderlich, die Länge von h zu kennen. h = 1 Z (5.6) Bei dem Wert Z handelt es sich hier um den z-wert der Texturkoordinate von P. Anschließend läßt sich der Offset berechnen: offset = h LV ec xy /LV ec z (5.7) Der Lichtvektor wird hierbei durch den LV ec angegeben. Es ist zu beachten, dass der Lichtvektor für alle Berechnungen unter Verwendung eines Normalisierungsfaktors in die Einheit der Textur konvertiert werden muss. Hierbei kann der gleiche Normalisierungsfaktor verwendet werden, der bereits zur Konvertierung des Blickvektors zum Einsatz kam. Die benötigte Texturkoordinate für den Schnittpunkt L kann nun wie folgt bestimmt werden: T L = T P x + offset x T P y + offset y 1 (5.8) Mit Hilfe der neu berechneten Texturkoordinate für den Punkt L und dem Lichtvektor LV ec kann nun ein weiterer Ray-Marching Schritt zur Bestimmung eines möglichen Schnittpunkts L mit der simulierten Geometrie ausgeführt werden. Existiert ein solcher Schnittpunkt L, so wird er mit dem Punkt P auf Gleichheit überprüft. Da es 36

37 5.5 Rendern des Bildes mit Per-Pixel Displacement Mapping immer zu einer gewissen Ungenauigkeit kommen kann, wird beim Test auf Gleichheit ein Epsilon-Faktor miteinbezogen. Für den Fall, dass P und L verschieden sind, liegt P im Schatten. Das entsprechende Fragment wird dann bei der Beleuchtung abgedunkelt. Liegt bei P und L jedoch Gleichheit vor, so befindet sich P nicht im Schatten und kann normal beleuchtet werden. [14] Filterung Bei der Mipmap-Filterung bzw. der anisotropen Filterung der Textur können bei Verwendung der neu berechneten Texturkoordinaten für die simulierte Geometrie Probleme auftreten. Die verschobenen Texturkoordinaten können Unstetigkeiten enthalten, welche aus Verdeckungen von simulierter Geometrie in der Textur resultiert. So werden zwei benachbarten Pixeln möglicherweise zwei weit voneinander entfernt liegende Bereiche aus der Textur zugeordnet. Aktiviert man Mipmapping oder anisotrope Filterung so benötigt die GPU Informationen über die Ableitungen der Texturkoordinaten. Normalerweise approximiert die GPU diese Ableitungen durch finite Differenzen. Da finite Differenzen bei Unstetigkeiten jedoch inkorrekte Werte der Ableitungen errechnen, ergibt sich daraus auch die Wahl eines falschen Mipmap-Levels. Somit können sichtbare Ränder im dargestellten Bild entstehen, wenn Unstetigkeiten in den Texturkoordinaten auftreten. Um diesen Effekt zu verhindern, berechnet man die Ableitungen mit Hilfe der unveränderten Texturkoordinaten. Möglich ist dieses Vorgehen, weil die veränderten Texturkoordinaten in der Theorie auch stetig sind. Lediglich bei unterschiedlichen Betrachtungswinkeln kann es zu Verdeckungen und somit zu Unstetigkeiten kommen. Darüberhinaus variieren die verschobenen Texturkoordinaten bezogen auf den theoretisch korrekten Fall in ähnlicher Weise zwischen zwei Pixeln wie es bei den originalen Texturkoordinaten auch der Fall ist. Mit Hilfe der Ableitungen der unveränderten Texturkoordinaten kann der Mipmap-Level beim Zugriff auf die Normal- und die Color- Map anschließend korrekt gewählt werden. Das funktioniert, da die Ableitungen der originalen Texturkoordinaten die Ableitungen der verschobenen Texturkoordinaten relativ gut annähern. Der Einsatz von Mipmapping bei einer Distance-Map erscheint als ungeeignet, da für einen entsprechend kleinen Mipmap-Level nur Mittelwerte in der Distance-Map gespeichert sind. Zur genauen Darstellung der zu simulierende Strukturen werden jedoch genaue Werte benötigt. Darüberhinaus kann es durch Unstetigkeiten in den veränderten Texturkoordinaten zur Wahl eines zu groben Mipmap-Levels kommen. Hieraus ergeben sich Probleme bei der Auswertung der Distance-Map. Aus diesen Gründen wird die Distance-Map ohne Mipmapping gefiltert. Hieraus entstehende Aliasing-Effekte sind allerdings nicht auf das Fehlen von Mipmapping zurückzuführen, da die Distanz- Werte nie direkt visualisiert werden, sondern nur bei der Generierung der verschobenen Texturkoordinaten zum Einsatz kommen. [4] Zum Vergleich der unterschiedlichen Filterungsmöglichkeiten für ein mit Displacement Mapping dargestelltes Objekt werden hier drei Abbildungen gezeigt. Bei allen 37

38 5.5 Rendern des Bildes mit Per-Pixel Displacement Mapping drei Bildern wird eine sehr klein strukturierte Farbtextur verwendet. Das erste Bild 5.9 wurde ohne Mipmapping und anisotrope Filterung erstellt. Deutlich sind bei dem hieraus entstandenen Bild die Artefakte zu erkennen, sobald das entsprechende Objekt sich weiter vom Betrachter entfernt. Abbildung 5.9: Ohne Filterung (a) Mit GPU-Ableitung (b) Mit eigener Ableitung Abbildung 5.10: Mipmapping und Anisotrope Filterung 38

39 5.6 Anwendung von Per-Pixel Displacement Mapping Zur Erstellung des zweiten Bildes 5.10 kamen Mipmapping sowie anisotrope Filterung zum Einsatz. Allerdings wurde zur Wahl des Mipmap-Levels die intern von der GPU berechnete Ableitung gewählt. Bei dem Ergebnisbild läßt sich gut erkennen, dass der Mipmap-Level an denjenigen Stellen, an welchen die Distance-Map flach ist, korrekt gewählt wurde, so dass keine Artefakte auftreten. Im Gegensatz dazu sind jedoch an den durch Displacement Mapping veränderten Bereichen deutliche Artefakte zu erkennen. Die Ursache dieser Artefakte ist durch die Unstetigkeiten in den durch Displacement Mapping veränderten Texturkoordinaten, welche zur internen Berechnung der Ableitung durch die GPU verwendet werden, und dem daraus resultierenden falsch gewähltem Mipmap-Level zu erklären. Bei der dritten Abbildung 5.10 hingegen wurden zur Wahl des Mipmap-Levels die eigenen mit Hilfe der unveränderten Texturkoordinaten berechneten Ableitungen eingesetzt. Auf diesem Bild sind nun keine Artefakte durch Schwierigkeiten beim Mipmapping oder der anisotropen Filterung mehr zu erkennen. 5.6 Anwendung von Per-Pixel Displacement Mapping Das Verfahren des Per-Pixel Displacement Mappings ermöglicht im Vergleich zu Bump Mapping und Parallax Mapping eine deutlich verbesserte Darstellung der einzelnen Strukturen. Da es sich bei der Technik des Per-Pixel Displacement Mappings nicht, wie bei Parallax Mapping, um eine Approximation handelt, lassen sich mit diesem Verfahren auch hochfrequente Strukturen mit hoher Amplitude darstellen. Darüberhinaus erzielt Displacement Mapping auch für flachere Betrachtungswinkel noch einen höheren Realitätsgrad als beispielsweise Parallax Mapping. Die Möglichkeit, Selbstverdeckung und - verschattung darzustellen, ist hierbei sicherlich ein wichtiger Faktor. Somit läßt sich mit Per-Pixel Displacement Mapping eine Struktur ideal simulieren. Eingeschränkt wird die Qualität der Darstellung jedoch dadurch, dass der Algorithmus des Per-Pixel Displacement Mappings keine Darstellung von Silhouetten ermöglicht. Außerdem ist dieser Algorithmus für planare Fläche konzipiert, weshalb es zu Verzerrungen kommen kann, wenn das Verfahren auf Oberflächen mit einer hohen Krümmung angewandt wird. [4] Die Abbildung 5.11 zeigt die Anwendung von Displacement Mapping auf die bereits bekannte Steinstruktur. Zur Demonstration von Displacement Mapping bei schwierigeren Fällen, in denen Techniken wie Bump Mapping oder Parallax Mapping schon erhebliche Defizite aufweisen, dient die Abbildung 5.12, welche den Einsatz von Displacement Mapping zur Visualisierung von Text zeigt. 39

40 5.6 Anwendung von Per-Pixel Displacement Mapping Abbildung 5.11: Ergebnis des Displacement Mappings: Steine Abbildung 5.12: Ergebnis des Displacement Mappings: Text 40

41 6 Die Beispielszene 6.1 Modellierung der Szene Eine geeignete Beispielszene zur Demonstration und zum Vergleich von Bump Mapping, Parallax Mapping und Displacement Mapping wurde mit Hilfe der Software Maya erstellt. Bei Maya, entwickelt von der Firma Alias, handelt es sich um eine 3D Modellierungs- und Animationssoftware, die unter anderem in der Filmindustrie und in der Computerspieleindustrie eingesetzt wird. Abbildung 6.1: Modellierte Beispielszene Die Szene wurde komplett aus Polygonen erstellt. Da der verwendete Ansatz des Displacement Mappings am besten für planare Flächen angewandt werden kann, wurde weitestgehend auf gekrümmte Oberflächen für Displacement Mapping Objekte verzichtet. Modelliert wurde ein Innenhof. Hierbei bieten sich vielfältige Möglichkeiten zur Anwendung von Displacement Mapping. Die Wände sowie der Fußboden, welche jeweils durch eine einflache Plane realisiert wurden, lassen sich mit dem Verfahren des Displacement Mappings mit unterschiedlichen Steinstrukturen versehen. Da die einzel- 41

42 6.2 VRML nen Steine nicht ausmodelliert werden müssen, wird die Anzahl der Dreiecke deutlich reduziert. Auch läßt sich mit Hilfe des Displacement Mappings ein besserer Tiefeneffekt bei den Steinstrukturen erzielen, als es zum Beispiel mit Bump Mapping möglich ist. Darüberhinaus finden sich Anwendungsmöglichkeiten für Displacement Mapping bei der Tür, welche ebenfalls nur aus einer einfachen Plane modelliert ist und sich mit Hilfe von Displacement Mapping mit Strukturen versehen läßt. Die Darstellung von Text wird in dieser Szene anhand eines Schildes demonstriert. Da das Verfahren des Per-Pixel Displacement Mappings keine Darstellung von Silhouetten ermöglicht, musste bei der Modellierung auf eine geeignete Wahl der Geometrie geachtet werden. Für einen realistischeren Eindruck war es erforderlich die Randbereiche der einzelnen Flächen, auf welche Displacement Mapping angewandt wurde, zu verdecken. Hierzu bot sich weitere Geometrie an. Am Beispiel der einzelnen Wände dienen größere Steine an den Kanten der Flächen zur Verdeckung der Randbereiche. Im Anschluss an die Modellierung wurde die Szene entsprechend texturiert. In einem abschließenden Schritt konnten zur Beleuchtung der Szene nun Lichtquellen wie Directional Light, Spot Light und Point Light gesetzt werden. Die Abbildung 6.1 zeigt die modellierte Szene ohne Anwendung von Shadern. Die Darstellung der Szene unter Verwendung von Shadern wird dagegen im Kapitel 7 gezeigt. 6.2 VRML Im Anschluß an die Modellierung muß die erstellte Szene in das eigene Demonstrations- Programm importiert werden. Zum Austausch der Daten bietet sich das VRML-Dateiformat 1 an. VRML ist ein Standard zur Beschreibung von 3D-Szenen und wurde ursprünglich für die Nutzung im Internet entwickelt. Im Jahr 1994 wurde die erste Version von VRML auf der Basis des Open Inventor Dateiformats von Silicon Graphics (SGI) entwickelt. Mit VRML 1.0 lassen sich statische 3D-Szenen beschreiben. Animationen der Objekte oder umfassende Möglichkeiten zur Interaktion wurden in dieser Version noch nicht zur Verfügung gestellt. Eine Verbesserung stellt hier die Version VRML 2.0 dar, welche 1996 auf der SIGGRAPH vorgestellt wurde. Im Jahr 1997 wurde VRML 2.0 als VRML97-ISO Standard festgeschrieben. VRML 2.0 basiert auf der Sprache Moving Worlds von Silicon Graphics. Im Gegensatz zu VRML 1.0 werden in dieser Version auch Möglichkeiten zur Animation und zur Interaktion mit den Objekten zu Verfügung gestellt. Der Nutzer hat nun die Möglichkeit, in einer VRML-Datei einzelnen Objekte anzuklicken und somit festgelegte Aktionen auszulösen oder in andere VRML-Welten zu gelangen. Da viele 3D-Modellierungstools auch Möglichkeiten zum Import und Export von VRML-Szenen bereitstellen, kann VRML auch zum Austausch von Daten zwischen den einzelnen Anwendungen genutzt werden. Dabei bietet das Format unter anderem Möglichkeiten um Objekte, Transformationen und Hierarchien, Lichtquellen, Materialien und Texturen zu beschreiben. [7] 1 Virtual Reality Modeling Language 42

43 6.2 VRML Maya stellt einen integrierten VRML-Exporter zur Verfügung. Zum Import der Daten wurde ein eigener VRML Importer implementiert. Der Importer verfügt über Funktionen zum Import der Punkte, Normalen und Texturkoordinaten der Objekte. Darüberhinaus ist der Import der verwendeten Materialien, Lichtquellen sowie der verwendeten Farbtextur möglich. Auch die Hierarchie der modellierten Objekte mit den Transformationen läßt sich importieren. Eine explizite Unterstützung von Shadern ist in VRML nicht integriert. Aus diesem Grund mussten die verwendeten Shader für die modellierte Szene auf anderem Wege in die VRML-Datei integriert werden. Hierzu bot der Materialname eine geeignete Möglichkeit. So wird bei der Erstellung des Materials in Maya der Name des verwendeten Shaders in den Materialnamen des Objektes integriert. Im Demonstrations- Programm werden mit Hilfe dieser Information der entsprechende Shader angebunden und die eingelesenen Materialeigenschaften verwendet. 43

44 7 Ergebnisse Beim Rendern der modellierten Beispielszene 7.1 kommen die bereits vorgestellten Shader für Bump Mapping, Parallax Mapping sowie Displacement Mapping zum Einsatz. Zum Vergleich der einzelnen Shader wurde die Szene zunächst nur mit Bump Mapping gerendert. Beim zweiten Rendering der Szene wurde sowohl Bump Mapping als auch Parallax Mapping zur Verbesserung der Oberflächenstruktur der Objekte verwendet. Im dritten Test hingegen wurden Bump Mapping und Displacement Mapping eingesetzt. Abbildung 7.1: Gerenderte Beispielszene Wie bereits in den Abschnitten 3.5, 4.3 und 5.6 beschrieben, lassen sich deutliche Unterschiede in der Darstellungsqualität der einzelnen Verfahren erkennen. Durch den Einsatz von Bump Mapping läßt sich die Darstellung der Oberflächenstruktur im Vergleich zum normalen Texture Mapping verbessern, jedoch ist diese Technik hauptsächlich zur Simulation feiner Strukturen geeignet. Zur Simulation gröberer Strukturen, wie zum Beispiel den Steinen der Wand oder des Bodens in Abbildung 7.2, erscheint diese Technik als weniger geeignet, da hier keine deutliche Verbesserung der Oberflächenstruktur beobachtet werden kann. 44

45 7 Ergebnisse (a) Bump Mapping (b) Parallax Mapping (c) Displacement Mapping Abbildung 7.2: Vergleich der verschiedenen Verfahren 45

46 7 Ergebnisse Die entsprechenden Strukturen wirken unter Bump Mapping relativ flach. Außerdem beinhaltet das Verfahren keine Selbstverdeckung und Selbstverschattung der simulierten Strukturen. Parallax Mapping stellt hier eine Verbesserung bei der Simulation gröberer Oberflächenstrukturen im Vergleich zum Bump Mapping dar. Diese Technik berücksichtigt die Parallaxe und ermöglicht so einen besseren Tiefeneindruck. Allerdings eignet sich dieses Verfahren, ebenso wie Bump Mapping, nicht zur Betrachtung der entsprechenden Objekte aus einem flachen Winkel. Darüberhinaus stellt auch diese Technik keine Selbstverdeckung und Selbstverschattung zur Verfügung. Die Probleme von Bump Mapping und Parallax Mapping bei der Simulation gröberer Oberflächenstrukturen lassen sich durch Einsatz des Displacement Mapping Verfahrens vermeiden. Mit Hilfe von Displacement Mapping sind selbst hochfrequente Strukturen mit hoher Amplitude gut darstellbar. Sogar aus einem relativ flachen Betrachtungswinkel sind die Strukturen noch gut zu erkennen. Außerdem ermöglicht diese Technik die Selbstverdeckung und Selbstverschattung der simulierten Strukturen. Hierdurch gewinnt der Betrachter einen realistischeren Eindruck von der Oberflächenstruktur. Anhand einzelner Ausschnitte der Szene lassen sich die Unterschiede zwischen den einzelnen Verfahren gut erkennen. So ist bei der Darstellung der Wand in Abbildung 7.2 mit Hilfe von Bump Mapping aus einem flachen Betrachtungswinkel keine deutliche Struktur zu sehen. Dennoch eignet sich Bump Mapping in diesem Beispiel zur Simulation der feineren Strukturen, wie es zum Beispiel an der Steinstruktur am Steinbogen des Kellerfensters deutlich wird. Die Darstellung der gröberen Strukturen hingegen kann durch den Einsatz von Parallax Mapping leicht verbessert werden. Erst mit Displacement Mapping jedoch sind die groben Steinstrukturen, sowie die Struktur der Metallplatte und des Kellerfensters deutlich zu erkennen. Anhand von weiteren Beispielen sind die verschiedenen Einsatzmöglichkeiten des Displacement Mappings zu erkennen. So lassen sich neben den Strukturen der Wand und des Bodens auch die Strukturen des Fensters, der Fensterläden und der Metallplatte, Abbildung 7.3, gut darstellen. Selbst Text, wie in Abbildung 7.3 gezeigt, stellt kein Problem für Displacement Mapping dar. 46

47 7 Ergebnisse (a) Fenster (b) Schild (c) Metallplatte Abbildung 7.3: Ergebnisse des Displacement Mappings im Detail 47

48 7 Ergebnisse Der vorgestellte Algorithmus des Per-Pixel Displacement Mappings bringt jedoch auch einige Probleme bei der Darstellung von Objekten in einer Szene mit sich. Das Hauptproblem ist sicherlich das Fehlen der Silhouetten. An den Kanten eines Objektes wird somit deutlich, dass es sich bei diesem Verfahren nur um eine Simulation handelt. Diesem Problem kann jedoch durch eine geeignete Modellierung der Szene begegnet werden. Dazu müssen sämtliche Kanten derjenigen Objekte, bei denen Displacement Mapping zum Einsatz kommt, durch andere Objekte verdeckt werden. Dies geschieht in der vorgestellten Szene zum Beispiel durch die Steinbalken in den Ecken zwischen den einzelnen Steinwänden. Abbildung 7.4: Gullideckel Ein weiteres Problem beim Einsatz von Displacement Mapping in Kombination mit mehreren Objekten läßt sich am Beispiel der Abbildung 7.4 beobachten. Hier sieht es so aus, als würde der Gullideckel über dem Boden, welcher mit Displacement Mapping dargestellt wird, schweben. Dieses Problem ergibt sich aus der Berechnung des Displacement Mappings. Die Ausgangsfläche, in diesem Fall eine einfache Fläche für den Boden, wird als Referenzoberfläche für das Displacement Mapping angesehen. Unter die Referenzoberfläche wird das Heightfield gelegt. Bei der anschließenden Berechnung zur Simulation der Strukturen mit Hilfe von Sphere Tracing wird vorausgesetzt, dass der höchste Punkt der jeweiligen Struktur stets auf der Höhe der Referenzoberfläche liegt. Alle anderen Strukturmerkmale liegen unterhalb dieser Referenzoberfläche. Somit entsteht der Eindruck, als würde ein Objekt, welches sich über einem mit Displacement Mapping dargestelltem Objekt befindet, über diesem schweben. Zur Lösung dieses Problems müssten sämtliche Displacement Objekte, sobald sie von einem anderen Objekt überlagert werden, an den Schnittkanten zu diesem Objekt den höchstmöglichen Wert in dem Height-Field aufweisen. Zur Texturierung einer Szene werden je- 48