Advanced Realtime Raytracing:...

2011

Matthias Winkler

Fakultät für Informatik und Mathematik

30.06.2011

Advanced Realtime Raytracing: Beschleunigunsstrukturen

Hauptseminar in Computergrafik und

Bildverarbeitung Sommersemester 2011

Betreut durch Herrn Prof. Dr. Alfred Nischwitz

Matthias Winkler Seite 2

1 EINLEITUNG 4

1.1 MOTIVATION 4

1.2 AUFBAU DER ARBEIT 4

2 GRUNDLAGEN 5

2.1 RAYTRACING 5

2.2 AUFWAND VON RAYTRACING 7

2.3 BESCHLEUNIGUNGSSTRUKTUREN 8

2.4 BOUNDING VOLUME HIERARCHIE 8

2.5 KD-BAUM 9

2.6 KONSTRUKTION VON KD-BÄUMEN UND BVHS 10

2.7 MEDIAN CUT 11

2.8 SURFACE AREA HEURISTIC 12

2.9 KD-BAUM VS. BVH 13

DIE NEUESTEN ENTWICKLUNGEN IM BEREICH DER BESCHLEUNIGUNGSSTRUKTUREN 15

3 LBVH – LINEARE BOUNDING VOLUME HIERARCHIE 16

3.1 PARALLELE KONSTRUKTION EINES SAH-BVH 19

3.2 DAS HYBRIDE GPU KONSTRUKTIONSVERFAHREN 21

4 HLBVH – HIERARCHICAL BVH 22

4.1 ZWEISTUFIGES SORTIERVERFAHREN 22

4.2 VERBESSERUNG DER BAUM-KONSTRUKTION 25

4.3 SAH OPTIMIERTER HLBVH 27

5 PARALLELE SAH K-D-TREE KONSTRUKTION 29

5.1 DER NESTED PARALLELE ALGORITHMUS 29

5.2 DER IN-PLACE ALGORITHMUS 32

5.3 VERGLEICH ZWISCHEN NESTED UND IN-PLACE ALGORITHMUS 35

6 OPTIX – RAYTRACING ENGINE VON NVIDIA 38

6.1 KONZEPT DER OPTIX ENGINE 38

6.2 BESCHLEUNIGUNGSSTRUKTUREN IN OPTIX 42

7 FAZIT 44

8 ABBILDUNGSVERZEICHNIS 45

9 LITERATURVERZEICHNIS 46


1 Einleitung

1.1 Motivation

Seit den 60er Jahren wird der Raytracing Algorithmus in der Computergrafik benutzt. Zu

Beginn um Verdeckungen zu berechnen, später - ab den 80er Jahren - um globale

Beleuchtungsmodelle zu verwirklichen. Trotz der langen Beständigkeit dieses

Algorithmus kann dieser erst seit wenigen Jahren effizient in der Echtzeit-

Computergrafik genutzt werden. Das Raytracing ermöglicht eine Kalkulation von

Lichteigenschaften die sehr nahe an den physikalischen Grundgesetzen der Natur

abgeleitet sind. Diese Eigenschaft ermöglicht die Berechnung von realitätsnahen

Beleuchtungskonzepten.

1.2 Aufbau der Arbeit

In dieser Arbeit möchte ich die Grundlagen des Raytracing zur Realisierung von globaler

Beleuchtung kurz erläutern. Es soll dargestellt werden wieso diese Berechnung so

aufwändig ist und deshalb so schwer in der Echtzeit-Computergrafik zu nutzen ist.

Beschleunigungsstrukturen sollen die Echtzeitfähigkeit von Raytracing ermöglichen.

Diese Arbeit soll die Grundlagen dieser Beschleunigungsstrukturen erklären und im

Hauptteil die neuesten Errungenschaften in diesem Gebiet ebenfalls erläutern. Um den

Bezug zur Praxis nicht zu verlieren, beschäftigte ich mich mit der zurzeit am weit

entwickeltsten Engine für Raytracing – OptiX. OptiX ist ein von NVIDIA generiertes

Framework, das Entwicklern ermöglicht neue Raytracing Programme so einfach wie

möglich zu entwickeln.


2 Grundlagen

Im folgenden Kapitel werden die Grundlagen für Raytracing und für

Beschleunigungsstrukturen erläutert.

2.1 Raytracing

Die Grundidee des Raytracing Algorithmus also dem Verfahren der Strahlverfolgung

existiert schon seit hunderten von Jahren. Ein Holzschnitt von Albrecht Dürrer von 1525

(Abbildung 1) zeigt wie schon zur damaligen Zeit Handwerker die Idee der

Strahlverfolgung einsetzten um Gegenstände zu zeichnen. In der Computergrafik

nutzten in den 60er Jahren die ersten Entwickler diesen Algorithmus um

Verdeckungsberechnungen zu realisieren.

Abbildung 1: Holzschnitt von Albrecht Dürrer 1525 – Quelle: wikipedia.org


Ende der 70er Jahre entwickelte Turner Whitted (Whitted, 1979) einen neuen auf dem

Raytracing basierenden Algorithmus, um globale Beleuchtungsberechnungen

durchführen zu können. Dieses Verfahren ist heute noch als rekursives Raytracing

bekannt und im Einsatz.

Die Funktionsweise ist recht simpel. Durch jedes Pixel des darzustellenden Bildbereichs

wird ein sogenannter Primärstrahl vom virtuellen Augpunkt aus losgeschickt. Trifft ein

Primärstrahl ein Objekt, so werden von ihm aus je nach Materialart des Objektes neue

Strahlen weitergeschickt. Die ersten Strahlen, die sogenannten Schattenstrahlen (in

Abbildung 2 mit einem I gekennzeichnet) reflektieren direkt zur Lichtquelle und

„fühlen“ ob diese von einem anderen Objekt verdeckt wird. Somit kann eine

Schattenberechnung durchgeführt werden. Zusätzlich werden je nach Art der

Oberfläche ein Reflexionsstrahl (gekennzeichnet mit r in Abbildung 2) und/oder ein

Brechungsstrahl (gekennzeichnet mit t in Abbildung 2) zurück in die Szene geschickt.

Diese Strahlen werden Sekundärstrahlen genannt. Treffen diese Strahlen auf ein Objekt,

können sie wiederum je nach Rekursionstiefe weitere Sekundärstrahlen generieren. So

kann ermittelt werden ob ein Objekt in einem anderen spiegelt oder hindurch scheint.

Mit dieser Vorgehensweise kann eine genaue Eigenschaft für jedes Bildpixel gefunden

werden.


Abbildung 2: Konzept des rekursiven Raytracing - Quelle: Prof. Dr. Alfred Nischwitz - Master Vorlesung Computergrafik - Sommersemester 2010

2.2 Aufwand von Raytracing

Das rekursive Raytracing nach Whitted (Whitted, 1979) wird seit knapp drei Jahrzenten

in der Computergrafik angewendet und doch kann es im Gebiet der Echtzeit-

Computergrafik erst seit wenigen Jahren produktiv genutzt werden. Der hohe

