Post on 02-Oct-2020
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
Matthias Winkler Seite 4
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.
Matthias Winkler Seite 5
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
Matthias Winkler Seite 6
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.
Matthias Winkler Seite 7
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.
Matthias Winkler Seite 8
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.
Matthias Winkler Seite 9
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.
Matthias Winkler Seite 10
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
Matthias Winkler Seite 11
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.
Matthias Winkler Seite 12
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
Matthias Winkler Seite 13
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.
Matthias Winkler Seite 14
Abbildung 7: Verbesserte Einteilung der Szene
Matthias Winkler Seite 15
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.
Matthias Winkler Seite 16
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.
Matthias Winkler Seite 17
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.
Matthias Winkler Seite 18
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.
Matthias Winkler Seite 19
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.
Matthias Winkler Seite 20
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.
Matthias Winkler Seite 21
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.
Matthias Winkler Seite 22
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.
Matthias Winkler Seite 23
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.
Matthias Winkler Seite 24
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.
Matthias Winkler Seite 25
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.
Matthias Winkler Seite 26
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.
Matthias Winkler Seite 27
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.
Matthias Winkler Seite 28
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.
Matthias Winkler Seite 29
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.
Matthias Winkler Seite 30
Pseudo-Code 1: Sequentielle KD-Baum Konstruktion - Quelle: (Choi, et al., 2010)
Matthias Winkler Seite 31
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)
Matthias Winkler Seite 32
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
Matthias Winkler Seite 33
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.
Matthias Winkler Seite 34
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.
Matthias Winkler Seite 35
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.
Matthias Winkler Seite 36
Tabelle 2: Hardware Setup
Abbildung 17: Absoluter Geschwindigkeitszuwachs auf einer in Beckton Maschine
Matthias Winkler Seite 37
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)
Matthias Winkler Seite 38
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.
Matthias Winkler Seite 39
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.
Matthias Winkler Seite 40
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.
Matthias Winkler Seite 41
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)
Matthias Winkler Seite 42
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:
Matthias Winkler Seite 43
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.
Matthias Winkler Seite 44
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.
Matthias Winkler Seite 45
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
Matthias Winkler Seite 46
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.