...
 
Commits (3)
%-------------------------------------------------------------------------------------------------------------
% Bibliotheken für tikz
%-------------------------------------------------------------------------------------------------------------
\usetikzlibrary{arrows, arrows.meta, shapes, trees, calc, decorations.pathreplacing, positioning}
%-------------------------------------------------------------------------------------------------------------
% Stile für Tikz
%-------------------------------------------------------------------------------------------------------------
\tikzset{current/.style = {draw, circle, fill=yellow!30, inner sep=1pt, minimum size=6mm}}
\tikzset{unvisited/.style = {draw, circle, fill=white, inner sep=1pt, minimum size=6mm}}
\tikzset{visited/.style = {draw, circle, fill=green!20, inner sep=1pt, minimum size=6mm}}
\tikzset{goodResult/.style = {draw, rectangle, fill=green!30, inner sep=1pt, minimum width=3cm}}
\tikzset{badResult/.style = {draw, rectangle, fill=red!30, inner sep=1pt, minimum width=3cm}}
\tikzset{variableNode/.style = {draw, circle, fill=white, inner sep=1pt, minimum size=6mm}}
\tikzset{currentVariableNode/.style = {draw, circle, fill=green!20, inner sep=1pt, minimum size=6mm}}
\tikzset{activeVariableNode/.style = {draw, circle, fill=orange!20, inner sep=1pt, minimum size=6mm}}
\tikzset{clauseNode/.style = {draw, rectangle, fill=white, inner sep=1pt, minimum size=6mm}}
\tikzset{activeClauseNode/.style = {draw, rectangle, fill=orange!20, inner sep=1pt, minimum size=6mm}}
\tikzset{emptyNode/.style = {inner sep=0pt, outer sep=0pt, anchor=base, baseline}}
%-------------------------------------------------------------------------------------------------------------
% Abkürzungen, Displaystyles, etc.
%-------------------------------------------------------------------------------------------------------------
\newcommand\todo[1]{\textcolor{red}{[#1]}\message{TODO: #1}}
\newcommand\dprod[0]{\displaystyle\prod}
\newcommand\tprod[0]{\textstyle\prod}
\newcommand\dsum[0]{\displaystyle\sum}
\newcommand\tsum[0]{\textstyle\sum}
%-------------------------------------------------------------------------------------------------------------
% Messages
%-------------------------------------------------------------------------------------------------------------
\newcommand\xamsg[4]{
\frac{
\dprod_{b\in N(#1)\setminus #2}m_{b\to #1}^{[#4]}(#3)
}
{
\dprod_{b\in N(#1)\setminus #2}m_{b\to #1}^{[#4]}(1) +
\dprod_{b\in N(#1)\setminus #2}m_{b\to #1}^{[#4]}(0)
}
}
\newcommand\axmsg[3]{
1-\dprod_{y\in N(#1)\setminus #2}m_{y\to #1}^{[#3]}(1-value(y, #1))
}
\newcommand\xmsg[2]{
\frac{
\dprod_{b\in N(#1)}m_{b\to #1}^{[#2]}(1)
}
{
\dprod_{b\in N(#1)}m_{b\to #1}^{[#2]}(1) +
\dprod_{b\in N(#1)}m_{b\to #1}^{[#2]}(0)
}
}
\newcommand\xamsgempty{
\frac{
\dprod_{\emptyset}
}
{
\dprod_{\emptyset} +
\dprod_{\emptyset}
}
}
%-------------------------------------------------------------------------------------------------------------
% true/false
%-------------------------------------------------------------------------------------------------------------
\newcommand\true{\textit{wahr}}
\newcommand\false{\textit{falsch}}
%-------------------------------------------------------------------------------------------------------------
% besondere Elemente für tikz
%-------------------------------------------------------------------------------------------------------------
\newcommand\connection[3][]{
\ifthenelse
{
\equal{#1}{}
}
{
\draw (#2) -- (#3);
}
{
\draw (#2) -- (#3) node[midway, fill=white] {\small{#1}};
}
}
\newcommand\negConnection[3][]{
\ifthenelse
{
\equal{#1}{}
}
{
\draw[dashed] (#2) -- (#3);
}
{
\draw[dashed] (#2) -- (#3) node[midway, fill=white] {\small{#1}};
}
}
\newcommand\fadingConnection[3][]{
\ifthenelse
{
\equal{#1}{}
}
{
\draw[dash pattern=on 1cm off 0.1cm on 0.1cm off 0.05cm on 0.05cm off 0.05cm on 0.05cm off 5cm] (#2) -- (#3);
}
{
\draw[dash pattern=on 1cm off 0.1cm on 0.1cm off 0.05cm on 0.05cm off 0.05cm on 0.05cm off 5cm] (#2) -- (#3) node[near start, fill=white] {\small{#1}};
}
}
\newcommand\arrowconnection[3][]{
\ifthenelse
{
\equal{#1}{}
}
{
\draw[draw, -latex] (#2) -- (#3);
}
{
\draw[draw, -latex] (#2) -- (#3) node[midway, fill=white] {\small{#1}};
}
}
%-------------------------------------------------------------------------------------------------------------
% Seitenumbrüche und abstract Title
%-------------------------------------------------------------------------------------------------------------
\newcommand\emptypage{
\newpage\null\thispagestyle{empty}\newpage
}
\newcommand\file[1]{
\texttt{#1}
}
\ifcsname abstitlestyle\endcsname
\renewcommand{\abstitlestyle}[1]{\centering\Large{\textbf{#1}}}
\fi
\ifcsname\glossaryname\endcsname
\renewcommand*{\glossaryname}{Glossar}
\fi
\newcommand{\gquote}[1]{\glqq#1\grqq}
\newcommand{\cgFuncRef}[1]{$\rightarrow$ \lstinline{lib::CgContext::#1()}\\}
\ No newline at end of file
\newcommand{\gquote}[1]{\glqq#1\grqq}
\ No newline at end of file
\section{Mögliche Lichteffekte}
In diesem Abschnitt sollen einige Lichteffekte genannt und kurz erläutert werden. Das Ziel einer Masterarbeit
wäre es, zu prüfen wie diese Lichteffekte mittels Raytracing gerendert werden
können und diese Techniken zu implementieren. Dabei soll immer auch der Vergleich zur Implementierung dieser
Technik bei einem \gquote{klassischen} Rasterisierer gezogen werden.\\
Zunächst muss eine Standardszene erstellt werden, an der die Effekte veranschaulicht werden können. Diese
Szene muss daher eine Lichtquelle und mehrere Objekte enthalten. Es muss mindestens ein Reflektor und ein
Refraktor enthalten sein.
%
\subsection{Einfaches Sampling}
Der einfachst mögliche Raytracer schießt nur einen Strahl pro Pixel in die Szene und ermittelt ohne weitere
Rekursion die Farbe dieses Pixels anhand des getroffenen Objekts. Dies ist der erste zu implementierende
Schritt, im Ergebnis muss die Szene sichtbar sein, es werden jedoch noch keinerlei Lichtberechnungen
durchgeführt.
%
\subsection{Harte Schatten}
Schatten stellen einen wichtigen Faktor für den Realismusgrad einer Szene dar. Bei einem Rasterisierer werden
dazu Shadowmaps genutzt, also Renderings der Szene aus Sicht der Lichtquelle(n). Durch geschicktes
Interpolieren zwischen mehreren Shadowmaps wird damit ein relativ gutes Ergebnis erzielt, das jedoch bei
kleinen Details oft nicht realistisch erscheint.
Beim Raytracing lassen sich Schatten sehr direkt berechnen: Trifft ein Strahl auf ein Objekt in der Szene
wird ein Strahl zur Lichtquelle geschickt. Dieser Strahl nennt sich Schattenfühler. Trifft der Schattenfühler
ein Objekt, so liegt der getroffene Punkt im Schatten, sonst wird der getroffene Punkt von der Lichtquelle
beleuchtet. Damit lassen sich relativ einfach harte Schatten erzeugen. Nach diesem Punkt lassen sich
Lichtberechnungen (z.B. nach Blinn-Phong) ausführen\\
Nach diesem Schritt muss die Szene mit einfacher Beleuchtung nach dem Blinn-Phong-Modell und harten Schatten
zu sehen sein.
%
\subsection{Reflexion}
Reflexion und Refraktion sind zwei weitere grafische Effekte, die den Realismusgrad einer Szene stark
erhöhen. Bei genauerer Betrachtung sind sehr viele Objekte in der realen Welt zu einem gewissen Grad
spiegelnd. Für Rasterisierer stellt dieser Effekt bisweilen Probleme dar. Mögliche Implementierungen sind
Stencil Reflection, Environment mapping und Screen Space Reflections.\\
Nach diesem Schritt muss in der Szene der Reflektor die umliegende Szene reflektieren.
%
\paragraph{Stencil Reflection} erzeugt zwar die besten und genauesten Ergebnisse, da die Szene wirklich gespiegelt
gerendert wird, ist jedoch auch sehr kostspielig (Szene muss ein zusätzliches Mal pro Reflektor gerendert
werden) und eignet sich nur für ebene Reflektoren.
%
\paragraph{Screen Space Reflections} berechnet Reflexionen im Screen Space.
Dies ist relativ schnell, jedoch können durch die Beschränkung auf den ScreenSpace
nur Objekte reflektiert werden, die auch tatsächlich im Bild sichtbar sind, was schnell zu unrealistischen
Ergebnissen führen kann.
%
\paragraph{Environment mapping} rendert die Szene von einem Punkt des Raumes aus in eine Cubemap und sampelt
diese Cubemap für Reflexionen. Dieses Verfahren kann gute Ergebnisse liefern, benötigt jedoch ein wenig
künstlerisches Geschick, da jede Cubemap nur für einen einzigen Punkt im Raum exakt ist und daher unter
Umständen zwischen mehreren Cubemaps interpoliert werden muss.
%
\paragraph{Raytraycing} ermöglicht Reflexionen auf eine sehr allgemeine Art.
Trifft ein Strahl auf ein reflektierendes Objekt, so wird einfach ein weiterer Strahls entsprechend des
Reflexionsgesetzes geschickt um die reflektierte Farbe zu bestimmten. Man kennt dabei den ausgehenden Strahl
und muss nur den einfallenden Strahl zurückverfolgen.
Dies ermöglicht eine relativ einfache Implementierung von Reflexionen, die zusätzlich auch pixelgenau und vom
Reflektor unabhängig sind. Dieser Effekt ist korrekt, wenn man von einer relativ groben Oberfläche ausgeht,
bei der jeder getroffene Punkt ein perfekter, ebener Reflektor ist. Außerdem wird hier von einer punktförmigen
Lichtquelle ausgegangen.
%
\subsection{Refraktion}
Refraktion, also die Brechung des Lichts ist ein weiterer subtiler Effekt, der in der Realität an
transparenten Objekten auftritt. Bei einem Rasterisierer lässt sich das Problem wieder mit Cubemaps lösen,
ganz ähnlich wie bei der Erstellung von Reflexionen. Beim Raytracing wird das Problem wieder sehr allgemein
gelöst: der einfallende Strahl wird entsprechend des Snelliusschen Brechungsgesetzes (Snell's law)
zurückverflogt. Der Vorteil liegt hier wieder in der Genauigkeit des Prozesses. \\
Nach diesem Schritt soll in der Szene eine Refraktion der Szene an einem geeigneten Objekt zu sehen sein. Dies
kann z.B. eine transparente Kugel sein. Zusätzlich lässt sich hier der Frage nachgehen, warum mit diesem
Vorgehen keine Kaustiken erzeugt werden können. In der Realität würde eine Glaskugel das einfallende Licht auf
einen Punkt bündeln, ähnlich einem Brennglas. Mit dieser Technik lässt sich der Effekt jedoch nicht erzeugen.
%
\subsection{Antialiasing}
Antialiasing lässt sich bei Raytracing ohne einen zusätzlichen Renderpass implementieren, indem Strahlen nicht
in der Mitte eines Pixels, sondern an verschiedenen Punkten erzeugt werden. Kleine Änderungen werden dabei
über mehrere Frames hinweg akkumuliert.\\
Nach diesem Schritt sollten Kanten geglättet erscheinen.
%
\subsection{Entrauschung (Denoising)}
Beim stochastischen Raytracing erreichen Strahlen in jedem Frame andere Punkte der Szene. Dadurch kann
sich die Farbe eines Pixels in jedem Frame leicht ändern und es entsteht ein verrauschtes Bild. In diesem
Schritt soll ein geeigneter Entrauschungsalgorithmus gefunden, implementiert und diskutiert werden.\\
Der Schritt lässt sich am besten implementieren, indem das Ergebnis des Raytracing in eine Textur gespeichert
wird, die dann in einem Post-processing-Schritt entrauscht wird. Es bietet sich auch an, einen Algorithmus
zu entwickeln, der beim Post-processing jeweils die letzten X Frames in die Berechnung einbezieht. Dadurch
stehen für jedes Bild mehr Daten zur Verfügung, was zu eine besseren Endergebnis führen könnte. Probleme sind
bei schnellen Bewegungen zu erwarten, da das Bild dann verzerrt werden kann. Ein solcher Algorithmus soll
entwickelt und getestet werden.
%
\subsection{Globale Beleuchtung}
Bisher wurden pro Trefferpunkt nur sehr wenige Strahlen genutzt: ein Schattenfühler und eventuell ein Strahl
für eine Reflexion oder Refraktion. In diesem Schritt soll das Konzept der globalen Beleuchtung umgesetzt
werden. Dazu soll nicht mehr nur die minimal nötige Anzahl an Strahlen erzeugt werden.
Es wird nun versucht, die Rendergleichung anzunähern. Dazu werden von einem Trefferpunkt aus mehrere Strahlen
in zufällige Richtungen ausgesendet um die Umgebung des Trefferpunktes zu sampeln. Aus den getroffenen (oder
nicht getroffenen) Objekten wird dann die Farbe das Punktes ermittelt. Dieses Vorgehen zieht die
mikroskopische Oberflächenstruktur von Objekten in Betracht und simuliert eine Oberfläche, bei der jeder Punkt
aus \textit{vielen} ebenen, perfekten Reflektoren besteht (Mikrofacettenmodell). Außerdem wird hier von einer
nicht-punktförmigen Lichtquelle ausgegangen.\\
Ein wichtiger Punkt dabei ist die Anzahl der Strahlen so zu wählen, dass die Performance nicht darunter
leidet, aber trotzdem noch ein gutes Ergebnis erzielt wird. \\
Hier lässt sich auch die BRDF vertiefen, da diese die Verteilung und Anzahl der Strahlen bestimmt.
Mit dieser Technik lassen sich zunächst Ambient Occlusion, weiche Schatten und Color Bleeding implementieren.
Am Ende dieses Schrittes muss die Szene leichte Schatten in kleinen Vertiefungen aufweisen, die
Schatten von Objekten dürfen keine harten Schatten mehr sein und die Farbe von Objekten muss leicht auf
umliegende Objekte abstrahlen. Dies lässt sich zum Beispiel mit farbigen Wänden und einem weißen Block direkt
daneben gut darstellen.\\
%
\subsubsection{Ambient Occlusion}
Ambient Occlusion beschreibt den Effekt, dass bei ambienter Beleuchtung tiefer gelegene Stellen eines Objekts,
z.B. Löcher oder Ritzen weniger beleuchtet sind. Für Rasterisierer kann der Effekt durch ein Screen
Space-Verfahren (SSAO, Screen Space Ambient Occlusion) recht gut angenähert werden.
%
\subsubsection{Weiche Schatten}
In der Realität besitzen die meisten Schatten einen dunklen Kernschatten und weniger dunklen Halbschatten,
sodass der Übergang von Schatten zu beleuchteter Fläche fließend ist. Bei einem Rasterisierer läst sich der
Effekt gut annähern, indem eine Mipmap der Shadowmap gesampelt wird. Beim Raytracing müssen hierfür mehrere
Strahlen genutzt werden, wie es die Rendergleichung vorsieht.
%
\subsubsection{Color Bleeding}
Color Bleeding bezeichnet den Fakt, dass Objekte auch Licht von benachbarten Objekten reflektieren und so die
Beleuchtung nicht nur von der Lichtquelle, sondern auch von der Umgebung eines Objektes abhängt. Bei einem
Rasterisierer würde man hierfür wieder auf zuvor erzeugte Cubemaps zurückgreifen. Beim Raytracing ergibt sich
dieser Schritt automatisch durch die Annäherung der Rendergleichung.
%
\subsection{Multiple Importance Sampling für \gquote{Glossy Reflection}}
Das bisherige Ergebnis sollte schon recht gut aussehen, hat allerdings einige Schwächen. Zum Beispiel sehen
matte Reflektoren eher sehr verrauscht aus. Dies liegt an der hohen Varianz der Strahlen, wenn nur die BRDF
berücksichtigt wird. Eine Verbesserung stellt daher das Multiple Importance Sampling (MIS) dar. Dabei wird
beachtet, dass Lichtquellen meist einen höheren Beitrag zur Beleuchtung eines Punktes liefern, als die
Umgebung des Punktes. Das bedeutet, dass Lichtstrahlen nicht nur entsprechend der BRDF erzeugt werden,
sondern, dass zu Lichtquellen immer Strahlen geschickt werden. Um weiche Schatten zu behalten müssen auch
mehrere Strahlen zu verschiedenen Punkten einer Lichtquelle geschickt werden.\\
Nach diesem Schritt sollten alle Arten von Reflexionen physikalisch plausibel und realitätsnah dargestellt
werden.
%
%
% Die Datei ist zunächst nur für Notizen gedacht!
%
\section{Vorläufige Gliederung}
%
\begin{enumerate}
......@@ -11,22 +8,10 @@
\item Umsetzung mit Vulkan \& NVIDIA-Erweiterung
\item Hardwareunterstützung
\end{enumerate}
%
\item Die Rendergleichung und ihre Umsetzung mittels Raytracing
\item Implementierungsgrundlagen eines Raytracers mit Vulkan \& NVIDIA-Erweiterung
% Zu viel oder am Thema vorbei?
% \item Umsetzung grafischer Effekte mit Raytracing
% \begin{enumerate}
% \item Harte Schatten
% \item Reflexion
% \item Refraktion
% \item Weiche Schatten
% \item Anti-Aliasing
% \item Globale Beleuhtung mit Monte-Carlo-Simulation und BRDF
% \item glossy reflection mit Multiple Importance Sampling
% \end{enumerate}
%
%
\item Darstellung von Strahlenbüscheln
\begin{enumerate}
\item Physikalische Grundlagen
......
\section{Implementierung}
Alle besprochenen Prinzipien sollen praktisch umgesetzt werden. Es soll dabei ein Raytracer programmiert
werden, der eine beliebige Szene in Echtzeit rendern kann. Dazu bieten sich vor allem eine Cornell-Box oder
das Sponza-Atrium an. Auch einzelne Objekte wie ein Utah-Teapot oder Suzanne können zur Darstellung der
Ergebnisse nützlich sein.\\
Zielsetzung sollen dabei etwa 15 Bilder pro Sekunde bei gegebenenfalls geringer Auflösung sein. Die
Demonstration verschiedener Techniken wiegt schwerer als die Entwicklung einer hoch optimierten Engine.
Dazu soll die Grafikschnittstelle Vulkan mit der Raytracing-Erweiterung von
NVIDIA (\texttt{NV\_VK\_RAY}) genutzt werden. Wichtige Punkte sind hierbei der Aufbau der Raytracing-Pipeline
und die verschiedenen Shader. Für die Umsetzung der Aufgabe werden nur Raygen-, Closest-Hit- und Miss-Shader
benötigt. Da jedoch auch der technische Aspekt von Raytracing beleuchtet werden soll, ist es günstig auch
Any-Hit- und Intersection-Shader genauer zu beleuchten. Auch eine kurze Exkursion zur Grafikschnittstelle
Vulkan bietet sich an.\\
Ebenfalls sollte hier (kurz) auf die spezielle Hardware für Raytracing eingegangen werden, da GPUs mit
Raytracing-Kernen (RT-Cores) Raytracing in Echtzeit überhaupt erst ermöglichen. Die Hardware stellt bei der
Implementierung den limitierenden Faktor dar und ermöglicht nur ein bestimmtes \gquote{Strahlenbudget}. Die
RT-Cores einer Grafikkarte können nominell $N$ Strahlen pro Sekunde berechnen. In einer realen Anwendung ist
der nominelle Wert jedoch schwer zu erreichen. Bei einer Auflösung von $X\times Y$ Pixeln und $R$ Bildern pro
Sekunde stehen pro Pixel pro Bild höchstens $\frac{N}{X\times Y \times R}$ Strahlen
zur Verfügung. Dies ist bei einer Implementierung immer zu bedenken und macht bei jedem grafischen Effekt eine
Abwägung zwischen Qualität und Geschwindigkeit nötig.\\
Die Implementierung an sich soll stufenweise erfolgen und sich an den grafischen Effekten des folgenden
Abschnitts orientieren, sodass für jeden Effekt eine Erweiterung der Implementierung stattfinden kann.
%
\ No newline at end of file
\section{Einleitung}
%
\begin{quotation}
There is an old joke that goes, \gquote{Raytracing is the technology of the future and it always will be!}\\
- David Kirk
\end{quotation}
%
Raytracing ist eine Rendertechnik, bei der der Verlauf von Lichtstrahlen und deren Interaktion mit der Umgebung
simuliert wird um photorealisitsche Bilder zu erstellen. Sowohl theoretische Grundlagen, als auch
Implementierung der Technik sind seit Ende der 1960er Jahre bekannt. Die Technik rückte jedoch erst vor
wenigen Jahren in den Fokus der breiten Masse, als mit NVIDIAs RTX-Serie erstmals erschwingliche Grafikkarten
mit Hardwarebeschleunigung für Raytracing auf den Markt kamen und Raytracing in Echtzeit ermöglichten.\\
Durch den Einsatz in der Spielebranche erlangte die Technik inzwischen einen hohen Bekanntheitsgrad und bietet
sich daher auch als Forschungsthema an. Die Technik unterscheidet sich dabei grundlegend vom klassischen und
praktisch allgegenwärtigen Ansatz des Rasterisierens. Dadurch bietet Raytracing viele neue Möglichkeiten, bringt aber auch
neue Probleme mit sich, die es zu lösen gilt. Gerade weil die Technik einen sehr allgemeinen Ansatz für das
Rendern in hoher Qualität bietet, scheint eine Vertiefung der Prinzipien des Raytracings
für zukünftige Forschung und Entwicklung wichtig.
\section{Problem: Darstellung von Godrays/Strahlenbüscheln}
Sogenannte Godrays lassen sich beobachten, wenn Licht an mikroskopisch kleinen Teilchen in einem Medium (z.B.
Luft oder Wasser) in Richtung des Beobachters gebrochen wird. Wenn die Lichtquelle dazu verdeckt ist, d.h.
wenn der Beobachter im Schatten steht, werden Lichtstrahlen sichtbar.
Dieser Effekt lässt sich während der Morgen- und Abenddämmerung besonders gut an Wolken beobachten, wenn diese
die Sonne verdecken. Auch unter Wasser oder wenn die Sonne in einen nebligen Wald scheint, lässt sich der Effekt
beobachten. Der Effekt ist recht eindrucksvoll und kann deswegen eine computergrafisch dargestellte Szene bereichern.
\subsection{Physikalische Grundlagen}
Wenn Licht an mikroskopisch kleinen Teilchen in einem Medium (z.B. Luft oder Wasser) gestreut wird und der
Beobachter im Schatten steht, zeichnen sich die Lichtstrahlen im Medium ab (siehe \ref{g:1}).
Dieser Effekt wird Tyndall-Effekt \footnote{Siehe z.B. \url{https://de.wikipedia.org/wiki/Tyndall-Effekt}}
genannt. Diese sichtbaren Strahlen werden auch Strahlenbüschel genannt und verdienen den Namen
\gquote{Godrays} (also göttliche Strahlen) ihrer äußerst eindrucksvollen Wirkung.
Der Effekt lässt sich besonders gut während der Morgen- und Abenddämmerung beobachten oder wenn eine kleine
Wolke die Sonne verdeckt.
Auch unter Wasser oder wenn die Sonne in einen nebligen Wald scheint, lässt sich der Effekt
beobachten. Aufgrund der Eindrücklichkeit des Effekts kann er eine computergrafisch dargestellte Szene
extrem bereichern.
%
\begin{figure}[ht]
\centering
\includegraphics[width=0.9\textwidth]{data/images/Streuung2.png}
\caption{Darstellung der Lichtbrechung an Partikeln}
\label{g:1}
\end{figure}
%
Andere Namen für diesen Effekt sind \gquote{crepuscular rays}, Wolkenstrahlen oder eben Strahlenbüschel. Das
Problem lässt sich mittels Raytracing nur annähern. Für eine physikalisch korrekte Darstellung müssten
unzählige Partikel simuliert werden, daher soll hier nach einer physikalisch plausiblen Darstellung gesucht
werden.
\ No newline at end of file
\subsection{Darstellung durch computergrafische Algorithmen}
Dieser Effekt soll nun computergrafisch dargestellt, also in eine Szene gerendert werden. Dabei existieren
natürlich sehr einfache Möglichkeiten, wie eine zuvor erzeugte Textur an einen bestimmten Platz zu rendern und
sehr aufwändige wie die physikalisch plausible Berechnung von Lichtbrechungen.\\
Das Ziel dieser Arbeit soll die Entwicklung eines Algorithmus' sein, der den oben besprochenen Effekt
physikalisch plausibel in beliebigen Szenen darstellen kann.
\ No newline at end of file
\section{Bisherige Arbeit}
%
\subsection{Backward Raytracing}
\paragraph{Quelle:} J. Arvo, \gquote{Backwards ray tracing} in SIGGRAPH Course
Notes, 1986, vol. 12, p. 100. \\
......@@ -24,7 +25,7 @@ befinden, das Licht von der Lichtquelle zum Beobachter hin reflektiert. Der Algo
Echtzeitanwendungen leider kaum
umsetzbar, da er sehr rechenintensiv ist. Allerdings ist der Algorithmus ein guter Ansatz für echte globale
Beleuchtung.
%
\subsection{Realistic Real-time Underwater Caustics and Godrays}
\paragraph{Quelle:} Papadopoulos, Charilaos \& Papaioannou, Georgios. (2010). Realistic Real-time Underwater Caustics and Godrays. 19th International Conference on Computer Graphics and Vision, GraphiCon'2009 - Conference Proceedings.
\url{http://graphics.cs.aueb.gr/graphics/docs/papers/GraphiCon09_PapadopoulosPapaioannou.pdf}
......@@ -32,4 +33,26 @@ Beleuchtung.
Papadopoulos und Papaioannou stellen einen Algorithmus vor, der einen sehr ähnlichen Ansatz zur hier
vorgestellten Umsetzung 2 bietet. Es wird versucht Schnittpunkte von Lichtstrahlen mit der Szene zu finden
und dann Linien-Primitive von den Schnittpunkten zur Lichtquelle zu zeichnen. Allerdings wird diese
Berechnung im Lightspace vorgenommen und nicht mittels Raytracing ausgeführt.
\ No newline at end of file
Berechnung im Lightspace vorgenommen und nicht mittels Raytracing ausgeführt.
%
\subsection{Ray Tracing Essentials Part 5: Ray Tracing Effects}
\paragraph{Quelle:} \url{https://news.developer.nvidia.com/ray-tracing-essentials-part-5-ray-tracing-effects/}
%
In diesem Video sagt Eric Haines in Bezug auf grafische Effekte beim Raytracing:
%
\begin{quote}
You can also atmospheric effects, so if, say you have a beam of light, you can do a thing called ray
marching, where the ray hits the beam, marches through it and light scattering in and light scattering out
and so and you just kind of walk through that thing and sample it as you go. And you can get these nice beams
of light, godrays, kind of effects.
\end{quote}
%
\paragraph{Anmerkung:} Der Begriff \gquote{ray marching} ist nicht eindeutig.
Prinzipiell beschreibt es - wie der Name vermuten lässt - eine Familie von Techniken, bei denen eine Strahl
abgetastet wird, bzw. bei denen entlang eines Strahls eine Funktion berechnet wird. Häufig wird die Technik
genutzt um den Schnittpunkt eines Strahls mit der Szene zu bestimmen (z.B. wenn die Objekte der Szene nicht
als Dreiecke sondern als mathematische Definitionen vorliegen).
\paragraph{Technik:}
Dieser kurze Ausschnitt des Videos stellt die Inspiration für Lösungsansatz 1 dar. Ein dichtes
Medium wird in der Szene modelliert und wenn ein Strahl dieses Medium durchläuft wird entlang des Strahls
die Lichtquelle gesampelt, der Strahl wird also \gquote{abgewandert}.
\ No newline at end of file
\section{Was ist Raytracing?}
Zunächst sollen die theoretischen Grundlagen des Raytracing beschrieben werden. Dazu gehört die Einführung der
Terminologie, z.B. die Erklärung, was ein Strahl in diesem Kontext überhaupt ist. Weiterhin sollen auch die
physikalischen Grundlagen der Technik kurz erklärt werden - vor allem in Hinblick auf das Prinzip der globalen
Beleuchtung und die Rendergleichung.\\
Hier bietet sich auch die Vertiefung der verschiedenen (Ab-)Arten des Raytracing an, da viele dieser Techniken
noch von Bedeutung sein werden.
Dabei sind vor allem die stochastischen Ansätze zu erwähnen, die
versuchen die Rendergleichung anzunähern, indem Strahlen in zufällige Richtungen erzeugt werden
(Monte-Carlo-Integration). Zur Bestimmung der groben Richtung der Strahlen werden dabei die BRDF oder
\textit{Multiple Importance Sampling} (MSI) genutzt, welche hier auch vertieft werden können.\\
Da durch diese Techniken oft ein verrauschtes Bild entsteht, bietet sich ein Exkurs zu Entrauschungstechniken
(Denoising) an, ist jedoch nicht essentiell für das eigentliche Thema.
%
\ No newline at end of file
......@@ -8,8 +8,6 @@ Wasser sein. Das Medium wird durch ein Objekt in der Szene umrissen.
\subsection{Umsetzung mittels Sampling der Lichtquelle aus dem Medium heraus}
%
Dieser Algorithmus ist anscheinend z.B. in Minecraft RTX implementiert, jedoch noch nicht weiter
beschrieben oder ausgearbeitet, daher lohnt sich die Überprüfung und Implementierung des Verfahrens.\\
Ein möglicher Algorithmus zur Lösung des Problems besteht darin, beim Durchgang eines Strahls durch ein
dichtes Medium mittels Schattenfühlern abzutasten, inwiefern der Strahl von der Lichtquelle aus erreichbar ist
und daraufhin zu berechnen, wieviel Licht entlang des Strahls zum Beobachter zurückgeworfen wird. Das grobe
......
......@@ -2,29 +2,29 @@
\begin{center}
\begin{tabular}{|lc|}
\hline
\textbf{Phase} & \textbf{Geschätzter Zeitbedarf in h} \\
\textbf{Phase} & \textbf{Geschätzter Zeitbedarf in h} \\
\hline
\textbf{Planung} & \textbf{240} \\
Algorithmus entwickeln & 120 \\
Änderungen an Infrastruktur planen & 30 \\
Implementierung planen & 60 \\
Überlegung zu Grenzfällen & 30 \\
\textbf{Planung} & \textbf{340} \\
Quellenarbeit/Recherche & 100 \\
Algorithmus entwickeln & 120 \\
Änderungen an Infrastruktur planen & 30 \\
Implementierung planen & 60 \\
Überlegung zu Grenzfällen & 30 \\
\hline
\textbf{Implementierung} & \textbf{330} \\
Verbesserung des bestehenden Programms & 100 \\
Anpassung für den jeweiligen Algorithmus & 50 \\
Implementierung selbst & 80 \\
Bug-Fixes & 100 \\
\textbf{Implementierung} & \textbf{260} \\
Verbesserung \& Anpassung der Engine & 100 \\
Implementierung selbst & 60 \\
Bug-Fixes & 100 \\
\hline
\textbf{Evaluierung} &\textbf{180} \\
Erstellung von Szenen für Grenzfälle & 40 \\
Visuelle Evaluierung & 30 \\
Bewertung der Implementierung & 30 \\
Bewertung anhand theoretischer Aspekte & 80 \\
\textbf{Evaluierung} & \textbf{100} \\
Erstellung von Szenen für Grenzfälle & 30 \\
Visuelle Evaluierung & 10 \\
Bewertung der Implementierung & 30 \\
Bewertung anhand theoretischer Aspekte & 30 \\
\hline
\textbf{Texterzeugung} &\textbf{150} \\
\textbf{Texterzeugung} & \textbf{200} \\
\hline
\textbf{Gesamt:} & \textbf{900} \\
\textbf{Gesamt:} & \textbf{900} \\
\hline
\end{tabular}
\end{center}
\ No newline at end of file
......@@ -22,41 +22,25 @@
\usepackage[hidelinks]{hyperref}
\usepackage{glossaries}
\usepackage[style]{abstract}
%
\pdfminorversion=7
\counterwithin{figure}{section}
\counterwithin{table}{section}
\counterwithin{equation}{section}
% \counterwithin{algorithm}{section}
\setcounter{secnumdepth}{3}
\lstset{language=C++,
basicstyle=\small,
keywordstyle={\bfseries \color{red}},
identifierstyle={\color{blue}},
commentstyle={\color{gray}},
showstringspaces=false}
%
\include{components/commands}
%
\begin{document}
\pagenumbering{gobble}
\input{components/title}
\clearpage
% \pagenumbering{roman}
% \tableofcontents
% \clearpage
\pagenumbering{arabic}
\input{components/preamble.tex}
\input{components/v2/grundlagen.tex}
\input{components/v2/problem.tex}
\input{components/v2/umsetzung.tex}
\input{components/v2/bewertung.tex}
\input{components/v2/quellen.tex}
\input{components/v2/gliederung.tex}
\input{components/v2/zeitplan.tex}
% \input{components/raytracing}
% \input{components/implementierung}
% \input{components/effekte}
% \input{components/entwicklung.tex}
\input{components/grundlagen.tex}
\input{components/problem.tex}
\input{components/umsetzung.tex}
\input{components/bewertung.tex}
\input{components/quellen.tex}
\input{components/gliederung.tex}
\input{components/zeitplan.tex}
\end{document}