Rechenaufwand, der durch das Verfahren entsteht, kann nur durch immer neuere

zusätzliche Techniken und dem rasanten Anstieg der Rechenleistung bewältigt werden.

Bei einer heute üblichen Bildschirmauflösung von 1920x1080 werden über zwei

Millionen Bildpunkte durch das Verfahren berechnet. Durch jeden dieser Bildpunkte

wird ein sogenannter Primärstrahl in die Szene geschickt. Trifft dieser Primärstrahl ein

Objekt der Szene werden weitere Strahlen erzeugt, die wiederum weitere Strahlen je

nach Rekursionstiefe erzeugen können. So kann es schon bei geringer Rekursionstiefe zu

einer extrem hohen Anzahl an erzeugten Strahlen kommen. Bei zwei Millionen

Bildpunkten sind 20 Millionen Strahlen und mehr keine Seltenheit. Diese Strahlen

müssen alle auf eine mögliche Kollision mit den Objekten der Szene getestet werden.


Das bedeutet, jeder ausgesendete Strahl muss mit jedem Grafikprimitiv der Szene auf

eine Kollision hin geprüft werden. Bei einer durchschnittlichen Szene mit 500 000

Grafikprimitiven müssen also ca. 10 Billionen Schnittpunkttests durchgeführt werden.

Da in der Echtzeit-Computergrafik mehrere Bilder pro Sekunde gewährleistet werden

müssen, ist die Verwendung dieses klassischen Ansatzes nicht vorstellbar. Deshalb

werden auch schon seit Jahrzenten sogenannte Beschleunigungsstrukturen entwickelt.

2.3 Beschleunigungsstrukturen

Die effektivste Lösung um das Raytracing Verfahren zu beschleunigen besteht in der

starken Reduzierung der benötigten Schnittpunkttests. Ein ausgesendeter Strahl wird in

der Regel nur einen sehr kleinen Teil der Szeneobjekte schneiden. Die Idee ist es, durch

eine strukturierte Einteilung der Szene eine Vorauswahl der Primitive zu treffen, welche

nicht von dem Strahl geschnitten werden können. Ist die Einteilung qualitativ

hochwertig, muss nur noch ein Bruchteil der Schnittpunkttests zwischen Grafikprimitiv

und Strahl durchgeführt werden. Im Bereich des Raytracing Verfahrens haben sich in

den letzten Jahren zwei grundlegende Beschleunigungsstrukturen durchgesetzt, die ich

im Folgenden genauer erörtern will.

2.4 Bounding Volume Hierarchie

Um den Schnittpunkttest zu vereinfachen, werden oft komplexe Szenenobjekte in

sogenannte „Bounding Volumes“ oder Hüllvolumen eingebettet. Diese Hüllvolumen

haben im Gegensatz zu den eingebetteten Szenenobjekten eine recht einfache Form. Ein

Schnittpunkttest mit diesem Hüllvolumen ist in der Regel deutlich einfacher und

schneller durchzuführen als mit dem Szeneobjekt. Wird das Hüllvolumen nicht

geschnitten, so ist auch keine Berechnung mit dem eigentlichen Szeneobjekt nötig.


Die Grundidee von „Bounding Volume Hierarchies“ ist es nun diese Hüllvolumen in

weitere Hüllvolumen zu gruppieren, um eine Hierarchische Anordnung der Szene zu

bekommen, wie in der Abbildung 3 zu sehen ist.

Abbildung 3: Aufteilung der Objekte einer 2-dimensionalen Szene in eine Bounding Volume Hierarchie

2.5 KD-Baum

Der k-dimensionale Baum ist ein Suchbaum mit k Dimensionen. Der KD-Baum unterteilt

den Szenen-Raum in mehrere Ebenen. Die Knoten des Baumes enthalten die

Unterteilungskriterien und die Blätter die Grafikprimitive der Szene. In der Abbildung 4

ist die Unterteilung einer Punktmenge einer 2-dimensionalen Ebene durch einen KD-

Baum dargestellt. Die Punkte stellen die Grafikprimitive da, welche sich durch ihre

Koordinaten ausgedrückt in den Blättern des KD-Baums wieder finden lassen.


Abbildung 4: Einteilung einer Punktemenge im 2-dimensionalen Raum in einen KD-Baum - Die Knoten des Baumes geben die Schnittkanten an. Die Blätter beinhalten die Punkt-Koordinaten

-- Quelle: wikipedia.org

2.6 Konstruktion von KD-Bäumen und BVHs

Für die Einteilung einer Szene in eine Bounding Volume Hierarchie oder in einen KD-

Baum wurden in den letzten Jahren die verschiedensten Algorithmen entwickelt. Es gibt

zwei Hauptkriterien mit denen diese Algorithmen gemessen werden. Die aktuellen

Entwicklungen zeigen, dass diese oft schlecht miteinander vereinbart werden können.

Das erste wichtige Kriterium ist die Geschwindigkeit des Konstruktionsverfahrens. Je


schneller die Szene strukturiert wird, umso früher kann mit dem eigentlichen Raytracing

begonnen werden. Doch auch die Qualität der Strukturierung spielt eine große Rolle. Je

besser die Beschleunigungsstruktur, desto schneller kann der Baum traversiert und

umso mehr Schnittpunkttests können vermieden werden. In den letzten Jahren haben

sich zwei Standards hervorgehoben, die jeweils die Vorzüge eines Hauptkriteriums

nahezu perfekt verwirklichen.

2.7 Median Cut

Das zu den schnellsten und auch einfachsten zählende Verfahren ist der sogenannte

Median Cut Algorithmus. Wie der Name schon verrät wird bei diesem Algorithmus keine

qualitativen Berechnungen zur Unterteilung der Szene durchgeführt, sondern ein

Mittelschnitt pro Unterteilung ausgeführt.

Beim KD-Baum wird unterschieden zwischen dem räumlichen Median Cut und dem

elementaren Median Cut. Der räumliche Median Cut unterteilt die Szene immer in gleich

große räumliche Gruppen. Dagegen setzt der elementare die Unterteilungen so, dass

pro Unterteilung gleich viele Elemente pro Untergruppe vorhanden sind. In Abbildung 5

und Abbildung 6 sind diese zwei Möglichkeiten der Unterteilung zu sehen. Auch beim

Aufbau eines BVH werden keine räumlichen Zusammenhänge zwischen den Primitiven

beachtet, sondern eine mediale Aufteilung der Elemente vorgenommen.


Abbildung 5: Räumlicher Median Cut

Abbildung 6: Objektbezogener Median Cut

2.8 Surface Area Heuristic

Da im vorherig beschriebenen Median Cut Algorithmus keine räumlichen Beziehungen

zwischen den einzelnen Grafikprimitiven beachtet werden, kann die Qualität der

Beschleunigungsstruktur stark gemindert sein und eine Traversierung des Graphen eine


zeitliche Schwachstelle darstellen. Die Surface Area Heuristic soll diesen Schwachpunkt

der mangelnden Qualität einer Beschleunigungsstruktur beheben. Eine Kostenfunktion

soll die erwarteten Kosten eines Strahltests auf beide Hälften gleichmäßig verteilen. Wie

in Abbildung 5 zu sehen, ist bei dieser mittigen Einteilung der Szene die

Wahrscheinlichkeit, dass ein Strahl links oder rechts schneidet gleich. Doch die

erwarteten Kosten für die linke oder die rechte Gruppierung sind sehr unterschiedlich.

Bei der elementaren mittigen Einteilung, welche in Abbildung 6 abgebildet ist, sind die

zu erwarteten Kosten auf beiden Seiten gleich, doch die Wahrscheinlichkeit, dass ein

Strahl links oder rechts durchgeht sehr verschieden. Das Prinzip der Surface Area

Heuristic ist es nun für alle drei Achsen die Splitposition zu finden, bei der die

Gesamtheit der Kosten und der Trefferwahrscheinlichkeit so gering wie möglich ist. Die

Minimierung der folgenden Gleichung ist das Ziel der Surface Area Heuristic. Eine

mögliche Lösung unseres Problems ist in Abbildung 7 zu sehen.

Formel 1: Zu minimierende Kostengleichung der Surface Area Heuristic

C(Übergruppe) = Fläche(Untergruppe1) x Anzahl der Primitive(U1)

+ Fläche(Untergruppe2) x Anzahl der Primitive(U2)

2.9 KD-Baum vs. BVH

Der BVH und der KD-Baum können beide mit dem Prinzip des Median-Cut, wie auch der

Surface Area Heuristic konstruiert werden. Der Vorteil des BVH gegenüber dem KD-

Baum ist die schnellere Konstruktionszeit, die Einteilung in gruppierte Hüllvolumen geht

schneller als die Unterteilung einer kompletten Szene. Dagegen kann der KD-Baum

schneller traversiert werden da eine Schnittpunktberechnung mit einer Ebene nicht so

kostenaufwändig wie mit einem Hüllvolumen ist.


Abbildung 7: Verbesserte Einteilung der Szene


Die neuesten Entwicklungen im Bereich

der Beschleunigungsstrukturen

Der Hauptgedanke dieser Arbeit ist die Analyse der neusten Forschungsergebnisse im

Bereich der Beschleunigungsstrukturen. Um Raytracing in der Echtzeitgrafik zu

etablieren wird nach immer effizienteren Konstruktionsmethoden geforscht. Im Bereich

der Prozessor Entwicklung gab es in den letzten Jahren einen starken Trend zur

Multicore Architektur. So sind auch die aktuellen Forschungen im Bereich der

Beschleunigungsstrukturen stark damit beschäftigt diese parallelen Eigenschaften der

CPUs und GPUs besser nutzen zu können. Sequentielle Konstruktionsverfahren können

die Vorteile der heutigen Hardwareentwicklung nicht effektiv nutzen. Im Folgenden

möchte ich auf drei zurzeit bedeutende Forschungsarbeiten im Bereich der parallelen

Konstruktion von Beschleunigungsstrukturen eingehen.


3 LBVH – Lineare Bounding Volume Hierarchie

Seit einigen Jahren suchen Forscher und Entwickler nach einer Lösung die Konstruktion

von BVHs zu parallelisieren. Den bisher bedeutendsten Durchbruch schafften

Lauterbach et al. (Lauterbach, et al., 2009) mit der Entwicklung des „Lineare Bounding

Volume Hierarchie“.

Das Grundprinzip dieses Verfahrens ist es, die räumliche Lage der Szenenobjekte zu

linearisieren und dadurch den Konstruktionsprozess zu einem Sortierproblem zu

reduzieren.

Für den ersten Schritt der Linearisierung der Szene nutzen Lauterbach et al. das

Morton-Code Verfahren, auch als Z-Order Algorithmus bekannt. Der Z-Order

Algorithmus unterteilt eine Fläche oder einen Raum bezüglich der räumlichen

Abhängigkeit. In Abbildung 8 sieht man wie die Z-Order Kurve der Ordnung zwei, die

Fläche unterteilt.


Abbildung 8: Der Morton-Code Algorithmus der Ordnung 2 - Quelle: (Lauterbach, et al., 2009)

In Abbildung 9 wird der Aufbau dieser Unterteilung skizziert. Die Unterteilungen der

ersten Ordnung, also die Einteilung der Gesamtfläche in vier Unterflächen, werden

durch die ersten beiden Bits eines Morton-Codes dargestellt. Die weitere Unterteilung

dieser Flächen wird durch die beiden folgenden Bits abgebildet. Für die Unterteilung

eines Raumes werden pro Ebene drei Bits benötigt. Für eine Unterteilung der Ordnung

zehn benötigt der Morton-Code also eine Bitlänge von 30.


Abbildung 9: Skizze der Z-Order Unterteilung - Quelle: wikipedia.org

Ziel dieser Unterteilung ist es die Schwerpunkte der einzelnen Grafikobjekte nicht

anhand ihrer Lage im Koordinatensystem zu unterscheiden, sondern durch ihren

Morton-Code. Durch diese Quantifizierung kann die räumliche Lage der Szeneobjekte

durch eine lineare Abfolge von Morton-Codes beschrieben werden.

Im nächsten Schritt müssen die Objekte anhand ihres Morton-Codes sortiert werden.

Dies wird durch eine parallele Sortierung mit Hilfe des Radixsort Sortieralgorithmus

realisiert. Die Einteilung in einen BVH kann damit sehr einfach gestaltet werden. Der

Konstruktionsalgorithmus inspiziert die Bitfolge zweier aufeinander folgenden Objekte

beginnend beim höchstens Bit b1 bis zum Bit bx, an dem sich die beiden Objekte

unterscheiden. Diese Unterscheidung wird in einem Split-Array gespeichert. Wird dies

für alle aufeinander folgenden Primitive durchgeführt, erhält man alle nötigen Split-

Positionen und kann damit den Baum traversieren.


Lauterbach et al. haben mit diesem Algorithmus ein Verfahren hervorgebracht, welches

die Vorteile der parallelen Architektur der heutigen GPUs erheblich nutzt. Zum Zeitpunkt

der Präsentation war es die schnellste Möglichkeit einen BVH zu erstellen. Einzig die

Qualität der BVH ist noch zu bemängeln. Das Lineare BVH Verfahren besitzt dieselben

Schwachpunkte wie der räumliche Median-Cut Algorithmus. Diese Schwachstelle kann

schnell zu sehr langen Traversierungszeiten beim eigentlichen Raytracing Verfahren

führen. Diese Erkenntnis führte dazu, dass Lauterbach et al. (Lauterbach, et al., 2009)

neben diesem LBVH Verfahren eine weitere Konstruktionsprozedur vorstellten, die

einen parallelen Aufbau eines SAH-BVH erlauben soll.

3.1 Parallele Konstruktion eines SAH-BVH

Die Surface Area Heuristic, wie in (Surface Area Heuristic) beschrieben, ermöglicht es

qualitativ hochwertige Bounding Volume Hierarchien zu erstellen. Lauterbach et al.

wollen mit der Parallelisierung des SAH Konstruktionsverfahren dieses erheblich

beschleunigen und so für die Echtzeitgrafik nutzbar machen.

Das Grundprinzip ist recht einfach, sobald eine Unterteilung einer Übergruppe erfolgt ist

können die beiden resultierenden Untergruppen unabhängig voneinander weiter

unterteilt werden.

Lauterbach et al. verwenden für die Realisierung des Algorithmus zwei Daten Queues:

eine Input Queue und eine Output Queue. Um die parallele Unterteilung kümmern sich

sogenannte „Split Kernels“. Sie lesen die zu unterteilenden Objektgruppen aus der

Input-Queue und schreiben die resultierenden Untergruppen in die Output-Queue.

Bearbeitet ein Split-Kernel die Position i der Input-Queue, so schreibt er die daraus

folgenden Unterteilungen an die Positionen 2i und 2i+1 der Output-Queue. Sollte ein

Objekt der Input-Queue keine weitere Unterteilung benötigen, schreibt der Split-Kernel

eine Null in eines der zugehörigen Output-Felder.


Ein sogenannter Compaction-Kernel liest die Ergebnisse der Output-Queue und schiebt

die noch weiter zu bearbeitenden Objekte zurück in die Input-Queue. Zusätzlich

beseitigt er die Nullstellen in der Output-Queue.

Die Berechnung einer möglichst guten Unterteilung der einzelnen Objektmengen,

welche innerhalb eines Split-Kernels durchgeführt wird, kann durch eine Verteilung in

mehrere Threads realisiert werden. Für jede Koordinaten-Achse werden n

unterschiedliche Unterteilungen und die dazugehörigen Kosten evaluiert. So werden

pro Kernel 3n Threads für die Berechnung der Kostenfunktion im dreidimensionalen

Raum benötigt. Nach der Auswertung der einzelnen Threads wird die Unterteilung mit

den geringsten Kosten durchgeführt.

Durch die Anwendung der Surface Area Heuristic entsteht eine qualitativ hochwertige

Bounding Volume Hierarchie, die eine schnelle Traversierung ermöglicht. Doch der

deutlich größere Rechenaufwand spiegelt sich in der Konstruktionszeit wieder. Ein

Problem stellt auch die geringe Parallelität des Verfahrens zu Beginn der Konstruktion

da. Erst ab einer bestimmten Menge an Objekten in der Input Queue kann der

Algorithmus seine komplette stärke entfalten. Wenn die Split Kernels alle mit Daten

beliefert werden kann das Verfahren die Vorteile einer GPU nutzen. Der LBVH kann hier

in der frühen Phase schon deutlich mehr Punkten und von Beginn die multikern

Architektur nutzen. Lauterbach et al. (Lauterbach, et al., 2009) schlagen deshalb ein

hybrides Konstruktionsverfahren vor.


3.2 Das hybride GPU Konstruktionsverfahren

Durch die Verschmelzung des schnell konstruierbaren LBVHs und des qualitativ

hochwertigen SAH-BVH soll eine besonders effektive Bounding Volume Hierarchie

Erstellung entstehen.

Die Schwachstelle des SAH-BVH bei Beginn der Konstruktion soll das Lineare-BVH

Verfahren beheben und die niedrige Qualität des Linearen-BVHs soll durch die Surface

Area Heuristic ausgemerzt werden. Lauterbach et al. empfehlen eine Konstruktion der

oberen k Ebenen der Bounding Volume Hierarchie durch den gut parallelisierten LBVH

Algorithmus. So ist eine gute Auslastung der GPU Ressource gegeben. Ab der Ebene k+1

soll das Konstruktionsverfahren durch die parallele SAH Konstruktion ersetzt werden. So

entsteht ein qualitativ hochwertiger Rumpf der eine schnelle Traversierung zulässt. Die

Bestimmung der Ebene k ist je nach Ressource und Anwendungsfall empirisch zu

ermitteln.

Das Resultat des hybriden Ansatzes ist eine Architektur, welche die Vorteile der

parallelen GPU Gestaltung voll ausnutzt und eine zum reinen SAH Ansatz deutliche

Beschleunigung erfährt. Zudem können die Traversierungszeiten der Hierarchie im

Vergleich zum Linearen BVH deutlich verkürzt werden.


4 HLBVH – Hierarchical BVH

Pantaleoni und Luebke erkannten das hohe Potenzial der von Lauterbach et al.

(Lauterbach, et al., 2009) vorgestellten Linearen BVH Konstruktion. Die hohe multikern

Auslastung machte diesen Algorithmus zum effizientesten Verfahren um Bounding

Volume Hierarchien zu erstellen. Darauf aufbauend präsentierten Pantaleoni und

Luebke ein Verfahren, das sie selbst Hierarchical LBVH Konstruktion nannten

(Pantaleoni, et al., 2010). Dieser Algorithmus stellt eine Verbesserung des vorhandenen

LBVHs dar. Durch Änderungen im Konstruktionsprozess konnte Pantaleoni und Luebke

die Konstruktionszeit des BVHs nochmals verbessern.

4.1 Zweistufiges Sortierverfahren

Die erste große Änderung gegenüber dem LBVH Verfahren beschreiben Pantaleoni und

Luebke (Pantaleoni, et al., 2010) in der neuen Einteilung der Szeneobjekte. Bei der LBVH

Konstruktion wurden alle Objekte anhand ihres 3n Bit langen Morton-Codes mit Hilfe

des Radixsort Sortieralgorithmus sortiert. Hier sieht das neue HLBVH Verfahren eine

Zweistufige Einteilung vor. Im ersten Level werden die Szeneobjekte anhand einer 3m-

Bit Morton-Kurve unterteilt, wobei m < n ist. So erhält man eine deutlich gröbere

Einteilung der Szene und viele Primitive haben noch denselben Morton-Code als

Sortierschlüssel. Visuell zu sehen ist das in Abbildung 10. Während auf der rechten Seite

eine Einteilung in n-Stufen jedes Primitiv in ein eigenes Quadrat unterteilt, befinden sich

im linken Teil viele Primitive in gemeinsamen Unterteilungen, die von demselben

Morton-Code beschrieben werden.


Abbildung 10: Einteilung der Ebene in m-Bit-Morton-Code und n-Bit-Morton-Code -- Quelle: (Pantaleoni, et al., 2010)

Diese Konstellation nutzen Pantaleoni und Luebke um einen „Compress-Sort-

Decompress“ Algorithmus anwenden zu können. Zu Beginn eines solchen Verfahrens

werden die Sortierschlüssel komprimiert. Das bedeutet, alle hintereinander mehrfach

vorkommen Sortierschlüssel werden zu einem zusammengefasst. Durch eine gute

Auswahl von m kann die Anzahl der Schlüssel um ein vielfaches verringert werden. Mit

dieser komprimierten Menge wird nun das Sortierverfahren gestartet, welches Dank der

geringeren Schlüsselanzahl erheblich schneller ist. Sobald die Sortierung vollbracht ist,

kann die Dekomprimierung gestartet werden. Hier wird wieder die richtige Anzahl der

Schlüssel in ihrer sortierten Reihenfolge hergestellt. Wie in Abbildung 11 zu sehen, ist

durch das „Compress-Sort-Decompress“ eine grobe Einteilung der Szeneobjekte erreicht

worden.


Abbildung 11: Grobe Sortierung durch den 3m-Bit großen Morton-Code

Nun können im zweiten Level des Sortierverfahrens die einzelnen Unterteilungen für

sich separat sortiert werden. Das bedeutet eine Sortierung der letzten 3(n-m) Bits des

Morton-Codes. Pantaleoni und Luebke weißen dafür die Elemente eines Blockes zu je

einem CUDA Thread der GPU. Jeder Block wird zu einem Thread Array zugewiesen. So

kann die komplette Sortierung im Shared Memory mit einem Odd-Even

Sortieralgorithmus durchgeführt werden. Die maximale Größe eines Blockes ist hier

begrenzt durch die Größe des verfügbaren Shared Memory pro Prozessor. Deshalb wird

darauf geachtet, dass nicht mehr als 2000 Elemente pro vorsortiertem Voxel vorhanden

sind. Dies kann durch die richtige Auswahl von m erreicht werden. In der Praxis hat sich

gezeigt, dass bei allen Szenen bis 1M Grafikprimitiven ein m der Größe gleich sechs(m =

6) gereicht hat. Bis zu 10 Millionen reicht ein m von sieben.

Im Vergleich zum Radixsort Sortieralgorithmus des LBVH kann diese Vorgehensweise in

drei Punkten überzeugen:

1. Reduzierung von Berechnungen und globalem Speicher-Verkehr (memory traffic) –

dies kann dank dem „Compress-Sort-Decompress“ Verfahren mit der Komplexität von

O(M) und der schnellen Sortierung innerhalb des Shared-Memory gewährleistet

werden

2. Verringerte Anzahl an globalen Synchronisationspunkten – durch das verwenden

eines 3m-Bit Radixsort im Vergleich zum 3n-Bit kann die globale Synchronisation

während der parallelen Sortierung deutlich verringert werden.


3. Größere Effizienz – Pantaleoni und Luebke gaben eine 8x größere Effizient ihres Odd-

Even Sortieralgorithmus innerhalb der einzelnen Kerne gegenüber aktuellen globalen

Radixsort Sortieralgorithmen, an.

4.2 Verbesserung der Baum-Konstruktion

Lauterbach et al. haben bei ihrem LBVH Verfahren für die Konstruktion der Hierarchie

ein wie im vorherigen Abschnitt beschriebenes Split Array verwendet. Pantaleoni und

Luebke kritisieren hier die Größe des dadurch entstehenden Arrays, auf die eine

Sortierung durchgeführt werden muss. Das Array mit den vorhandenen Split-Positionen

ist deutlich größer als N die Anzahl der vorhandenen Primitive, da jeder Morton-Code

oft mehrere Unterteilungen beisteuert. Des Weiteren verursacht der Algorithmus wie

oben beschrieben sogenannte Singletons, die anschließend wieder durch einen extra

Durchlauf behoben werden müssen.

Pantaleoni und Luebke unterteilen ihr Verfahren in mehrere Phasen. Jede Phase

analysiert p aufeinanderfolgende Bitebenen der sortierten Morton-Codes. Die

Grundidee ist zu sehen in Abbildung 12. Zu Beginn eines Durchlaufs wird das Array mit

den Grafikprimitiven in Segmente unterteilt die zu einem Blattknoten gehören. Jedes

dieser Segmente generiert eine Baumstruktur der Tiefe p. Die Baumstruktur kann durch

eine Liste von Split-Ebenen pro Segment beschrieben werden. Die Liste besteht aus den

Indizes der Morton-Codes, welche sich von ihren Vorgängern unterscheiden. Da in

diesem Verfahren nur p mögliche Split-Ebenen betrachtet werden ist die maximale

Anzahl an Unterteilungen 2p -1. Diese werden in einem Block Deskriptor gespeichert.

In Abbildung 12 ist ein Deskriptor der Größe p = 3 zu sehen. Das erste Element enthält

die erste Oberunterteilung, die beiden folgenden die Unterteilungen für die

darunterliegende Ebene usw. Sollte eine Unterteilung nicht vorhanden sein, so wird das

mit einem nicht vorhandenen Index (-1) markiert. Zum Schluss werden die vorhanden

Baumstrukturen jeder Unterteilung zusammengefügt.


Abbildung 12:Durch die Analyse der Morton-Codes eines Segmentes kann der Block Deskriptor konstruiert werden, dieser beschreibt die Baumstruktur eines Segments -- Quelle: (Pantaleoni,

et al., 2010)

Durch diese Verbesserung des Verfahrens erzielen Pantaleoni und Luebke zwei wichtige

Vorteile gegenüber der Konstruktion des LBVH Verfahrens.

1. Reduzierung des Rechenaufwands und des globalen Speicher-Verkehrs - dies

wird durch die Vermeidung einer zusätzlichen Sortierung auf einem sehr großen

Array verhindert

2. Besseres Speicherlayout – die Erstellung ohne Singletons welche anschließen

wieder entfernt werden müssen erzeugt eine 2-4x kleineren Knoten-Bereich

Der HLBVH nutzt die Vorteile seines Vorgängers und behebt effizient die

Konstruktionsmängel, dadurch kann er wie in Tabelle 1 zu sehen den LBVH bei der

Konstruktionszeit nochmals deutlich unterbieten. Die Qualität des HLBVH ist wiederum

dieselbe wie des LBVH und kann wieder als große Schwachstelle bei der Traversierung

angesehen werden.


Tabelle 1: Konstruktionszeiten von LBVH und HLBVH bei verschiedenen Szenen - Quelle:

4.3 SAH optimierter HLBVH

Auch Pantaleoni und Luebke stellen in ihrer Arbeit (Pantaleoni, et al., 2010) eine

Erweiterung ihres Algorithmus mit der Surface Area Heuristic vor. Im Gegensatz zum

hybriden Ansatz des SAH-LBVH wird beim HLBVH Verfahren nicht die untere Hälfte der

Struktur qualitativ verbessert, sondern die ersten Ebenen also der Kopf der

Beschleunigungsstruktur.

Zu Beginn wird wieder eine grobe Einteilung durch den m-Bit Morton-Code

vorgenommen. Es wird Angenommen, dass alle Grafikprimitive die gleichen Kosten

verursachen. Anschließend wird ein SAH sweep Builder mit den grobunterteilten

Containern aus Primtiven gefüttert. Mit den Containern und der Anzahl der enthaltenen

Primitiven kann der SAH Builder einen mit der Surface Area Heuristic optimierten Kopf

der Beschleunigungsstruktur schaffen.


Abbildung 13: Hybride Konstruktion eines SAH-HLBVH – Quelle: (Pantaleoni, et al., 2010)

Der Vorteil eines SAH optimierten Kopfes gegenüber eines SAH optimierten Rumpfes ist

die Tatsache, dass zuerst alle Strahlen über den Kopf einer Beschleunigungsstruktur

getestet werden. Und nur ein Teil mit dem untersten Bereich der

Beschleunigungsstruktur.


5 Parallele SAH k-d-Tree Konstruktion

Nach dem in dieser Arbeit bisher das Augenmerk auf die besten und neuesten Verfahren

im Bereich der BVH-Konstruktion gelegt war, möchte ich in diesem Abschnitt den

aktuellen Stand im von KD-Bäumen beleuchten. Der KD-Baum hat seine Vorteile in der

Traversierung, wogegen die Konstruktionszeit meist länger dauert im Vergleich zum

BVH. Deshalb besteht auch hier ein großes Interesse die Ausnutzung der Multicore-

Architektur von aktuellen Prozessoren zu verbessern. Choi et al. stellten 2010 zwei neue

parallele Konstruktionsverfahren zur KD-Baum Erstellung vor (Choi, et al., 2010).

1. Nested Parallel Algorithm

2. In-Place Parallel Algorithm

5.1 Der Nested parallele Algorithmus

Der erste Algorithmus zerlegt den zurzeit effizientesten sequentiellen Algorithmus zur

Erstellung von SAH-KD-Bäumen und parallelisiert große Teile des Verfahrens. Der

Pseudo-Code 1 zeigt die Vorgehensweise der sequentiellen Form.

Das Verfahren erstellt für jede Koordinatenachse eine sogenannte Eventliste, sie besteht

aus den entlang der Achse sortierten Grafikprimitiven. Für jeden Anfang und jedes Ende

eines Grafikprimitiv wird ein Event erstellt. Die Funktion FindBestPlane durchsucht

diese Eventliste nach der besten Unterteilungsposition bei der die SAH Kosten am

geringsten sind. ClassifyTriangles ordnet die Grafikprimitive je nach

Unterteilungsposition zur linken oder rechten Untergruppe. FilterGeom unterteilt

das Array der Grafikprimitive an der zuvor berechneten Position und gibt beide

Unterteilungen wieder an FindBestPlane zurück. Dies wird solange durchgeführt

bist die gewünschte Feinunterteilung gegeben ist.


Pseudo-Code 1: Sequentielle KD-Baum Konstruktion - Quelle: (Choi, et al., 2010)


Sobald eine Unterteilung gemacht ist, können diese jede für sich weiterunterteilt

werden. Diese Form der parallelisierten Berechnung wurde auch schon in vorherigen

Verfahren demonstriert. Das Problem ist die parallelisierte Berechnung des oberen Teils

einer Beschleunigungsstruktur. Choi et al. haben eine Möglichkeit gefunden, die

sequentiellen Programmteile FindBestPlane, ClassifyTriangles und

FilterGeom zum größten Teil zu parallelisieren.

FindBestPlane

In Abbildung 14 kann man sehen wie die Funktion arbeitet. Anhand der Eventliste

erstellt sie ein Array mit der Anzahl der befindlichen Grafikprimitive auf der linken und

der rechten Seite. Zu Beginn befinden sich alle Primitive auf der rechten Seite. Wird ein

Event START erreicht, erhöht sich die Anzahl auf der linken Seite um eins. Wird ein Event

END erreicht, wird die Anzahl der Primitive der rechten Seite dekrementiert. Gerade zu

Beginn der Konstruktion ist dieses Array sehr groß, da alle Grafikprimitive dort enthalten

sind. Deshalb kann hier durch eine parallele Berechnung viel Zeit eingespart werden.

Wie das funktioniert zeigt der parallele Teil der Abbildung 14.

Abbildung 14: Die Funktion FindBestPlane in sequentieller und paralleler Ausführung - Quelle: (Choi, et al., 2010)


Die Länge des Arrays wird in n Chunks aufgeteilt. Jeder Chunk berechnet für sich die

rechte und linke Seite. Anschließend wird ein Push durchgeführt, in dem die Gesamtzahl

jedem Chunk hinzugefügt wird. In der dritten Phase der SAHScan-Phase kann nun jeder

Chunk für sich dank der Push-Phase die gesamte Anzahl der Primitive pro Event

berechnen und damit auch für jedes Event die SAH-Kosten. Zum Schluss werden die

geringsten Kosten zurückgegeben und der Chunk mit den niedrigsten Kosten ermittelt.

ClassifyTriangles

Diese Funktion sorgt für die richtige Einteilung der Primitive und könnte ähnlich wie die

vorherige parallelisiert werden. Doch Choi et al. entschieden sich dagegen, da es dort zu

erheblichen „false-sharing“ gekommen ist.

FilterGeom

Diese Funktion erstellt zwei neue Arrays unbekannter Größe, in der die zwei

Untergruppen entstehen. Sie sind deshalb unbekannter Größe, da Dreiecke auf Split-

Ebene liegen können und so anschließend zu beiden Untergruppen hinzugefügt werden.

Um diese Funktion zu parallelisieren wird eine ähnliche Vorgehensweise wie bei

FindBestPlane benutzt. Wiederum sorgt ein PreScan dafür Chunks zu generieren und pro

Chunk herauszufinden wie viele Primitive nach rechts oder links wandern. Eine Push

Funktion sorgt dafür, dass die Informationen von jedem Chunk weitergereicht werden.

Dadurch weiß jeder Chunk wie die aktuelle Startposition im rechten und linken Array für

seine Primitive ist und kann in der FilterScan-Phase so seine Dreiecke hinzufügen.

Mit den parallelisierten Funktionen kann der Anfang eines SAH-KD-Baums solange

effizient berechnet werden bis die Knoten die Anzahl der Kerne erreichen. Anschließend

können die Knoten für sich parallel weiter unterteilt werden.

5.2 Der In-Place Algorithmus

Choi et al. (Choi, et al., 2010) präsentieren noch eine weitere Methode eines parallelen

Verfahrens der KD-Baum Konstruktion. Den Grund für ein weiteres Verfahren erörtern

sie anhand der großen Datenbewegungen des vorherigen Algorithmus. Die Zerlegung


und Verteilung der Eventliste und der Dreiecksliste sind der Hauptgrund dafür. Das neue

Daten-Layout des In-Place Algorithmus, zu sehen in Abbildung 15, soll es ermöglichen

den erhöhten Datenbewegungsaufwand zu mindern.

Abbildung 15: Datenlayout der In-Place Variante - Quelle: (Choi, et al., 2010)

Für jede Achse ist ein Event Array vorhanden. Jeder Event enthält einen Pointer zu dem

Dreieck, welches den Event produziert. Wiederum jedes Dreieck besitzt sechs Pointer zu

den zugehörigen Events. Sowie eine Liste der aktuellen Knoten einer Ebene zu der das

Primitiv gehört. Der Pseudo-Code 2 zeigt die Funktionsweise des In-Place Algorithmus.

Er besteht aus vier Hauptphasen. Knoten der aktuellen Ebene werden mit „live“

deklariert.


Pseudo-Code 2: Pseudo-Code des In-Place Verfahrens - Quelle: (Choi, et al., 2010)

FindBestPlane

Im Gegensatz zur gleichnamigen Funktion des vorherigen Algorithmus werden in dieser

Phase alle „live“ Knoten parallel abgewickelt anstatt nur einer pro Durchlauf.


Newgen

In dieser Phase wird der Baum um eine Ebene erweitert, es entstehen zwei Kinder für

jede Unterteilung eines live-Knotens.

ClassifyTriangles

Die ClassifyTriangles Phase aktualisiert für jedes Grafikprimitiv die zugehörige Knoten-

Liste.

Fill

Die letzte Phase wird nur einmal zum Schluss der Baumkonstruktion aufgerufen. In

dieser Phase wird der erstellte Baum in das bekannte Format der sequentiellen Funktion

übersetzt.

5.3 Vergleich zwischen Nested und In-Place Algorithmus

Abbildung 16: Testszenen mit Vertexanzahl

Abbildung 17 zeigt den absoluten Geschwindigkeitszuwachs der parallelen Algorithmen

auf ein in Tabelle 2 beschriebenen Beckton Maschine. Die getesteten Szenen und ihre

Anzahl an Vertices sind in Abbildung 16 zu sehen. Der Nested Algorithmus kann vor

allem bei den Szenen mit höherer Anzahl an Grafikprimitiven punkten. Während der In-

Place Algorithmus schon bei den kleinen Szenen überzeugen kann. Den besten Wert

erreicht das Nested Verfahren mit einem acht fachen Speedup bei der Angel-Szene.


Tabelle 2: Hardware Setup

Abbildung 17: Absoluter Geschwindigkeitszuwachs auf einer in Beckton Maschine


In Abbildung 18 wird die Performance beider Algorithmen auf beiden

Hardwareeinstellungen gegenübergestellt. Auf der neueren Beckton Architektur gibt es

eine Bewegung hin zum In-Place Algorithmus. Choi et al. erörtern hier eine für die

Zukunft bessere Nutzung von mehreren Threads mit Hilfe des In-Place Verfahrens.

Abbildung 18: Performance Vergleich von In-Place und Nested - Quelle:(Choi, et al., 2010)


6 OptiX – Raytracing Engine von NVIDIA

Im bisherigen Teil dieser Seminararbeit wurde erörtert wie das so rechenaufwändige

Raytracing Verfahren mit Beschleunigungsstrukturen unterstützt wird und so in der

Echtzeit-Computergrafik angewendet werden kann.

Im letzten Teil dieser Arbeit möchte ich ein von NVIDIA entwickeltes Framework

untersuchen, welches verspricht die Programmierung von Raytracing Algorithmen

extrem zu vereinfachen. Die „OptiX Ray Tracing Engine“ ist für jeden Entwickler

zugänglich und kann auf der Nvidia Homepage heruntergeladen werden.

6.1 Konzept der OptiX Engine

Die Grundidee der OptiX Engine besteht in der Annahme, dass die meisten Raytracing

Algorithmen mit einem kleinen Set programmierbarer Operationen verwirklicht werden

können (Parker, et al.). Das Framework stellt diese Operationen durch acht kleine

Programme zu Verfügung. Diese vom Entwickler veränderbaren Programme und der

hartcodierte OptiX Kernel stellen die Raytracing Pipeline da. In Abbildung 19 wird das

Zusammenspiel dieser Operationen grafisch dargestellt. Im Gegensatz zur einer strikten

Rasterization Pipeline kann diese Architektur als ein Raytracing Graph anstatt einer

Pipeline angesehen werden. Die Hauptoperation rtTrace vermittelt zwischen der

Traversierung und der Szenegenerierung. Der Benutzer hat die Möglichkeit durch

Benutzung der folgenden Operationen seinen gewünschten Raytracing Algorithmus zu

verwirklichen.


Abbildung 19: Raytracing Graph der OptiX Engine - Quelle:(Parker, et al.)

1. Ray generation Programme: Sie sind der Einstieg zur Raytracing Pipeline. Mit

dieser Operation kann die Aussendung von Strahlen in die Szene verwirklicht

werden.

2. Intersection Programme: Je nach Beschleunigungsstruktur wird mit diesen

Operationen die Geometrie nach Kollisionen durchsucht. Mit ihnen kann

ermittelt werden wo und was mit dem ausgesendeten Strahl kollidiert.

3. Bounding Box Programme: Das Bounding Box Programm kann für die Erstellung

von Hüllvolumen auf ein gewünschtes Szeneobjekt angewendet werden. Um

Beschleunigungsstrukturen zu verwirklichen.

4. Closet Hit Programm: Wird bei der nächstliegenden Kollision eines

ausgesendeten Strahls aufgerufen. Von diesem Punkt können z.B. neue Strahlen

generiert werden.


5. Any Hit Programm: Werden dafür benutzt um eine Kollision eines Strahls mit

einer Geometrie feststellen zu können. Sie werden z.B. für die Ausstrahlung von

Shadow-Rays genutzt werden.

6. Miss Programm: Diese Programme werden ausgeführt wenn der Strahl keine

Geometrie im zu testenden Bereich trifft.

7. Exception Programm: Ermöglicht System Exceptions abzufangen oder auch

eigene Exceptions zu generieren.

8. Selector Visit: Ermöglicht eine grobunterteilte Traversierung des Szenegraphens.

In Abbildung 20 ist ein Anwendungsbeispiel der OptiX Engine skizziert. An der Stelle 1

werden mit dem Ray generation Programm Strahlen erzeugt und in die Szene

verschickt. Bei Position 2 trifft ein Strahl die Geometrie des Hasen. Sobald dieser Treffer

gefunden ist, wird das Closet Hit Programm aufgerufen. Bei 3 wird darauf ein

Schattenfühler losgeschickt der bei 4 auf die Geometrie trifft. Beim ersten gefunden

Treffer des Strahls wird ein Any Hit Programm gestartet und die Traversierung

gestoppt. Die Informationen eines Hits werden an die Schattenberechnung

weitergeleitet. An Position 5 wird ein Miss Programm ausgeführt und es könnte zum

Beispiel eine Hintergrundfarbe diesem Pixel zugewiesen werden.


Abbildung 20: Der OptiX Kontext veranschaulicht an einer simplen Szene - Quelle: (Parker, et al.)

Der komplette Kontext dieser Szene wird in einer Art Szenegraph gespeichert. In

Abbildung 21 ist die Szene mit dem Hasen als Szenegraph skizziert.

Abbildung 21: Der Aufbau der Hasen-Szene skizziert in einem OptiX Szenegraph - Quelle:(Pantaleoni, et al., 2010)


6.2 Beschleunigungsstrukturen in OptiX

Beschleunigungsstrukturen werden in OptiX als Element an einen Szenegraphknoten

gehängt zu sehen in Abbildung 21. Der Benutzer von OptiX hat zurzeit die Möglichkeit

zwischen verschiedenen Beschleunigungsstrukturen zu wählen. Es ist möglich

verschiedene Teile einer Szene mit unterschiedlichen Beschleunigungsstrukturen zu

verbinden. So ist es möglich für eine Übergruppe und eine darunterliegende Gruppe

verschiedene Beschleunigungsstrukturen zu wählen. In Abbildung 22 ist so eine

Differenzierung skizziert.

Abbildung 22: OptiX Szenegraph mit mehreren Beschleunigungsstrukturen - Quelle: (NVIDIA, 2011)

Die Auswahl der möglichen Beschleunigungsstrukturen ist zurzeit noch recht begrenzt.

Derzeit kann zwischen sechs verschiedenen Arten unterschieden werden wobei der zur

Auswahl stehende LBVH im aktuellen Release noch nicht funktionsfähig ist. Im

Folgenden sind die Strukturen der OptiX Engine:


1. BVH

2. SBVH

3. MedianBVH

4. LBVH

5. TriangleKDTree

6. NoAccel

Genaue Angaben welcher Algorithmus sich hinter dieser Auswahl verbirgt wird nicht

gegeben es werden nur die Vorteile der einzelnen Strukturen kurz benannt. NoAccel

bedeutet erst wird keine Beschleunigungsstruktur genutzt sondern alle Strahlen werden

mit allen Primitiven getestet. Da der HLBVH eine Entwicklung der NVIDIA R&D Abteilung

ist könnte es sein, dass sich in diesem Bereich zu kommenden Releases Verbesserungen

hervortun.


7 Fazit

Das Thema Advanced Realtime Raytracing wurde in dieser Arbeit im speziellen mit der

Analyse der neuesten Beschleunigungsstrukturen abgearbeitet. Genau diese sind auch

der Grund, dass das Raytracing Verfahren schon in einigen Teilen der Echtzeit-

Computergrafik genutzt werden kann. Der deutliche Performance-Gewinn durch

Beschleunigungsstrukturen ist aus dem Algorithmus der Strahlverfolgung nicht mehr

wegzudenken.

Dank der rasanten Weiterentwicklung von Beschleunigungsstrukturen und der breiten

Bereitstellung einer Raytracing Engine, wird es nicht mehr lang dauern bis Raytracing

flächendeckend effizient in der Echtzeit-Computergrafik genutzt werden kann.

Gerade die Fokussierung auf die parallele Architektur moderner Prozessoren ermöglicht

eine stätige Beschleunigung. Die Arbeit zeigt, dass es nicht nur einen Lösungsansatz gibt

sondern in verschiedene Richtungen Verbesserungen gefunden werden. Noch ist der

BVH, für dynamische Szenen, dem KD-Baum durch seine kurze Konstruktionszeit

überlegen (Pantaleoni, et al., 2010). Doch auch im Bereich der KD-Baum Konstruktion

wurde durch Choi et al.(Choi, et al., 2010) das große Potential der parallelisierbarkeit

gezeigt.


8 Abbildungsverzeichnis

Abbildung 1: Holzschnitt von Albrecht Dürrer 1525 – Quelle: wikipedia.org .................................. 5

Abbildung 2: Konzept des rekursiven Raytracing - Quelle: Prof. Dr. Alfred Nischwitz - Master

Vorlesung Computergrafik - Sommersemester 2010 ...................................................................... 7

Abbildung 3: Aufteilung der Objekte einer 2-dimensionalen Szene in eine Bounding Volume

Hierarchie ......................................................................................................................................... 9

Abbildung 4: Einteilung einer Punktemenge im 2-dimensionalen Raum in einen KD-Baum - Die

Knoten des Baumes geben die Schnittkanten an. Die Blätter beinhalten die Punkt-Koordinaten --

Quelle: wikipedia.org ..................................................................................................................... 10

Abbildung 5: Räumlicher Median Cut ............................................................................................ 12

Abbildung 6: Objektbezogener Median Cut ................................................................................... 12

Abbildung 7: Verbesserte Einteilung der Szene ............................................................................. 14

Abbildung 8: Der Morton-Code Algorithmus der Ordnung 2 - Quelle: (Lauterbach, et al., 2009)

........................................................................................................................................................ 17

Abbildung 9: Skizze der Z-Order Unterteilung - Quelle: wikipedia.org ......................................... 18

Abbildung 10: Einteilung der Ebene in m-Bit-Morton-Code und n-Bit-Morton-Code -- Quelle:

(Pantaleoni, et al., 2010) ................................................................................................................ 23

Abbildung 11: Grobe Sortierung durch den 3m-Bit großen Morton-Code .................................... 24

Abbildung 12:Durch die Analyse der Morton-Codes eines Segmentes kann der Block Deskriptor

konstruiert werden, dieser beschreibt die Baumstruktur eines Segments -- Quelle: (Pantaleoni,

et al., 2010) .................................................................................................................................... 26

Abbildung 13: Hybride Konstruktion eines SAH-HLBVH – Quelle: (Pantaleoni, et al., 2010) ......... 28

Abbildung 14: Die Funktion FindBestPlane in sequentieller und paralleler Ausführung - Quelle:

(Choi, et al., 2010) .......................................................................................................................... 31

Abbildung 15: Datenlayout der In-Place Variante - Quelle: (Choi, et al., 2010) ............................ 33

Abbildung 16: Testszenen mit Vertexanzahl .................................................................................. 35

Abbildung 17: Absoluter Geschwindigkeitszuwachs auf einer in Beckton Maschine .................... 36

Abbildung 18: Performance Vergleich von In-Place und Nested - Quelle:(Choi, et al., 2010) ....... 37

Abbildung 19: Raytracing Graph der OptiX Engine - Quelle:(Parker, et al.) ................................... 39

Abbildung 20: Der OptiX Kontext veranschaulicht an einer simplen Szene - Quelle: (Parker, et al.)

........................................................................................................................................................ 41

Abbildung 21: Der Aufbau der Hasen-Szene skizziert in einem OptiX Szenegraph -

Quelle:(Pantaleoni, et al., 2010) .................................................................................................... 41

Abbildung 22: OptiX Szenegraph mit mehreren Beschleunigungsstrukturen - Quelle: (NVIDIA,

2011) .............................................................................................................................................. 42


9 Literaturverzeichnis

Choi, Byn, et al. 2010. Parallel SAH k-D Tree Construction. 2010.

Kalojanov, Javor, Billeter, Markus und Slusallek, Philipp. 2011. Two-Level Grids for Ray Tracing

on GPUs. 2011.

Klein, Andreas. 2010. Master Thesis: Optimizing a GPU based Ray Tracer. 2010.

Lauterbach, C., et al. 2009. Fast BVH Construction on GPUs. 2009.

NVIDIA. 2011. Programming Guide - Nvidia OptiX Ray Tracing Engine. 2011.

Pantaleoni, J. und Luebke, D. 2010. HLBVH: Hierarchical LBVH Construction for Real-Time Ray

Tracing of Dynamic Geometry. 2010.

Parker, Steven G., et al. OptiX: A General Purpose Ray Tracing Engine.

Whitted, Turner. 1979. An Improved Illumination Model for Shaded Display. 1979.

Advanced Realtime Raytracing:...

Documents

Transcript of Advanced Realtime Raytracing:...