Ray Tracing und Texturierung von Freiformflächen - OPUS Bayern

Diplomarbeit
RAY TRACING UND TEXTURIERUNG
VON FREIFORMFLÄCHEN
Fachbereich: Informatik
Verfasser: Josef Scheuer
Betreuer: Prof. Raymond Zavodnik

Vorwort
Diese Diplomarbeit basiert auf den Arbeiten von A. Riepl [7] und O. Groth [3]. Das Ziel
dabei war die Planung und Integration von Freiformflächen und deren Texturierung in ein
bestehendes Ray Tracing-System.
Diese Aufgabenstellung macht den Anschein eines sehr gut abgrenzbaren Themas. Die vielen
Sonderbehandlungen, die diese Objekte erfordern, führten in ihrer Implementierung jedoch zu
so manchem Designproblem. Daraus ergab sich die Notwendigkeit, bereits bestehende Teile
des Systems zu überarbeiten und an die neuen Gegebenheiten anzupassen. Nur so war es
möglich zu einem funktionsfähigen Ganzen zu kommen.
Durch diese Arbeit war es mir möglich, sehr tief in den Bereich der Computergraphik einzusteigen
und viele Erfahrungen zu sammeln. Daher gilt besonderer Dank meinem Betreuer
Herrn Prof. Raymond Zavodnik, bei dem ich immer ein offenes Ohr für meine Fragen fand,
und der mir bei Problemen oft neue Lösungswege aufzeigte.
An dieser Stelle möchte ich mich auch bei Herrn Prof. Dr. Wilhelm Barth bedanken, der diese
Diplomarbeit durch das Zusenden einiger seiner Arbeiten unterstützte.
Marius Strobl und Christian Buchberger danke ich für die Bereitstellung von Rechenkapazität
zur Erstellung der Beispielbilder. Ohne ihre Hilfe hätten die Berechnungen bei diesen hohen
Auflösungen ein Vielfaches an Zeit in Anspruch genommen.
Josef Scheuer
Regensburg
September, 2004
i

Inhaltsverzeichnis
Einführung v
1 Das Ray Tracing-Verfahren 1
1.1 Grundlegende Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Beleuchtungsmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Die Phong-Schattierung . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Das Whitted-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.3 Materialien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Schnittpunkt- und Normalenberechnung . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Primitive Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Objekt-Transformationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.1 Instancing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.5 Optimierungstechniken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5.1 Adaptive Depth Control . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5.2 Bounding Volumes . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5.3 Hierarchische Bounding Volumes und Octrees . . . . . . . . . . . . 9
2 Freiformflächen 10
2.1 Tensorprodukt-Flächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Bernstein-Polynome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Bézierkurven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3.1 Algorithmus nach de Casteljau . . . . . . . . . . . . . . . . . . . . . 14
2.3.2 Aufteilung von Bezierkurven . . . . . . . . . . . . . . . . . . . . . . 16
2.4 Bezierflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.1 Flächennormalen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4.2 Aufteilung von Bezierflächen . . . . . . . . . . . . . . . . . . . . . 19
2.5 Methoden zur Schnittpunktberechnung . . . . . . . . . . . . . . . . . . . . . 20
ii

INHALTSVERZEICHNIS iii
2.5.1 Das Newton Näherungs-Verfahren . . . . . . . . . . . . . . . . . . . 20
2.5.1.1 Konvergenzprobleme . . . . . . . . . . . . . . . . . . . . 21
2.5.2 Vorverarbeitung der Flächen . . . . . . . . . . . . . . . . . . . . . . 22
2.5.2.1 Das Parallelepiped als Hüllkörper . . . . . . . . . . . . . . 22
2.5.2.2 Kriterien zur Flächenaufteilung . . . . . . . . . . . . . . . 24
2.5.2.3 Organisation der Teilflächen . . . . . . . . . . . . . . . . . 25
2.5.2.4 Aufbau des Suchbaumes . . . . . . . . . . . . . . . . . . . 26
2.5.3 Schnittpunktermittlung . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.3.1 Durchsuchen der Flächensegmente . . . . . . . . . . . . . 27
2.5.3.2 Schnittberechnung der Hüllkörper . . . . . . . . . . . . . 28
2.5.3.3 Ermittlung des Iterationsstartpunkts . . . . . . . . . . . . . 29
2.5.3.4 Die Bedeutung der Grundfläche . . . . . . . . . . . . . . . 31
2.5.3.5 Der Iterationsablauf . . . . . . . . . . . . . . . . . . . . . 32
2.6 Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3 Texturierung 35
3.1 Arbeitsweise von Texturierungssystemen . . . . . . . . . . . . . . . . . . . . 36
3.2 Arten von Texturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2.1 2D Texture Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2.1.1 Die Bitmap-Textur . . . . . . . . . . . . . . . . . . . . . . 38
3.2.1.2 Environment Mapping . . . . . . . . . . . . . . . . . . . . 39
3.2.2 Prozedurale Texturen . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.2.1 Noise - Der Rauschgenerator . . . . . . . . . . . . . . . . 41
3.2.2.2 Die Karo-Textur . . . . . . . . . . . . . . . . . . . . . . . 43
3.2.2.3 Die Klotz-Textur . . . . . . . . . . . . . . . . . . . . . . . 44
3.2.2.4 Die Marmor-Textur . . . . . . . . . . . . . . . . . . . . . 44
3.2.2.5 Die Holz-Textur . . . . . . . . . . . . . . . . . . . . . . . 45
3.2.3 Bump Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.2.3.1 Die Bump-Funktion . . . . . . . . . . . . . . . . . . . . . 48
3.2.3.2 Grenzen des Bump Mapping . . . . . . . . . . . . . . . . 49
3.3 Das Textur-System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.4 Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4 Implementierung 51
4.1 Allgemeine Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

INHALTSVERZEICHNIS iv
4.1.1 Vorbereitungen und Parsing . . . . . . . . . . . . . . . . . . . . . . 52
4.1.2 Ablauf der Bildberechnung . . . . . . . . . . . . . . . . . . . . . . . 53
4.2 Die Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.2.1 Objekt-Transformation . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.2.2 Ablauf objektinterner Berechnungen . . . . . . . . . . . . . . . . . . 56
4.3 Die Texturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3.1 Das Textur-System . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3.2 Ablauf interner Textur-Berechnungen . . . . . . . . . . . . . . . . . 58
4.4 Änderungen am Gesamtsystem . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.4.1 Die Szenendefinition . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.4.1.1 Die Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.4.1.2 Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.4.1.3 Include-Dateien . . . . . . . . . . . . . . . . . . . . . . . 60
4.4.2 Die Bildformate . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
A Diagramme 61
B Parameterliste für den Programmstart 66
C Szenen-Definition 67
D C++ Quelltexte 73
Erklärung 211

Einführung
Computergenerierte Bilder und Animationen gehören mittlerweile zum Alltag. Man ist es
gewohnt, in Werbung, Film und Fernsehen synthetisch erzeugte Szenen zu sehen, die zum
Teil sehr nahe an die Grenze zur Photorealität reichen.
Der Aufwand den jedoch die Erstellung solcher Sequenzen erfordert bleibt meist im Verborgenen.
Abhängig von der Komplexität der Szene und dem eingesetzten Verfahren können die
Berechnungen dazu auch Rechnerfarmen über mehrere Wochen beschäftigen.
Die Berechnungsmethoden, die dabei zum Einsatz kommen und der Versuch damit die Realität
so gut wie möglich nachzubilden, machen die Computergraphik nach wie vor zu einem
der interessantesten Gebiete im weiten Feld der Computerwissenschaften.
Ray Tracing als eines der Verfahren ist Thema dieser Diplomarbeit. Speziell die Berechnung
von Freiformflächen und deren Texturierung stellen dabei die Schwerpunkte dar.
Kapitel 1 beschreibt die elementare Funktionalität des Ray Tracing. Die Grundlagen dazu
waren die Voraussetzungen für dieser Arbeit, weshalb auf diese auch nur kurz eingegangen
wird.
Kapitel 2 behandelt die Berechnung von Freiformflächen. Besonders in Verbindung mit
Ray Tracing werden dabei meist stark optimierte Verfahren eingesetzt. Die hier beschriebene
Methode basiert auf einer Arbeit von W. Barth und W. Stürzlinger.
Kapitel 3 erläutert die wesentlichen Vorgehensweisen zur Texturierung in Graphiksystemen.
Insbesondere die Integration in das vorliegende Ray Tracing-Systeme ist Thema dieses
Abschnittes.
Kapitel 4 stellt Details zur Implementierung und den Abläufen während den Berechnungen
dar. Dabei wird auch auf die Modifikationen und Erweiterungen des zu Grunde gelegten Ray
Tracing-Systems eingegangen.
v

Kapitel 1
Das Ray Tracing-Verfahren
Das Verfahren des Ray Tracing ist ein sehr intuitives Vorgehen zur synthetischen Erzeugung
photorealistischer Szenen. Die ersten Entwicklungen in diese Richtung gehen auf T. Whitted
in den späten 70’er Jahren zurück. Seit dieser Zeit wurden die dabei verwendeten Algorithmen
kontinuierlich verbessert und die Berechnungen durch viele Tricks beschleunigt, beruhen
jedoch nach wie vor auf den ursprünglichen Konzepten: Die Farbberechnung durch die Verfolgung
von Lichtstrahlen - vom Beobachter aus, zu den Objekten der Szene.
Eine vollständige Beschreibung der Verfahren ist in diesem Rahmen nicht möglich und auch
nicht Ziel dieser Arbeit. Da diese auf Ray Tracing aufbaut, soll hier dennoch ein kleiner Einblick
in die Algorithmen und Techniken gegeben werden. Für weitreichendere Informationen
sei hier allerdings auf auf die Diplomarbeit von Angela Riepl [7] und viele gute Bücher zu
diesem Thema (siehe Literaturverzeichnis im Anhang) verwiesen.

KAPITEL 1. DAS RAY TRACING-VERFAHREN 2
1.1 Grundlegende Funktionsweise
Licht ist eine grundlegende Voraussetzung für ein sichtbares Bild. In der Realität durchlaufen
Unmengen von Lichtstrahlen, ausgehend von Lichtquellen den Raum und breiten sich gemäß
den Regeln der Physik durch Strahlung, Brechung und Reflexion aus.
Ray Tracing basiert auf der Simulation der Lichtausbreitung nach den Gesetzen der Optik.
Tatsache ist jedoch, dass nur ein winziger Bruchteil des ausgesendeten Lichtes in das Auge des
Beobachters trifft. Es wäre ein unglaublich großer, wenn nicht gar unmöglicher Aufwand alle
Lichtstrahlen der Szene zu verfolgen. Deshalb wird bei diesem Verfahren die gegensätzliche
Richtung des Lichtes verfolgt: Vom Auge des Beobachters ausgehend, durch die Szene.
Für den Aufbau des Bildes wird durch jeden Punkt der Ansichtsebene wenigstens ein Lichtstrahl
in die Szene geschickt. Abbildung 1.1 zeigt diese Situation.
Die während der Verfolgung des Strahles S gesammelten Farbanteile bestimmen die Farbe,
die dieser Pixel im Bild annimmt. Um die entsprechenden Lichtanteile zu finden, werden für
die ausgesendeten Strahlen, im einfachsten Fall, jeweils alle Objekte der Szene auf Treffer
getestet. Bei mehreren Schnittpunkten (wie in der Abbildung P 1, P 2 und P 3), entscheidet
die Distanz zum Beobachter und es wird der am nächsten liegende Punkt gewählt (hier P 1).
Dadurch löst sich auf elegante und einfache Weise das Problem der Hinterschneidungen und
verdeckten Flächen.
Auch die sehr einfache Berechnung des Schattenwurfes ist eine der Stärken des Ray Tracing.
Die Entscheidung, ob der Punkt eines getroffenen Objektes im Licht oder Schatten liegt, kann
einfach durch die Verfolgung eines Strahls (hier L1 bzw. L2) in Richtung der Lichtquellen
entschieden werden.
S
P1
L1
Abbildung 1.1: Grundlegende Funktionsweise des Ray Tracing
L2
P2
P3

KAPITEL 1. DAS RAY TRACING-VERFAHREN 3
1.2 Beleuchtungsmodelle
Die physikalischen Vorgänge, die beim Auftreffen von Licht auf einer Oberfläche stattfinden,
sind entscheidend für das Erscheinungsbild von Körpern. Diese Abläufe können durch
komplexe Berechnungsverfahren sehr genau bestimmt werden, erfordern aber auch einen sehr
hohen Aufwand an Rechenkapazität. Daher werden sie meist durch die Näherungsberechnungen
der verschiedenen Beleuchtungsmodelle beschrieben, die das Geschehen mehr oder weniger
gut nachbilden. Auf die dafür durchgeführten Berechnungen sei hier nur in aller Kürze
eingegangen.
1.2.1 Die Phong-Schattierung
Ein einfach und sehr schnell zu berechnendes Modell, ist die Schattierung nach Phong 1 . Dabei
handelt es sich um ein rein lokales Beleuchtungsmodell - d.h. in den Berechnungen der
Lichtanteile werden nur die Lichtquellen und die Informationen der Oberfläche, wie Material
und Farbe berücksichtigt. Berechnungen von Transparenz und Reflexionen anderer Objekte
sind deshalb nicht möglich. Aus diesem Grund wird das reine Phong-Modell im Bereich des
Ray Tracing, wenn überhaupt, nur für schnelle Näherungsberechnungen eingesetzt.
Nach Phong wird das Licht dabei in drei Teile aufgespalten:
• Das ambiente Licht hat keinen ausgezeichneten Ursprung oder Richtung. Es stellt vielmehr
eine Art Grundleuchten der Objekte, unabhängig von den Lichtquellen dar.
• Der diffuse Lichtanteil berücksichtigt die Lage eines Punktes bezüglich der Lichtquellen.
Daher sind verdunkelte Stellen der Oberfläche durch Schatten unter anderem auf
das Fehlen dieses Lichtanteils zurückzuführen.
• Der spekulare unterscheidet sich vom diffusen Anteil des Lichtes durch zusätzliche
Berücksichtigung des Beobachterstandpunktes. Dadurch entstehen die Glanzeffekte der
Oberflächen. In die Berechnung dieser Komponente fließt auch ein Wert n für die Rauhheit
der Oberfläche mitein.
Dadurch die Summierung und Skalierung der einzelnen Lichtkomponenten entsteht die Farbinformation
im berechneten Punkt.
IP hong := kaIa ����
ambient
+ kdId + ksIs(n)
���� � �� �
diffus spekular
(1.1)
Dabei werden durch die Faktoren ka, kd und ks sowie dem Wert n, die Eigenschaften des
Materials in die Berechnung miteinbezogen (vgl. Abschnitt 1.2.3).
1 Phong Bui-Tuong: ”Illumination for Computer Generated Pictures”, 1975

KAPITEL 1. DAS RAY TRACING-VERFAHREN 4
1.2.2 Das Whitted-Modell
Das Modell nach Whitted verbessert die Berechnung des sekularen Lichtanteils nach Phong
und erweitert die Schattierung um die globalen Lichtanteile der Transparenz und Reflexion.
Die Ermittlung dieser Anteile verlangt eine gesonderte Verfolgung der gebrochenen bzw.
reflektierten Lichtstrahlen. Daher lassen sich die dafür notwendigen Berechnungen sehr gut
durch rekursive Verfahren beschreiben und implementieren.
Dieses Modell ergänzt die Berechnungen nach Phong durch folgende Lichtanteile:
• Transparente Flächen verursachen durch den Übergang des Lichtstrahls von Luft (bzw.
Vakuum) in das transparente Medium, eine Richtungsänderung des Strahls - er wird
gebrochen. Diese Änderung kann durch das Snelliussche Brechungsgesetz, abhängig
vom Brechungsindex η berechnet werden.
• Eine Reflexion des Lichtstrahls tritt bei verspiegelten Oberflächen auf. Dabei wird die
Richtung des einfallenden Strahls gemäß dem Reflexionsgesetz 2 verändert.
Daraus ergibt sich für die erweiterte Berechnung des Whitted-Modells:
IW hitted := kaIa ����
+ kdId ����
ambient diffus
+ ksIs(n)
� �� �
spekular
+ ktIt(η)
� �� �
T ransparenz
+ krIr
����
Reflexion
(1.2)
Die Faktoren kt und kr sowie der Brechungsindex η, sind dabei abhängig vom Material.
Das Whitted-Beleuchtungsmodell wird sehr häufig in Ray Tracing-Systemen eingesetzt. Es
kann schnell ausgewertet werden und liefert trotz seiner Einfachheit recht gute Ergebnisse.
1.2.3 Materialien
Die Gewichtung der einzelnen Lichtanteile hängt von den Materialeigenschaften der Oberfläche
ab. Deshalb zählen diese bei der Auswertung des Beleuchtungsmodells zu den entscheidenden
Faktoren und werden in Form von Koeffizienten in den Berechnungen berücksichtigt.
Für die Simulation verschiedener Materialien ist die Wahl der Materialkoeffizienten sehr
wichtig. Besonders an Stellen der Oberfläche an denen Glanzlichter auftreten, beeinflussen
diese Faktoren das Erscheinungsbild des Materials erheblich.
Für gewöhnlich wird bei der Festlegung der Koeffizienten nicht zwischen den Farbkanälen
Rot, Grün und Blau unterschieden. Dieses verleiht den Materialien allerdings ein eher plastikartiges
Aussehen.
Durch Unterscheidung der Farbkanäle und sorgfältiger Auswahl der Werte, kann eine etwas
realistischere Erscheinung erzielt werden (vgl. [6],[4]).
2 Der Betrag des Einfallswinkels ist gleich dem Betrag des Reflexionswinkels

KAPITEL 1. DAS RAY TRACING-VERFAHREN 5
1.3 Schnittpunkt- und Normalenberechnung
Im Ray Tracing tasten Strahlen die Szene nach darstellbaren Objekten ab. Deshalb sind die
Algorithmen zur Ermittlung von Schnittpunkten des Strahls mit den Objekten zentraler Bestandteil
von Ray Tracing-Systemen, denn letztendlich bestimmen diese Berechnungen die
Form, Größe und Position von allen Objekten der Szene. Um dabei auch die richtigen Berechnungen
durchzuführen, ist natürlich eine Unterscheidung der Körper notwendig. Je nach
Art des Objekts wird ein Algorithmus benötigt, der Schnittpunkte identifizieren und berechnen
kann (vgl. [2]).
Eine weitere, sehr wichtige Größe ist die Flächennormale. Diese hat auf die Auswertung des
Beleuchtungsmodells entscheidenden Einfluss. Auch zu deren Ermittlung muss zwischen den
Objekten unterschieden werden und erfordert ein jeweils eigenes Verfahren. Dabei ist jeweils
zu beachten, dass die Normale in Richtung des Strahlenursprungs zeigen muss.
1.3.1 Primitive Objekte
Die Verfahren zur Bestimmung von Schnittpunkten und Normalen einiger Grundkörper wurden
aus der Arbeit von A. Riepl [7] übernommen, mussten jedoch aufgrund einiger Erweiterungen
angepasst werden. Die deshalb veränderten Algorithmen werden im Folgenden kurz
beschrieben.
Die Berechnungen liefern dabei jeweils die Distanz t zum Ursprung o des Strahls 3 .
Daraus errechnet sich der tatsächliche Schnittpunkt durch Einsetzen in die Strahlengleichung
mit dem normierten Vektor d als Richtung des Strahles.
hitP oint := o + td (1.3)
Die Ebene ist eines der am einfachsten zu berechnenden Objekte. In der Normalenform mit
dem Koordinatenursprung (< 0, 0, 0 >) als Aufpunkt und dem Basisvektor Z (< 0, 0, 1 >) als
Normale, errechnet sich die Distanz mittels
tplane := −oz
dz
(1.4)
Die Normale ist durch die Annahme bereits festgelegt. Das Vorzeichen von t gibt Auskunft
über den Halbraum, in dem der Strahlursprung liegt. Besitzt t ein negatives Vorzeichen, so
muss die Normale negiert werden um in Richtung des Strahlursprungs zu zeigen.
Die Kugel weist bei einem Schnitt in der Regel zwei Schnittpunkte auf. Dabei ist nur der
in positiver Richtung, am nächsten zum Strahlursprung liegende Punkt von Bedeutung.
3 Diese zum Teil sehr vereinfachten Rechenschritte gelten nur für die gemachten Annahmen und leiten sich
aus den allgemein gültigen Verfahren ab.

KAPITEL 1. DAS RAY TRACING-VERFAHREN 6
Für den Ursprung als Zentrum und einem Radius von 1 ergeben sich die Distanzen durch
tsphere0,1 := −(d · o) ± � (d · o) 2 − (d · d)(o · o − 1)
d · d
(1.5)
Durch Auswertung des Terms unter der Wurzel - die Diskriminante - können bereits Aussagen
über die Anzahl der Schnittpunkte gemacht werden: Ist die Diskriminante negativ, so verfehlt
der Strahl die Kugel. Bei einem Wert von 0 existiert nur eine Lösung und der Strahl berührt
die Kugel in einem Punkt. Für alle positiven Werte existieren zwei Lösungen - für den Einund
Austrittspunkt des Strahls (vgl. Abbildung 1.2(a)).
Durch die Lage im Ursprung kann zur Bestimmung der Normalen einfach der durch die Strahlengleichung
ermittelte Schnittpunkt als Vektor aufgefasst und verwendet werden. Durch den
Radius von 1 erübrigt sich auch die Normierung.
Ein Zylinder mit einem Radius und einer Höhe von 1, wird mit einer Grundstellung auf
der positiven Y -Achse angenommen. (vgl. Abbildung 1.2(b)). Durch einen Schnitt mit dem
Strahl ergeben sich im Allgemeinen die Distanzen zweier Punkte.
tcylinder0,1 := a ± � a2 − b(o2 x + o2 z + 1)
, wobei (1.6)
b
a = −(oxdx + ozdz) und b = d 2 x + d 2 z
Auch hier entstehen nur für die reellen Lösungen von t, Schnittpunkte mit dem Zylinder.
Diese sind jedoch nur dann gültig, wenn die Y -Koordinate der dadurch festgelegten Punkte
nicht über die Höhe des Zylinders hinausgehen, also o.y + tdy ∈ [0, 1].
Wie in der Abbildung angedeutet, liegt die Normale in einer Ebene parallel zur XZ-Ebene.
Deshalb reicht zu deren Bestimmung die Projektion des Schnittpunktes. Dazu wird der
gewählte Punkt als Vektor behandelt, und dessen Y -Koordinate auf 0 gesetzt. Durch einen
Zylinderradius von 1 besitzt dieser auch schon die normierte Länge.
Für die Innenseite der Zylinderoberfläche muss die Normale allerdings negiert werden. Dieser
Fall tritt bei unterschiedlichen Vorzeichen der beiden Lösungen (sofern vorhanden) auf.
S
n
P1
−1
(a)
1
Radius = 1
0
−1
P2
1
S
n
P1
y
P2
Radius = 1
Abbildung 1.2: Schnittpunkt- und Normalenberechnung bei primitiven Objekten
(a) Kugel. (b) Zylinder.
−1
−1
(b)
1
0
Höhe = 1
1
z
x

KAPITEL 1. DAS RAY TRACING-VERFAHREN 7
1.4 Objekt-Transformationen
Die Algorithmen zur Berechnung von Schnittpunkten und Normalenvektoren gehen von einem
Initialzustand des jeweiligen Objektes aus. Dadurch haben alle definierten Objekte eine
festgelegte Ausrichtung und liegen im Ursprung des Koordinatensystems.
Dieser Zustand ist noch nicht optimal. Es soll schließlich möglich sein, die Objekte frei im
Raum anzuordnen, zu drehen und zu verzerren. Dazu müssen Objekt-Transformationen in das
System integriert werden.
1.4.1 Instancing
Die Technik des Instancing erlaubt die freie Transformation von Objekten. Dazu werden alle
Objekte mit einem eigenen Koordinatensystem ausgestattet. Für die Ermittlung von Schnittpunkten
und Normalen macht es keinen Unterschied, ob eine Transformation auf das Objekt
oder die dazu inverse Transformation auf den Strahl angewendet wird. Deshalb ist es sinnvoll,
nicht die Punkte der Objektdefinition, sondern den Ursprung und den Richtungsvektor des
Strahls zu transformieren. Dadurch wird es auch auf einfache Weise möglich, die Transformationen
auf alle Typen von Objekten, völlig unabhängig von deren internen Berechnungen,
anzuwenden.
Durch die Transformation des Strahls, werden objektspezifische Berechnungen im standardisierten
Objekt-Koordinatensystem durchgeführt. Dadurch befindet sich die ermittelte Normale
natürlich innerhalb dieses Systems. Die Berechnungen der Schattierung durch das Beleuchtungsmodell
basieren jedoch auf Weltkoordinaten. Aus diesem Grund muss eine Rücktransformation
der Normalen erfolgen (siehe Abbildung 1.3).
Dabei gilt es jedoch einen Punkt zu beachten: Anders als bei Transformation von herkömmlichen
Vektoren, muss bei Normalenvektoren die transponierte der dazu inversen Transformation4
angewendet werden:
(1.7)
S
−1
M x S
�nworld = (M −1 ) T �nobject
y
1
0
S
n
1
z
x
−1 T
(M ) x n
Abbildung 1.3: Die Transformation von Strahl und Normalenvektor
4 Dies ist die gleiche Transformation, mit der bereits der Strahl in das Objekt-System überführt wurde
n

KAPITEL 1. DAS RAY TRACING-VERFAHREN 8
1.5 Optimierungstechniken
Ray Tracing ist ein recht intuitives Verfahren zur Erzeugung photorealistischer Bilder, das
trotz seiner Einfachheit recht gute Ergebnisse liefern kann. Leider fällt dieses Verfahren allerdings
auch durch seinen enormen Bedarf an Rechenleistung auf. Untersuchungen am Algorithmus
zeigen, dass dabei der weitaus größte Teil, etwa 95%, auf die Suche und die Berechnung
von Schnittpunkten entfällt. Daher sind Möglichkeiten zur Optimierung des Vorgehens
gefragt.
Es gibt viele Ansätze, die alle mehr oder weniger zur Verbesserung des Laufzeitverhaltens
beitragen. Die dabei am häufigsten eingesetzten Methoden beruhen auf den Prinzipien der
Raumaufteilung und Bewertung der Relevanz von Farbanteilen.
Im Folgenden wird auf die wichtigsten Verfahren kurz eingegangen: Adaptive Depth Control,
Bounding Volumes und Octrees.
1.5.1 Adaptive Depth Control
Beleuchtungsmodelle ermitteln die Farbinformation eines Punktes durch Aufspaltung und
getrennte Berechnung der Lichtanteile (vgl. Abschnitt 1.2). Die Anteile durch Transparenz
und Reflexion werden dabei durch rekursive Verfolgung der gebrochenen bzw. reflektierten
Strahlen berechnet. Verspiegelte Flächen, zwischen denen Lichtstrahlen unendlich hin- und
her-reflektiert werden, würden dadurch eine Endlosrekursion verursachen. Deshalb muss eine
Beschränkung der Rekursionstiefe definiert werden, die bei erreichen der Grenze einen
weiteren Abstieg verhindert.
Während der Verfolgung des Strahls geht, aufgrund der Materialeigenschaften, durch Streuung
und Dämpfung Leuchtkraft verloren. Darum nimmt der Beitrag, den ein weiterverfolgter
Strahl zur Farbinformation des Bildpunktes liefert, stetig ab.
Bei Einsatz von Adaptive Depth Control, wird dieser Beitrag überwacht. Sinkt dieser unter
einen festgelegten Schwellwert, ist der Lichtanteil zu gering und die Verfolgung des Strahls
wird vorzeitig abgebrochen. Dadurch werden sehr lichtschwache Strahlen nicht bis zur maximalen
Rekursionstiefe verfolgt und die dazu notwendigen Berechnungen vermieden.
1.5.2 Bounding Volumes
Der weitaus größte Teil des Rechenaufwands wird beim Ray Tracing durch die Suche nach
Schnittpunkten verursacht. Da für jeden Strahl alle Objekte der Szene auf Schnittpunkte getestet
werden müssen, liegt das größte Optimierungspotential im Algorithmus der Schnittpunktsuche.
Der für den Test eines Objektes notwendige Rechenaufwand hängt von der Komplexität der
Schnittpunktberechnung ab. Dieser Aufwand unterscheidet sich zwischen den verschiedenen
Objekten zum Teil erheblich. Bei Körpern wie Ebenen oder Kugeln sind Schnittpunkte sehr
einfach und schnell zu berechnen. Für komplexere Objekte, wie Freiformflächen kann diese
Auswertung jedoch sehr viel mehr Rechenzeit beanspruchen.

KAPITEL 1. DAS RAY TRACING-VERFAHREN 9
Die Technik der Bounding Volumes basiert auf der Idee, komplexe Objekte in virtuelle, einfach
zu berechnende Körper einzuschließen. Bei der Überprüfung auf Schnittpunkte wird erst
der Hüllkörper auf Treffer getestet. Verläuft dieser Test negativ, verfehlt der Strahl den umgebenden
Körper und kann so auch das darin eingeschlossene Objekt nicht schneiden.
Dadurch ist auch bei sehr aufwändig zu berechnenden Körpern eine sehr schnelle Überprüfung
möglich und eine vollständige Berechnung des Schnittpunktes muss nur bei Bedarf
durchgeführt werden.
Zur optimalen Ausnutzung dieses Verfahrens, müssen als Bounding Volume verwendete Objekte
folgende Anforderungen erfüllen:
• Komplette Umhüllung: Das eingeschlossene Objekt muss komplett im Hüllkörper enthalten
sein.
• Enge Umschliessung: Die Hülle sollte möglichst eng am Objekt anliegen. Dadurch werden
unnötige Schnittpunktberechnungen vermieden.
• Schneller Test: Der Hüllkörper sollte möglichst schnell auf Treffer getestet werden
können.
Um diese Forderungen zu erfüllen, sollten die als Bounding Volume verwendeten Objekte
passend zu den Formeigenschaften der umhüllten Körper gewählt werden. Zu den dazu am
häufigsten eingesetzten Objekten zählen Kugeln, Quader und Parallelepipeds.
1.5.3 Hierarchische Bounding Volumes und Octrees
Die Hierarchische Organisation erweitert das Konzept der Bounding Volumes um die Information
der geometrischen Anordnung von Objekten innerhalb der Szene. Darunter ist eine
rekursive Verschachtelung von Bounding Volumes zu verstehen, die es ermöglicht, Objekte,
gruppiert nach ihrer Lage in der Szene, zusammenzufassen. Durch diese Art der Raumunterteilung
ist es möglich, die Körper für die Schnittpunktberechnungen gezielt auszuwählen und
Objekte, die in nicht betroffenen Bereichen der Szene liegen, von vorn herein auszuschließen
und bei den Schnittpunkttests zu übergehen.
Eines der Verfahren, die auf diese Strategie aufbauen, ist der Octree. Diese Art der Optimierung
wurde bereits im Rahmen der Diplomarbeit von Angela Riepl [7] beschrieben und
implementiert. Deshalb sei hier nicht näher darauf eingegangen.
Ein zum Octree sehr ähnliches Verfahren wird bei der Schnittpunktberechnung von Freiformflächen
benutzt und wird im Kapitel 2, Abschnitt 2.5.2.3 eingehend beschrieben.

Kapitel 2
Freiformflächen
Bei der Modellierung von Szenen, die dem großen Vorbild Realität möglichst nahe kommen
wollen, spielen gekrümmte und unregelmäßige Oberflächen eine entscheidende Rolle. Es besteht
die Möglichkeit, diese Art von Flächen mittels Approximation durch primitive Objekte
zu konstruieren. Bei umfangreichen Modellen oder stark detaillierten Oberflächen ist dies allerdings
ein sehr schwieriges und mühsames Unterfangen. Zudem erfordert dieses Vorgehen
ein hohes Maß an Speicher- und Rechenkapazität und kann so die Möglichkeiten bei der Gestaltung
von Szenen merklich einschränken.
Ein weiterer Nachteil macht sich besonders bei Ray Tracing-Verfahren bemerkbar: Die stark
erhöhte Anzahl von Objekten. Da für die Ermittlung von Schnittpunkten des Strahls die
Schnittalgorithmen aller Objekte durchgeführt werden müssen, wirkt sich dieses negativ auf
die Laufzeit aus. So eignet sich dieses Vorgehen nur begrenzt für den Einsatz.
Freiformflächen stellen hier eine effiziente Methode zur Lösung der genannten Probleme dar.
Diese, durch Kontrollpunkte definierten Flächen bieten durch ihre Flexibilität erstaunliche
Möglichkeiten bei der Modellierung. Durch Ausnutzung der mathematischen Eigenschaften
dieser Art von Flächen ist es dennoch möglich, die hierzu notwendigen Berechnungen schnell
durchzuführen. Dadurch finden Freiformflächen auch im sehr rechenintensiven Bereich des
Ray Tracing Verwendung.

KAPITEL 2. FREIFORMFLÄCHEN 11
2.1 Tensorprodukt-Flächen
Es gibt verschiedene Vorgehensweisen zur Konstruktion von Freiformflächen. Einen sehr naheliegenden
und intuitven Ansatz bildet hier das Tensorprodukt von Freiformkurven.
Es seien F und G zwei Kurven im dreidimensionalen Raum:
F (t) = �
Ni(t)bi G(t) = �
Mi(t)di
i
i
bi, di ∈ R 3
mit den skalaren Basisfunktionen Ni(t) und Mi(t). Daraus ergibt sich für das Tensorprodukt:
P (u, v) := � �
Ni(u)Mk(v)ci,k ci,k ∈ R 3
(2.1)
i
k
Die Eigenschaften der daraus resultierenden, viereckigen Oberflächen werden dabei vom Verhalten
der zu Grunde gelegten Freiformkurven bestimmt. Zu den wichtigsten Anforderungen
an die Interpolationsverfahren dieser Kurven zählen hierbei:
• Kontrollierbarkeit: Die Veränderung von Parametern hat voraussagbare und kontrollierbare
Auswirkungen auf den Verlauf der Kurve.
• Lokalität: Eine lokale Änderung von Kontrolldaten hat im Idealfall nur eine Veränderung
in einem kleinen Bereich des Kurvenverlaufs zur Folge. Die Auswirkungen auf die
globale Gestalt sind gering.
In den folgenden Abschnitten wird die Technik der Tensorprodukt-Flächen anhand Bézierkurven
und den sich ergebenden Bézieroberflächen genauer beschrieben.
2.2 Bernstein-Polynome
Freiformkurven entstehen durch Gewichtung und Summation ihrer Kontrollpunkte. Die Gewichtung
erfolgt dabei durch die Basis- oder Überblendungsfunktionen. Im Falle von Bézierkurven
(vgl. Abschnitt 2.3) werden dazu Bernstein 1 -Polynome verwendet.
Definition von Bernstein-Polynomen
Ein Bernstein-Polynom vom Grad n ist definiert durch:
B n i (t) :=
� �
n
t
i
i (1 − t) n−i
Desweiteren wird festgelegt: B n i (t) ≡ 0, falls i < 0 oder i > n.
1 Sergei N. Bernstein, 1912
t ∈ [0, 1] , i = 0, · · · , n (2.2)

KAPITEL 2. FREIFORMFLÄCHEN 12
Eigenschaften von Bernstein-Polynomen
Bernstein-Polynome weisen einige interessante Eigenschaften auf, wodurch sie sich sehr gut
als Überblendungsfunktion von Freiformkurven eignen:
• Positivität: Für t ∈ [0, 1] gilt:
• Symmetrie: Bernstein-Polynome sind symmetrisch, da
B n i (t) ≥ 0. (2.3)
B n i (t) = B n n−i(1 − t). (2.4)
• Zerlegung der Eins: Wie sich mit Hilfe des Binomischen Lehrsatzes2 leicht zeigen
lässt, gilt:
n�
B n i (t) ≡ 1 ∀t ∈ [0, 1] (2.5)
i=0
Dadurch stellt die Interpolation von Punkten eine affine Kombination dar.
• Rekursivität: Die Berechnung der Werte kann rekursiv erfolgen, wegen:
Bn i (t) = (1 − t)B n−1
i (t) + tB n−1
i−1 (t), wobei (2.6)
B0 0(t) = 1, B0 1(t) = 0 und B0 −1(t) = 0.
• Extrema: Für B n i (t) ergibt sich in [0, 1] genau ein Maximum. Dieses liegt bei t = i
n .
Abbildung 2.1 zeigt die Graphen der Bernstein-Polynome für den Grad 3. Die genannten
Eigenschaften sind deutlich im Verlauf der Kurven erkennbar.
1
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
B 3
0
B B
3
1
0
0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1
Abbildung 2.1: Verlauf von Bernstein-Polynomen vom Grad 3
2 Binomischer Lehrsatz: (a + b) n = n�
k=0
� � n k n−k
k a b
3
2
B
3
3
t

KAPITEL 2. FREIFORMFLÄCHEN 13
2.3 Bézierkurven
Bézierkurven wurden 1959 von Paul de Casteljau bei Citroën und unabhängig davon, Anfang
der sechziger Jahre, von Pierre Bézier bei Rénault für den Entwurf von Autokarosserien entwickelt.
Diese Art der Kurvendarstellung revolutionierte die Entwicklung von frei geformten
Kurven und Oberflächen in CAD-Systemen.
Inzwischen finden Bézierkurven in vielen Bereichen der Computergraphik Verwendung und
dienen unter anderem als Basis für die Berechnung von Zeichen in PostScript-Systemen.
Definition von Bézierkurven
Eine Bézierkurve vom Grad n wird definiert durch:
F (t) :=
n�
B n i (t)bi
i=0
t ∈ [0, 1] , bi ∈ R 3
(2.7)
mit dem Bernstein-Polynom B n i (t) (vgl. Abschnitt 2.2) als Basis- oder Überblendungsfunktion.
Daraus ergibt sich für eine kubische Bézierkurve in der parametrierten Form:
F (t) = (1 − t) 3 b0 + 3(1 − t) 2 tb1 + 3(1 − t)t 2 b2 + t 3 b3
(2.8)
Die Punkte bi werden als Kontroll- oder Bézier-Punkte bezeichnet und bilden das Kontrollpolygon
P der Kurve (siehe Abbildung 2.2).
y
0.5
0.4
0.3
0.2
0.1
0
b1
Eigenschaften von Bézierkurven
b
0
F
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
Abbildung 2.2: Eigenschaften von Bézierkurven
Bézierkurven erfüllen die bereits erwähnten Anforderungen der Kontrollierbarkeit und Lokalität
(vgl. Abschnitt 2.1) und besitzen darüberhinaus einige wichtige Formeigenschaften, die
K
b
3
P
H
b
2
x

KAPITEL 2. FREIFORMFLÄCHEN 14
sie für den Bereich der Computergraphik so interessant machen. Diese Eigenschaften sind in
Abbildung 2.2 dargestellt und begründen sich durch das Verhalten der Bernstein-Polynome
(vgl. Abschnitt 2.2) als ihre Basisfunktion. Im Einzelnen sind dies:
• Affine Invarianz: Die Kurve verhält sich invariant bei affinen Abbildungen der Kontrollpunkte
- d.h. für eine affine Abbildung ϕ(x) = Ax + b gilt:
ϕ(F (t)) =
n�
B n i (t)ϕ(bi). (2.9)
i=0
• Endpunkt-Interpolation: Die beiden Kontrollpunkte b0 und bn liegen auf der Kurve,
was für die dazwischenliegenden Punkte im Allgemeinen nicht gilt.
F (0) = b0 und F (1) = bn. (2.10)
• Eigenschaft der konvexen Hülle: Eine Bézierkurve liegt vollständig innerhalb der konvexen
3 Hülle K, die durch ihre Kontrollpunkte definiert wird. Für 0 ≤ t ≤ 1 gilt:
F (t) ∈ K bzw. F ⊆ K. (2.11)
• Tangentenbedingung: In ihren Endpunkten verläuft die Kurve tangential zum Kontrollpolygon.
F ′ (0) = n(b1 − b0) und F ′ (1) = n(bn − bn−1) (2.12)
• Variationsreduzierung: Eine Bézierkurve F schwankt in ihrem Verlauf nicht stärker
als ihr Kontrollpolygon P - denn für eine beliebige Hyperebene H in R d (z.B. Gerade
in R 2 ) gilt:
#(H ∩ F ) ≤ #(H ∩ P ). (2.13)
2.3.1 Algorithmus nach de Casteljau
De Casteljau entwickelte 1959 einen einfachen Algorithmus zur geometrischen Konstruktion
der Punkte einer Bézierkurve. Das Verfahren beruht dabei auf der wiederholten Anwendung
der linearen Interpolation von Punkten und ist definiert als:
b k i (t) = (1 − t)b k−1
i−1 (t) + tbk−1 i (t) i = 1, · · · , n; k = 0, · · · , i (2.14)
Ist n der Grad der Kurve, so stellt b n n(t) einen Kurvenpunkt dar.
Abbildung 2.3 zeigt dieses Vorgehen anhand der Konstruktion des Punktes F (0.6) auf einer
Bézierkurve vom Grad 2.
Für t = 0.6 ergibt sich hier der Punkt b 1 1 durch lineare Interpolation der Kontrollpunkte b 0 0
und b 0 1. Äquivalent dazu folgt der Punkt b 1 2, für gleiches t, aus den Kontrollpunkten b 0 1 und b 0 2.
Daher können diese Punkte beschrieben werden als:
b 1 1 = (1 − t)b 0 0 + tb 0 1 und b 1 2 = (1 − t)b 0 1 + tb 0 2. (2.15)
3 Eine Punktmenge M heißt konvex, wenn für zwei beliebige Punkte p1, p2 ∈ M gilt: p1p2 ∈ M

KAPITEL 2. FREIFORMFLÄCHEN 15
y
0.5
0.4
0.3
0.2
0.1
0
b
0
0
b
1
1
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
b
0
1
2
b = F(t)
Abbildung 2.3: Geometrische Punktkonstruktion nach de Casteljau
Die erneute Anwendung der linearen Interpolation auf die Punkte b 1 1 und b 1 2 mit gleichem t
liefert den Kurvenpunkt
b 2 2 = (1 − t)b 1 1 + tb 1 2. (2.16)
Durch Substitution der Gleichungen (2.15) in (2.16) und anschließender Umformung zeigt
sich die aus den Gleichungen (2.7) und (2.2) bekannte Form:
b 2 2 = (1 − t) 2 b 0 0 + 2t(1 − t)b 0 1 + t 2 b 0 2 (2.17)
= 1 · t 0 (1 − t) 2 b 0 0 + 2 · t 1 (1 − t) 1 b 0 1 + 1 · t 2 (1 − t) 0 b 0 2 (2.18)
=
� �
2
0
t 0 (1 − t) 2−0 b 0 0 +
� �
2
1
t 1 (1 − t) 2−1 b 0 1 +
2
b
� �
2
2
1
2
b
0
2
x
t 2 (1 − t) 2−2 b 0 2
(2.19)
Für den allgemeinen Fall lässt sich dieses Verfahren sehr gut durch das de Casteljau-Schema
darstellen:
b0 = b 0 0
↘
b1 = b 0 1 → b 1 1
↘ ↘
b2 = b 0 2 → b 1 2 → b 2 2
.
.
. ..
.
. ..
bn−1 = b 0 n−1 → b 1 n−1 → b 2 n−1 · · · b n−1
n−1
↘ ↘ ↘
bn = b 0 n → b 1 n → b 2 n · · · b n−1
n → b n n
Abbildung 2.4: Berechnungsschema nach de Casteljau
.
. ..

KAPITEL 2. FREIFORMFLÄCHEN 16
2.3.2 Aufteilung von Bezierkurven
In den meisten Fällen werden Bézierkurven über dem Intervall 4 [0,1] definiert und können für
Parameter innerhalb dieses Bereichs aufgeteilt werden. Dieses wird durch die Unterteilung
der Kontrollpunkte in zwei neue Kontrollpunktmengen erreicht. Abbildung 2.5 zeigt dies am
Beispiel der Unterteilung einer kubischen Bézierkurve an der Stelle c.
y
0.5
0.4
0.3
0.2
0.1
0
l 1
b1
b = l
0
0
L
l 2
l 3 = F(c) = r0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9
b2
b = r
Abbildung 2.5: Aufteilung einer kubischen Bézierkurve
Wie in der Abbildung ersichtlich, können die zu bestimmenden Endpunkte der Teilkurve L
direkt übernommen werden: Der Punkt l0 ist identisch mit dem Punkt b0 der Originalkurve.
Der Endpunkt l3 entsteht aus der Durchführung des de Casteljau-Algorithmus für den Parameter
c. Dies folgt aus der Eigenschaft von Bézierkurven (2.10).
Für die Bestimmung der beiden Zwischenpunkte l1 und l2 kann die Tangentenbedingung
(2.12) bzw. die Ableitungen der Kurven genutzt werden. Hieraus ergibt sich:
l1 = b0 + c(b1 − b0)
l2 = (1 − c) 2 b0 + 2c(1 − c)b1 + c 2 b2
Wie sich herausstellt, ergeben sich diese Punkte direkt durch die lineare Interpolation bei der
Durchführung des de Casteljau- Algorithmus (vgl. (2.15) und (2.17)). Durch die Symmetrie,
die Bézierkurven aufweisen, gelten diese Zusammenhänge auch für die Teilkurve R.
Deshalb können die Kontrollpunkte der beiden Teilkurven durch die Schritte im de Casteljau-
Algorithmus bestimmt werden:
li = b i i(c) und ri = b n−i
n i = 0, · · · , n (2.20)
Die entstandenen Kontrollpolygone der Teilkurven L und R bilden eine bessere Näherung der
Kurve als das ursprüngliche. So entsteht durch weitere, gleichmäßige Unterteilung der Teilkurven
eine Folge von Kontrollpolygonen, die quadratisch gegen die Bézierkurve konvergiert.
4 Das Parameterintervall ist von der verwendeten Basisfunktion abhängig. Für das verallgemeinerte Bernstein-
Polynom gilt: ∆ := [a, b] , B ∆,n
i (t) = 1
(b−a) n
� n
i
� (t − a) i (b − t) n−i
r 1
R
3
r 2
3
x

KAPITEL 2. FREIFORMFLÄCHEN 17
2.4 Bezierflächen
Durch den im Abschnitt 2.1 genannten Ansatz des Tensorproduktes, können Bézierkurven zu
Bézierflächen verallgemeinert werden.
Definition von Bézierflächen
Für die beiden Bézierkurven
F m (t) =
m�
B m i (t)bi und G n (t) =
i=0
vom Grad n bzw. m ergibt sich für das Tensorprodukt:
P m,n (u, v) =
m�
i=0
n�
B n i (t)di
i=0
n�
B m i (u)B n k(v)ci,k u, v ∈ [0, 1] (2.21)
k=0
Analog zum Kontrollpolygon bei Bézierkurven bilden hier die Bézierpunkte ci,k ein charakteristisches
Kontrollpolyeder, das die Form der Oberfläche festlegt. Abbildung 2.6 zeigt dieses
Polyeder für den Fall einer bikubischen Bézieroberfläche.
0.2
0.35
0.3
0.25
0.2
0.15
0.1
0.05
0
0.8
0.4
0.7
0.6
0.6
0.8
0.5
0.4
Abbildung 2.6: Bikubische Bézierfläche mit Kontrollpolyeder
Eigenschaften von Bézierflächen
Wie bereits im Abschnitt 2.1 erwähnt, bestimmen die zu Grunde liegenden Kurven die Eigenschaften
der durch das Tensorprodukt konstruierten Freiformflächen. Deshalb leiten sich die
meisten Eigenschaften von Bézierflächen von denen der Bézierkurven (vgl. Abschnitt 2.3) ab.
Zu den wichtigsten zählen hierbei:
0.3
0.2

KAPITEL 2. FREIFORMFLÄCHEN 18
• Affine Invarianz: Auch Bézierflächen verhalten sich invariant unter affinen Transformationen.
Daher gilt
ϕ(P m,n m� n�
(u, v)) = B m i (u)B n k(v)ϕ(ci,k) (2.22)
i=0
• Eckpunkt-Interpolation: Die vier Kontrollpunkte an den Ecken c0,0, c0,m, cn,0 und cn,m
liegen auf der Oberfläche:
k=0
P m,n (0, 0) = c0,0, P m,n (0, 1) = c0,n, P m,n (1, 0) = cm,0, P m,n (1, 1) = cm,n (2.23)
Wie bei Bézierkurven, gilt dies für die anderen Punkte im Allgemeinen nicht.
• Eigenschaft der konvexen Hülle: Eine Bézierfläche ist vollständig in der konvexen
Hülle K enthalten, die von ihrem Kontrollpolyeder aufgespannt wird.
P m,n (u, v) ∈ K{ci,k|0 ≤ i ≤ m, 0 ≤ k ≤ n} u, v ∈ [0, 1] (2.24)
• Eigenschaft der Schnittkurven: Die sich für einen Parameter als konstant ergebenden
Kurven sind Bézierkurven.
P m,n (c, v) bzw. P m,n (u, c) ist Bézierkurve, c ∈ [0, 1] konstant, v ∈ [0, 1]
(2.25)
Insbesondere gilt dies für die vier Randkurven P m,n (0, v), P m,n (1, v), P m,n (u, 0) und
P m,n (u, 1).
2.4.1 Flächennormalen
Die Flächennormale ist eine entscheidende Größe für die Berechnungen des Beleuchtungsmodells.
Für Bézierflächen kann diese mit Hilfe der Tangentenvektoren im entsprechenden Punkt
berechnet werden. Diese Vektoren ergeben sich aus den partiellen Ableitungen der Flächenfunktion
(2.21) nach u und v.
∂
∂uP m,n (u, v) = m m−1 �
n�
i=0 k=0
mit ∆ 1,0 ci,k = ci+1,k − ci,k
∂
∂v P m,n (u, v) = n m�
n−1 �
i=0 k=0
mit ∆0,1ci,k = ci,k+1 − ci,k
B m−1
i (u)B n k (v)∆1,0 ci,k (2.26)
B m i (u)B n−1
k (v)∆ 0,1 ci,k (2.27)
Die Tangentenvektoren bilden die Basisvektoren der Tangentialebene im Punkt (u, v). So ergibt
sich die Flächennormale durch das Vektorprodukt dieser Vektoren und anschließender
Normierung.
�n(u, v) = ∂
∂u P m,n (u, v) × ∂
∂v P m,n (u, v)
�n 0 (u, v) =
�n(u, v)
|�n(u, v)|

KAPITEL 2. FREIFORMFLÄCHEN 19
g v
g u
Abbildung 2.7: Normalenberechnung bei Bézierflächen
2.4.2 Aufteilung von Bezierflächen
Um Bézierflächen aufzuteilen, ist es notwendig, die Kontrollpunkte der entstehenden Teilflächen
zu finden. Dazu sind folgende Überlegungen hilfreich:
Eine Bézierfläche der Grade m und n kann als Überlagerung von m + 1 Kurven mit jeweils
konstantem Parameter v und n + 1 Kurven mit jeweils konstantem Parameter u interpretiert
werden. Die Kontrollpunkte dieser Kurven ergeben sich aus den Zeilen und Spalten der Kontrollpunktmatrix
der Fläche (siehe Abbildung 2.8(a)). Da sich für einen konstanten Parameter
aus einer Bezierfläche eine Bezierkurve ergibt (vgl. (2.25)), kann auf jede dieser Kurven der
Algorithmus zur Aufteilung von Bezierkurven angewandt werden. Die Kontrollpunkte der
daraus entstehenden Teilkurven (siehe Abbildung 2.8(b)) können wieder zusammengefasst
werden und bilden die Kontrollpunktmatrizen der Teilflächen.
(a) (b)
Abbildung 2.8: Unterteilung von Bézierflächen
(a) Kontrollpolygone der vier Kurven. (b) Kontrollpolygone nach Aufteilung.
Durch die so entstandenen Teilflächen verbessert sich die Näherung des Kontrollpolyeders an
die Bézierfläche. Weitere Unterteilungsschritte führen zu immer flacher werdenden Kontrollpolyedern
deren Folge gegen die ursprüngliche Bézierfläche konvergiert.
n

KAPITEL 2. FREIFORMFLÄCHEN 20
2.5 Methoden zur Schnittpunktberechnung
Bézieroberflächen sind polynomiale Funktionen, die von den Parametern u und v abhängen
und erlauben deshalb keine explizite Berechnung von Schnittpunkten des Strahls mit der
Oberfläche. Daher muss die Auswertung über iterative Näherungsverfahren erfolgen. Abgesehen
davon, dass die Berechnungen mit Hilfe dieser Verfahren sehr rechenintensiv sind, setzen
diese Algorithmen für gewöhnlich Oberflächen voraus, die frei von Singularitäten und starken
Krümmungen sind. Diese Bedingung stellt allerdings eine sehr große Einschränkung für die
Modellierung dar. Um auch Schnittpunkte mit derartigen Flächen in akzeptabler Zeit berechnen
zu können, sind einige Schritte als Vorarbeit zu leisten.
Die im Folgenden beschriebene Methode basiert auf der Arbeit von W. Barth und W.Stürzlinger
[1] ” Efficient Ray Tracing for Bézier and B-Spline Surfaces “.
2.5.1 Das Newton Näherungs-Verfahren
Das Iterationsverfahren nach Newton ist eine Methode zur Lösung nichtlinearer Gleichungssysteme,
die quadratische Konvergenz5 erreicht.
Die geometrische Deutung dieses Verfahrens ist in Abbildung 2.9 dargestellt:
Für den Startpunkt P0, der sich aus Gleichung (2.21) mit den Parametern u0 und v0 ergibt,
werden die Gradienten gu0 und gv0 der Richtungen u und v ermittelt. Durch das Vektorprodukt
dieser beiden Vektoren entsteht die Flächennormale n0. Der Schnitt des Strahls mit der
dadurch definierten Tangentialebene legt den Punkt P1 fest. Der Vektor −−→
P0P1, der aus diesen
beiden Punkten gebildet wird, stellt eine Linearkombination der Gradienten gu0 und gv0 dar
und kann durch das Lösen des sich ergebenden Gleichungssystems in seine Komponenten
zerlegt werden. Die so bestimmten Gewichte ∆u und ∆v stellen die Werte für die Parameteränderung
in Richtung u und v dar. Für die aktualisierten Parameter u1 und v1 ergibt sich
ein Punkt der Fläche, der viel näher beim Schnittpunkt liegt, als der Startpunkt P0.
Δv
P1
g v0
Δu
n 0
P 0 (u 0 ,v 0 )
g u0
Abbildung 2.9: Die Newton-Methode
Durch wiederholte Durchführung dieser Berechnungsschritte, ist der Schnittpunkt sehr genau
bestimmbar. Die Iteration kann beendet werden, falls die Schrittweiten der Aktualisierung
einen festgelegten Betrag ɛ unterschreiten.
5 Bei quadratischer Konvergenz verdoppelt sich die Anzahl der gültigen Dezimalstellen pro Iterationsschritt

KAPITEL 2. FREIFORMFLÄCHEN 21
2.5.1.1 Konvergenzprobleme
Das soeben beschriebene Verfahren konvergiert in der Regel sehr schnell zum Schnittpunkt
des Strahls mit der Fläche. Durch die Flexibilität, die Freiformflächen bei der Modellierung
bieten, können hier jedoch Probleme auftreten. Im Allgemeinen ist die Konvergenz für iterative
Verfahren nicht garantiert. Aufgrund der Flächenbeschaffenheit ist für einige Fälle nicht
sichergestellt, dass die Iteration zu den richtigen Schnittpunkten führt oder überhaupt konvergiert.
Abbildung 2.5.1.1 zeigt Situationen in denen die Iteration falsche Ergebnisse liefern
kann.
n2
P2
P1
(a)
n1
Abbildung 2.10: Problemfälle bei der Schnittpunktapproximation
(a) Hinterschneidung (b) Zu starke Krümmung.
Durch Hinterschneidungen der Fläche können sich für einen Strahl mehrere Schnittpunkte
ergeben (siehe Abbildung 2.10(a)). Für diesen Fall existieren Lösungen in den Punkten P1
und P2 und die Iteration konvergiert unter Umständen zum (hier falschen) Schnittpunkt P2.
Da die Flächennormale (n2) in diesem Punkt eine völlig andere Ausrichtung aufweist als die
erwartete (n1), ergeben sich sichtbare Fehler in den Berechnungen des Beleuchtungsmodells.
Wie in Abbildung 2.10(b) angedeutet, führen zu starke Krümmungen der Fläche wie auch
Singularitäten bei ungünstig gewählten Startpunkten zur Divergenz der Iteration. Der Algorithmus
schließt daraus, dass kein Schnittpunkt existiert und der Strahl die Fläche verfehlt -
Löcher in der Oberfläche sind die Folge.
Eine häufig angewandte Methode diesen Problemen zu begegnen ist die Aufteilung der
Fläche, um so die Suche nach dem Schnittpunkt auf kleine Teilbereiche zu beschränken.
Der Grund für dieses Vorgehen ist die Tatsache, dass sich durch wiederholte Unterteilung
auch komplexe, stark gekrümmte Oberflächen auf einfache und annähernd planare Segmente
zurückführen lassen (vgl. Abschnitt 2.4.2), auf welchen die Iteration sehr zuverlässig arbeitet.
n 0
o
P0 o
t
o
(b)
*

KAPITEL 2. FREIFORMFLÄCHEN 22
2.5.2 Vorverarbeitung der Flächen
Im Ray Tracing ist es die Regel, dass ein Körper sehr oft auf Schnittpunkte mit Strahlen getestet
und diese Punkte bei einem Treffer exakt berechnet werden müssen. Im Fall von Freiformflächen
werden diese Berechnungen anhand einfacher Teilflächen durchgeführt, die mit Hilfe
des Algorithmus nach de Casteljau einfach erstellt werden können. Dieser ist zwar schnell,
jedoch wäre es viel zu aufwändig, eine Fläche bei jedem Test erneut in möglichst planare
Bereiche zu zerlegen. Daher bietet es sich an, diesen Schritt in einer Vorverarbeitungsphase
durchzuführen und die daraus resultierenden Teilflächen während der Ray Tracing-Phase in
einer geeigneten Datenstruktur bereitzuhalten.
Trotz dieser Vorbereitungen bleiben Schnittpunktberechnungen für Freiformflächen aufwändig
und rechenintensiv und sollten auf die nötigsten reduziert bzw. unnötige von vorn herein vermieden
werden. Deshalb lohnt sich auch hier der Einsatz von Bounding Volumes.
Wie bereits in Kapitel 1 Abschnitt 1.5 erwähnt, gehören die möglichst enge Umhüllung des
Objekts und der schnelle Schnittpunkttest zu den wichtigsten Anforderungen an die Hüllkörper.
Bei Freiformflächen kommt darüberhinaus ein weiterer Aspekt hinzu: Für den Startpunkt
der Iteration müssen entsprechende Parameter u0 und v0 der Flächenfunktion (2.21)
ermittelt werden. Hierbei erfüllt die Grundfläche des Hüllkörpers eine wichtige Funktion und
sollte deshalb das umschlossene Flächenstück in seiner Form bestmöglich annähern. Bei unzureichender
Approximation kommt es zu Fehlberechnung der Startparameter. Auf dieses
Problem wird im Abschnitt 2.5.3.4 genauer eingegangen.
2.5.2.1 Das Parallelepiped als Hüllkörper
Eine sehr gute Approximation von Flächen wird im Allgemeinen durch ein Parallelogramm
erreicht, das durch die beiden Vektoren �v1 und �v2 definiert wird (siehe Abbildung 2.11(a)).
Diese ergeben sich jeweils aus dem arithmetischen Mittel der gegegenüberliegenden Vektoren,
gebildet durch die vier Eckpunkte E1, E2, E3 und E4. Bei linearer Abhängigkeit der
errechneten Vektoren, müssen hierfür alternative gefunden werden. Für diesen Fall bietet es
sich an, die Basisvektoren des Koordinatensystems zu verwenden.
Um die Lage des Parallelogramms im Raum zu fixieren, wird zusätzlich ein Basispunkt E
benötigt. Dieser Punkt wird dadurch festgelegt, dass die am weitesten vom Parallelogramm
entfernten Kontrollpunkte bei verschiedenen Vorzeichen - d.h. sie liegen auf unterschiedlichen
Seiten - die gleiche Distanz zum Parallelogramm aufweisen. Räumlich gesehen wird
dabei das Parallelogramm orthogonal zu den beiden Basisvektoren �v1 und �v2 ins Zentrum des
Kontrollpolyeders verschoben.
Ausgehend von diesem Parallelogramm als Grundfläche, kann ein Parallelepiped als Hüllkörper
für die Freiformfläche definiert werden (siehe Abbildung 2.11(b)). Bei der Wahl des
dritten, dafür erforderlichen Basisvektors �v3 ist es möglich, weitere Formeigenschaften des
Kontrollpolyeders zu berücksichtigen. Im einfachsten Fall kann dafür ein Vektor senkrecht
zur Grundfläche, gebildet durch das Vektorprodukt der Basisvektoren �v1 und �v2, angenommen
werden. Für stark entartete Flächen folgt daraus eine etwas großzügigere Umhüllung. Da dies
allerdings nur einen sehr kleinen Bruchteil der Flächen betrifft, sind die daraus resultierenden

KAPITEL 2. FREIFORMFLÄCHEN 23
E3(u,v)
−
−
v 2
v 2
E
v 1
E1(u,v)
− −
E
v 3
v 1
(a)
(b)
− −
E4(u,v)
−
E2(u,v)
−
Abbildung 2.11: Flächenumhüllung durch Parallelepiped
(a) Flächenapproximation durch Parallelogramm. (b) Daraus entstandenes Parallelepiped.
Einbußen durch zusätzliche Durchläufe der Schnittpunktsuche vernachlässigbar.
Im Allgemeinen entsteht dadurch das schiefwinklige Parallelepiped
P = E + α1�v1 + α2�v2 + α3�v3
(2.28)
mit dem Basispunkt E, den Basisvektoren �v1 bis �v3 und den zugehörigen Intervallen α1 bis α3.
Aufgrund der Eigenschaften von Bézierflächen, speziell (2.24), ist durch die Umhüllung aller
Kontrollpunkte sichergestellt, dass die zugehörige Fläche vollständig innerhalb dieser Hülle
liegt. Dazu ist es notwendig, die Gleichung (2.28) für alle Kontrollpunkte zu lösen und die
Intervallgrenzen entsprechend zu erweitern. Liegen alle errechneten Koeffizienten innerhalb
der Intervalle α1, α2 und α3, so ist die Menge der Kontrollpunkte und somit die gesamte
Bézierfläche im Parallelepiped enthalten.
Für die Basisvektoren in normierter Form, empfiehlt es sich für die Ermittlung der Intervallgrenzen,
die Intervalle α1, α2 und α3 als [0, 0] anzunehmen und diese nach und nach zu
erweitern. Durch dieses Vorgehen entsteht ein Hüllkörper, der die Bézierfläche sehr eng umschließt.

KAPITEL 2. FREIFORMFLÄCHEN 24
2.5.2.2 Kriterien zur Flächenaufteilung
Freiformflächen können unter Umständen sehr bizarre Gestalt annehmen. Durch die Zurückführung
auf einfache Flächensegmente können die, im Abschnitt 2.5.1.1 dargestellten Probleme
bei der Berechnung der Schnittpunkte vermieden werden.
Dazu bedarf es der Unterteilung der entsprechenden Flächen. Ob und entlang welcher Achse
eine Fläche aufgeteilt werden sollte, muss anhand der Anordnung der Kontrollpunkte entschieden
werden. Wie bei der Aufteilung von Bézierflächen (vgl. Abschnitt 2.4.2) ist es
auch hier hilfreich, die Zeilen und Spalten der Kontrollpunktmatrix zu Kontrollpolygonen
von Bézierkurven zusammenzufassen. Durch die Bewertung der daraus entstehenden Kurven
kann die Gestalt der Fläche abgeschätzt werden. Dazu können folgende Kriterien herangezogen
werden:
b0
• Krümmung: Die Krümmung lässt sich über das Verhältnis der Länge des Kontrollpolygons
P zum Abstand d der beiden Endpunkte b0 und b3 abschätzen (vgl. Abbildung
2.12(a)). Dieser Wert sollte eine vordefinierte Schwelle nicht überschreiten.
• Vorzeichenwechsel der Krümmung: Innere Kontrollpunkte 6 - hier die Punkte b1 und
b2 - liegen auf unterschiedlichen Seiten der Geraden g, die durch die beiden Endpunkte
definiert wird (vgl. Abbildung 2.12(b)).
• Überschreitende Kontrollpunkte: Für den Fall, dass innere Kontrollpunkte außerhalb
der Endpunkte liegen, können starke Krümmungen entstehen, die mit der Abschätzung
des ersten Kriteriums nicht erkennbar sind. Diese Kontrollpunkte sind dadurch identifizierbar,
dass sie mit einem der Endpunkte einen Winkel α > 90 ◦ bilden (vgl. Abbildung
2.12(c)).
P
d
(a)
b3
b0
b1
P
g
(b)
Abbildung 2.12: Bewertungskriterien für Bézierkurven
(a) Krümmungsabschätzung. (b) Vorzeichenwechsel der Krümmung. (c) Überschreitende
Kontrollpunkte.
Damit die Achse, entlang derer eine mögliche Unterteilung erfolgen soll, bestimmt werden
kann, werden die Kurven aus den Zeilen und Spalten der Kontrollpunktmatrix getrennt analysiert.
Erfüllen nicht alle Kurven einer Achse diese Kriterien, so muss die Fläche entlang
6 Die zwischen den Endpunkten liegenden Kontrollpunkte werden hier als Innere Kontrollpunkte bezeichnet.
b2
b3
b0
(c)
b1
α
b3
b2

KAPITEL 2. FREIFORMFLÄCHEN 25
der entgegengesetzten Achse aufgespalten werden, um die Aufteilung der Problemkurven zu
erreichen. Die daraus entstehenden Teilkurven kommen diesen Flachheitskriterien sehr viel
näher, sofern die diese dann nicht bereits erfüllen.
Zusätzlich zur Planarität einer Fläche, ist eine weitere Größe von Bedeutung: Die Längendifferenz
gegenüberliegender Randkurven sollte einen festgelegten Wert nicht überschreiten.
Dadurch kann geprüft werden, ob das Flächensegment durch die Grundfläche des Hüllkörpers
ausreichend approximiert werden kann.
2.5.2.3 Organisation der Teilflächen
Um die im Voraus berechneten Teilflächen schnell durchsuchen zu können, ist die Art ihrer
Organisation von entscheidender Bedeutung. Die dazu benutzte Datenstruktur sollte die Eigenschaften
der gespeicherten Daten berücksichtigen.
Die Unterteilung einer Fläche spaltet diese in zwei Teile etwa gleicher Größe. Werden dadurch
die für den Ablauf der Iteration geforderten Kriterien noch nicht erfüllt, müssen diese
Teile erneut aufgespalten werden. Aufgrund der Eigenschaft der konvexen Hülle von Bézierflächen
sind die Hüllkörper der Teilflächen in der Umhüllung des gespaltenen Flächensegmentes
vollständig enthalten. Dadurch ist es möglich, aus den Hüllkörpern eine ineinander
verschachtelte Hierarchie rekursiv aufzubauen.
Eine Datenstruktur, die diese Art der Aufspaltung und die rekursiv verschachtelte Anordnung
sehr gut organisiert, ist der Binärbaum.
§¡§¡§ ¨¡¨¡¨
¨¡¨¡¨ §¡§¡§
£¡£¡£ ¤¡¤¡¤
¤¡¤¡¤ £¡£¡£
©¡©¡©¡© �¡�¡�¡�
�¡�¡�¡� ©¡©¡©¡©
¥¡¥¡¥ ¦¡¦¡¦
¦¡¦¡¦ ¥¡¥¡¥
¡ ¡ ¢¡¢¡¢
¢¡¢¡¢ ¡ ¡
Abbildung 2.13: Binärbaum zur Teilflächenorganisation
Die Daten, die für die Iteration sowie zum Durchsuchen des Baumes erforderlich sind, werden
in den Knoten wie folgt abgelegt:
• Die Inneren Knoten repräsentieren die Teile der Fläche, die aufgrund ihrer Beschaffenheit
weiter unterteilt wurden. Die hier gespeicherten Informationen steuern den Verlauf
der Suche und werden benötigt um den Pfad zu den richtigen Blattknoten und so zu den
passenden Teilflächen zu finden. Dazu sind nur die Daten des Hüllkörpers notwendig.
Hierzu zählen die Basisvektoren v1, v2 und v3, der Basispunkt E und die Intervalle α1
bis α3.

KAPITEL 2. FREIFORMFLÄCHEN 26
• Die Blattknoten stellen die Flächensegmente dar, die die Kriterien für die Iteration
erfüllen. Deshalb werden hier zusätzlich zu den Daten des Hüllkörpers, die Werte gespeichert,
die für die Iteration wichtig sind. Konkret sind dies die Intervallgrenzen der
Parameter u und v des Flächensegmentes. Da das Verfahren mit den Kontrollpunkten
der gesamten Fläche arbeitet, ist es nicht nötig, die Kontrollpunkte der zum Blattknoten
gehörenden Teilfläche zu speichern. Deshalb besteht die Aufgabe des Suchbaumes
lediglich darin, mit Hilfe der Hüllkörper, den bestmöglichen Startpunkt für das Iterationsverfahren
zu finden.
2.5.2.4 Aufbau des Suchbaumes
Der Binärbaum zur Organisation der Flächensegmente kann sehr einfach durch einen rekursiven
Ablauf aufgebaut werden. Die Bearbeitung beginnt mit der Gesamtfläche, die im Baum
durch den Wurzelknoten repräsentiert wird. Hierbei gilt für die Parameter u und v ein initialer
Bereich von [0, 1] × [0, 1].
Da die Hüllkörper ungeachtet der Flächenbeschaffenheit ermittelt werden, erfolgen die dazu
erforderlichen Berechnungen für alle Knoten gleich. Dies geschieht anhand des in Abschnitt
2.5.2.1 beschriebenen Verfahrens. Die daraufhin folgende Prüfung der Flachheitskriterien entscheidet,
ob das aktuell bearbeitete Flächensegment für den Ablauf der Iteration geeignet ist
oder weiter unterteilt werden muss. Erfüllt das Flächensegment die Kriterien, so können die
ermittelten Daten als Blattknoten in den Baum eingefügt werden.
Macht die Flächenbeschaffenheit eine weitere Unterteilung notwendig, so werden die Informationen
über den Hüllkörper als innerer Knoten in den Baum eingefügt und das Flächensegment
wird entlang der, durch die Analyse ermittelten Achse halbiert. Für die sich ergebenden
Teilflächen wird der Bereich der Parameter u und v bestimmt und der Ablauf rekursiv fortgesetzt.
addToSearchTree( surface, uvDomain )
hull := getBoundingVolume( surface ) // berechne Hüllkörper
// teste auf ausreichende Planarität und bestimme ggf. Achse für Aufteilung
if( isFlat( surface, &divAxis ) )
else
addLeafNode( hull, uvDomain ) // erstelle Blattknoten
addInnerNode( hull ) // erstelle inneren Knoten
// halbiere Fläche entlang der ermittelten Achse
[partLeft, partRight] := divide( surface, divAxis, 0.5 )
// bestimme Parameterbereiche der Teilflächen
[domainLeft, domainRight] := splitDomain( uvDomain, divAxis, 0.5 )
// fahre fort für beide Teilflächen ...
call addToSearchTree( partLeft, domainLeft )
call addToSearchTree( partRight, domainRight )
Abbildung 2.14: Pseudocode zum Aufbau des Suchbaumes

KAPITEL 2. FREIFORMFLÄCHEN 27
2.5.3 Schnittpunktermittlung
Der in der Vorverarbeitungsphase aufgebaute Suchbaum wird während der Ray Tracing-Phase
genutzt, um Strahlen so nah wie möglich bis zum Schnittpunkt mit der Fläche zu verfolgen
um so den bestmöglichen Startpunkt für die Iteration zu ermitteln. Dadurch ist es möglich, die
Anzahl der Schritte, die zum Erreichen des Schnittpunktes erforderlich sind, deutlich zu verringern
und Probleme durch zu starke Krümmungen oder Hinterschneidungen zu vermeiden.
2.5.3.1 Durchsuchen der Flächensegmente
Das Ziel der Suche ist das schnelle Auffinden aller Flächenbereiche, die die geforderten Kriterien
erfüllen und Schnittpunkte mit dem Strahl aufweisen könnten. Aufgrund des Binärbaums
als Datenstruktur und der verschachtelten Hüllkörper-Hierarchie kann diese Suche sehr effizient
durchgeführt werden. Für alle gefundenen Bereiche muss durch iterative Approximation
(vgl. Abschnitt 2.5.3.5) ermittelt werden, ob und an welcher Stelle es tatsächlich zu Schnittpunkten
mit der Fläche kommt.
Der Suchdurchlauf beginnt in der Wurzel des Binärbaums und wird bis in die Blattknoten
fortgesetzt. Der Weg durch den Baum, den der Suchalgorithmus dabei durchläuft, wird durch
die, in den Knoten gespeicherten Hüllkörper bestimmt. Wird der Hüllkörper eines Knotens
vom Strahl getroffen, muss dieser Bereich des Baumes näher untersucht werden. Handelt es
sich hierbei um einen inneren Knoten, wird der Test für beide Nachfolgerknoten rekursiv
fortgesetzt, um dadurch die Bereiche für die Iteration weiter einzuschränken.
Wurde durch diesen Ablauf ein Blattknoten erreicht, erfüllt der zugehörige Flächenbereich die
geforderten Kriterien und der Startpunkt der Iteration kann anhand des Hüllkörpers bestimmt
werden. Der daraufhin folgende Iterationsablauf zeigt, ob für diesen Abschnitt tatsächlich ein
Schnittpunkt existiert oder der Strahl die Fläche dennoch verfehlt.
searchNode( node )
// teste auf Schnittpunkt mit Hüllkörper
if( intersectBoundingVolume( node ) )
else
if( isInnerNode( node ) // teste auf inneren Knoten
else
// führe Suche für beide Nachfolger fort ...
call searchNode( node.left )|
call searchNode( node.right )|
// Blattknoten wurde erreicht
start := determineStartPoint() // bestimme Startpunkt
hit := doIteration( node, start ) // führe Iteration durch
return // Abbruch der Suche im aktuellen Teilbaum
Abbildung 2.15: Pseudocode zum rekursiven Durchlauf des Suchbaumes
Infolge der hierarchischen Verschachtelung der Hüllkörper, kann beim Erreichen eines Knotens,
dessen Hüllkörper nicht getroffen wird, die Suche im aktuellen Ast des Baumes abgebrochen
werden, da alle direkten und indirekten Nachfolger unmöglich Treffer aufweisen können.

KAPITEL 2. FREIFORMFLÄCHEN 28
Dadurch können Flächenbereiche, die vom Strahl nicht geschnitten werden, sehr schnell identifiziert
und übergangen werden.
Häufig ergeben sich während des Durchlauf eines Suchbaumes mehrere Flächensegmente,
die der Iteration unterzogen werden müssen. Dies gilt vor allem bei mehrfach auftretenden
Schnittpunkten und Strahlen, die die Hüllkörper der Flächensegmente sehr flach schneiden.
Da nur der am nächsten zum Strahlursprung liegende Schnittpunkt benötigt wird, muss die
Iteration allerdings nicht zwangsläufig für alle ermittelten Bereiche durchgeführt werden.
Aufgrund der Eigenschaft der konvexen Hülle kann ein Flächenschnittpunkt nicht näher am
Ursprung des Strahles liegen, als der Schnittpunkt mit dem Hüllkörper. Deshalb kann durch
einen Vergleich der Distanz eines bereits ermittelten Schnittpunktes mit der Distanz des
Hüllkörperschnittpunktes entschieden werden, ob durch das zu prüfende Flächensegment ein
näher liegender Schnittpunkt erreichbar ist. Dadurch können unnötige Durchläufe der Iteration
leicht eingespart werden. Um die laufzeittechnischen Nachteile einer rekursiven Prozedur
zu vermeiden, empfiehlt es sich diesen Suchalgorithmus als iterativen Ablauf zu implementieren.
2.5.3.2 Schnittberechnung der Hüllkörper
Um den richtigen Pfad durch den Suchbaum zu finden, müssen die abgelegten Hüllkörper auf
Schnittpunkte mit dem Strahl getestet werden. Im Fall von Parallelepipeds gestalten sich diese
Berechnungen recht einfach und können schnell durchgeführt werden.
Der Strahl mit dem Ursprung A und der Richtung � d kann beschrieben werden durch die Geradengleichung:
A + λ � d (2.29)
Für die Berechnung der Schnittpunkte können die Eigenschaften des Parallelepiped ausgenutzt
werden. Dieses zeichnet sich dadurch aus, dass gegenüberliegende Flächen parallel zueinander
sind. So kann für jedes der drei Ebenenpaare ein Parameterintervall λi berechnet
werden, in welchem der Strahl jeweils zwischen den beiden Ebenen verläuft. Ausgehend von
der Schnittberechnung des Strahls mit einer Ebene 7 , ergibt sich durch Substitution der Gleichungen
(2.29) und (2.28) für diese Intervalle:
λi = �ni · (E − A) + αi(�vi · �ni)
�ni · � d
i = 1, 2, 3 (2.30)
mit ni als den Normalenvektoren der Flächen des Parallelepipeds. Der Schnitt der daraus
folgenden drei Intervalle
[λP ] = [λ1] ∩ [λ2] ∩ [λ3] (2.31)
7 Der Parameter für den Schnittpunkt einer Geraden mit einer Ebene ergibt sich aus λ = �n·(O−A)
�n· � d

KAPITEL 2. FREIFORMFLÄCHEN 29
stellt den Bereich des Parameters λ dar, für den der Strahl innerhalb des Parallelepipeds
verläuft. Entsteht durch diese Schnittberechnung ein leeres Intervall, so verfehlt der Strahl
das Parallelepiped.
Ein Strahl, der parallel zu einem Ebenenpaar verläuft, führt in der Berechnung des entsprechenden
Intervalls zu einem Nullwert im Nenner der Gleichung (2.30). Anstatt diesen kritischen
Fall durch Unterscheidungen zu behandeln, empfiehlt es sich, den Nenner vor der Division
auf einen sehr kleinen Wert abzuändern. Dadurch ergibt sich ein sehr großes Intervall
für den Strahl zwischen den Ebenen oder ein leeres Intervall für einen außerhalb verlaufenden
Strahl.
Diese Berechnungen werden während des Baumdurchlaufs sehr häufig durchgeführt und sollten
daher sorgfältig auf vermeidbare Rechenschritte überprüft werden. So enthält die Gleichung
(2.30) Teile, die nicht von der Richtung des Strahls abhängig sind. Diese können bereits
während der Vorverarbeitungsphase ausgewertet und im Suchbaum abgelegt werden. Vor
allem bietet es sich hier an, die Flächennormalen ni aus den Basisvektoren vi vorab zu berechnen.
Eine weitere Möglichkeit zur Optimierung bietet sich für die Schnittberechnung mit Primärstrahlen.
Da diese alle den Standpunkt des Beobachters als Ursprung haben, ist für diesen Fall
der Zähler der Gleichung (2.30) vollständig im Voraus berechenbar und kann im Suchbaum
gespeichert werden.
2.5.3.3 Ermittlung des Iterationsstartpunkts
Zur Durchführung der Iteration wird eine initialer Punkt benötigt. Um aufwändige Schritte
der Iteration einzusparen, sollte dieser so nah wie möglich am tatsächlichen Schnittpunkt von
Strahl und Fläche liegen.
Durch die Kriterien zur Unterteilung von Flächen wird bereits in der Vorverarbeitungsphase
sichergestellt, dass die Flächensegmente durch die Grundfläche ihres Hüllkörpers ausreichend
angenähert werden können. Deshalb ergibt sich durch den Schnittpunkt des Strahls mit dieser
Grundfläche in der Regel ein sehr guter Startpunkt.
Für das Parallelepiped mit einem Parallelogramm als Grundfläche, entsteht aus Gleichung
(2.30), durch Setzen der Parameter i = 3 und α3 = 0
λ0 = �n3 · (E − A)
�n3 · � d
(2.32)
Die Substitution dieses Parameters λ0 in die Strahlengleichung (2.29) ergibt den Schnittpunkt
D0. Durch das Lösen des Gleichungssystems
D0 = E + γ1 �v1 + γ2 �v2
(2.33)
entstehen die beiden Koeffizienten γ1 und γ2. Diese können dazu verwendet werden um die
Distanz des Schnittpunktes zum Basispunkt in den u, v-Raum zu übertragen. Da die Basisvek-

KAPITEL 2. FREIFORMFLÄCHEN 30
toren v1 und v2 in normalisierter Form vorliegen, ist für die berechneten Werte eine Skalierung
mit den Seitenlängen der Grundfläche nötig. Daraus ergeben sich die Initialschritte der Iteration
1
∆u = γ1 ·
(α1 − α1)
1
bzw. ∆v = γ2 ·
(α2 − α2)
Aufgrund der annähernden Planarität der Fläche und der Annahme, dass E ≈ P (u, v), können
aus diesen Werten und den Grenzen des u, v-Bereiches der Fläche die Startparameter wie folgt
errechnet werden:
u0 = u + ∆u(u − u) bzw. v0 = v + ∆v(v − v) (2.34)
Für Strahlen, die das Flächensegment annähernd tangential schneiden (siehe Abbildung 2.16),
kann jedoch dieses Vorgehen zu Problemen führen. In diesem Fall schneidet der Strahl die
Grundfläche möglicherweise weit außerhalb des Hüllkörpers oder - für einen Strahl parallel
zur Grundfläche - gar nicht. Außerdem ist es sehr wahrscheinlich, dass aufgrund einer Hinterschneidung
innerhalb dieser Teilfläche, mehrere Schnittpunkte existieren. Deshalb ist hier
nicht sichergestellt, dass die Iteration den richtigen Schnittpunkt liefert. Die Berechnungsfehler,
die sich hieraus ergeben können, sind in Abschnitt 2.5.1.1 dargestellt.
h
b
Abbildung 2.16: Annähernd tangential schneidender Strahl
Diese Situation ist mit Hilfe des Kriteriums
φ
tan φ > b
h
l
(2.35)
einfach identifizierbar. Es ist unter diesen Umständen nicht möglich, den Startpunkt über den
Schnittpunkt der Grundfläche zu bestimmen. Um hier fehlerhafte Berechnungen zu vermeiden,
kann stattdessen der, auf die Grundfläche projizierte Eintrittspunkt des Strahls in den
Hüllkörper verwendet werden. Allerdings kann dieser weit vom tatsächlichen Schnittpunkt
entfernt liegen und erfordert dadurch einige Iterationsschritte mehr.

KAPITEL 2. FREIFORMFLÄCHEN 31
2.5.3.4 Die Bedeutung der Grundfläche
Für das im vorhergehenden Abschnitt beschriebene Verfahren, aus dem Startpunkt die entsprechenden
Initialparameter u0 und v0 zu bestimmen, ist die Form der Grundfläche des
Hüllkörpers von entscheidender Bedeutung. Wird durch die Grundfläche nur eine unzureichende
Approximation des Flächensegmentes erreicht, so können sich daraus schwerwiegende
Probleme ergeben. Diese werden durch die geometrische Darstellung des Verfahrens für
den Fall eines stark verformten Flächensegments deutlich.
Für eine rechteckige Grundfläche stehen die beiden Basisvektoren �v1 und �v2 senkrecht aufeinander.
Dadurch kann die in Abbildung 2.17 dargestellte Teilfläche nur sehr schlecht angenähert
werden. Da die Aufspaltung von Freiformflächen, die auf dem Tensorprodukt basieren,
nur entlang der Achsen der Parameter u und v erfolgen kann, ist die entartete Form dieser
Teilfläche auch durch weitere Unterteilung nicht korrigierbar.
v 2
u,v
E
v
v1
Abbildung 2.17: Unzureichende Approximation durch Grundfläche
Durch das Lösen des Gleichungssystems (2.33) für den Startpunkt D0 wird der Vektor −−→
ED0
in seine Komponenten bzgl. der Basisvektoren �v1 und �v2 zerlegt. Weicht die Ausrichtung der
Flächenränder, wie in diesem Beispiel, stark von der der Basisvektoren �v1 und �v2 ab, entstehen
dadurch Initialschritte ∆u und ∆v, die zu einem extrem verschobenen Initialpunkt P (u0, v0)
führen. Dieser kann unter Umständen weit außerhalb der gültigen Intervalle liegen. Für diese
Bereiche ist nicht sichergestellt, dass die für die Iteration erforderlichen Flächeneigenschaften
erfüllt werden. So können hier starke Krümmungen oder Richtungswechsel in der Krümmung
auftreten, die die Iteration divergieren lassen.
Ein Parallelogramm, das sich für die allgemein gehaltene Form der Gleichung (2.28) als
Grundfläche ergibt, liefert auch für stark verzerrte Flächen eine sehr gute Approximation.
Dennoch reicht dies nicht aus, um Schnittpunkte in allen Situationen sicher zu ermitteln. Deshalb
sind im Ablauf der Iteration weitere Maßnahmen zu treffen um die Wahrscheinlichkeit
von Fehlberechnungen zu minimieren. Diese sind im nächsten Abschnitt genauer beschrieben.
u
D0
u,v

KAPITEL 2. FREIFORMFLÄCHEN 32
2.5.3.5 Der Iterationsablauf
Wird während des Baumdurchlaufs ein Blattknoten erreicht, dessen Hüllkörper vom Strahl
getroffen wird, so muss das entsprechende Flächensegment der Iteration unterzogen werden.
Dabei wird der exakte Schnittpunkt des Strahls mit der Fläche mit Hilfe der im Abschnitt
2.5.1 beschriebenen Newton-Methode ermittelt. Diese liefert für die beiden Parameter u und
v Werte für deren Veränderung um im nächsten Schritt der Iteration eine bessere Näherung
des Schnittpunktes zu erreichen. Die dafür benötigten Initialwerte werden anhand der Grundfläche
des Hüllkörpers bestimmt (vgl. Abschnitt 2.5.3.3). Da dieses Verfahren dabei auf der
vollständigen Fläche arbeitet, bedarf es dazu auch nur der Kontrollpunkte der Gesamtfläche.
Durch wiederholte Durchführung ist der Schnittpunkt sehr genau bestimmbar. Als Abbruchkriterium
kann dabei der Betrag der Schrittweiten herangezogen werden. Unterschreitet dieser
den festgelegten Wert ɛ, so wurde die geforderte Genauigkeit erreicht.
doIteration( node, start )
[u, v] := convertPointToUV( node.hull, start ) // bestimme Startparameter
// wiederhole bis maximale Anzahl Schritte ...
while( #steps < maxSteps )
// berechne Parameterschritte
[∆u, ∆v] := getNewtonUpdate( u, v )
// prüfe erreichte Genauigkeit
if( |∆u| < ɛ and |∆v| < ɛ )
else
hit := pickHitData()
return hit // Schnittpunkt gefunden
// aktualisiere Parameter ...
u := u + ∆u
v := v + ∆v
// teste auf Bereichsüberschreitung
if( exceedingBounds( node.uvDomain, u, v ) )
// beende Iteration bei zweitem Versuch
if( isSecondTry )
exitLoop
doNextStep // nächster Schritt
return noHit // kein Schnittpunkt gefunden
Abbildung 2.18: Pseudocode des Iterationsablaufs
Wie bereits im vorhergehenden Abschnitt erwähnt, sind zusätzliche Maßnahmen nötig, um
die Zuverlässigkeit des Algorithmus’ zu erhöhen. Besonders in Randbereichen der Flächensilhouette
entsteht oft die Situation, dass zwar der Hüllkörper Schnittpunkte aufweist, jedoch
das entsprechende Flächensegment vom Strahl verfehlt wird. Für diesen Fall kann die Iteration
nicht konvergieren. Wurde deshalb nach einer vorgegebenen maximalen Anzahl von
Schritten noch kein Schnittpunkt gefunden, so muss die Iteration abgebrochen werden, mit
dem Ergebnis, dass kein Schnittpunkt existiert.
Ein weiteres Kriterium dafür, dass der Strahl das Flächensegment nicht trifft, ist das Über-

KAPITEL 2. FREIFORMFLÄCHEN 33
schreiten der Grenzen des u, v-Bereiches während der Iteration. Ein Grund dafür kann sein,
dass der Schnittpunkt innerhalb eines benachbarten Segments liegt. Um jedoch die Iteration
nicht wegen eines zu groß geratenen Initialschrittes vorschnell abzubrechen (vgl. Abbildung
2.19(a)), sollte der überschreitende Parameter auf den Grenzwert gesetzt und so dem Algorithmus
eine zweite Chance gegeben werden. Führt auch der nächste Schritt über den gültigen
Bereich hinaus, kann davon ausgegangen werden, dass der Schnittpunkt tatsächlich außerhalb
liegt. Insbesondere bei Schnittpunkten im Randbereich einer Teilfläche, können diese zusätzlichen
Versuche mehrmals in Anspruch genommen werden und erhöhen die Anzahl der Iterationsschritte.
Deshalb müssen bei der Wahl der maximalen Schrittanzahl einige Durchläufe
mehr eingeplant werden.
P 1
St
(a)
St
P 1 P 2
Abbildung 2.19: Fehlerhafte Überschreitung der Flächengrenzen
(a) Zu große Schrittweite. (b) Schnittpunkte benachbarter Teilflächen.
Trotz dieses recht zuverlässigen Vorgehens, kann es zu Situationen kommen, in denen der
Algorithmus falsche Ergebnisse liefert. Diese entstehen meist in Fällen, in denen der Strahl
zwei benachbarte Flächensegmente schneidet. Wie in Abbildung 2.19(b) dargestellt, ist es
möglich, dass der Startpunkt St näher am Schnittpunkt P2 des Nachbarsegmentes liegt als an
dem des aktuellen Segmentes (P1). Unter diesen Umständen konvergiert die Iteration gegen
den Schnittpunkt P2 des benachbarten Flächenstückes und wird deshalb die Bereichsgrenzen
auch beim zweiten Versuch überschreiten. Das bedeutet, dass der Algorithmus so für die
aktuelle Teilfläche keinen Schnittpunkt ermitteln kann, obwohl dieser eindeutig existiert.
Damit diese Schnittpunkte nicht übergangen werden, muss die Iteration nach einem erfolglosen
Durchlauf mit verändertem Initialpunkt erneut gestartet werden. Dafür eignet sich der
Eintrittspunkt des Strahls in den Hüllkörper sehr gut. Führt auch dieser Versuch zu keinem
Schnittpunkt, so macht es ein dritter Start der Iteration - diesmal mit dem Austrittspunkt des
Strahls als Initialpunkt - beinahe unmöglich, in dieser Situation einen Schnittpunkt zu verlieren.
(b)

KAPITEL 2. FREIFORMFLÄCHEN 34
2.6 Fazit
Allen Bemühungen zum Trotz, ist es durch dieses doch recht aufwändigen Verfahrens nicht
immer möglich, Schnittpunkte korrekt zu berechnen. Nicht zuletzt wegen der hohen Flexibilität
von Freiformflächen, kommt es immer wieder zu Situationen, für die das beschriebene
Verfahren versagt. Insbesondere in den schmalen Randbereichen der Objektsilhouette schneidet
ein Strahl die Fläche sehr flach. Dadurch entstehen Schnittpunkte, die sehr nah beisammen
liegen. Selbst mit dem Eintrittspunkt des Strahls in den Hüllkörper ist nicht zu vermeiden, dass
sich daraus für den ein oder anderen Fall der falsche Schnittpunkt ergibt. Abhängig von den
Verhältnissen der Beleuchtung und der Bildauflösung werden diese Fehlberechnungen in vereinzelten
Bildpunkten sichtbar.
Abhilfe schafft hier die Technik des Supersampling, indem für einen Bildpunkt mehrere, in
der Richtung leicht unterschiedliche Strahlen ausgewertet und die ermittelten Farben anteilig
vermischt werden. Dadurch werden solche Fehler - solange diese nur für vereinzelte Strahlen
auftreten - unsichtbar.
(a)
Abbildung 2.20: Ein berühmtes Beispiel: Der Utah Teapot
(a) Drahtgittermodell. (b) Gerendert mit Gold als Material.
(b)

Kapitel 3
Texturierung
Synthetisch erzeugte Bilder sollen, so echt und natürlich wie möglich wirken. Die Modellierung
solcher Szenen erfordert große Liebe zum Detail, denn die wenigsten Gegenstände
haben eine glatte und einheitliche Oberfläche. Alle Feinheiten und Unregelmäßigkeiten, die
in einer natürlichen Umgebung selbstverständlich vorhanden sind, müssen für einen realistischen
Eindruck mühsam nachgebildet werden.
Die Verwendung von Texturen ist eine sehr elegante Methode, die den dazu erforderlichen
Aufwand deutlich zu reduzieren vermag und Szenen dennoch ein sehr realistisches Aussehen
verleiht.
Im Allgemeinen versteht man unter Texturierung das Überziehen von Oberflächen mit Mustern
oder Bildern. Zur Erzeugung von Texturen gibt es erstaunlich viele Ansätze und Algorithmen.
Neben dem klassischen ”Aufkleben” von Bildern auf Objekte, stellt die Klasse der
so genannten Prozeduralen Texturen den größten Teil der heute verwendeten Texturen dar.
Diese werden praktisch ausschließlich durch mathematische Funktionen beschrieben, die die
Eigenschaften der Oberfläche, wie z.B. die Farbe, in den einzelnen Punkten bestimmen.
Die Möglichkeiten von Texturen beschränken sich allerdings nicht auf Farb- und Materialverläufe.
Durch gezielte Veränderung der Flächennormalen ist es auch möglich, Oberflächen
mit Unregelmäßigkeiten oder feinen Strukturen zu versehen, die allein aus den Informationen
der Textur berechnet werden. Dadurch kann eine natürliche Oberflächenbeschaffenheit
erreicht werden ohne diese aufwändig geometrisch modellieren zu müssen.
Da sich die Algorithmen zur Erzeugung diese Effekte größtenteils mit sehr wenig Aufwand
an Speicher und Rechenkapazität begnügen, kommen heute Texturen in den meisten Graphiksystemen
zum Einsatz.

KAPITEL 3. TEXTURIERUNG 36
3.1 Arbeitsweise von Texturierungssystemen
Das Erscheinungsbild eines Objekts hängt stark von den Eigenschaften seiner Oberfläche ab.
Dazu zählen die Farbe, die Materialkoeffizienten für die lokalen Lichtanteile, Werte für die
Berechnung der Transparenz sowie die Flächennormale in dem zu berechnenden Punkt des
Objekts. Grundsätzlich ist es möglich, durch Texturen alle dieser Eigenschaften beeinflussen
zu lassen. Viele Systeme beschränken sich allerdings auf die Farbe und die Flächennormale
als die wichtigsten dieser Attribute.
Texturen arbeiten losgelöst von den Objekten und bestimmen Punkt für Punkt die Größen für
die weiteren Berechnungen. Da in Graphiksystemen die Schattierung von Flächen letztendlich
auch punktweise berechnet werden muss, sind Texturierungssysteme meist ohne großen
Aufwand einzubinden.
Im Grunde werden für die Auswertung der Textur als Parameter nur die Koordinaten des
Oberflächenpunktes und die Flächennormale benötigt. Durch diese unabhängige Arbeitsweise
ergeben sich für die Implementierung von Texturen folgende Vorteile:
• komplett vom Objekt trennbarer Algorithmus
• i.d. Regel ohne oder mit nur geringer Anpassung auf alle Objekte anwendbar
• durch Objektorientierte Programmierung einfach erweiterbar.
Durch die Einbindung der Texturierung in ein Ray Tracing-System ergibt sich für die Berechnung
der Schattierung der in Abbildung 3.1 dargestellte Ablauf:
Schattierung
Schnittpunktberechnung
Schnittdaten setzen
Objektdaten holen
Berechnungen des
Beleuchtungsmodells
Objekt
Transformationen &
Normalen−Berechnung
Objektdaten setzen
Textur auswerten
Farbe & Material holen
# Normale & Ambience
Textur
Transformationen &
Turbulenzberechnung
Texturspezifische
Berechnungen
# Farbe & Material
Abbildung 3.1: Integration eines Texturierungssystems

KAPITEL 3. TEXTURIERUNG 37
3.2 Arten von Texturen
Durch die Freiheiten der Vorgehensweise und Algorithmen bei der Generierung von Texturen
ergibt sich eine Vielzahl von Mustern und Oberflächenstrukturen. Durch die Art der Verfahren
lassen sich die Texturen in Klassen einteilen. Die dabei grundlegenden und sehr häufig
verwendeten Techniken werden im Folgenden beschrieben und Texturbeispiele vorgestellt, in
denen diese zum Einsatz kommen. Große Teile davon basieren auf der Arbeit von O. Groth
[3]. Deshalb sei im Folgenden nur ein Einblick in die Texturarten und deren Besonderheiten
gegeben.
3.2.1 2D Texture Mapping
Die Darstellung von Bildern sowie flachen Mustern auf Objektoberflächen erfordert die Zuordnung
jedes Punktes der Oberfläche zu einem Punkt innerhalb des Bildes oder Musters.
Diese Zuordnung wird mittels einer mathematischen Abbildung der Punktkoordinaten auf
das Intervall [0, 1] × [0, 1] erreicht. Um Verzerrungen des Bildes zu vermeiden, sollte die Art
Abbildung (linear, sphärisch oder extern) passend zur Form der Oberfläche gewählt werden.
Lineare Abbildung: Diese Art der Projektion kommt bei geraden Achsen zum Einsatz (vgl.
Abbildung 3.2(a)) und wird durch folgendes Verhältnis ausgedrückt:
lx := Px − Xa
Xb − Xa
bzw. ly := Py − Ya
Yb − Ya
(3.1)
Mercator-Projektion: Die sphärische Abbildung oder Mercator-Projektion wird bei kreisförmig
gekrümmten Flächenachsen verwendet (vgl. Abbildung 3.2(b)). Hier werden erst die
Polarkoordinaten (θ, φ) des Punktes P bzgl. des Zentrums Z und dem Radius R berechnet.
Wegen den unterschiedlichen Intervallen ((θ, φ) ∈ [0, π] × [−π, π]) muss dabei zwischen den
X- und Y -Achsen unterschieden werden.
θ = arccos Py − Zy
R
φ = arctan Pz − Zz
Px − Zx
(3.2)
Für die Berechnung des arctan a sind aufgrund des Quotienten und der Punktsymmetrie des
b
Arcus Tangens einige Fallunterscheidungen zu beachten. Deshalb empfiehlt sich für diese Berechnung
die Benutzung der atan2(a,b)- Funktion der math-Bibliothek, die diese Fälle korrekt
berücksichtigt. Aus den Polarkoordinaten ergibt sich für die Abbildung auf das Intervall [0, 1]:
sx := φ
2π
bzw. sy :=
π − θ
π
(3.3)
Externe Abbildungen: Projektionen auf Freiformflächen (siehe Kapitel 2), verlangen hier
eine Sonderbehandlung. Diese Objekte bestimmen schon während der Schnittpunktberechnung
die nötigen Werte und müssen diese nur der Texturierung zur Verfügung stellen.

KAPITEL 3. TEXTURIERUNG 38
X /Y
b b
P
X /Y
a a
(a)
y
1.0
Abbildung 3.2: Arten des Texture Mapping
(a) Lineare Abbildung. (b) Sphärische Abbildung (Mercator-Projektion).
P
Durch die Multiplikation der so errechneten Faktoren mit den Bildabmessungen in X- und
Y -Richtung, ergeben sich die Pixelkoordinaten des Bildpunktes, dessen Farbe der dargestellte
Oberflächenpunkt annehmen soll.
Diese Abbildungen haben gemein, das verwendete Bild auf die gesamte Oberfläche zu strecken
bzw. zu stauchen. Durch das Einbeziehen der Abmessungen des zu projizierenden Bildes
oder Musters, kann dieses Verhalten beeinflusst und eine gekachelte Anordnung erzielt werden.
Dies wird mittels einer zusätzlich durchgeführten Restwert-Division (modulo) durch die
Bildabmessungen erreicht.
3.2.1.1 Die Bitmap-Textur
Die Bitmap-Textur ist eine sehr einfache Textur, die nach den beschriebenen Verfahren das
Motiv einer Bilddatei auf den Oberflächen von Objekten darstellt. Das Beispiel der Weltkarte,
die auf eine Kugel projiziert wird (vgl. Abbildung 3.3), zeigt, dass Bilder für die Mercator-
Projektion entsprechend vorverzerrt werden müssen, um eine nahtlose und gleichmäßige
”Ummantelung” der Oberfläche zu erreichen.
Abbildung 3.3: Die Mercator-Projektion
Umwickeln einer Kugel mit einer Weltkarte
1.0
x
(b)
y
Z
P
R
z
x

KAPITEL 3. TEXTURIERUNG 39
3.2.1.2 Environment Mapping
Environment Mapping ist ein recht einfaches und schnelles Verfahren, Reflexionen der Umgebung
in der verspiegelten Oberfläche eines Objektes nachzubilden. Hierbei liegt die umgebende
Szene bereits als Bild vor. Da die Ausrichtung dieses Bildes unabhängig vom Ort und
der Lage der Oberfläche ist, bleibt die gespiegelte Kulisse auch bei bewegtem Objekt stabil.
Daher sorgt diese Textur besonders bei Animationen für sehr interessante und realitätsnahe
Effekte.
Abbildung 3.4: Environment Mapping bei Animationen
Zur Berechnung des Environment Mapping, wird die Umgebung des Objekts durch die Projektion
des Bildes auf einen virtuellen Hüllkörper simuliert. Für die Bestimmung der Farbinformation
wird die Richtung der Reflexion im Schnittpunkt des Sichtstrahls S berechnet
und dadurch der Reflexionsstrahl R festgelegt (vgl. Abbildung 3.5). Der Schnittpunkt dieses
Strahls mit dem Hüllkörper identifiziert den Farbpunkt der Umgebung, der auf der Oberfläche
des Objekts sichtbar wird. Für die Abbildung des Hüllkörperpunktes P auf das zweidimensionale
Intervall des Umgebungsbildes, werden auch hier die oben beschriebenen Verfahren
verwendet.
S
Abbildung 3.5: Environment Mapping mit Kugel als Hüllkörper
Sehr einfach gestalten sich diese Berechnungen für eine Kugel als Hüllkörper. Da für die
Mercator-Projektion letztendlich nur die Richtung des Vektors Zentrum − Schnittpunkt
entscheidend ist, bleibt der Radius frei wählbar. Daher kann der Reflexionsvektor ohne weitere
Berechnung direkt als Punkt auf der Kugel für die Projektion verwendet werden. Allerdings
R
P

KAPITEL 3. TEXTURIERUNG 40
besteht auch hier der Nachteil, dass das Umgebungsbild passend vorverzerrt sein muss, um
eine gleichmäßige Spiegelung zu simulieren. Leider ist die Erzeugung solcher Bilder recht
aufwändig und hohe Qualität dementsprechend rar.
Für einen Würfel als Hüllkörper bereitet die Aufnahme der Kulisse sehr viel weniger Probleme.
Zwar werden hier natürlich für alle sechs Seiten Bilder benötigt, jedoch müssen diese
nicht vorverzerrt werden. Die Kehrseite dieser Methode ist die um einiges aufwändigere Bestimmung
des Farbpunktes, da hierzu eine vollständige Schnittpunktberechnung des Reflexionsstrahls
mit der Würfelhülle erforderlich wird.
Dennoch besitzt Environment Mapping auch einen entscheidenden Nachteil: Hinterschneidungen
der Objektoberfläche werden nicht berücksichtigt und die Spiegelungen für diesen
Fall falsch berechnet (vgl. Abbildung 3.6). Da es bei Ray Tracing allerdings auf wirklichkeitsgetreue
Bilder ankommt, werden Spiegelungen möglichst direkt berechnet und diese Texturen
meist nur für schnelle Näherungsberechnungen verwendet.
Abbildung 3.6: Grenzen des Environment Mapping
Fehlerhafte Spiegelungen bei Hinterschneidungen

KAPITEL 3. TEXTURIERUNG 41
3.2.2 Prozedurale Texturen
Prozedurale Texturen sind in der Texturierung sehr weit verbreitet und werden dazu verwendet,
Strukturen sowie Farbverläufe von natürlichen Materialien nachzubilden. Holz, Marmor
und Steine sind nur ein paar Beispiele aus dem schier endlosen Repertoire der dadurch simulierten
Oberflächenstrukturen.
Allen Texturen gemein ist die Eigenschaft, die veränderlichen Punktkoordinaten als Eingangsgröße
zu verarbeiten um daraus Werte bzw. Mischverhältnisse für Farbe und Material zu generieren.
Durch eine Vielzahl von mathematische Algorithmen beschrieben, erzeugen diese
Texturen so eine breite Palette an Farb- und Material-Verläufen.
3.2.2.1 Noise - Der Rauschgenerator
Unregelmäßigkeiten in Struktur und Farbverlauf sind oft entscheidend für die realistische Wirkung
Prozeduraler Texturen. Eine der wichtigsten Komponenten, die bei deren Erzeugung
zum Einsatz kommen, ist Noise. Dieser Rauschgenerator ordnet jedem Punkt im 3D-Raum
einen scheinbar zufälligen Wert zu. Die Anforderungen, die dabei an das erzeugte Rauschen
gestellt werden, sind:
• Der Wiederholungszyklus der Zahlenfolgen sollte möglichst lang sein, damit sich
daraus generierte Muster nicht zu offensichtlich wiederholen und der Pseudo-Zufall
auffällt.
• Die Werte müssen alle in einem bestimmten Intervall, meist [−1, 1], liegen. Dadurch
können Algorithmen, die das Rauschen verwenden, mit standardisierten Wertebereichen
arbeiten.
• Die generierten Zufallswerte sollten möglichst gleichverteilt sein, damit Zahlen aus dem
Zufallsintervall alle gleich wahrscheinlich auftreten.
• Der Zufall muss reproduzierbar sein: Für die gleichen Eingangsparameter muss die
Funktion immer die gleichen Ergebnisse liefern. Der Grund dafür ist die gewünschte
Reproduzierbarkeit der daraus generierten Muster. Auch aus Gründen der Parallelisierung
von Berechnungen, wofür sich Ray Tracing hervorragend eignet, ist dies entscheidend.
• Das erzeugte Rauschen muss eine maximale Auflösung besitzen - das bedeutet, für eine
genügend kleine Parameteränderung, können die ermittelten Werte zueinander in Beziehung
gebracht werden. Diese Eigenschaft ist insbesondere für Anitaliasing-Techniken,
wie Supersampling wichtig.
Rauschgeneratoren, die all diese Forderungen erfüllen, basieren meist auf lattice noise (Gitterrauschen),
das in einem dreidimensionalen Raster, dem so genannten integer lattice (vgl.
Abbildung 3.7(a)), jedem Raumpunkt ganzzahliger Koordinaten, einen festen, aber zufälligen
Wert aus dem Intervall [−1, 1] zuweist.

KAPITEL 3. TEXTURIERUNG 42
Implementiert wird dies meist durch das Speichern dieser Werte in einer Rauschwert-Tabelle.
Dies wird bereits dem Anspruch auf begrenzte Auflösung, Reproduzierbarkeit und dem standardisierten
Werteintervall gerecht.
Ein langer Wiederholungszyklus und eine wenigstens annähernde Gleichverteilung der Werte
kann durch das Verwenden von guten Zufallsgeneratoren sichergestellt werden. Diese erzeugen
die Zufallsfolgen meist recht aufwändig. Da die Tabelle aber nur einmal initialisiert werden
muss, ist dabei die Geschwindigkeit nicht ausschlaggebend.
Natürlich ist es nicht möglich, eine dreidimensionale Tabelle zu generieren, die tatsächlich
für jeden Raumpunkt einen Rauschwert bereithält. Deshalb besitzen solche Tabellen verhältnismäßig
geringe Ausmaße. Für durchaus gute Ergebnisse reicht bereits eine Größe von 1024
Einträgen aus. Der Zugriff auf die Werte erfolgt dabei über eine Indexfunktion, die die Raumkoordinaten
auf die verfügbare Größe der Tabelle abbildet.
y
z x
(a)
y
1.0
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0
0
0.1
0.2 0.3 0.4
0.5
0.6 0.7 0.8 0.9
Abbildung 3.7: Generierung von Rauschen
(a) Zufallswerte im integer lattice. (b) Polynom als Glättungsfunktion.
Für Punkte im Raum, deren Koordinaten rational sind, also irgendwo zwischen den Punkten
im Gitter liegen, werden die Rauschwerte der umliegenden Punkte interpoliert. Mit lineare
Interpolation treten in den ermittelten Werten allerdings schnelle Richtungswechsel auf, die
in daraus generierten Mustern zu sichtbaren Kanten führen.
Eine bessere Möglichkeit zur Interpolation bietet ein Polynom mit einem Wertebereich von
[0, 1] als Glättungsfunktion (vgl. Abbildung 3.7(b)). Diese liefert streng monoton steigende
Funktionswerte aus dem Intervall [0, 1] und sorgt mit der Steigung 0 in den Grenzen des Wertebereichs
für fließende Übergänge.
Dennoch ist das dadurch erzeugte Rauschen noch sehr grob. Durch die Interpolation entstehen
zwischen den Rauschwerten der Tabelle monotone Bereiche. Diese werden bei ausreichender
Vergrößerung deutlich sichtbar.
Die Spektralsynthese ist eine Methode, die es ermöglicht, auch die Gebiete zwischen den
Zufallswerten der Tabelle zu ”verrauschen” ohne dafür die Auflösung des Rauschens erhöhen
(b)
1.0 x

KAPITEL 3. TEXTURIERUNG 43
zu müssen. Dazu werden mehrere Rauschanteile mit steigender Frequenz, jedoch abnehmender
Amplitude aufaddiert. Die ansteigende Frequenz der Rauschbänder wird dabei durch
größer werdende Schrittweiten bei der Abtastung des Rauschraumes erreicht. Durch die Skalierung
mit ihrer immer geringer werdenden Amplitude, liefern diese allerdings immer kleinere
Beiträge. Dabei reichen bereits 3 Frequenzen aus, um dem Rauschen auch in Bereichen
oberhalb der maximalen Auflösung einen sehr unregelmäßigen Werteverlauf zu geben.
3.2.2.2 Die Karo-Textur
(a) (b)
Abbildung 3.8: 2D-Plot des generierten Rauschens
(a) Interpoliert. (b) Spektralsynthese mit 3 Frequenzen.
Die Karo-Textur ist eine sehr einfache, aber dennoch sehr oft genutzte Textur. Sie liefert eine
karierte Anordnung zweier Grundeinstellungen von Farbe und Material. Da es sich dabei
um eine zweidimensionale Anordnung handelt, werden auch hier die, in Abschnitt 3.2.1 beschriebenen
Verfahren benutzt, um die 3D-Punktkoordinaten auf das Intervall ([0, 1] × [0, 1])
des Karo-Musters abzubilden. Deshalb ergeben sich für diese Textur auch dieselben Verzerrungen
auf der Oberfläche (vgl. Abbildung 3.9(a)).
Für die, in einem Punkt zu wählenden Werte, kann mit einer XOR-Verknüpfung und den errechneten
Faktoren mx und my ein sehr einfacher Ausdruck als Kriterium formuliert werden:
boolV alue := mx > qx ⊕ my > qy
(3.4)
Um daraus ein schachbrettartiges Muster zu erhalten, reicht es aus, den beiden Zuständen
(wahr und falsch) jeweils Farbe und Material zuzuordnen. Die beiden Vergleichswerte qx
und qy geben dabei das Größenverhältnis nebeneinander liegender Karos in X- bzw. Y -
Richtung an. Für die Werte qx = 0.5 und qy = 0.5 ergibt sich also ein klassisches Schachbrett.
Da sich dieser Ausdruck nur für eine 2 × 2-Aufteilung einer Fläche eignet, muss die Größe
der Karos über die Punkt- Abbildung gesteuert werden. Dazu kommt die, im Abschnitt 3.2.1
erwähnte, gekachelte Anordnung zum Einsatz. Dabei werden die Ausdehnungen des zu projizierenden
Musters (hier eine 2 × 2 Kachel) berücksichtigt. Dadurch wird die Karogöße bestimmbar.

KAPITEL 3. TEXTURIERUNG 44
3.2.2.3 Die Klotz-Textur
Auch die Klotz-Textur erzeugt eine karierte Anordnung zweier Farben bzw. Materialien. Im
Unterschied zur Karo-Textur füllt die dadurch entstehende Struktur den Raum des texturierten
Objektes vollständig aus. Deshalb zählt diese Textur zur Klasse der 3D-Texturen. Diese
zeichnen sich dadurch aus, dass sie ohne Abbildung auf jeden Punkt im Raum anwendbar sind
und jedem eine Farbe bzw. Material zuordnen.
Auch hier kann diese Zuordnung für einen Punkt P über einen einfachen Ausdruck gesteuert
werden:
boolV alue := |⌊Px/Size.x⌋ + ⌊Py/Size.y⌋ + ⌊Pz/Size.z⌋| mod 2 (3.5)
Wichtig ist hierbei das Abrunden der Summanden. Dadurch wird eine Spiegelung der Anordnung
an den Koordinatenachsen verhindert.
(a) (b)
Abbildung 3.9: Texturbeispiele: Karo- und Klotz-Textur
(a) An den Polen der Kugel ergeben sich deutliche Verzerrungen. (b) Klötze in Kugelform.
3.2.2.4 Die Marmor-Textur
Eine sehr eindrucksvolle und breit einsetzbare Textur ist die Marmorierung. Verschiedene
Schichten aus Kalkgestein, die durch Druck und hohe Temperaturen in Marmor umgewandelt
wurden, bilden die typische verwirbelte Maserung, die hellere Schichten durchzieht. Diese
Verwirbelungen von Materialien versucht die Marmor-Textur nachzuahmen.
Um Marmor zu simulieren, ist ein recht intuitives Vorgehen, dessen natürliche Entstehung aus
mehreren Schichten zu imitieren. Diese Schichten können durch das Mischen der Grundwerte
entlang einer Koordinate, z.B. X, entstehen. Das Mischungsverhältnis bestimmt dabei eine,
über dem Intervall [0, 1] oszillierende Funktion.
Durch eine Spline-Kurve im Intervall [−1, 1] [8][4], die die Werte aus dem gewünschten Bereich
durchläuft, kann die Charakteristik der Marmorierung sehr gut beschrieben werden. Die

KAPITEL 3. TEXTURIERUNG 45
Oszillation zur Abtastung der Spline-Werte, kann mittels einer Sinus-Funktion, mit der X-
Koordinate als Parameter, erfolgen.
y
1.0
0.9
0.8
0.7
0.6
0.5
0.4
0.3
0.2
0.1
0.0
−1.0
−0.8
−0.6
−0.4
−0.2
0.0 0.2 0.4 0.6 0.8 1.0 x
(a) (b) (c)
Abbildung 3.10: Generierung der Marmor-Textur
(a) Spline-Kurve. (b) Streifen-Textur ohne Turbulenz. (c) Verrauschte Streifen-Textur.
Um nun für die typischen Verwirbelungen in den so entstandenen Schichten zu sorgen, reicht
es aus, fraktales Rauschen als Phase auf den Sinus zu geben. Den Mischwert für die Farb- und
Materialanteile im Punkt P liefert dann folgender Ausdruck:
3.2.2.5 Die Holz-Textur
marble := spline(sin(Px + fractalNoise)) (3.6)
Holz ist ein sehr vielseitig eingesetztes Material. Als Bau- oder Werkstoff verwendet, ist es
fast überall zu finden. Darum wird die Holz-Textur in praktisch jedem Texturierungssystem
integriert. Die typische Holzzeichnung basiert auf den Jahresringen von Bäumen. Abhängig
von der Richtung, in der diese Ringe beim Zuschneiden durchtrennt werden, entstehen die
charakteristischen Muster.
Die Funktion dieser Textur lässt sich auf das Erzeugen konzentrischer Kreise entlang einer
festen Koordinatenachse zurückführen. Diese Kreise entstehen aus dem Abstand des Punktes
zum Objektursprung. Entlang des berechneten Radius muss die gewählte Funktion dazu zwischen
zwei Farbwerten alternieren.
Eine einfache Möglichkeit für diesen Wechsel, ist die Anwendung der Modulo-Funktion auf
den abgerundeten Radius. Wird die X-Koordinate als feste Achse gewählt, ergibt sich für den
Punkt P :
��
rings := Py 2 + Pz 2
�
mod 2
Jedoch werden dadurch die Ränder der Ringe sehr scharfkantig und sehen damit nicht sonderlich
natürlich aus (vgl. Abbildung 3.11(a)). Weichere Übergänge, zumindest für die inneren

KAPITEL 3. TEXTURIERUNG 46
Ränder, versprechen hier Besserung. Dieser Effekt kann durch das Verwerfen des Ganzzahlanteils
des Radius erzielt werden. Die weichen Farb-Verläufe an den Innenrändern der Ringe
sind dadurch allerdings noch zu breit. Eine Korrektur wird durch Potenzierung mit einem
Wert für die Ringschärfe möglich. Dadurch werden die Übergänge schmaler (vgl. Abbildung
3.11(b)).
�
smoothRings(Py, Pz) :=
Py 2 + Pz 2 −
��
Py 2 + Pz 2
wood := smoothRings(Py + fractalNoise, Pz + fractalNoise) sharpness (3.7)
Natürlich wachsen Bäume nicht immer gleichmäßig. Dies wird an den Jahresringen durch
Schwankungen in Dicke und Form sichtbar. Aus diesem Grund wird auf die variablen Koordinaten
Y und Z fraktales Rauschen addiert, um diese Schwankungen zu simulieren (vgl.
Abbildung 3.11(c)).
(a) (b) (c)
Abbildung 3.11: Generierung der Holz-Textur
(a) Scharfkantige Jahresringe. (b) Ringe mit weicheren Übergängen. (c) Ringe mit Turbulenz.
�

KAPITEL 3. TEXTURIERUNG 47
3.2.3 Bump Mapping
Die Wahrnehmung von Flächen wird wesentlich vom Spiel mit Licht und Schatten beeinflusst.
Rauheit und kleine Strukturen an der Oberfläche prägen das Erscheinungsbild durch
Veränderung des Schattenwurfs und der Reflexionsmuster. Deshalb ist es für einen realistischen
Eindruck von simulierten Objekten sehr wichtig auch diese Feinheiten nachzubilden.
Es ist klar, dass die geometrische Konstruktion dieser Details eine sehr aufwändige, wenn
nicht gar unmögliche Vorgehensweise darstellt. Der damit verbundene Aufwand an Speicher
und Rechenzeit setzt einfach zu enge Schranken.
Bump Mapping ist ein von Blinn 1 entwickeltes Verfahren, das es ermöglicht, einer Oberfläche
ein rauhes oder verbeultes Aussehen zu verleihen, ohne diese Details mühsam konstruieren
zu müssen.
Der Effekt des Bump Mapping beruht auf der gezielte Veränderung der Flächennormalen und
beeinflusst dadurch natürlich die Berechnung der davon abhängigen Lichtanteile, während
der Schattierung. Abbildung 3.12 zeigt diese Perturbation - eine ”Störung” konstruktiver Art
- des Normalenvektors:
u
u ’
n
Abbildung 3.12: Perturbation der Flächennormale
Wie die Abbildung zeigt, entsteht die veränderte Normale �n ′ durch Aufaddieren des ”Störungsvektors”
� d, der sich aus den beiden Vektoren �u ′ und �v ′ zusammensetzt. Diese wiederum errechnen
sich aus den zwei Vektoren �u und �v sowie der Bump-Funktion F , wie folgt:
v ’
d
n ’
v
�u ′ = ∂F
�u
∂u
(3.8)
�v ′ = ∂F
�v
∂v
(3.9)
�d = �u ′ + �v ′
(3.10)
�n ′ = �n + � d (3.11)
Hierbei stellen die beiden Vektoren �u und �v zwei beliebige, aber zueinander senkrechte Vektoren
aus der Tangentialebene im Punkt P dar. Um diese zu konstruieren muss ein Hilfsvektor
� h gefunden werden, der nicht parallel zu �n ist. Dabei hilft eine Analyse des Normalenvektors
1 Blinn, J.F.: ”Simulation of Wrinkled Surfaces”, SIGGRAPH ’78

KAPITEL 3. TEXTURIERUNG 48
�n: Handelt es sich dabei um ein Vielfaches des Vektors (1, 0, 0), kann dazu beispielsweise der
Vektor (0, 1, 0) verwendet werden, andernfalls (1, 0, 0). Mit Hilfe des Vektorproduktes und
anschließender Normierung ergeben sich daraus �u und �v:
�u = �n × � h, �u 0 = 1
|�u| �u
�v = �n × �u, �v 0 = 1
|�v| �v
Die Bump-Funktion F (siehe nächster Abschnitt) ermittelt die Steigung der Textur im Punkt
P , die sich durch das Punktprodukt in ihre Anteile der Richtungen �u und �v aufspalten lässt:
3.2.3.1 Die Bump-Funktion
∂F
∂u
∂F
∂v
−−−→
= F (P ) · �u
−−−→
= F (P ) · �v
Das Ausmaß der Veränderung der Flächennormalen durch Perturbation, wird durch die Steigung
der Textur festgelegt. Aufgabe der Bump-Funktion ist es, diese Steigung für jeden Punkt
der Textur zu ermitteln. Diese kann sich aus den Beiträgen mehrerer Komponenten zusammensetzen:
• Die Bump Map ist der Klassiker und daher auch eine der bekanntesten Methoden, die
im Bump Mapping zum Einsatz kommen. Hierbei wird eine Bilddatei verwendet, um
aus der Differenz der Grauwerte ihrer Pixel, Steigungen in den einzelnen Punkten zu ermitteln
(vgl. Abbildung 3.13(a)). Im Grunde kann dazu zwar jedes Bild als Bump Map
verwendet werden, die besten Ergebnisse lassen sich allerdings nur mit speziell dafür
präparierten Graustufenbildern erzielen.
Ähnlich zur Bitmap-Textur muss die verwendete Map auch hier passend auf die Oberfläche
projiziert werden. Für diese Abbildung werden die im Abschnitt 3.2.1 beschriebenen
Algorithmen verwendet.
• Auch die Textur kann von sich aus einen Beitrag zur Steigung liefern. Dies ist natürlich
von der Art der Textur und deren Vorgehen bei der Ermittlung von Farbe und Material
abhängig. Am Beispiel der Karo-Textur wird dies ersichtlich:
Die ermittelte Steigung in einem Punkt, wird auf die Ränder der Karos abgestimmt.
So liefert diese Textur in den Randbereichen der Primärfarbe ein Gefälle von 45 ◦ (vgl
Abbildung 3.13(b)).
• Turbulenzen durch fraktales Rauschen ermöglichen durch Simulation von Unebenheiten
und Rauheit den Eindruck realistischer Oberflächen. Die Steigung in den einzelnen
Punkten wird durch Spektralsynthese - d.h. durch Aufaddieren von Steigungen immer
höher werdender Frequenz aber abnehmender Amplitude - entwickelt.
Die Kombination der ermittelten Steigungen erfolgt mittels Addition und ergibt die Steigung
für die weitere Berechnung nach Gleichung (3.8) bzw. (3.9).

KAPITEL 3. TEXTURIERUNG 49
Die Anteile beeinflussen sich durch die Kombination natürlich gegenseitig und können durch
Verstärken oder Auslöschen einzelner Steigungsanteile unerwartete Ergebnisse hervorrufen.
Aus diesem Grund sollten die einzelnen Komponenten mit Bedacht kombiniert und deren
Einstellungen entsprechend vorsichtig gewählt werden, um die gewünschten Resultate zu erzielen.
(a) (b) (c)
Abbildung 3.13: Texturbeispiel: Bump Mapping
(a) Bild mit Mauerwerk als Bump Map. (b) Bump mittels Karo-Textur. (c) Oberflächenturbulenz.
3.2.3.2 Grenzen des Bump Mapping
Gewiss bringt auch Bump Mapping Nachteile mit sich und stößt dadurch an die Grenzen seiner
Einsetzbarkeit. Die durch Bump Mapping simulierten Details der Oberfläche, beeinflussen
nur die Berechnungen der Schattierung. Die Schnittberechnungen, die ja zum Zeitpunkt der
Texturierung längst abgeschlossen sind, werden dadurch natürlich nicht beeinflusst. Darum
bleiben die ursprünglichen Konturen und der Schattenwurf der Objekte unverändert (vgl. Abbildung
3.14). Diese Fehler treten vor allem bei kontrastreichem Hintergrund oder größerer
Bump-Tiefe auf sehr deutlich hervor.
Abbildung 3.14: Grenzen des Bump Mapping
Fehler in Kontur und Schattenwurf

KAPITEL 3. TEXTURIERUNG 50
3.3 Das Textur-System
Texturen sind den Oberflächen von Objekten in der Regel fest zugeordnet. Daran sollte auch
eine Transformation des Objektes nichts ändern. Eine auf das Objekt angewandte Rotation
muss sich demnach auch auf die Textur auswirken - sie dreht sich mit. Mit Ausnahme von
Texturen, die explizit mit den Weltkoordinaten arbeiten (z.B. Environment Mapping), gilt
dies für alle Texturen.
Dennoch sollte es möglich sein, die Lage und Ausrichtung einer Textur auf der Oberfläche
zu beeinflussen. Darum macht es Sinn, Texturen mit einem eigenen Koordinatensystem auszustatten.
Da dieses System relativ zu den Objektkoordinaten orientiert ist, muss die entsprechende
Transformation von Schnittpunkten und Flächennormalen nach der Objekt-Transformation
stattfinden.
Für die Entwicklung von Texturen ergeben sich daraus klare Vorteile:
• Textur-Algorithmen können sehr einfach gehalten werden, da standardisierte Koordinatenräume
zu Grunde gelegt werden können.
• Transformationen der Texturen können sehr einfach, schnell und zentral durchgeführt
werden.
• Die implementierten Transformationen können ohne Modifikation auf alle Texturen angewendet
werden. Ob dies auch sinnvoll ist, muss natürlich von Fall zu Fall entschieden
werden.
3.4 Fazit
Texturen machen modellierte Szenen erst lebendig. Meist ist der zusätzliche Berechnungsaufwand
auch recht gering. Wie die vorgestellten Algorithmen zeigen, eröffnen dabei schon
einfache Methoden, sehr interessante Möglichkeiten für die Gestaltung von Oberflächen.
Auch die Implementierung kann zum Teil sehr einfach und kompakt gehalten werden. Details
werden dazu in Kapitel 4 beschrieben.

Kapitel 4
Implementierung
Die in den vorhergehenden Kapiteln beschriebenen Funktionen und Algorithmen wurden in
der Programmiersprache C++ implementiert und in einen bestehenden Ray Tracer integriert.
Als Grundlage wurden hierfür die Systeme aus den Arbeiten von A. Riepl [7] und O. Groth
[3] verwendet. Auch fanden dabei viele, der für Freiformflächen erforderlichen Berechnungen
aus der Arbeit von U. Lugauer [5] Verwendung.
Ein Ziel war, die ursprünglichen Systeme so weit wie möglich zu erhalten. Aufgrund von erforderlichen
Änderungen an Abläufen und den bestehenden Klassenhierarchien war es meist
jedoch notwendig, die übernommenen Algorithmen unter anderen Gesichtspunkten zu strukturieren
und Funktionsgruppen anders zu organisieren. Daraus ergab sich eine, zum Teil erheblich
veränderte Aufteilung.
Nicht zuletzt durch die Integration von Freiformflächen in die Objekthierarchie, mussten viele
bereits bestehende Bereiche überarbeitet und angepasst werden. Im Zuge dieser Veränderungen
ergaben sich einige Ergänzungen des Systems, die Erweiterungen der Definitionssprache
für den Szenenentwurf nötig machten.

KAPITEL 4. IMPLEMENTIERUNG 52
4.1 Allgemeine Funktionsweise
Aufgrund der erfolgten Veränderungen am System, ist es sinnvoll zunächst einen Überblick
über die aktuelle Aufteilung und Funktionsweise des Ray Tracing-Systems zu geben. Der
Ablauf des Ray Tracing-Prozesses ist im Anhang A, Abbildung A.1 als Sequenzdiagramm
dargestellt, auf welches sich die folgende Erläuterung bezieht.
4.1.1 Vorbereitungen und Parsing
Das Programm startet im Modul Raytrace mit der Auswertung der Parameterliste. Diese bestimmt
die zu verarbeitende Datei zur Definition der Szene sowie einiger weiterer, für den
Ablauf wichtiger Einstellungen. Detaillierte Angaben zu den Optionen der Parameterliste finden
sich im Anhang B.
Der erste Schritt der Vorbereitungen ist die Instanzierung der Klasse Model. Diese ist für
die Verwaltung aller Daten verantwortlich, die während des Ray Tracing-Durchlaufs benötigt
werden. Dazu zählen vor allem die interne Szenendefinition, bestehend aus allen Objekten und
Lichtquellen, die Konfiguration des Beobachterstandpunktes sowie ein optional definierter
Octree zur Optimierung der Berechnungen.
Der Aufbau der benötigten Datenstrukturen erfolgt durch den Parser. Mit Hilfe der Klasse
Scanner liest dieser die Szenenbeschreibung der zu verarbeitenden Datei ein und wandelt die
darin festgelegten Definitionen in die interne Darstellung durch die verschiedenen Strukturen
um. Die für die Spezifikation zu beachtende Syntax der Beschreibungs-Sprache ist im Anhang
C mittels EBNF 1 beschrieben.
Der Parser arbeitet nach dem Recursive-Descent-Verfahren. Deshalb ist der Ablauf sehr stark
an der verwendeten Syntax orientiert. Aus diesem Grund wird auch der Parsing-Prozess bereits
durch die abstrakte Sprach-Beschreibung der EBNF übersichtlich dokumentiert und soll
deshalb an dieser Stelle nicht detaillierter beschrieben werden.
Die finale Initialisierung des Modells (buildModel()) stellt den Abschluss der Parsing-Phase
dar. Dazu gehören der Aufbau eines eventuell spezifizierten Octrees sowie das Einhängen der
passenden Funktionen für die Schnittpunktsuche und das verwendete Beleuchtungsmodell.
Nach dem erfolgreichen Durchlauf des Parsers und Konstruktion des internen Modells erfolgt
das Anlegen eines Image-Objekts als Einheit für die Ausgabe der berechneten Bilddaten.
Der genaue Typ der Instanzierung wird dabei durch die Optionen der Parameterliste
festgelegt. Im aktuellen Stand umfasst die Implementierung eine Window-Klasse, basierend
auf dem XWindow-System für die Darstellung während der Bildberechnung sowie das TGA-
Bildformat für die Ausgabe als Datei.
1 Extended Backus Naur Form

KAPITEL 4. IMPLEMENTIERUNG 53
4.1.2 Ablauf der Bildberechnung
Die Berechnungen der Bilddaten startet mit dem Aufruf der zur Model-Klasse gehörenden
Methode renderModel(). Hier findet die Iteration über alle Bildpunkte der Ansicht statt. Das
Ziel ist es dabei, für jeden Pixel die Farbanteile zu bestimmen und diese durch die Methode
setPixelColor() des Image-Objektes in das Bild eintragen zu lassen.
Zur Bestimmung der Farbe eines Bildpunktes wird in die Funktion sample() aus dem Modul
Shade verzweigt. In dieser Funktion erfolgen die Berechnungen des Adaptive Supersampling
2 . Die Rekursion des Sampling wird dabei durch einen Schwellwert für die Farbdifferenz
und einem maximalen Level des Abstiegs begrenzt.
Von hier aus startet auch die Verfolgung der Strahlen durch die Szene. Wie im Diagramm
dargestellt, werden diese erst mittels newRayDirection() bestimmt und dann der Funktion
trace() als Parameter übergeben. Da die Verfolgung der Strahlen vom Algorithmus und den
Berechnungen des gewählten Beleuchtungsmodells 3 abhängt, wurde trace() als Funktionspointer
realisiert, der vom Parser auf die zu verwendende Funktion gesetzt wird.
Für die Berechnungen der Schattierung, wird der Schnittpunkt des Strahls mit dem naheliegensten
Objekt gesucht. Diese Suche kann dabei durch einen normalen Durchlauf und Test
aller Objekte oder über den optimierten Algorithmus des Octrees erfolgen. Aus diesem Grund
wird auch dieser Aufruf über einen Funktionspointer gesteuert, der durch den Parser entweder
auf die Standardimplementierung in der Model-Klasse oder, bei aktiviertem Octree, auf
dessen Suchfunktion zeigt.
Die tatsächliche Berechnung von Schnittpunkten während dieser Suche muss natürlich passend
zum Typ des Objekts durchgeführt werden. Die Objekt-Hierarchie wurde rein durch
klassische Vererbung aufgebaut. Aus diesem Grund kann die Unterscheidung und Auswahl
der Schnittalgorithmen getrost dem Polymorphismus überlassen werden. Für eine detaillierte
Beschreibung des Aufbaus der Object-Hierarchie sei hier auf den Abschnitt 4.2 verwiesen.
Liefert die Schnittpunktsuche ein positives Ergebnis, werden für die weiteren Berechnungen
des Beleuchtungsmodells die genauen Daten des naheliegendsten Objekts benötigt. Dazu
gehören das Ausmaß der ambienten Beleuchtung des Objekts sowie die Flächennormale, die
Farbe und das Material im Punkt des Treffers. Diese Daten können über die Schnittstellen der
Object-Klasse angefordert werden.
Damit das getroffene Objekt allerdings diese Werte liefern kann, müssen ihm vorher die Daten
des Treffers - Strahl und Schnittpunkt - für eine Auswertung zur Verfügung gestellt werden.
Dies erfolgt über setHitData() der Object-Klasse.
Dabei führt diese Methode die erforderlichen Transformationen der Daten durch und veranlasst
die Berechnung aller wichtigen Größen und Werte, die für die Schattierung benötigt
werden.
2 Rekursives Anti-Aliasing-Verfahren, das dazu dient, den Stufeneffekt an Kanten und harten Farbübergängen
zu reduzieren. Dies erfolgt durch Mischen der Farbbeiträge mehrerer Strahlen (vgl. [7]).
3 Im aktuellen Stand sind die Modelle nach Whitted und Phong implementiert

KAPITEL 4. IMPLEMENTIERUNG 54
Wie das Diagramm andeutet, werden die Daten des Schnittpunktes auch zur Berechnung der
Textur verwendet und deshalb an die zugeordnete Texturinstanz weitergegeben. Der Ablauf,
der im Objekt und in den Klassen der Textur während dieser Auswertung stattfindet, wird in
den Abschnitten 4.2 und 4.3 genauer beschrieben.
Anhand der dadurch ermittelten Informationen über die Objektoberfläche, erfolgt die Schattierung
des Punktes. Abhängig von den Eigenschaften des Materials, konkret sind dies die
Transparenz und die Reflektivität, wird die Strahlverfolgung mittels trace() rekursiv fortgesetzt.
Der Abstieg wird dabei durch die Überprüfung eines Schwellwertes für den Beitrag zur
Farbinformation sowie einen Test auf maximale Rekursionstiefe kontrolliert.

KAPITEL 4. IMPLEMENTIERUNG 55
4.2 Die Objekte
Zur Implementierung der Objekte, wurde die bereits bestehende Klassen-Hierarchie weitgehend
übernommen. Allerdings musste diese zwecks Integration von Freiformflächen (siehe
auch nächster Abschnitt) überarbeitet werden. Ein Hauptgrund dafür war die Art der Definition
dieses Flächentyps: Die dazu benötigten Kontrollpunkte müssen absolut, d.h. in Weltkoordinaten
spezifiziert werden. Zur Anordnung dieser Objekte innerhalb der Szene war es deshalb
notwendig, erweiterte Transformationen zu ermöglichen und ein Objekt-Koordinatensystem
einzuführen (vgl. auch Kapitel 1, Abschnitt 1.4).
Desweiteren mussten hinsichtlich der Veränderungen an der Textur-Hierarchie, die Schnittstellen
zur Kommunikation mit dem Texturierungssystem (vgl. Abschnitt 4.3) angepasst werden.
Leider ist es nicht möglich, die Texturen ganz unabhängig vom Objekt einzusetzen. Für
die 2D-Abbildungen (vgl. Kapitel 3, Abschnitt 3.2.1) müssen die Abmessungen der Oberfläche
und die Art der Projektion bekannt sein. Um diese Einstellungen spezifisch anpassen
zu können, werden die Methoden zu den Schnittstellen matchMappingMode() und matchSurfaceDimension()
von den Objekten implementiert. Diese werden vom Parser dazu verwendet,
die passenden Einstellungen zu ermitteln und angewendete Texturen auf die Art der Objekte
abzustimmen.
Abbildung 4.1 zeigt den Aufbau der abstrakten Basisklasse Object. Ein Diagramm der gesamten
Objekt-Hierarchie findet sich im Anhang A.
Object
+ setHitData(hitPoint) : void
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
+ getColor() : Color
+ getNormal() : Vector
+ getAmbience() : Color
+ getMaterial() : Material
# toObject : Matrix
# toWorld : Matrix
# ambience : Color
# texture : Texture *
4.2.1 Objekt-Transformation
Abbildung 4.1: Die Basisklasse der Objekte
Es sprechen einige Punkte für die Implementierung des Objekt-Systems:
• Es ergeben sich vereinfachte Berechnungen für Schnittpunkte und Normalenvektoren,
da diese nur die Grundstellung der Objekte berücksichtigen müssen.

KAPITEL 4. IMPLEMENTIERUNG 56
• Die Transformation des Strahls kann mittels Transformationsmatrizen schnell und einheitlich
durchgeführt werden.
• Die implementierten Transformationen können leicht kombiniert werden und sind auf
alle Objekte anwendbar.
Zur Implementierung der Objekt-Koordinaten wurde die Object-Basisklasse mit zwei Transformationsmatrizen
ausgestattet. Eine der beiden (toObject) dient zur Transformation des
Strahles in Objekt-Koordinaten und wird bereits während des Parser-Durchlaufs für die nötigen
Transformationen vorbereitet. Bei Kombination von mehreren Einzeltransformationen
werden diese mit Hilfe der Matrizenmultiplikation zusammengefasst.
Um Punkte aus dem Objekt-System in Weltkoordinaten zu überführen, benötigen die Algorithmen
des Octree die inverse der Objekt-Transformation. Diese wird mit Hilfe des Gauss-
Jordan-Algorithmus berechnet und in der zweiten Transformationsmatrix (toWorld) abgelegt.
4.2.2 Ablauf objektinterner Berechnungen
Die Suche nach Treffern des Strahls erfordert die Schnittpunktberechnungen der Objekte. Dazu
bietet die abstrakte Basisklasse Object die Schnittstelle intersect(). Diese Methode ist rein
virtuell und muss in den Objekten, die sich von Object ableiten, implementiert werden. Dadurch
erfolgt eine Typenüberprüfung zur Laufzeit und die Algorithmen für die Berechnungen
werden automatisch passend gewählt.
Der Aufruf erwartet den Strahl als Parameter und liefert einen Wahrheitswert sowie, im Fall
eines Treffers, die Distanz des Schnittpunktes zum Strahlursprung.
Für das Objekt, das den am nächsten zum Strahlursprung liegenden Treffer aufweist, müssen
die vom Beleuchtungsmodell geforderten Daten der Oberfläche ermittelt werden. Die hierzu
notwendigen Auswertungen werden in der Methode setHitData() koordiniert und typspezifische
Berechnungen, wie die Normalenermittlung, veranlasst. Hier erfolgt auch der Datenaustausch
mit dem Texturierungssystem (Texture::setHitData()), das die Werte für Farbe, Material
und die Perturbation des Normalenvektors liefert (siehe Abschnitt 4.3).
Da dieses Vorgehen für die meisten Objekte einheitlich ist, wurde die Behandlung bereits in
Object implementiert. Objekte, wie Box und FreeformSurface bilden hier allerdings die Ausnahme,
weshalb die Methode auch virtual und damit überschreibbar gehalten wurde.
Nach Ablauf von setHitData(), können die ermittelten Daten vom Objekt angefordert werden.
Dazu stellt die Klasse Object die Schnittstellen getColor(), getMaterial(), getNormal()
und getAmbience() bereit. Die Farbe und das Material werden von der Textur bereitgehalten,
wodurch die entsprechenden Aufrufe direkt an diese weitergeleitet werden.

KAPITEL 4. IMPLEMENTIERUNG 57
4.3 Die Texturen
Die Klassen-Hierarchie des Texturierungssystems wurde neu entworfen und implementiert.
Die dabei verwendeten Texturalgorithmen wurden zu großen Teilen aus der Arbeit von O.
Groth [3] übernommen. Diese wurden jedoch unter anderen Gesichtspunkten strukturiert und
gegliedert. Daher ergaben sich zum Teil erhebliche Veränderungen hinsichtlich Aufteilung
und Funktionsweise.
Der komplette Aufbau der Textur-Hierarchie wird aus dem Diagramm A.3 im Anhang A
ersichtlich. An dieser Stelle werden die Eigenschaften und Besonderheiten des Systems
erläutert. Dabei wird auf Abbildung 4.2 Bezug genommen, die dazu die wichtigsten Daten
und Methoden der Basisklasse Texture und der davon abgeleiteten Klasse BumpTexture zeigt.
Texture
+ setHitData(hitPoint) : void
+ setRayAndNormal(ray,normal) : void
+ is2D() : bool
+ needsRayAndNormal() : bool
+ detectTextureData() : void
+ getColor() : Color
+ getMaterial() : Material
# toTexture : Matrix
# fromTexture : Matrix
# baseColor : Color
# baseMaterial : Material
− getCoordTurbulence(point) : Vector
− turbulence : Turbulence
4.3.1 Das Textur-System
BumpTexture
+ getBumpNormal(Vector) : Vector
+ is2D() : bool
+ needsRayAndNormal() : bool
+ detectTextureData() : void
# getTextureSlope()
− getMapSlope()
− getNoiseSlope()
− bumpSize : Real
− turbulence : Turbulence
− mapper : PointMapper
− bumpMap : TGAImage *
Abbildung 4.2: Die Spitze der Textur-Klassenhierarchie
Ähnlich zum Koordinatensystem der Objekte, wurden die Texturen mit einem eigenen Transformations-System
ausgestattet (siehe auch Kapitel 3, Abschnitt 3.3). In der Implementierung
werden auch hier zueinander inverse Transformationsmatrizen (toTexture und fromTexture)
für die Überführung zwischen den Koordinatensystemen verwendet. Diese werden bereits
während des Parser-Durchlaufs entsprechend der Texturtransformationen berechnet.
Da sich die Textur mit dem Objekt bewegen muss, werden die Texturtransformationen auf den
Strahl angewendet nachdem dieser bereits in das Objekt-System transformiert wurde.
Probleme bei der Implementierung ergaben sich durch Rundungsfehler bei den Transformationen.
Diese beeinflussen das Erscheinungsbild vor allem bei Texturen, deren Algorithmen
die Texturinformationen wie Farbe und Material aufgrund diskreter Schwellwerte

KAPITEL 4. IMPLEMENTIERUNG 58
auswählen, wie dies bei der Karo- und Klotz-Textur geschieht. Besonders auffällig sind diese
Fehler bei Objekten mit ebenen Flächen in den Koordinatenebenen, wie der Box. Hier entsteht
ein sichtbares Rauschen in einzelnen Abschnitten der Textur.
Zur Lösung dieses Problems müssen in diesen Objekten, nach der Transformation, die Rundungsfehler
durch Korrektur der Schnittpunktkoordinaten ausgeglichen werden.
4.3.2 Ablauf interner Textur-Berechnungen
Zur Bestimmung von Farbe und Material brauchen die Texturen einige Daten. Diese werden
von der Methode setHitData() der Object-Klasse aus an die Textur übergeben. Dies geschieht
mit Hilfe der Schnittstellen der Texture-Basisklasse sowie der Klasse BumpTexture.
Eine der wichtigsten Informationen ist der Schnittpunkt des Strahls mit dem Objekt. Dieser
muss dazu bereits in Objekt-Koordinaten vorliegen und kann der Textur durch die Methode
setHitData() bekannt gemacht werden. Unter Umständen ist dabei für das Objekt die Dimension
der Textur entscheidend 4 . Ob eine 2D-Textur vorliegt, kann durch die Schnittstelle is2D()
ermittelt werden.
Der Verlauf von Farbe und Material kann, unabhängig von der Art der Textur, einer Turbulenz
unterworfen werden. Die dazu notwendigen Schritte zum ”Verrauschen” der Koordinaten
werden auch in dieser Methode, unmittelbar vor der Transformation in Textur-Koordinaten
durchgeführt.
Bei aktiviertem Bump Mapping benötigt die Textur außerdem die Flächennormale im Schnittpunkt.
Diese wird durch die Methode getBumpNormal() der Klasse BumpTexture entsprechend
der Einstellungen perturbiert und direkt zurückgegeben.
Für Environment Mapping benötigen die Berechnungen zusätzlich den Strahl und die Normale
in Weltkoordinaten. Dabei kann der Normalenvektor bereits durch Bump Mapping
verändert worden sein. Bei Bedarf werden diese Daten vom Objekt mittels setRayAndNormal()
an die Textur übergeben. Ob dieser Datentransfer nötig ist, wird dabei durch das Prädikat
needsRayAndNormal() entschieden.
Nachdem so alle erforderlichen Daten der Textur mitgeteilt wurden, veranlasst der Aufruf der
Methode detectTextureData() die Berechnung der Texturinformationen. Genau wie is2D() und
needsRayAndNormal, ist diese Schnittstelle rein virtuell und erfordert die Implementierung in
den Klassen des jeweiligen Texturtyps.
Wie aus Abbildung 4.2 ersichtlich ist, geschieht dieses bereits in der von Texture abgeleiteten
Klasse BumpTexture. Dadurch entsteht die Standardtextur ohne Änderungen in Farbe und
Material, aber mit allen Voraussetzungen für Bump Mapping. Diese ist dem Texturierungs-
System auch als PlainTexture bekannt.
4 Dies ist bei 2D-Texturen, wie der Karo- oder Bildtextur, auf Objekten mit nicht durchgehender Oberfläche
(z.B. Box) der Fall.

KAPITEL 4. IMPLEMENTIERUNG 59
4.4 Änderungen am Gesamtsystem
Durch die Überarbeitung und die Erweiterungen in den Klassen der Objekte und Texturen,
waren auch viele Änderungen am Gesamtsystem erforderlich. Die wichtigsten der dadurch
entstandenen Modifikationen und Ergänzungen werden in den folgenden Abschnitten kurz
beschrieben.
4.4.1 Die Szenendefinition
Zur Definition von Szenen, existierten bereits Routinen, die das Einlesen aus Dateien und
die Umsetzung in interne Datenstrukturen ermöglichten. Die dabei zu Grunde liegende Sprache
musste natürlich an die neuen Gegebenheiten angepasst werden. Durch die Notwendigkeit
sehr viele neue Schlüsselwörter und Definitionsabschnitte in die Sprache aufnehmen zu
müssen, erschien es sinnvoll, die Symbolerkennung und die Abläufe der Syntaxüberprüfung
von einander zu trennen und in eigenständigen Klassen zu kapseln. Dadurch entstanden aus
den rein prozeduralen Funktionen, die beiden Klassen Scanner und Parser.
4.4.1.1 Die Syntax
Einige Definitionen führten durch ihre Aufnahme in die Sprache zu doppeldeutigen Konstruktionen,
die in den Parsingroutinen zum Teil nicht erkannt und aufgelöst werden konnten. Um
diese Mehrdeutigkeiten zu beseitigen, wurde der Sprachaufbau zu einer an VRML 5 angelehnten
Syntax hin verändert. Davon abweichend wurden zusätzlich Blockkommentare im Stil von
C/C++ mit in die Sprache integriert.
Eine der auffälligsten Veränderungen an der Sprache ist wohl die Klammerung von Definitionsblöcken.
Die dadurch vorhandenen Endekennungen von zusammengehörigen Bereichen
erleichtern das Parsing erheblich und Fehler in den Definitionen können auf sehr kleine Bereiche
eingegrenzt werden. Deshalb werden auch sehr viel exaktere Fehlermeldungen möglich.
Eine genaue Spezifikation der Syntax findet sich in Backus Naur Form im Anhang C.
4.4.1.2 Definitionen
Zur Festlegung von Farben, Materialien und Flächenkontrollpunkten müssen häufig sehr viele
Werte in der Szenenbeschreibung eingetragen werden. Sehr oft werden auch die selben Definitionen
mehrfach in einer Szene verwendet. Die Beschreibung von umfangreicheren Szenen
in denen Definitionen von Freiformflächen vorkommen, wird dadurch schwer und absolut
unübersichtlich.
Um den Entwurf von Modellen zu erleichtern, wurde der Parser mit der Möglichkeit ausgestattet,
Spezifikationsblöcke außerhalb der Szene zu definieren und auf diese später in den
Objektbeschreibungen zu verweisen.
5 Virtual Reality Modeling Language

KAPITEL 4. IMPLEMENTIERUNG 60
Damit wird es möglich, Farben, Materialien, komplexe Texturspezifikationen sowie Kontrollpunkte
von Freiformflächen und deren Flächenzugehörigkeit unter einem frei wählbaren Namen
zu deklarieren und diese mehrfach zu verwenden.
Für diese Funktion wurden die beiden neuen Schlüsselwörter def und use eingeführt.
4.4.1.3 Include-Dateien
Vielfach werden in verschiedenen Szenen die gleichen Definitionen von Farben, Materialien
oder auch Freiformflächen verwendet. Include-Dateien erweitern die Möglichkeiten der Vorabdeklaration
von mehrfach verwendeten Spezifikationsblöcken und ersparen bei der Modellierung
oft die Eingabe von Zahlenkolonnen. So können selbst ganze Teilbereiche von Szenen
zusammengefasst, ausgelagert und gesondert konstruiert werden.
Vor allem Materialkoeffizienten sollten für einen realistischen Eindruck sehr sorgfältig ausgewählt
werden. Für Standardmaterialien existieren dazu Zusammenstellungen von experimentell
gemessenen Werten, womit recht gute Ergebnisse erzielt werden können. Durch die
Verwendung von eigenen Definitionsdateien können diese Werte zentral abgelegt werden und
sind trotzdem in allen Szenen verfügbar.
4.4.2 Die Bildformate
Die Ausgabe der berechneten Bildinformationen kann als Bilddatei im TGA-Format erfolgen.
Eine Klasse mit den Möglichkeiten zum Laden und Speichern dieses Formates konnte aus der
Arbeit von O. Groth [3] übernommen werden. Diese dient gleichzeitig zum Laden der Bilddateien,
die für die Texturierung benötigt werden.
Durch die direkte Ausgabe des Bildes in eine Datei bleibt das berechnete Bild allerdings
erstmal unsichtbar und kann erst nach Beendigung der Berechnungen mit Hilfe von Bildbetrachtern
begutachtet werden. Aus diesem Grund sollte das System um die Möglichkeit zur
Darstellung, während den Berechnungen, erweitert werden.
Für die Darstellung des Bildes wurde die auf das XWindow-System basierende Klasse Gfx-
Window implementiert. Diese wurde mit einer Event-verarbeitenden Hauptschleife und einer
Möglichkeit zur Registrierung von Callback-Funktionen ausgestattet, um auf Ereignisse, wie
z.B. Tastatureingaben, reagieren zu können.
Zur nahtlosen Integration dieser Erweiterung, wurden die Klassen der Ausgabeformate hierarchisch
zusammengefasst. Abbildung A.4 im Anhang A zeigt die dafür entworfene Hierarchie.
Wie im Diagramm ersichtlich, leiten sich beide Ausgabeformate von der abstrakten Klasse
Image ab. Deren Aufgabe ist die Verwaltung des Puffers für die berechneten Bilddaten.
Aufgrund dieser Anordnung der Klassen wird es möglich, ein bestehendes Ausgabeformat
allein durch einen cast in ein anderes zu konvertieren. Dadurch kann eine Bilddatei, die durch
eine TGAImage-Instanz geladen wurde, ohne Aufwand in einem Fenster dargestellt werden.
Umgekehrt dazu ist es möglich, ein im Fenster berechnetes Bild, z.B. auf Tastendruck, in ein
TGAImage zu konvertieren und als Bilddatei abzuspeichern.

Anhang A
Diagramme
Im Folgenden finden sich die, in den Kapiteln referenzierten Diagramme. Diese sind meist
zu groß für die Integration in den Textfluss und werden aus Gründen der Übersicht in diesem
Teil des Anhangs dargestellt.
61

ANHANG A. DIAGRAMME 62
Raytrace
getArguments()
main()
newModel
:Model
newParser
newScanner
:Parser
#DefinitionFile
:Scanner
getInclude
:Parser
setDefinition()
Scene
getChar()
getSymbol()
getScene()
getLight()
:Light
getView()
:View
getObjects()
newObject
:Object
getObjectData() / getTextureData()
buildTexture()
:Texture
getOctree()
Octree
buildModel()
buildOctree() getNodeList()
split()
newImage
Shade
:Image
sample()
newRayDirection()
renderModel()
trace()
getNormal()
getColor()
getAmbience()
getMaterial()
setHitData()
findPoint()
setHitData()
getBumpNormal()
detectTextureData()
Abbildung A.1: Ablauf des Ray Tracing-Prozesses
findNode()
intersect
getColor()
getMaterial()
octreeIntersect()
intersect()
intersect
shadowTest()
¡ ¢¡¢
¢¡¢ ¡
nextPoint()
trace()
test()
findNode()
sample()
Model
setPixelColor()
defaultIntersect()
intersect()

ANHANG A. DIAGRAMME 63
Object
+ setHitData(hitPoint) : void
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
+ getColor() : Color
+ getNormal() : Vector
+ getAmbience() : Color
+ getMaterial() : Material
Bezier
SimpleList
# toObject : Matrix
# toWorld : Matrix
# ambience : Color
# texture : Texture *
$ factorial(x) : unsigned int
$ bernstein(i,j,t) : Real
+ append() : type *
+ delete(index) : bool
+ begin() : iterator
+ operator[](index) : type &
Sphere
Box
FreeformSurface
BezierCurve
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
+ setHitData(hitPoint) : void
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
+ setHitData(hitPoint) : void
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
+ buildSearchTree() : void
+ newControlPoint() : Point *
+ deleteControlPoint(index) : bool
+ curvePoint(t) : Point
+ devide(t) : BezierCurve[2]
− searchTreeRoot : TreeNode *
Cone Plane
Cylinder
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
+ intersect() : bool
− detectNormal() : void
+ matchMappingMode() : MappingMode[2]
+ matchSurfaceDimension() : Real[2]
BezierSurface
+ surfacePoint(u,v) : Point
+ surfaceGradients(u,v) : Vector[2]
+ isFlat() : Axis, bool
+ devide(axis,t) : FreeformSurface[2]
Abbildung A.2: Die Klassenhierarchie der Objekte

ANHANG A. DIAGRAMME 64
Texture
Noise (Singleton)
$ getNoise() : Noise *
+ getFractalNoise(Point,int,Real) : Real
+ getFractalGradient(Point,int,Real) : Vector
+ setHitData(hitPoint)
+ detectTextureData()
+ getMaterial() : Material
+ getColor() : Color
− getSmoothNoise(Point) : Real
− getSmoothGradient(Point) : Vector
− noiseTable : Real[ ]
− indexTable : usigned int[ ]
# baseMaterial : Material
# baseColor : Color
− turbulence : Turbulence
− noise : Noise *
BumpTexture
TGAImage
PointMapper
+ setPixelColor(color,x,y) : void
+ getPixelColor(x,y) : Color
+ loadTGA() : void
+ saveTGA24() : void
+ getBumpNormal(Vector) : Vector
+ detectTextureData()
+ mapPoint(Point) : Point
+ getMapDirections(Point) : Vector[2]
# getTextureSlope()
− getMapSlope()
− getNoiseSlope()
− bumpSize : Real
− turbulence : Turbulence
− mapper : PointMapper
− bumpMap : TGAImage *
− mode : MappingMode[3]
− layout : MappingLayout
− mapDim : Real[3]
ProceduralTexture
BitmapTexture
+ getColor() : Color
+ getMaterial() : Material
Abbildung A.3: Die Klassenhierarchie des Texturierungssystems
+ detectTextureData()
− mapper : PointMapper
# procColor : Color *[2]
# procMaterial : Material *[2]
− extColor : Color
− extMaterial : Material
ReflectionTexture
+ detectTextureData()
WoodTexture
MarbleTexture
BrickTexture
CheckerTexture
+ detectTextureData()
+ getColor() : Color
+ getMaterial() : Material
+ detectTextureData()
+ getColor() : Color
+ getMaterial() : Material
+ detectTextureData()
+ detectTextureData()
− brickSize : Real
− checkerSize : Real
− mapper : PointMapper
− turbulence : Turbulence
− sharpness : Real
− woodColor : Color
− woodMaterial : Material
− turbulence : Turbulence
− marbleColor : Color
− marbleMaterial : Material

ANHANG A. DIAGRAMME 65
+ setPixelColor(color,x,y) : void
+ getPixelColor(x,y) : Color
+ loadTGA() : void
+ saveTGA24() : void
− imgFile : FILE *
Image
+ setPixelColor(color,x,y) : void
+ getName() : const char *
+ getDim(coord) : unsigned int
# getPixelBuffer(x,y) : bool
# name : char[]
# dimension : unsigned int[]
# buffer : Pixel *
TGAImage GfxWindow
+ setPixelColor(color,x,y) : void
+ displayWindow() : void
+ redraw() : void
+ registerCallback(event,void(*func)()): void
# display : Display *
# window : Window
# callback : void(*func)(XEvent *)[]
Abbildung A.4: Die Klassenhierarchie der Bildformate

Anhang B
Parameterliste für den Programmstart
Die Funktionsweise des implementierten Ray Tracing-Systems kann durch die Parameterliste
beim Aufruf von der Konsole aus gesteuert werden. Die dabei möglichen Parameter und
Optionen werden im Folgenden beschrieben, können jedoch auch in der Hilfeseite des Programms
eingesehen werden.
Grundlegend hat ein Aufruf folgendes Format:
Raytrace [-h|-v] scenefile [-o name] [-f format] [-x width] [-y height]
Optionale Angaben:
-h Zeigt die Hilfeseite an und beendet das Programm
-v Veranlasst die Anzeige von Schnittinformationen pro berechneter Zeile
Weitere Parameter:
scenefile Dateiname der Szenenbeschreibung
-o name Name des erzeugten Bildes. Standardmäßig wird der Dateiname der
Szenendefinition verwendet und mit der Formatkennung erweitert.
-f format Erzeugtes Bildformat.
Implementierte Formate: TGA (default), X11
-x width Bildbreite in Pixel. Der Defaultwert ist 600.
-y height Bildhöhe in Pixel. Der Defaultwert ist 600.
66

Anhang C
Szenen-Definition
In diesem Teil des Anhangs finden sich detailierte Beschreibungen zur Definition von Modellen.
Die Darstellung der Sprachsyntax erfolgt dabei in Extended Backus Nour Form, kurz
EBNF. Ein Beispiel zur Anwendung findet sich im nächsten Abschnitt.
Lexikalische Elemente
char ::= A..Z | a..z | _
digit ::= 0..9
block_comment ::= /* {} */
line_comment ::= # {}
string_ident ::= "{}"
keyword ::= ambience | ambient | angle | aspectratio | bezier |
bitmap | blue | box | brick | bump | camera | checker |
color | cone | csg | cylinder | def | diffuse |
direction | exponent | false | file | frequencies |
green | include | index | lights | location | lookat |
marble | material | move | objects | octree | patch |
plain | plane | point | red | reflect | reflection |
right | rotate | scale | scene | shear | size |
specular | specularexp | sphere | spot | stretch |
supersample | texture | tile | transform |
transparency | true | turbulence | up | use | vertex |
view | wood | x | y | z | zoom
number ::= {}
real ::= [.][(e|E) [+|-] ]
Modell-Definition
model ::= { | | }
include ::= include
define ::= def {definable block}
scene ::= scene { { | | | } }
view ::= view { { | | | | } }
object_list ::= objects { { | | | | | } }
octree ::= octree { {(size ) | } }
light_list ::= lights { { | } }
sphere ::= sphere { }
cone ::= cone { size }
67

ANHANG C. SZENEN-DEFINITION 68
cylinder ::= cylinder { }
box ::= box { }
plane ::= plane { }
bezier ::= bezier { }
point_light ::= point { { | } }
spot_light ::= spot { { | | | } }
object_data ::= {(ambience ) | | }
transformation ::= transform { (move ) |
(rotate ) |
(scale ) |
(shear ) }
definable ::= color | material | patch | texture | vertex
color ::= (use color ) | (color { { } })
material ::= (use material ) |
(material { {(ambient ) |
(diffuse ) |
(specular ) |
(specularexp ) |
(reflect ) |
(transparency ) |
(index )} })
patch ::= (use patch ) |
(patch { size (file | ) })
texture ::= (use texture ) |
(texture { { | | | |
| } })
vertex ::= (use vertex ) |
(vertex { { | (file )} })
turbulence ::= turbulcene { {(size ) |
(scale ) |
(frequencies ) |
(exponent )} }
texture_mode ::= { | | | | | }
bump ::= bump { size }
bitmap ::= bitmap { }
reflection ::= reflection { }
checker ::= checker { size x y }
brick ::= brick { size }
marble ::= marble { }
wood ::= wood { size }
map ::= file {scale } (stretch | tile)
location ::= location
direction ::= direction
up ::= up
right ::= right
supersample ::= supersample
vector ::=
angle ::= angle
boolean ::= true | false
color_channel ::= red | green | blue
coordinate ::= x | y | z

ANHANG C. SZENEN-DEFINITION 69
Die Modellierung einer Beispiel-Szene
Um die Möglichkeiten der Modellierungssprache sowie einen möglichst großen Funktionsumfang
an einem Beispiel darzustellen, wird im Folgenden der Aufbau eines etwas größeren
Modells in Auszügen beschrieben. Die dabei verwendeten Einstellungen sind in der Definition
in Form von Kommentar erklärt. Im Anschluss daran findet sich das daraus berechnete
Bild.
/* Beispiel-Szene */
include "defines/colors.def" # einbinden von Farb-Definitionen
include "defines/materials.def" # einbinden von Material-Definitionen
# Einlesen der Punktdaten für Freiformflächen aus Dateien
def vertex "teacup_vertex" { file "defines/utah_teacup.vertex" }
def vertex "teaspoon_vertex" { file "defines/utah_teaspoon.vertex" }
def vertex "teapot_vertex" { file "defines/utah_teapot.vertex" }
# Einlesen der Punktzuordnung für die Flächen aus Dateien
def patch "teacup_patches" { size 4 4 file "defines/utah_teacup.patch" }
def patch "teaspoon_patches" { size 4 4 file "defines/utah_teaspoon.patch" }
# Manuelle Definition von Punktzuordnungen für Flächen der Größe 4x4
def patch "teapot_body_patches" {
size 4 4
size 4 4
...
size 4 4
# Manuelle Definition mehrfach verwendeter Farben, Materialien und Texturen
def color "marble_color1" { red 0.85 green 0.86 blue 0.78 }
def color "marble_color2" { red 0.397 green 0.275 blue 0.216 }
def material "marble_material" {
ambient 0.85 0.85 0.85
diffuse 0.47 0.47 0.47
specular 0.77 0.77 0.77
specularExp 95
}
def texture "chinaware" {
use color "white"
material {
ambient 0.94 0.94 0.94 # Koeffizienten für die einzelnen
diffuse 0.35 0.35 0.35 # Farbkanäle Rot, Grün, Blau
specular 0.43 0.43 0.43
specularExp 93
reflect 0.1
}
}
def texture "sugar" {
use color "white"
use material "polished silver"
bump {
size 0.5
turbulence {
size 0.4
scale 0.05
frequencies 2
}
}
}
...
# Beginn eines Szenenabschnittes
scene {
# Definition der Ansicht
view {
location # Beobachterstandpunkt

ANHANG C. SZENEN-DEFINITION 70
}
direction # Blickrichtung
up # Up-Richtung
right # Right-Richtung für Verhältnis 4:3
supersample true # aktiviere Supersampling
objects {
# teapot #
bezier {
use vertex "teapot_vertex" # Benutze vordefinierte Punktmenge
use patch "teapot_body_patches" # und Flächenzuordnungen
ambience 0.2 0.2 0.2 # Grundleuchten des Objekts
texture {
use color "marble_color1" # Benutze vordefinierte Farben ...
use color "marble_color2"
use material "marble_material" # ... und Materialien
use material "marble_material"
marble { # Art der Textur
turbulence { # Die von Marmor benötigte Turbulenz
size 4.4 # Stärke
scale 0.35 # Auflösung
frequencies 3 # Anzahl verwendeter Frequenzen
exponent 2.9 # Schärfe
}
}
transform { # Transformation der Textur relativ zum Objekt
scale # Skalierung in X Y Z-Richtung
rotate # Rotation um X Y Z-Achse (in Grad) ...
rotate # ... in dieser Reihenfolge
}
}
transform { # Transformation des Objektes
rotate # Rotation
move # Verschiebung
move
}
}
...
# wall #
plane {
transform {
move
}
ambience 0.2 0.2 0.2
texture {
...
}
}
# picture #
box {
transform {
scale
move
}
ambience 0.8 0.8 0.8
texture {
use material "chrome"
bitmap { file "maps/world.tga" stretch } # Bitmap-Textur - gestreckt
}
}
# sugar pot #
cylinder {
transform {
scale
move
}
ambience 0.5 0.5 0.5
use texture "bumpy chrome"

ANHANG C. SZENEN-DEFINITION 71
}
}
}
sphere {
transform {
scale
scale
move
}
ambience 0.5 0.5 0.5
use texture "bumpy chrome"
}
# lid #
cone { # Kegeldefinition
size 0 1 1 # kleiner Radius, großer Radius und Höhe
transform {
scale
rotate
move
}
ambience 0.5 0.5 0.5
use texture "bumpy chrome"
}
# Definition der Lichtquellen
lights {
# candle light #
point {
location # Position
color { red 0.86 green 0.63 blue 0.06 } # Farbe
}
...
}
point {
location
color { red 0.7 green 0.6 blue 0.6 }
}
# Octree-Definition
octree {
}
size 1000 # Kantenlänge
location # Position der minEcke

ANHANG C. SZENEN-DEFINITION 72
Abbildung C.1: Fertig erstelltes Bild der Beispiel-Szene

Anhang D
C++ Quelltexte
Die C++ Quellen in diesem Teil des Anhangs dokumentieren den aktuellen Stand des Ray
Tracing-Systems. Eine Zusammenfassung der Quelldateien ist auf der nächsten Seite in Form
eines Inhalsverzeichnisses aufgelistet.
73

Table of Contents
1 raytrace.h.......... sheets 1 to 1 ( 1) pages 1− 1 43 lines
2 raytrace.cpp........ sheets 2 to 4 ( 3) pages 2− 4 251 lines
3 Model.h............. sheets 5 to 6 ( 2) pages 5− 6 146 lines
5 4 Model.cpp........... sheets 7 to 9 ( 3) pages 7− 9 249 lines
5 shade.h............. sheets 10 to 10 ( 1) pages 10− 10 45 lines
6 shade.cpp........... sheets 11 to 15 ( 5) pages 11− 15 442 lines
7 Noise.h............. sheets 16 to 16 ( 1) pages 16− 16 63 lines
8 Noise.cpp........... sheets 17 to 19 ( 3) pages 17− 19 280 lines
10 9 PointMapper.h....... sheets 20 to 20 ( 1) pages 20− 20 62 lines
10 PointMapper.cpp..... sheets 21 to 22 ( 2) pages 21− 22 149 lines
11 Texture.h........... sheets 23 to 23 ( 1) pages 23− 23 94 lines
12 Texture.cpp......... sheets 24 to 24 ( 1) pages 24− 24 101 lines
13 BumpTexture.h....... sheets 25 to 25 ( 1) pages 25− 25 69 lines
15 14 BumpTexture.cpp..... sheets 26 to 27 ( 2) pages 26− 27 199 lines
15 BitmapTexture.h..... sheets 28 to 28 ( 1) pages 28− 28 35 lines
16 BitmapTexture.cpp... sheets 29 to 29 ( 1) pages 29− 29 54 lines
17 ReflectionTexture.h. sheets 30 to 30 ( 1) pages 30− 30 27 lines
18 ReflectionTexture.cpp sheets 31 to 31 ( 1) pages 31− 31 35 lines
20 19 ProceduralTexture.h. sheets 32 to 32 ( 1) pages 32− 32 43 lines
20 ProceduralTexture.cpp sheets 33 to 33 ( 1) pages 33− 33 25 lines
21 BrickTexture.h...... sheets 34 to 34 ( 1) pages 34− 34 33 lines
22 BrickTexture.cpp.... sheets 35 to 35 ( 1) pages 35− 35 41 lines
23 CheckerTexture.h.... sheets 36 to 36 ( 1) pages 36− 36 44 lines
25 24 CheckerTexture.cpp.. sheets 37 to 37 ( 1) pages 37− 37 74 lines
25 MarbleTexture.h..... sheets 38 to 38 ( 1) pages 38− 38 46 lines
26 MarbleTexture.cpp... sheets 39 to 39 ( 1) pages 39− 39 38 lines
27 WoodTexture.h....... sheets 40 to 40 ( 1) pages 40− 40 40 lines
28 WoodTexture.cpp..... sheets 41 to 41 ( 1) pages 41− 41 58 lines
30 29 Image.h............. sheets 42 to 42 ( 1) pages 42− 42 39 lines
30 Image.cpp........... sheets 43 to 43 ( 1) pages 43− 43 47 lines
31 TGAImage.h.......... sheets 44 to 45 ( 2) pages 44− 45 124 lines
32 TGAImage.cpp........ sheets 46 to 52 ( 7) pages 46− 52 656 lines
33 GfxScreen.h......... sheets 53 to 53 ( 1) pages 53− 53 41 lines
35 34 GfxScreen.cpp....... sheets 54 to 54 ( 1) pages 54− 54 58 lines
35 GfxWindow.h......... sheets 55 to 55 ( 1) pages 55− 55 77 lines
36 GfxWindow.cpp....... sheets 56 to 57 ( 2) pages 56− 57 164 lines
37 Object.h............ sheets 58 to 58 ( 1) pages 58− 58 53 lines
38 Object.cpp.......... sheets 59 to 60 ( 2) pages 59− 60 117 lines
40 39 Box.h............... sheets 61 to 61 ( 1) pages 61− 61 46 lines
40 Box.cpp............. sheets 62 to 64 ( 3) pages 62− 64 274 lines
41 Cone.h.............. sheets 65 to 65 ( 1) pages 65− 65 46 lines
42 Cone.cpp............ sheets 66 to 66 ( 1) pages 66− 66 93 lines
43 Cylinder.h.......... sheets 67 to 67 ( 1) pages 67− 67 49 lines
45 44 Cylinder.cpp........ sheets 68 to 68 ( 1) pages 68− 68 65 lines
45 Plane.h............. sheets 69 to 69 ( 1) pages 69− 69 38 lines
46 Plane.cpp........... sheets 70 to 70 ( 1) pages 70− 70 62 lines
47 Sphere.h............ sheets 71 to 71 ( 1) pages 71− 71 36 lines
48 Sphere.cpp.......... sheets 72 to 72 ( 1) pages 72− 72 53 lines
50 49 FreeformSurface.h... sheets 73 to 74 ( 2) pages 73− 74 159 lines
50 FreeformSurface.cpp. sheets 75 to 81 ( 7) pages 75− 81 695 lines
51 Bezier.h............ sheets 82 to 82 ( 1) pages 82− 82 35 lines
52 BezierCurve.h....... sheets 83 to 83 ( 1) pages 83− 83 54 lines
53 BezierCurve.cpp..... sheets 84 to 86 ( 3) pages 84− 86 272 lines
55 54 BezierSurface.h..... sheets 87 to 87 ( 1) pages 87− 87 27 lines
55 BezierSurface.cpp... sheets 88 to 90 ( 3) pages 88− 90 275 lines
56 Octree.h............ sheets 91 to 91 ( 1) pages 91− 91 70 lines
57 Octree.cpp.......... sheets 92 to 96 ( 5) pages 92− 96 430 lines
58 Parser.h............ sheets 97 to 98 ( 2) pages 97− 98 184 lines
60 59 Parser.cpp.......... sheets 99 to 117 (19) pages 99−117 1844 lines
60 Scanner.h........... sheets 118 to 119 ( 2) pages 118−119 120 lines
61 Scanner.cpp......... sheets 120 to 123 ( 4) pages 120−123 366 lines
62 SimpleList.h........ sheets 124 to 125 ( 2) pages 124−125 199 lines
63 PatchBuffer.h....... sheets 126 to 126 ( 1) pages 126−126 95 lines
65 64 Types.h............. sheets 127 to 127 ( 1) pages 127−127 101 lines
65 utils.h............. sheets 128 to 130 ( 3) pages 128−130 286 lines
66 utils.cpp........... sheets 131 to 136 ( 6) pages 131−136 508 lines

5
10
#ifndef __RAYTRACE_H
#define __RAYTRACE_H
#include
// predeclarations
class Model;
class Parser;
class Image;
typedef enum {
TGAFORMAT,
XWINDOW
//***************
15 } ImageFormat;
//***************
typedef struct __Arguments {
bool verbose;
20 char *sceneFile;
char *imgName;
ImageFormat imgFormat;
unsigned int imgWidth;
unsigned int imgHeight;
25 //*************
} Arguments;
//*************
// globals
30 static Model *model;
static Parser *parser;
static Image *image;
// functions
35 void windowExpose( XEvent *event );
void keyPressEvent( XEvent *event );
void cleanup();
void getArguments( char **argv, Arguments *args );
void printHelp( bool showDetails );
40
#endif /* __RAYTRACE_H */

#include
#include
#include
5 #include "raytrace.h"
#include "TGAImage.h"
#include "GfxWindow.h"
#include "Parser.h"
#include "Model.h"
10 #include "Types.h"
/* Raytrace main
*/
//**********************************
15 int main( int argc, char **argv )
//**********************************
{
Arguments args;
20 // initialize pointers
model = NULL;
parser = NULL;
image = NULL;
25 // register cleanup function
atexit( cleanup );
getArguments( argv, &args );
30 // get model
if( (model = new Model()) == NULL )
{
fprintf( stderr, "Can’t get model\n" );
exit(1);
35 }
// parse scene description file
if( (parser = new Parser( args.sceneFile, model, ((args.verbose)? stdout : NULL) )) == NULL )
{
40 fprintf( stderr, "Parser not availible!\n" );
exit(1);
}
// release parser
45 delete parser; parser = NULL;
// get image
switch( args.imgFormat )
{
50 case TGAFORMAT: image = new TGAImage( args.imgName, args.imgWidth, args.imgHeight );
break;
case XWINDOW: if((image = new GfxWindow( args.imgWidth, args.imgHeight, args.imgName, ""))!=NULL)
((GfxWindow *)image)−>displayWindow();
55 break;
}
default: break;
60 if( image == NULL )
{
fprintf( stderr, "Can’t get image!\n" );
exit(1);
}
65
// render model
model−>renderModel( image, &args );
if( args.imgFormat == XWINDOW )
70 {
// start window event recognition
((GfxWindow *)image)−>registerCallback( Expose, windowExpose );
((GfxWindow *)image)−>registerCallback( KeyPress, keyPressEvent );
((GfxWindow *)image)−>enableEvent( KeyPressMask | ExposureMask );
75 ((GfxWindow *)image)−>mainLoop();
}
// release image and model
delete image; image = NULL;
80 delete model; model = NULL;
}
return 0;
85 /**
* Event handler
*/
// expose event
//***********************************
90 void windowExpose( XEvent *event )
//***********************************
{
GfxWindow *window = (GfxWindow *)image;
95 if( window−>getWidth() != image−>getDim( X ) || window−>getHeight() != image−>getDim( Y ) )
window−>resizeWindow( image−>getDim( X ), image−>getDim( Y ) );
100
}
((GfxWindow *)image)−>redraw();

key press event
//************************************
void keyPressEvent( XEvent *event )
//************************************
105 { char charBuffer[10];
XLookupString( (XKeyEvent *)event, charBuffer, 10, NULL, NULL );
110 switch (charBuffer[0])
{
case ’q’: ((GfxWindow *)image)−>quitMainLoop();
break;
115 case ’s’: fprintf( stdout, "saving image \"%s.tga\" ... ", image−>getName() );
((TGAImage *)image)−>saveTGA24();
fprintf( stdout, "OK\n" );
break;
120 default: break;
}
}
125 /* Clean up at exit
*/
//***************
void cleanup()
//***************
130 {
if( image != NULL ) delete image;
if( model != NULL ) delete model;
if( parser != NULL ) delete parser;
}
135
/* Get Arguments from argument list
*/
//**************************************************
void getArguments( char **argv, Arguments *args )
140 //**************************************************
{
bool argError = false;
// set defaults
145 args−>verbose = false;
args−>imgName = NULL;
args−>imgFormat = TGAFORMAT;
args−>imgWidth = 600;
args−>imgHeight = 600;
150
// skip program name
++argv;
// check for options
155 if( *argv != NULL && (*argv)[0] == ’−’ )
{
switch( (*argv)[1] )
{
case ’h’: printHelp( true );
160 exit(0);
165 }
}
case ’v’: args−>verbose = true;
++argv;
break;
// check for scene description file
if( *argv == NULL )
170 argError = true;
else
args−>sceneFile = *argv++;
// check for optional arguments
175 while( !argError && *argv != NULL )
{
if( (*argv)[0] != ’−’ )
{
argError = true;
180 break;
}
switch( (*argv)[1] )
{
185 case ’o’: args−>imgName = *(++argv);
break;
case ’f’: if( *(++argv) != NULL && !strncmp( *argv, "TGA", 3 ) )
args−>imgFormat = TGAFORMAT;
190 else if( *argv != NULL && !strncmp( *argv, "X11", 3 ) )
args−>imgFormat = XWINDOW;
else
argError = true;
break;
195
case ’x’: argError = ( *(++argv) == NULL || (args−>imgWidth = atoi( *argv )) == 0 );
break;
case ’y’: argError = ( *(++argv) == NULL || (args−>imgHeight = atoi( *argv )) == 0 );
200 break;

205 }
default: argError = true;
}
argv++;
if( argError )
{
printf("Error in arguments!\n");
210 printHelp( false );
exit(1);
}
if( args−>imgName == NULL )
215 args−>imgName = args−>sceneFile;
}
/* Print help page
*/
220 //***********************************
void printHelp( bool showDetails )
//***********************************
{
printf("\nUsage: Raytrace [−h | −v] scenefile [−o imagename] [−f imageformat] [−x width] [−y height]\n\n");
225
if( showDetails )
{
printf(" Options:\n");
printf(" −h Print this help page and exit.\n");
230 printf(" −v Causes Raytrace to be verbose, showing trace information per image line.\n\n");
printf(" scenefile Specify the scene description file to be rendered.\n\n");
printf(" −o imagefile Specify the image filename.\n");
235 printf(" The format extention will be appended. By default,\n");
printf(" Raytrace uses the basename of the scenefile.\n");
printf(" Note: Raytrace will overwrite image files may exist!\n\n" );
printf(" −f imageformat Specify the format of the image file.\n");
240 printf(" Implemented formats: TGA (default)\n");
printf(" X11\n\n");
245
250
}
}
printf(" −x width Determine the width of the image in pixels.\n");
printf(" The default value for width is 600.\n\n");
printf(" −y height Determine the height of the image in pixels.\n");
printf(" The default value for height is 600.\n\n");

5
#ifndef __MODEL_H
#define __MODEL_H
#include "Types.h"
// forward declarations
class Image;
class Object;
struct __Octree;
10 struct __Arguments;
typedef enum {
POINTLIGHT,
15 SPOTLIGHT,
NUMBER_OF_LIGHTSOURCE_TYPES
//*******************
} LightSourceType;
20 //*******************
/**
* Defintions of specific light sources
*/
25 typedef struct {
LightSourceType type;
Point location;
Color color;
//**************
30 } PointLight;
//**************
typedef struct {
LightSourceType type;
35 Point location;
Color color;
Vector direction;
Real spotBound;
//*************
40 } SpotLight;
//*************
typedef struct {
LightSourceType type;
45 Point location;
Color color;
//************
} AnyLight;
//************
50
/**
* Light data structure
*/
typedef union __Light {
55 LightSourceType type;
AnyLight any;
PointLight point;
SpotLight spot;
//*********
60 } Light;
//*********
typedef struct __LightNode {
65 Light light;
struct __LightNode *next;
//*************
} LightNode;
//*************
70
typedef struct __ObjectNode {
Object *object;
struct __ObjectNode *next;
75 //**************
} ObjectNode;
//**************
80 typedef struct __ObjectHit {
Object *object;
Real distance;
Point point;
//*************
85 } ObjectHit;
//*************
typedef struct __View {
90 Vector location;
Vector direction;
Vector up;
Vector right;
Real widthHalf;
95 Real heightHalf;
bool superSampling;
//********
} View;
//********
100

* The Model class
*/
//**************
105 class Model {
//**************
public:
Model();
~Model();
110
void renderModel( Image *image, struct __Arguments *args );
bool addObject( Object *obj );
Light *addLight();
115 struct {
Real intersectionCnt;
unsigned int rayCnt;
unsigned int viewRayCnt;
unsigned int lightRayCnt;
120 unsigned int reflectionCnt;
unsigned int transpCnt;
} statistics;
struct {
125 LightNode *lights;
unsigned int numOfLights;
130
135
ObjectNode *objects;
unsigned int numOfObjects;
View view;
} scene;
struct __Octree *octree;
// function pointers
bool (* intersect)( Model *model, const Ray &ray, ObjectHit *hit );
void (* trace)( Model *model, Ray *ray, Real weight, int level );
140 // Default function for determination of ray/object−intersections
static bool defaultIntersect( Model *model, const Ray &ray, ObjectHit *hit );
};
145
#endif /* __MODEL_H */

#include
#include
#include "Model.h"
5 #include "Object.h"
#include "Image.h"
#include "Octree.h"
#include "utils.h"
#include "shade.h"
10 #include "raytrace.h"
/* Constructor
*/
//***************
15 Model::Model()
//***************
{
octree = NULL;
20 statistics.intersectionCnt =
statistics.rayCnt =
statistics.viewRayCnt =
statistics.lightRayCnt =
statistics.reflectionCnt =
25 statistics.transpCnt = 0;
scene.lights = NULL;
scene.objects = NULL;
scene.numOfLights =
30 scene.numOfObjects = 0;
// set default view
scene.view.right = baseVector[X];
scene.view.up = baseVector[Y];
35 scene.view.direction = baseVector[Z];
scene.view.location.x = 0;
scene.view.location.y = 0;
scene.view.location.z = −1;
40 scene.view.superSampling = false;
}
/* Destructor
*/
45 //****************
Model::~Model()
//****************
{
LightNode *lightPtr;
50 ObjectNode *objPtr;
// delete lights
while( scene.lights != NULL )
{
55 lightPtr = scene.lights;
scene.lights = scene.lights−>next;
delete lightPtr;
}
60 // delete objects
while( scene.objects != NULL )
{
objPtr = scene.objects;
scene.objects = scene.objects−>next;
65 if( objPtr−>object != NULL ) delete objPtr−>object;
delete objPtr;
}
// delete octree
70 if( octree != NULL )
deleteOctree( octree );
}
75 /* Adds a light source to model
*/
//*************************
Light *Model::addLight()
//*************************
80 { LightNode *tmp;
if( (tmp = new LightNode) != NULL )
{
85 tmp−>next = scene.lights;
scene.lights = tmp;
++scene.numOfLights;
return &tmp−>light;
90 }
return NULL;
}
/* Adds an object to model
95 */
//*************************************
bool Model::addObject( Object *obj )
//*************************************
{
100 ObjectNode *tmp;

if( (tmp = new ObjectNode) != NULL )
{
tmp−>object = obj;
105 tmp−>next = scene.objects;
scene.objects = tmp;
++scene.numOfObjects;
return true;
110 }
return false;
}
/* Renders the model by tracing and sampling each pixel of the view.
115 */
//*******************************************************
void Model::renderModel( Image *img, Arguments *args )
//*******************************************************
{
120 Ray ray;
Color pixelColor;
SamplePoint point[5];
time_t start;
time_t end;
125 struct tm *localTime;
long int duration;
fprintf( stdout, "ray tracing in progress ... ");
130 ray.origin = scene.view.location;
scene.view.widthHalf = args−>imgWidth * 0.5;
scene.view.heightHalf = args−>imgHeight * 0.5;
135 // start timer
time( &start );
for( unsigned int y = 1; y imgHeight; ++y )
{
140 for( unsigned int x = 1; x imgWidth; ++x )
{
/**
* Shot at least five rays per pixel
*/
145 if( x == 1 )
{
// reset line statistics ...
statistics.rayCnt =
statistics.lightRayCnt =
150 statistics.reflectionCnt =
statistics.transpCnt = 0;
point[0].x = 0.5; point[0].y = y − 0.5;
point[1].x = 0.5; point[1].y = y + 0.5;
155 point[2].x = 1.5; point[2].y = y − 0.5;
point[3].x = 1.5; point[3].y = y + 0.5;
point[4].x = 1.0; point[4].y = y;
newRayDirection( point[0], scene.view, &ray.direction );
160 trace( this, &ray, 1.0, 1 );
point[0].color = ray.color;
newRayDirection( point[1], scene.view, &ray.direction );
trace( this, &ray, 1.0, 1 );
165 point[1].color = ray.color;
}
else
{
point[0] = point[2];
170 point[1] = point[3];
point[2].x = x + 0.5; point[2].y = y − 0.5;
point[3].x = x + 0.5; point[3].y = y + 0.5;
point[4].x = x; point[4].y = y;
}
175
sample( this, point, &pixelColor, 1 );
img−>setPixelColor( pixelColor, x−1, y−1 );
/**
180 * Print line statistics
*/
if( x == args−>imgWidth )
if( args−>verbose )
fprintf( stdout, "\nline %5d: %10d rays ( %10d light, %10d reflect, %10d transp )", y,
185 statistics.rayCnt,
statistics.lightRayCnt,
statistics.reflectionCnt,
statistics.transpCnt
);
190 else
fprintf( stdout, "\b\b\b\b%3d%c", (int)(y * 100 / args−>imgHeight), ’%’ );
}
}
195 time( &end );
fprintf( stdout, "\ncomplete!\n" );
/**
* Print out statistics
200 */

duration = (long int)end − start;
fprintf( stdout, "\nStatistics:\n" );
localTime = localtime( &start );
205 fprintf( stdout, " start : %02d:%02d:%02d\n",
localTime−>tm_hour, localTime−>tm_min, localTime−>tm_sec );
localTime = localtime( &end );
fprintf( stdout, " end : %02d:%02d:%02d\n",
210 localTime−>tm_hour, localTime−>tm_min, localTime−>tm_sec );
fprintf( stdout, " duration : %02d:%02d:%02d\n",
(int)(duration / 3600), (int)((duration % 3600) / 60), (int)(duration % 60) );
fprintf( stdout, " number of intersections : %−10.0f\n\n",
215 statistics.intersectionCnt );
}
/* Default function for determination of intersections
*/
220 //***************************************************************************
bool Model::defaultIntersect( Model *mdl, const Ray &ray, ObjectHit *hit )
//***************************************************************************
{
Real distance;
225 bool hitsObject = false;
ObjectNode *curObj = mdl−>scene.objects;
hit−>distance = DBL_MAX;
230 // loop all objects of the scene ...
while( curObj != NULL )
{
mdl−>statistics.intersectionCnt++;
235 if( curObj−>object−>intersect( ray, &distance ) )
if( distance < hit−>distance )
{
hitsObject = true;
hit−>object = curObj−>object;
240 hit−>distance = distance;
}
245
}
}
curObj = curObj−>next;
return hitsObject;

5
#ifndef __SHADE_H
#define __SHADE_H
#include "Types.h"
// forward declarations
class Model;
struct __View;
10 typedef enum {
AMBIENT, DIFFUSE,
SPECULAR, TRANSPARENCY,
REFLECTION,
15 NUMBER_OF_LightTypes
//*************
} LightType;
//*************
20 typedef struct {
Real x;
Real y;
Color color;
//***************
25 } SamplePoint;
//***************
//*************************
#define MAXLEVEL 6
30 #define MAXSAMPLE 4
#define THRESHOLD 0.1
#define MINWEIGHT 0.01
//**************************
35 void newRayDirection( const SamplePoint &point, const struct __View &view, Vector *direction );
void sample( Model *model, SamplePoint point[], Color *pixelColor, int level );
bool shadowTest( Model *model, Ray *ray );
// prototypes of shading functions
40 void tracePhong( Model *model, Ray *ray, Real weight, int level );
void traceWhitted( Model *model, Ray *ray, Real weight, int level );
#endif /* __SHADE_H */

ay−>direction.y /= distance;
ray−>direction.z /= distance;
if( light.type == SPOTLIGHT )
105 {
dotProduct( light.spot.direction, ray−>direction, cosAngle );
// The hit point is out of spot light
// if cosine of angle is less then spot bound
if( cosAngle < light.spot.spotBound ) return true;
110 }
++model−>statistics.lightRayCnt;
++model−>statistics.rayCnt;
115 if( model−>intersect( model, *ray, &hit ) )
return ( hit.distance < distance );
else
return false;
}
120
/* Determines the color of a ray using the phong model.
*
* Traces the ray through the scene until the maxmum level of
* depth is reached or the ray leaves the scene.
125 */
//******************************************************************
void tracePhong( Model *model, Ray *ray, Real weight, int level )
//******************************************************************
{
130 Real nl, rv;
Real t;
Ray lightRay;
ObjectHit hit;
Vector reflection;
135 Vector point;
Vector v;
LightNode *lightNode;
Color colQuota[NUMBER_OF_LightTypes];
unsigned int j;
140 const ColorChannel *i;
++model−>statistics.viewRayCnt;
if( model−>octree != NULL )
145 {
findPoint( *model−>octree, *ray, &point );
findNode( model−>octree, point );
}
150 // initialize color quotas ...
colQuota[AMBIENT] =
colQuota[DIFFUSE] =
colQuota[SPECULAR] =
colQuota[TRANSPARENCY] =
155 colQuota[REFLECTION] = black;
++model−>statistics.rayCnt;
// check ray for object hit ...
160 if( !model−>intersect( model, *ray, &hit ) )
{
// no object hit => set background color − black
ray−>color = black;
}
165 else
{
// get hit point
rayPoint( *ray, hit.distance, hit.point );
170 // set hit data
hit.object−>setHitData( *ray, hit.point );
// get hit properties ...
const Color &hitColor = hit.object−>getColor();
175 const Vector &hitNormal = hit.object−>getNormal();
const Material &hitMaterial = hit.object−>getMaterial();
const Color &hitAmbience = hit.object−>getAmbience();
/* −−−−−−−−−−−−−−−−− ambient light −−−−−−−−−−−−−−−*/
180 for( i = RGBfirst; *i != ALPHA; i++ )
colQuota[AMBIENT].channel[*i] = hitAmbience.channel[*i] * hitColor.channel[*i];
// ray to light starts at hit point
185 lightRay.origin = hit.point;
// traverse all light sources ...
for( lightNode = model−>scene.lights; lightNode != NULL; lightNode = lightNode−>next )
{
190 Light &curLight = lightNode−>light;
// get light ray direction
subVector( curLight.any.location, hit.point, lightRay.direction );
195 if( !shadowTest( model, curLight, &lightRay ) )
{
/* −−−−−−−−−−−−−−−−−−−−− diffuse reflection −−−−−−−−−−−−−−−−−− */
dotProduct( lightRay.direction, hitNormal, nl );
if( nl > 0.0 )
200 for( i = RGBfirst; *i != ALPHA; i++ )

colQuota[DIFFUSE].channel[*i] += curLight.any.color.channel[*i] * hitColor.channel[*i]*nl;
/* −−−−−−−−−−−−−−−−−−−−− specular reflection −−−−−−−−−−−−−−−−− */
205 normalizeVector( lightRay.direction, lightRay.direction );
negateVector( lightRay.direction, lightRay.direction );
dotProduct( hitNormal, lightRay.direction, nl );
scaleVector( hitNormal, (−2 * nl), reflection );
210 addVector( reflection, lightRay.direction, reflection );
normalizeVector( reflection, reflection );
215
negateVector( ray−>direction, v );
dotProduct( reflection, v, rv );
if( rv > 0.0 )
{
t = pow( rv, hitMaterial.specularExp );
for( i = RGBfirst; *i != ALPHA; i++ )
220 colQuota[SPECULAR].channel[*i] += curLight.any.color.channel[*i] * t;
}
}
}
225 // consider surface properties
for( i = RGBfirst; *i != ALPHA; i++ )
{
colQuota[AMBIENT].channel[*i] *= hitMaterial.ambient.channel[*i];
colQuota[DIFFUSE].channel[*i] *= hitMaterial.diffuse.channel[*i];
230 colQuota[SPECULAR].channel[*i] *= hitMaterial.specular.channel[*i];
}
// check for invalid color quotas ...
for( i = RGBfirst; *i != ALPHA; i++ )
235 for( j = AMBIENT; j < NUMBER_OF_LightTypes; ++j )
if( colQuota[j].channel[*i] < 0.0 )
colQuota[j].channel[*i] = 0.0;
240 // initialize ray color
ray−>color = black;
// sum light types ...
for( i = RGBfirst; *i != ALPHA; i++ )
245 {
for( j = AMBIENT; j < NUMBER_OF_LightTypes; ++j )
ray−>color.channel[*i] += colQuota[j].channel[*i];
if( ray−>color.channel[*i] > 1.0 )
250 ray−>color.channel[*i] = 1.0;
}
}
}
255 /* Determines the color of a ray using the whitted model.
*
* Traces the ray through the scene until the maxmum level of
* depth is reached or the ray leaves the scene.
*/
260 //********************************************************************
void traceWhitted( Model *model, Ray *ray, Real weight, int level )
//********************************************************************
{
Real nl, nh, nv;
265 Real s, t;
Real totalReflection;
Ray lightRay;
Ray newRay;
ObjectHit hit;
270 Vector reflection;
Vector half;
Vector point;
LightNode *lightNode;
Color colQuota[NUMBER_OF_LightTypes];
275 unsigned int j;
280
const Color *objAmbience;
const Material *objMaterial;
const ColorChannel *i;
if( level == 1 )
{
++model−>statistics.viewRayCnt;
285 if( model−>octree != NULL )
{
findPoint( *model−>octree, *ray, &point );
findNode( model−>octree, point );
}
290 }
else if( model−>octree != NULL )
findNode( model−>octree, ray−>origin );
// initialize color quotas ...
295 colQuota[AMBIENT] =
colQuota[DIFFUSE] =
colQuota[SPECULAR] =
colQuota[TRANSPARENCY] =
colQuota[REFLECTION] = black;
300

++model−>statistics.rayCnt;
// check ray for object hit ...
if( !model−>intersect( model, *ray, &hit ) )
305 {
// no object hit => set background color − black
ray−>color = black;
}
else
310 {
// get hit point
rayPoint( *ray, hit.distance, hit.point );
// set hit data
315 hit.object−>setHitData( *ray, hit.point );
// get hit properties ...
const Color &hitColor = hit.object−>getColor();
const Vector &hitNormal = hit.object−>getNormal();
320 const Material &hitMaterial = hit.object−>getMaterial();
const Color &hitAmbience = hit.object−>getAmbience();
/* −−−−−−−−−−−−−−−−− ambient light −−−−−−−−−−−−−−−*/
for( i = RGBfirst; *i != ALPHA; i++ )
325 colQuota[AMBIENT].channel[*i] = hitAmbience.channel[*i] * hitColor.channel[*i];
330
335
// ray to light starts at hit point
lightRay.origin = hit.point;
// traverse all light sources ...
for( lightNode = model−>scene.lights; lightNode != NULL; lightNode = lightNode−>next )
{
Light &curLight = lightNode−>light;
// get light ray direction
subVector( curLight.any.location, hit.point, lightRay.direction );
if( !shadowTest( model, curLight, &lightRay ) )
340 {
/* −−−−−−−−−−−−−−−−−−−−− diffuse reflection −−−−−−−−−−−−−−−−−− */
dotProduct( lightRay.direction, hitNormal, nl );
if( nl > 0.0 )
for( i = RGBfirst; *i != ALPHA; i++ )
345 colQuota[DIFFUSE].channel[*i] += curLight.any.color.channel[*i] * hitColor.channel[*i]*nl;
/* −−−−−−−−−−−−−−−−−−−−− specular reflection −−−−−−−−−−−−−−−−− */
negateVector( lightRay.direction, lightRay.direction );
addVector( lightRay.direction, ray−>direction, half );
350 scaleVector( half, 0.5, half );
normalizeVector( half, half );
negateVector( half, half );
dotProduct( half, hitNormal, nh );
355 if( nh > 0.0 )
{
t = pow( nh, hitMaterial.specularExp );
for( i = RGBfirst; *i != ALPHA; i++ )
colQuota[SPECULAR].channel[*i] += curLight.any.color.channel[*i] * t;
360 }
}
}
// consider material coefficients
365 for( i = RGBfirst; *i != ALPHA; i++ )
{
colQuota[AMBIENT].channel[*i] *= hitMaterial.ambient.channel[*i];
colQuota[DIFFUSE].channel[*i] *= hitMaterial.diffuse.channel[*i];
colQuota[SPECULAR].channel[*i] *= hitMaterial.specular.channel[*i];
370 }
dotProduct( ray−>direction, hitNormal, nv );
totalReflection = 0.0;
375 /* −−−−−−−−−−−−−−−−−− global transparency −−−−−−−−−−−−−−−−−− */
if( (level < MAXLEVEL) && (weight * hitMaterial.transparency > MINWEIGHT) )
{
s = (nv < 0.0)? 1 / hitMaterial.refractIndex : hitMaterial.refractIndex;
t = 1 − s * s * (1 − nv * nv);
380
if( t >= 0.0 )
{
t = −s * nv + ((nv < 0.0)? −sqrt( t ) : sqrt( t ));
scaleVector( ray−>direction, s, newRay.direction );
385 scaleVector( hitNormal, t, reflection );
addVector( reflection, newRay.direction, newRay.direction );
normalizeVector( newRay.direction, newRay.direction );
newRay.origin = hit.point;
390 ++model−>statistics.transpCnt;
model−>trace( model, &newRay, (weight * hitMaterial.transparency ), level + 1 );
colQuota[TRANSPARENCY] = newRay.color;
395 for( i = RGBfirst; *i != ALPHA; i++ )
colQuota[TRANSPARENCY].channel[*i] *= hitMaterial.transparency;
}
else
totalReflection = hitMaterial.transparency;
400 }

* −−−−−−−−−−−−−−−− global reflection −−−−−−−−−−−−−−−−−− */
if( (level < MAXLEVEL) && (weight * hitMaterial.reflect + totalReflection > MINWEIGHT) )
{
405 ++model−>statistics.reflectionCnt;
410
scaleVector( hitNormal, (−2 * nv), reflection );
addVector( reflection, ray−>direction, reflection );
normalizeVector( reflection, newRay.direction );
// reflected ray starts at hit point
newRay.origin = hit.point;
model−>trace( model, &newRay, (weight * hitMaterial.reflect), level + 1 );
415 colQuota[REFLECTION] = newRay.color;
420
}
for( i = RGBfirst; *i != ALPHA; i++ )
colQuota[REFLECTION].channel[*i] *= (hitMaterial.reflect + totalReflection);
// check for invalid color quotas ...
for( i = RGBfirst; *i != ALPHA; i++ )
for( j = AMBIENT; j < NUMBER_OF_LightTypes; ++j )
if( colQuota[j].channel[*i] < 0.0 )
425 colQuota[j].channel[*i] = 0.0;
// initialize ray color
ray−>color = black;
430 // sum light types ...
for( i = RGBfirst; *i != ALPHA; i++ )
{
for( j = AMBIENT; j < NUMBER_OF_LightTypes; ++j )
ray−>color.channel[*i] += colQuota[j].channel[*i];
435
440 }
}
}
if( ray−>color.channel[*i] > 1.0 )
ray−>color.channel[*i] = 1.0;

5
#ifndef __NOISE_H
#define __NOISE_H
#include "Types.h"
#define TABSIZE (1

5
10
#include
#include "Noise.h"
#include "utils.h"
// initialize static elements
const Noise::Turbulence Noise::defaultTurbulence = { 0, 0.0, 1.0, 1.0 };
Noise *Noise::noise = NULL;
int Noise::refCnt = 0;
/**
* Inline functions
*/
// smooth noise values
15 //**************************
Real smoothStep( Real x )
//**************************
{
return ((− 2 * x + 3) * x * x);
20 }
// smooth noise gradients
//******************************
Real smoothGradient( Real x )
25 //******************************
{
return ((−6 * x + 6) * x);
}
30 /* Get a pointer to a noise object.
*/
//*************************
Noise *Noise::getNoise()
//*************************
35 {
if( noise == NULL )
if( (noise = new Noise()) != NULL )
++refCnt;
else ++refCnt;
40
}
return noise;
/* Release noise object pointer.
45 */
//***************************
void Noise::releaseNoise()
//***************************
{
50 if( refCnt > 0 )
{
−−refCnt;
if( refCnt == 0 ) delete noise;
}
55 }
/* Constructor
*/
//***************
60 Noise::Noise()
//***************
{
unsigned int i;
unsigned int swp_a, swp_b;
65
// setting seed for random generator
srand( 42 );
// fill tables
70 for( i = 0; i < TABSIZE; ++i )
{
noiseTable[i] = 1.0 − 2.0 * (Real)rand() / (Real)RAND_MAX; // −> [−1,1]
indexTable[i] = i;
}
75
// shuffle index table
for( i = 0; i < TABSIZE*TABSIZE/2; ++i )
{
swp_a = i % TABSIZE;
80 swp_b = rand() % TABSIZE;
85
}
}
swapXOR( indexTable[swp_a], indexTable[swp_b] );
/* Destructor
*/
//****************
Noise::~Noise()
90 //****************
{
}
/* Determines interpolated noise in point given by parameter.
95 */
//*************************************************
Real Noise::getSmoothNoise( const Point &point )
//*************************************************
{
100 int pInt[3];

105
110
Real pFrct[3];
Real ltc_x0, ltc_x1;
Real edge[4];
Real face_z0, face_z1;
// split point coordinates into integer
// part and smooth fractional part
pInt[X] = floorVal( point.x );
pFrct[X] = smoothStep( point.x − pInt[X] );
pInt[Y] = floorVal( point.y );
pFrct[Y] = smoothStep( point.y − pInt[Y] );
pInt[Z] = floorVal( point.z );
115 pFrct[Z] = smoothStep( point.z − pInt[Z] );
/**
* Get lattice noise values at the eight points
* of the lattice noise cube and interpolate these values
120 * according to the fractional parts of the 3D−point.
*/
// front edge − top
ltc_x0 = latticeNoise( pInt[X], pInt[Y], pInt[Z] );
ltc_x1 = latticeNoise( pInt[X] + 1, pInt[Y], pInt[Z] );
125 edge[0] = blend( ltc_x1, ltc_x0, pFrct[X] );
// front edge − bottom
ltc_x0 = latticeNoise( pInt[X], pInt[Y] + 1, pInt[Z] );
ltc_x1 = latticeNoise( pInt[X] + 1, pInt[Y] + 1, pInt[Z] );
edge[1] = blend( ltc_x1, ltc_x0, pFrct[X] );
130 // back edge − top
ltc_x0 = latticeNoise( pInt[X], pInt[Y], pInt[Z] + 1 );
ltc_x1 = latticeNoise( pInt[X] + 1, pInt[Y], pInt[Z] + 1 );
edge[2] = blend( ltc_x1, ltc_x0, pFrct[X] );
// back edge − bottom
135 ltc_x0 = latticeNoise( pInt[X], pInt[Y] + 1, pInt[Z] + 1 );
ltc_x1 = latticeNoise( pInt[X] + 1, pInt[Y] + 1, pInt[Z] + 1 );
edge[3] = blend( ltc_x1, ltc_x0, pFrct[X] );
// blend over front and back face
140 face_z0 = blend( edge[1], edge[0], pFrct[Y] );
face_z1 = blend( edge[3], edge[2], pFrct[Y] );
145 }
// return blended face values
return blend( face_z1, face_z0, pFrct[Z] );
/* Determines the gradient vector in point given by parameter.
*/
150 //**********************************************************************
void Noise::getSmoothGradient( const Point &point, Vector *gradient )
//**********************************************************************
{
int pInt[3];
155 Real pFrct[3];
Real ltc000, ltc001, ltc010, ltc011, ltc100, ltc101, ltc110, ltc111;
Real edge[4];
Real face[2];
160 // split point coordinates into integer
// part and fractional part
pInt[X] = floorVal( point.x );
pFrct[X] = point.x − pInt[X];
pInt[Y] = floorVal( point.y );
165 pFrct[Y] = point.y − pInt[Y];
pInt[Z] = floorVal( point.z );
pFrct[Z] = point.z − pInt[Z];
// get lattice noise values at the eight
170 // points ltc of the lattice noise cube.
ltc000 = latticeNoise( pInt[X], pInt[Y], pInt[Z] );
ltc001 = latticeNoise( pInt[X], pInt[Y], pInt[Z] + 1 );
ltc010 = latticeNoise( pInt[X], pInt[Y] + 1, pInt[Z] );
ltc011 = latticeNoise( pInt[X], pInt[Y] + 1, pInt[Z] + 1 );
175 ltc100 = latticeNoise( pInt[X] + 1, pInt[Y], pInt[Z] );
ltc101 = latticeNoise( pInt[X] + 1, pInt[Y], pInt[Z] + 1 );
ltc110 = latticeNoise( pInt[X] + 1, pInt[Y] + 1, pInt[Z] );
ltc111 = latticeNoise( pInt[X] + 1, pInt[Y] + 1, pInt[Z] + 1 );
180 /**
* Determine gradient of X−axis
*/
// blend along the four Z−edges of the cube
edge[0] = blend( ltc001, ltc000, pFrct[Z] );
185 edge[1] = blend( ltc011, ltc010, pFrct[Z] );
edge[2] = blend( ltc101, ltc100, pFrct[Z] );
edge[3] = blend( ltc111, ltc110, pFrct[Z] );
// blend over left and right face
face[0] = blend( edge[1], edge[0], pFrct[Y] );
190 face[1] = blend( edge[3], edge[2], pFrct[Y] );
// determine gradient
gradient−>x = (face[1] − face[0]) * smoothGradient( pFrct[X] );
/**
195 * Determine gradient of Y−axis
*/
// blend over top and bottom face
face[0] = blend( edge[2], edge[0], pFrct[X] );
face[1] = blend( edge[3], edge[1], pFrct[X] );
200 // determine gradient

gradient−>y = (face[1] − face[0]) * smoothGradient( pFrct[Y] );
/**
* Determine gradient of Z−axis
205 */
// blend along the four Y−edges of the cube
edge[0] = blend( ltc010, ltc000, pFrct[Y] );
edge[1] = blend( ltc110, ltc100, pFrct[Y] );
edge[2] = blend( ltc011, ltc001, pFrct[Y] );
210 edge[3] = blend( ltc111, ltc101, pFrct[Y] );
// blend over front and back face
face[0] = blend( edge[1], edge[0], pFrct[X] );
face[1] = blend( edge[3], edge[2], pFrct[X] );
// determine gradient
215 gradient−>z = (face[1] − face[0]) * smoothGradient( pFrct[Z] );
}
/* Calculates the fractal sum noise in point given by parameter.
220 */
//**************************************************************************
Real Noise::getFractalNoise( const Point &point, const Turbulence &turb )
//**************************************************************************
{
225 Point noisePoint, p;
Real fktlNoiseVal;
Real curFreq = FQ_SCALE;
scaleVector( point, turb.scale, noisePoint );
230 fktlNoiseVal = getSmoothNoise( noisePoint );
for( int i = 1; i < turb.frequencies; ++i )
{
scaleVector( noisePoint, curFreq, p );
235 fktlNoiseVal += getSmoothNoise( p ) / curFreq;
curFreq *= FQ_SCALE;
}
fktlNoiseVal = (fktlNoiseVal+1.0) / 2.0; // [−1,1] −> [0,1]
240 if( fktlNoiseVal < 0.0 ) fktlNoiseVal = 0.0;
if( fktlNoiseVal > 1.0 ) fktlNoiseVal = 1.0;
if( turb.exponent == 0.0 ) return turb.size;
if( turb.exponent == 1.0 ) return fktlNoiseVal * turb.size;
245 else return pow( fktlNoiseVal, turb.exponent ) * turb.size;
}
/* Calculates the fractal sum gradient in point given by parameter.
250 */
//***********************************************************************************************
void Noise::getFractalGradient( const Point &point, const Turbulence &turb, Vector *fktlGrad )
//***********************************************************************************************
{
255 Vector gradient;
Point noisePoint, p;
Real curFreq = FQ_SCALE;
Real scale;
int i;
260
scaleVector( point, turb.scale, noisePoint );
getSmoothGradient( noisePoint, fktlGrad );
for( i = 1; i < turb.frequencies; ++i )
265 {
// scale point
scaleVector( noisePoint, curFreq, p );
// determine gradient
getSmoothGradient( p, &gradient );
270
// sum gradient
fktlGrad−>x += gradient.x / curFreq;
fktlGrad−>y += gradient.y / curFreq;
fktlGrad−>z += gradient.z / curFreq;
275 curFreq *= FQ_SCALE;
}
scaleVector( *fktlGrad, turb.size, *fktlGrad );
}

5
#ifndef __POINTMAPPER_H
#define __POINTMAPPER_H
#include "Types.h"
/* The PointMapper class
*/
//********************
class PointMapper {
10 //********************
public:
typedef enum {
LAYOUT_STRETCH,
LAYOUT_TILE
15 //*****************
} MappingLayout;
//*****************
typedef enum {
20 MAP_LINEAR,
MAP_SPHERIC,
MAP_EXTERN
//***************
} MappingMode;
25 //***************
typedef struct {
char filename[256];
Vector scale;
30 MappingLayout layout;
MappingMode mappingMode[3];
//*************
} ParseInfo;
//*************
35
40
static const ParseInfo defaultData;
PointMapper( const ParseInfo &data = defaultData );
virtual ~PointMapper() {}
void setMappingMode( Coordinate c, MappingMode m ) { mode[c] = m; }
void setMappingLayout( MappingLayout l ) { layout = l; }
void setMapDimension( Coordinate c, Real dim ) { mapDim[c] = dim; }
void setSurfaceDimRef( const Real * const ref ) { surfDim = ref; }
45 void setExternMappingRef( const Real * const ref ) { extMapping = ref; }
Real getMapDimension( Coordinate c ) { return mapDim[c]; }
void mapPoint( const Point &point, Point *result );
50 void getMapDirections( const Point &point, Vector *dirX, Vector *dirY );
protected:
MappingMode mode[3];
MappingLayout layout;
55 Real mapDim[3];
const Real *surfDim;
const Real *extMapping;
};
60 #endif /* __POINTMAPPER_H */

#include "PointMapper.h"
#include "utils.h"
5 // initialize default data
const PointMapper::ParseInfo PointMapper::defaultData = { "", oneVector, LAYOUT_STRETCH,
{ MAP_LINEAR, MAP_LINEAR, MAP_LINEAR } };
/* Constructor
10 */
//***************************************************************
PointMapper::PointMapper( const PointMapper::ParseInfo &data )
//***************************************************************
{
15 layout = data.layout;
for( unsigned int i = X; i [−pi,+pi]
40 phi = atan2( point.z, point.x );
// [−pi,+pi] −> [0,1]
fract = (phi + M_PI) / (2 * M_PI);
// tiling
45 if( layout == LAYOUT_TILE )
fract = (surfDim[X] * fract) / mapDim[X];
fract −= (int)fract;
result−>x = fract;
50 break;
case MAP_LINEAR: // map coordinate lineary
if( layout == LAYOUT_STRETCH )
fract = point.x / surfDim[X];
55 else // tiling
fract = point.x / mapDim[X];
fract −= (int)fract;
// prevent image mirroring
60 if( fract < 0.0 ) fract += 1.0;
result−>x = fract;
break;
case MAP_EXTERN: // use extern result
65 if( layout == LAYOUT_STRETCH )
result−>x = extMapping[X];
else // tiling
{
fract = extMapping[X] / mapDim[X];
70 fract −= (int)fract;
result−>x = fract;
}
}
75 /**
* Map Y coordinate according to mapping info
* Note: Due to the y−axis of the image increasing downwards,
* the sign of the y−coordinate of the point is changed!
*/
80 switch( mode[Y] )
{
case MAP_SPHERIC: // map coordinate spherical
radius = vectorLength( point );
85 if( radius != 0.0 )
{
// acos −> [0,pi]
phi = acos( −point.y / radius );
// [0,pi] −> [0,1]
90 fract = (M_PI − phi) / M_PI;
95
fract −= (int)fract;
result−>y = fract;
}
else
100 result−>y = 0.0;
// tiling
if( layout == LAYOUT_TILE )
fract = (surfDim[Y] * fract) / mapDim[Y];

eak;
case MAP_LINEAR: // map coordinate lineary
if( layout == LAYOUT_STRETCH )
105 fract = −point.y / surfDim[Y];
else // tiling
fract = −point.y / mapDim[Y];
fract −= (int)fract;
110 // prevent image mirroring
if( fract < 0.0 ) fract += 1.0;
result−>y = fract;
break;
115 case MAP_EXTERN: // use extern result
if( layout == LAYOUT_STRETCH )
result−>y = extMapping[Y];
else // tiling
{
120 fract = extMapping[Y] / mapDim[Y];
fract −= (int)fract;
result−>y = fract;
}
}
125 result−>z = 0;
}
/* Determines mapping directions X and Y
*/
130 //*************************************************************************************
void PointMapper::getMapDirections( const Point &point, Vector *dirX, Vector *dirY )
//*************************************************************************************
{
if( mode[X] == MAP_SPHERIC )
135 {
crossProduct( point, baseVector[Y], *dirX );
normalizeVector( *dirX, *dirX );
}
else *dirX = baseVector[X];
140
if( mode[Y] == MAP_SPHERIC )
{
crossProduct( *dirX, point, *dirY );
normalizeVector( *dirY, *dirY );
145 }
else *dirY = baseVector[Y];
}

#ifndef __TEXTURE_H
#define __TEXTURE_H
#include "Types.h"
5 #include "Noise.h"
#include "utils.h"
/* The Texture class
*/
10 //****************
class Texture {
//****************
public:
typedef struct {
15 Matrix transform;
Noise::Turbulence turbulence;
//*************
} ParseInfo;
//*************
20
25
static const ParseInfo defaultData;
Texture();
virtual ~Texture() { Noise::releaseNoise(); }
void setupTextureSystem( const Matrix &transform )
{
toTexture = transform;
invertMatrix( toTexture, &fromTexture );
30 }
void setTurbulence( const Noise::Turbulence &turb )
{
turbulence = turb;
35 isTurbulent = (turb.frequencies > 0 && turb.size != 0.0);
}
void setBaseColor( const Color &color ) { baseColor = color; }
void setBaseMaterial( const Material &material ) { baseMaterial = material; }
40 void setSurfaceDimension( Coordinate coord, Real dim ) { surfDimension[coord] = absVal( dim ); }
void setExternMapping( Coordinate coord, Real fact ) { externMapping[coord] = absVal( fact ); }
void setHitData( const Point &colHit, const Point &nrmlHit );
/*
45 * Set parameters may be used by some textures (e.g. ReflectionTexture)
* Note: normal and ray direction are expected to be in world system!
*/
void setRayAndNormal( const Ray &ray, const Vector &normal )
{
50 if( needsRayAndNormal() ) {
rayDirection = ray.direction;
vertexNormal = normal;
}
}
55
/**
* Texture specific methods.
*/
virtual bool is2D() = 0;
60 virtual bool needsRayAndNormal() = 0;
virtual void detectTextureData() = 0;
virtual const Color &getColor() { return baseColor; }
virtual const Material &getMaterial() { return baseMaterial; }
65 // methods for texture sharing
void registerHandle() { handles++; }
void releaseHandle() { if( handles > 0 ) handles−−; };
bool isReferenced() { return (handles > 0); }
70 protected:
Matrix toTexture;
Matrix fromTexture;
Color baseColor;
Material baseMaterial;
75 Noise *noise;
Vector colorHitPoint;
Vector normalHitPoint;
Vector rayDirection;
80 Vector vertexNormal;
Real surfDimension[3];
Real externMapping[3];
private:
85 void getCoordTurbulence( const Vector &point, Vector *displacement );
90 };
Noise::Turbulence turbulence;
bool isTurbulent;
int handles;
#endif /* __TEXTURE_H */

5
#include
#include "Texture.h"
#include "utils.h"
// initialize default data
const Texture::ParseInfo Texture::defaultData = { identityMatrix, Noise::defaultTurbulence };
/* Constructor
10 */
//*******************
Texture::Texture()
//*******************
{
15 // initialize texture system
toTexture =
fromTexture = identityMatrix;
baseColor = white;
20 baseMaterial = defaultMaterial;
// get noise object
noise = Noise::getNoise();
25 // set defaults
for( unsigned int i = X; i x = noise−>getFractalNoise( noisePoint, turbulence );
addVector( point, noiseDispY, noisePoint );
90 displacement−>y = noise−>getFractalNoise( noisePoint, turbulence );
addVector( point, noiseDispZ, noisePoint );
displacement−>z = noise−>getFractalNoise( noisePoint, turbulence );
95 // move noise displacement from interval [0,1] to [−1,1]
// and scale it by turbulence size
translateVector( *displacement, −0.5, *displacement );
scaleVector( *displacement, 2.0 * turbulence.size, *displacement );
}
100

#ifndef __BUMPTEXTURE_H
#define __BUMPTEXTURE_H
#include "Texture.h"
5 #include "PointMapper.h"
#include "Types.h"
10
// forward declaration
class TGAImage;
/* The BumpTexture class
*/
//*************************************
class BumpTexture : public Texture {
15 //*************************************
public:
typedef struct {
PointMapper::ParseInfo mapperInfo;
Real bumpSize;
20 Noise::Turbulence turbulence;
//*************
} ParseInfo;
//*************
25 static const ParseInfo defaultData;
BumpTexture();
virtual ~BumpTexture();
30 // setup bump texture
void setBumpData( const ParseInfo &data );
35
void getBumpNormal( const Vector &normal, Vector *bumpNormal );
bool isBumpy() { return isBumpyTexture; }
/* This default implementation provides
* a plain colored and bumpy texture
*/
virtual bool is2D() { return false; }
40 virtual bool needsRayAndNormal() { return false; }
virtual void detectTextureData() {}
protected:
virtual void getTextureSlope( Vector *slope ) {}
45 bool isBumpyTexture;
private:
void getMapSlope( Vector *slope );
50 void getNoiseSlope( Vector *slope )
{
Vector noiseGradient;
noise−>getFractalGradient( normalHitPoint, turbulence, &noiseGradient );
addVector( *slope, noiseGradient, *slope );
55 }
TGAImage *bumpMap;
Real bumpSize;
Noise::Turbulence turbulence;
60 PointMapper mapper;
};
//**********************************
typedef BumpTexture PlainTexture;
65 //**********************************
#endif /* __BUMPTEXTURE_H */

#include "BumpTexture.h"
#include "TGAImage.h"
#include "Noise.h"
5 #include "utils.h"
10
// initialize default data
const BumpTexture::ParseInfo BumpTexture::defaultData = { PointMapper::defaultData, 0.0,
Noise::defaultTurbulence };
/* Constructor
*/
//***************************
BumpTexture::BumpTexture()
15 //***************************
: Texture(), mapper()
{
bumpMap = NULL;
bumpSize = 0.0;
20 isBumpyTexture = false;
turbulence = Noise::defaultTurbulence;
}
/* Destructor
25 */
//****************************
BumpTexture::~BumpTexture()
//****************************
{
30 if( bumpMap != NULL ) delete bumpMap;
}
/* Enable bump mapping by setting bump data
*/
35 //********************************************************************
void BumpTexture::setBumpData( const BumpTexture::ParseInfo &data )
//********************************************************************
{
/**
40 * Set bump map, scaling and layout
*/
// release bump map may be loaded
if( bumpMap != NULL ) delete bumpMap;
45 // try to load bump map file
if( data.mapperInfo.filename[0] )
{
if( (bumpMap = new TGAImage( data.mapperInfo.filename )) == NULL )
fprintf( stderr, "Unable to load bump map %s\n", data.mapperInfo.filename );
50 else
{
// set map scaling
bumpMap−>setScale( X, data.mapperInfo.scale.x );
bumpMap−>setScale( Y, data.mapperInfo.scale.y );
55 bumpMap−>setScale( Z, data.mapperInfo.scale.z );
mapper.setMappingLayout( data.mapperInfo.layout );
for( unsigned int i = X; i getScaledDim( (Coordinate)i ) );
}
}
}
65 mapper.setSurfaceDimRef( &surfDimension[0] );
mapper.setExternMappingRef( &externMapping[0] );
70
// set bump turbulence
turbulence = data.turbulence;
// set bump size
bumpSize = data.bumpSize;
// enable/disable bump mapping
75 isBumpyTexture = (bumpSize != 0.0);
}
/* Get the normal vector adjusted to the textures properties
*/
80 //****************************************************************************
void BumpTexture::getBumpNormal( const Vector &normal, Vector *bumpNormal )
//****************************************************************************
{
Vector n;
85 Vector slope;
Vector vct_U, vct_V, vct_D;
Real size_U, size_V;
// transform normal vector by inverse matrix into texture system
90 transformNormal( fromTexture, normal, &n );
normalizeVector( n, n );
// Place vectors U and V in the
// tangent plane of the surface:
95 vct_U = nullVector;
// Set vector U for being not parallel to n.
if( n.y == 0.0 && n.z == 0.0 )
vct_U.y = 1.0; // n is multiple of (1,0,0)
100 else

vct_U.x = 1.0; // n is not multiple of (1,0,0)
// Use cross product of n and vector U to
// set vector U perpendicular to n.
105 crossProduct( n, vct_U, vct_U );
110
// Determine cross product of n and vector U to get a vector V
// perpendicular to n and vector U.
crossProduct( n, vct_U, vct_V );
// normalize vectors U and V
normalizeVector( vct_U, vct_U );
normalizeVector( vct_V, vct_V );
115 /* Get slope from bump functions ...
*/
slope = nullVector;
// get texture specific slope
getTextureSlope( &slope );
120 // get caused by bump map
if( bumpMap != NULL )
getMapSlope( &slope );
// get slope caused by turbulence
if( turbulence.frequencies > 0 && turbulence.size != 0.0 )
125 getNoiseSlope( &slope );
130
// get quota of slope in directions u and v
dotProduct( vct_U, slope, size_U );
dotProduct( vct_V, slope, size_V );
scaleVector( vct_U, size_U * bumpSize, vct_U );
scaleVector( vct_V, size_V * bumpSize, vct_V );
// tilt normal by sum of u and v
135 addVector( vct_U, vct_V, vct_D );
addVector( n, vct_D, n );
normalizeVector( n, n );
// transform new normal by inverse(!) matrix from texture system
140 transformNormal( toTexture, n, bumpNormal );
normalizeVector( *bumpNormal, *bumpNormal );
}
/* Determine slope in normal point mapped to bumpmap
145 */
//***********************************************
void BumpTexture::getMapSlope( Vector *slope )
//***********************************************
{
150 int pxlInt[2];
double pxlFrct[2];
Point pxlCoord;
Color pxlColor;
double grayVal[2][2];
155 double dx, dy;
Vector mapDir[2];
Vector noisePoint;
Vector noiseGradient;
160 // get pixel coordinate
mapper.mapPoint( normalHitPoint, &pxlCoord );
pxlCoord.x *= bumpMap−>getDim( X ) − 1;
pxlCoord.y *= bumpMap−>getDim( Y ) − 1;
165 // split pixel coordinate into integer and fractional part
pxlInt[X] = (int)pxlCoord.x;
pxlFrct[X] = pxlCoord.x − pxlInt[X];
pxlInt[Y] = (int)pxlCoord.y;
pxlFrct[Y] = pxlCoord.y − pxlInt[Y];
170
// get colors of 2x2 pixel matrix and convert them into gray scale
bumpMap−>getPixelColor( &pxlColor, pxlInt[X], pxlInt[Y] );
grayVal[0][0] = grayValue( pxlColor );
bumpMap−>getPixelColor( &pxlColor, pxlInt[X], pxlInt[Y] + 1 );
175 grayVal[0][1] = grayValue( pxlColor );
bumpMap−>getPixelColor( &pxlColor, pxlInt[X] + 1, pxlInt[Y] );
grayVal[1][0] = grayValue( pxlColor );
bumpMap−>getPixelColor( &pxlColor, pxlInt[X] + 1, pxlInt[Y] + 1 );
grayVal[1][1] = grayValue( pxlColor );
180
// get difference in gray values
dy = blend( grayVal[1][0], grayVal[1][1], pxlFrct[X] );
dy −= blend( grayVal[0][0], grayVal[0][1], pxlFrct[X] );
185 dx = blend( grayVal[0][1], grayVal[1][1], pxlFrct[Y] );
dx −= blend( grayVal[0][0], grayVal[1][0], pxlFrct[Y] );
190
// get mapping directions
mapper.getMapDirections( normalHitPoint, &mapDir[X], &mapDir[Y] );
// scale directions
scaleVector( mapDir[X], dx, mapDir[X] );
scaleVector( mapDir[Y], dy, mapDir[Y] );
195 addVector( mapDir[X], *slope, *slope );
addVector( mapDir[Y], *slope, *slope );
}

#ifndef __BITMAPTEXTURE_H
#define __BITMAPTEXTURE_H
#include "BumpTexture.h"
5 #include "PointMapper.h"
#include "Types.h"
10
// predeclarations
class TGAImage;
/* The BitmapTexture class
*/
//*******************************************
class BitmapTexture : public BumpTexture {
15 //*******************************************
public:
typedef PointMapper::ParseInfo ParseInfo;
BitmapTexture( const ParseInfo &data = PointMapper::defaultData );
20 virtual ~BitmapTexture();
// implement dimension info
bool is2D() { return true; }
25 // *** color calculations ***
virtual void detectTextureData();
protected:
PointMapper mapper;
30 TGAImage *bitmap;
};
#endif /* __BITMAPTEXTURE_H */

#include
#include
#include "shade.h"
5 #include "utils.h"
#include "Model.h"
#include "Object.h"
#include "Octree.h"
10 /* Generate the direction vector for a new ray,
* starting from the given view location.
*/
//**************************************************************************************
void newRayDirection( const SamplePoint &point, const View &view, Vector *direction )
15 //**************************************************************************************
{
direction−>x = view.direction.x + (point.x − view.widthHalf) * view.right.x / view.widthHalf +
(point.y − view.heightHalf) / view.heightHalf * view.up.x * −1;
direction−>y = view.direction.y + (point.x − view.widthHalf) * view.right.y / view.widthHalf +
20 (point.y − view.heightHalf) / view.heightHalf * view.up.y * −1;
direction−>z = view.direction.z + (point.x − view.widthHalf) * view.right.z / view.widthHalf +
(point.y − view.heightHalf) / view.heightHalf * view.up.z * −1;
25 }
normalizeVector( *direction, *direction );
/* Tone down the aliasing of edges by tracing additional rays through pixels
* with high color fluctuation.
*/
30 //*******************************************************************************
void sample( Model *model, SamplePoint point[], Color *pixelColor, int level )
//*******************************************************************************
{
Ray ray;
35 Real colorDiff;
SamplePoint extraPoint[5];
Color extraColor;
register unsigned int i;
40 ray.origin = model−>scene.view.location;
for( i = 2; i < 5; ++i )
{
newRayDirection( point[i], model−>scene.view, &ray.direction );
45 model−>trace( model, &ray, 1.0, 1 );
point[i].color = ray.color;
}
50
*pixelColor = black;
for( i = 0; i < 4; ++i )
{
if( model−>scene.view.superSampling )
{
55 colorDiff = grayValue( subColor( point[i].color, point[4].color ) );
if( (level < MAXSAMPLE) && (absVal( colorDiff ) > THRESHOLD) )
{
/**
60 * Deterimine subpoints to shot additional rays
*/
extraPoint[0] = point[i];
extraPoint[1] = point[4];
extraPoint[2].x = point[i].x; extraPoint[2].y = point[4].y;
65 extraPoint[3].x = point[4].x; extraPoint[3].y = point[i].y;
extraPoint[4].x = (point[i].x + point[4].x) * 0.5;
extraPoint[4].y = (point[i].y + point[4].y) * 0.5;
// ... and sample again
70 sample( model, extraPoint, &extraColor, level + 1 );
75 }
80
}
}
}
*pixelColor = addColor( *pixelColor, extraColor );
continue;
for( const ColorChannel *j = RGBfirst; *j != ALPHA; j++ )
pixelColor−>channel[*j] += (point[i].color.channel[*j] + point[4].color.channel[*j]) * 0.5;
*pixelColor = scaleColor( *pixelColor, 0.25 );
/* Tests the origin of a ray for being in
85 * the shadow of the light source hit by the
* ray’s direction.
*/
//**************************************************************
bool shadowTest( Model *model, const Light &light, Ray *ray )
90 //**************************************************************
{
Real distance;
Real cosAngle;
ObjectHit hit;
95
// ray−>direction not normalized yet!
distance = vectorLength( ray−>direction );
// normalize direction
100 ray−>direction.x /= distance;

5
#include "BitmapTexture.h"
#include "TGAImage.h"
#include "utils.h"
/* Constructor
*/
//********************************************************************
BitmapTexture::BitmapTexture( const BitmapTexture::ParseInfo &data )
10 //********************************************************************
: BumpTexture(), mapper( data )
{
if( (bitmap = new TGAImage( data.filename )) != NULL )
{
15 bitmap−>setScale( X, data.scale.x );
bitmap−>setScale( Y, data.scale.y );
bitmap−>setScale( Z, data.scale.z );
for( unsigned int i = X; i getScaledDim( (Coordinate)i ) );
}
else
fprintf( stderr, "Unable to load bitmap file %s\n", data.filename );
25 mapper.setSurfaceDimRef( &surfDimension[0] );
mapper.setExternMappingRef( &externMapping[0] );
}
/* Destructor
30 */
//********************************
BitmapTexture::~BitmapTexture()
//********************************
{
35 if( bitmap != NULL ) delete bitmap;
}
/* Get the texture data according to the texture properties
*/
40 //****************************************
void BitmapTexture::detectTextureData()
//****************************************
{
Point bmp;
45
50
}
// map point to flat image
mapper.mapPoint( colorHitPoint, &bmp );
bmp.x *= bitmap−>getDim( X ) − 1;
bmp.y *= bitmap−>getDim( Y ) − 1;
bitmap−>getPixelColor( &baseColor, Round( bmp.x ), Round( bmp.y ) );

#ifndef __REFLECTIONTEXTURE_H
#define __REFLECTIONTEXTURE_H
#include "BitmapTexture.h"
5 #include "Types.h"
#include "utils.h"
/* The ReflectionTexture class
*/
10 //*************************************************
class ReflectionTexture : public BitmapTexture {
//*************************************************
public:
typedef PointMapper::ParseInfo ParseInfo;
15
ReflectionTexture( const ParseInfo &data = PointMapper::defaultData )
: BitmapTexture( data ) {}
virtual ~ReflectionTexture() {}
20 // Override methods inherited from class BitmapTexture
bool needsRayAndNormal() { return true; }
void detectTextureData();
};
25 #endif /* __REFLECTIONTEXTURE_H */

5
#include "ReflectionTexture.h"
#include "TGAImage.h"
#include "utils.h"
/* Get the color according to the texture properties
*/
//********************************************
void ReflectionTexture::detectTextureData()
10 //********************************************
{
Real nv;
Point bmp;
Vector reflection;
15
20
// determine reflection vector − need not to be normalized
dotProduct( rayDirection, vertexNormal, nv );
scaleVector( vertexNormal, (−2 * nv), reflection );
addVector( reflection, rayDirection, reflection );
/**
* Use the reflection vector to determine a point
* on a sphere with infinite radius surrounding the object.
* Apply texture transformations to surrounding sphere first
25 * by transforming the reflection vector.
*/
transformVector( toTexture, reflection, &reflection );
mapper.mapPoint( reflection, &bmp );
bmp.x *= bitmap−>getDim( X ) − 1;
30 bmp.y *= bitmap−>getDim( Y ) − 1;
}
bitmap−>getPixelColor( &baseColor, Round( bmp.x ), Round( bmp.y ) );

#ifndef __PROCEDURALTEXTURE_H
#define __PROCEDURALTEXTURE_H
#include "BumpTexture.h"
5 #include "Types.h"
/* The ProceduralTexture class
*/
//***********************************************
10 class ProceduralTexture : public BumpTexture {
//***********************************************
public:
typedef struct {
Color color;
15 Material material;
//*************
} ParseInfo;
//*************
20 static const ParseInfo defaultData;
ProceduralTexture( const ParseInfo &data = defaultData );
virtual ~ProceduralTexture() {}
25 void setExtraColor( const Color &col ) { extColor = col; }
void setExtraMaterial( const Material &mat ) { extMaterial = mat; }
30
35
40
};
virtual const Color &getColor() { return *procColor[procIndex]; }
virtual const Material &getMaterial() { return *procMaterial[procIndex]; }
protected:
Color *procColor[2];
Material *procMaterial[2];
unsigned int procIndex;
private:
Color extColor;
Material extMaterial;
#endif /* __PROCEDURALTEXTURE_H */

#include "ProceduralTexture.h"
#include "utils.h"
5 // initialize default data
const ProceduralTexture::ParseInfo ProceduralTexture::defaultData = { black, defaultMaterial };
/* Constructor
*/
10 //*********************************************************************************
ProceduralTexture::ProceduralTexture( const ProceduralTexture::ParseInfo &data )
//*********************************************************************************
: BumpTexture()
{
15 procColor[0] = &baseColor;
procColor[1] = &extColor;
procMaterial[0] = &baseMaterial;
procMaterial[1] = &extMaterial;
procIndex = 0;
20
}
extColor = data.color;
extMaterial = data.material;

#ifndef __BRICKTEXTURE_H
#define __BRICKTEXTURE_H
#include "ProceduralTexture.h"
5 #include "Types.h"
/* The BrickTexture class
*/
//************************************************
10 class BrickTexture : public ProceduralTexture {
//************************************************
public:
typedef struct {
ProceduralTexture::ParseInfo procInfo;
15 Vector brickSize;
//*************
} ParseInfo;
//*************
20 static const ParseInfo defaultData;
BrickTexture( const ParseInfo &data = defaultData );
~BrickTexture() {}
25 void detectTextureData();
30
};
private:
Vector brickSize;
#endif /* __BRICKTEXTURE_H */

5
#include
#include "BrickTexture.h"
#include "utils.h"
// initialize default data
const BrickTexture::ParseInfo BrickTexture::defaultData = { ProceduralTexture::defaultData, oneVector };
/* Constructor
10 */
//******************************************************************
BrickTexture::BrickTexture( const BrickTexture::ParseInfo &data )
//******************************************************************
: ProceduralTexture( data.procInfo )
15 { brickSize = data.brickSize;
}
/* Get texture data
20 */
//***************************************
void BrickTexture::detectTextureData()
//***************************************
{
25 int pos[3];
unsigned int idx;
pos[X] = (int)(colorHitPoint.x / brickSize.x);
pos[Y] = (int)(colorHitPoint.y / brickSize.y);
30 pos[Z] = (int)(colorHitPoint.z / brickSize.z);
// prevent mirroring at origin by calc floor value
// use RAYEPS to compensate rounding errors
if( colorHitPoint.x < −RAYEPS ) pos[X]−−;
35 if( colorHitPoint.y < −RAYEPS ) pos[Y]−−;
if( colorHitPoint.z < −RAYEPS ) pos[Z]−−;
40
}
procIndex = absVal(pos[X] + pos[Y] + pos[Z]) % 2;

#ifndef __CHECKERTEXTURE_H
#define __CHECKERTEXTURE_H
#include "ProceduralTexture.h"
5 #include "Types.h"
/* The CheckerTexture class
*/
//**************************************************
10 class CheckerTexture : public ProceduralTexture {
//**************************************************
public:
typedef struct {
ProceduralTexture::ParseInfo procInfo;
15 PointMapper::ParseInfo mapperInfo;
Real checkerSize;
Real quota[2];
//*************
} ParseInfo;
20 //*************
static const ParseInfo defaultData;
CheckerTexture( const ParseInfo &data = defaultData );
25 ~CheckerTexture() {}
// implement dimension info
bool is2D() { return true; }
void getTextureSlope( Vector *slope )
30 { addVector( *slope, textureSlope, *slope ); }
void detectTextureData();
private:
35 Real checkerSize;
Real quota[2];
Real q10[2];
PointMapper mapper;
Vector textureSlope;
40 };
#endif /* __CHECKERTEXTURE_H */

#include "CheckerTexture.h"
#include "utils.h"
5 // initialize default data
const CheckerTexture::ParseInfo CheckerTexture::defaultData = { ProceduralTexture::defaultData,
PointMapper::defaultData, 1.0, {0.5, 0.5} };
/* Constructor
10 */
//************************************************************************
CheckerTexture::CheckerTexture( const CheckerTexture::ParseInfo &data )
//************************************************************************
: ProceduralTexture( data.procInfo ), mapper( data.mapperInfo )
15 {
checkerSize = data.checkerSize;
quota[X] = data.quota[X];
quota[Y] = data.quota[Y];
q10[X] = quota[X]/10;
20 q10[Y] = quota[Y]/10;
mapper.setMappingLayout( PointMapper::LAYOUT_TILE );
mapper.setMapDimension( X, 2.0 * checkerSize );
mapper.setMapDimension( Y, 2.0 * checkerSize );
mapper.setSurfaceDimRef( &surfDimension[0] );
25 mapper.setExternMappingRef( &externMapping[0] );
textureSlope = nullVector;
}
/* Detect texture data
30 */
//*****************************************
void CheckerTexture::detectTextureData()
//*****************************************
{
35 Point chk;
Real dx, dy;
Vector mapDir[2];
// map point onto checker pattern
40 mapper.mapPoint( colorHitPoint, &chk );
procIndex = ((chk.x > quota[X]) ^ (chk.y > quota[Y]));
// determine slope on bump mapping enabled
if( isBumpyTexture )
45 {
// determine slope on primary color
if( procIndex == 0 )
{
if( chk.x > quota[X] )
50 {
dx = (chk.x < quota[X] + 0.05)? 0.5 : (chk.x > 0.95)? −0.5 : 0;
dy = (chk.y < quota[Y] + 0.05)? 0.5 : (chk.y > 0.95)? −0.5 : 0;
}
else
55 {
dx = (chk.x < 0.05)? 0.5 : (chk.x > quota[X] − 0.05)? −0.5 : 0;
dy = (chk.y < 0.05)? 0.5 : (chk.y > quota[Y] − 0.05)? −0.5 : 0;
}
60 // get mapping directions
mapper.getMapDirections( normalHitPoint, &mapDir[X], &mapDir[Y] );
// scale directions
scaleVector( mapDir[X], dx, mapDir[X] );
65 scaleVector( mapDir[Y], dy, mapDir[Y] );
addVector( mapDir[X], mapDir[Y], textureSlope );
}
else
70 textureSlope = nullVector;
}
}

#ifndef __MARBLETEXTURE_H
#define __MARBLETEXTURE_H
#include "ProceduralTexture.h"
5 #include "Noise.h"
#include "Types.h"
/* The MarbleTexture class
*/
10 //*************************************************
class MarbleTexture : public ProceduralTexture {
//*************************************************
public:
typedef struct {
15 ProceduralTexture::ParseInfo procInfo;
Noise::Turbulence turbulence;
//*************
} ParseInfo;
//*************
20
25
static const ParseInfo defaultData;
MarbleTexture( const ParseInfo &data = defaultData );
~MarbleTexture() {}
void detectTextureData();
const Color &getColor() { return marbleColor; }
const Material &getMaterial() { return marbleMaterial; }
30 protected:
// Quadratic spline function generating tone wave
Real toneSpline( Real x ) {
if( x < −0.4 ) return ((3.95 * x + 5.94) * x + 2.24 );
else if ( x

5
#include
#include "MarbleTexture.h"
#include "utils.h"
// initialize default data
const MarbleTexture::ParseInfo MarbleTexture::defaultData = { ProceduralTexture::defaultData,
Noise::defaultTurbulence };
10 /* Constructor
*/
//*********************************************************************
MarbleTexture::MarbleTexture( const MarbleTexture::ParseInfo &data )
//*********************************************************************
15 : ProceduralTexture( data.procInfo )
{
turbulence = data.turbulence;
}
20 /* Get texture data
*/
//****************************************
void MarbleTexture::detectTextureData()
//****************************************
25 { Vector marblePoint;
Real noiseValue;
Real marbleValue;
30 noiseValue = noise−>getFractalNoise( colorHitPoint, turbulence );
marbleValue = toneSpline( sin( 2.0 * M_PI * colorHitPoint.x + noiseValue ) );
// get point color by blending of procedural colors
blendColor( *procColor[0], *procColor[1], marbleValue, &marbleColor );
35 blendMaterial( *procMaterial[0], *procMaterial[1], marbleValue, &marbleMaterial );
}

#ifndef __WOODTEXTURE_H
#define __WOODTEXTURE_H
#include "ProceduralTexture.h"
5 #include "Noise.h"
#include "Types.h"
/* The WoodTexture class
*/
10 //*************************************************
class WoodTexture : public ProceduralTexture {
//*************************************************
public:
typedef struct {
15 ProceduralTexture::ParseInfo procInfo;
Noise::Turbulence turbulence;
Real sharpness;
//*************
} ParseInfo;
20 //*************
static const ParseInfo defaultData;
WoodTexture( const ParseInfo &data = defaultData );
25 ~WoodTexture() {}
30
void detectTextureData();
const Color &getColor() { return woodColor; }
const Material &getMaterial() { return woodMaterial; }
private:
Noise::Turbulence turbulence;
Real sharpness;
Color woodColor;
35 Material woodMaterial;
};
#endif /* __WOODTEXTURE_H */

5
#include
#include "WoodTexture.h"
#include "utils.h"
// initialize default data
const WoodTexture::ParseInfo WoodTexture::defaultData = { ProceduralTexture::defaultData,
Noise::defaultTurbulence, 1.0 };
10 /* Constructor
*/
//***************************************************************
WoodTexture::WoodTexture( const WoodTexture::ParseInfo &data )
//***************************************************************
15 : ProceduralTexture( data.procInfo )
{
turbulence = data.turbulence;
sharpness = data.sharpness;
}
20
/* Get texture data
*/
//**************************************
void WoodTexture::detectTextureData()
25 //**************************************
{
Vector woodPoint;
Vector noisePoint;
Real woodValue;
30 static Vector displacement = { 1.23, −5.42, 3.1409 };
/* Consider ring turbulence
*/
// get fractal noise value for y−dimension
35 noisePoint = woodPoint = colorHitPoint;
woodPoint.y += noise−>getFractalNoise( noisePoint, turbulence );
// add displacement and get fractal noise value for z−dimension
addVector( noisePoint, displacement, noisePoint );
40 woodPoint.z += noise−>getFractalNoise( noisePoint, turbulence );
/* Generate annual rings of tree
*/
// determine distance to object’s origin −> circles around origin
45 woodValue = sqrt( woodPoint.y * woodPoint.y + woodPoint.z * woodPoint.z );
// only fractional part matters
woodValue = woodValue − floorVal( woodValue );
50 // consider sharpness of rings
woodValue = pow( woodValue, sharpness );
// do final blending ...
blendColor( *procColor[0], *procColor[1], woodValue, &woodColor );
55 blendMaterial( *procMaterial[0], *procMaterial[1], woodValue, &woodMaterial );
}

5
#ifndef __IMAGE_H
#define __IMAGE_H
#include "Types.h"
/* The Pixel structure
*/
typedef union {
unsigned int pixel;
10 unsigned char channel[4];
//*********
} Pixel;
//*********
15 /* The Image class
*/
//**************
class Image {
//**************
20 public:
Image( const char *name, unsigned int width, unsigned int height );
virtual ~Image();
25
virtual void setPixelColor( const Color &color, unsigned int x_pos, unsigned int y_pos ) = 0;
const char *getName() { return name; }
unsigned int getDim( Coordinate coord ) { return dimension[coord]; }
protected:
30 bool getPixelBuffer( unsigned int width, unsigned int height );
35 };
char name[256];
unsigned int dimension[3];
Pixel *buffer;
#endif /* __IMAGE_H */

#include
#include "Image.h"
5 /* Constructor
*/
//***********************************************************************************
Image::Image( const char *imgName, unsigned int imgWidth, unsigned int imgHeight )
//***********************************************************************************
10 { name[255] = ’\0’;
strncpy( name, imgName, 255 );
dimension[X] = imgWidth;
dimension[Y] = imgHeight;
15 buffer = NULL;
}
getPixelBuffer( imgWidth, imgHeight );
20 /* Destructor
*/
//****************
Image::~Image()
//****************
25 { if( buffer != NULL ) delete[] buffer;
}
/* Try to get memory for pixel buffer
30 */
//****************************************************************************
bool Image::getPixelBuffer( unsigned int imgWidth, unsigned int imgHeight )
//****************************************************************************
{
35 if( buffer != NULL )
{
delete[] buffer;
buffer = NULL;
}
40
45 }
if( imgWidth != 0 && imgHeight != 0 )
buffer = new Pixel[imgWidth * imgHeight];
return (buffer != NULL);

5
#ifndef __TGAIMAGE_H
#define __TGAIMAGE_H
#include
#include "Image.h"
#include "Types.h"
#include "utils.h"
10 /* Definitions for image types. */
#define TGA_Null 0
#define TGA_Map 1
#define TGA_RGB 2
#define TGA_Mono 3
15 #define TGA_RLEMap 9
#define TGA_RLERGB 10
#define TGA_RLEMono 11
#define TGA_CompMap 32
#define TGA_CompMap4 33
20
25
/* Definitions for interleave flag. */
#define TGA_IL_None 0
#define TGA_IL_Two 1
#define TGA_IL_Four 2
#define MAXCOLORS 16384
#define MAXMAXVAL 1023
/* TGA pixel
30 */
//**************************
typedef Byte TGAPixel[3];
//**************************
35 /* Targa header definition
*/
typedef struct {
Byte idLength; // Lenght of ID field
Byte colMapType; // 0=no palette, 1=palette
40 Byte imgType; // 0=none, 1−3=uncompressed, 9−11= compressed
Byte colMapStart[2]; // Offset to first entry of colormap
Byte colMapLength[2]; // Number of colormap entries
Byte colMapDepth; // Bits per colormap entry [8, 15, 16, 24, 32]
Byte offsetX[2]; // Image origin X−axis (lo hi)
45 Byte offsetY[2]; // Image origin Y−axis (lo hi)
Byte width[2]; // Image width in pixels (lo hi)
Byte height[2]; // Image height in pixels (lo hi)
Byte pixelDepth; // Bits per pixel [8, 16, 24, 32]
50 union {
Byte imgDescriptor;
struct {
Byte attBits:4, // 4 bits, number of attribute bits per pixel
55 rsrvd:1, // 1 bit, reserved
orgBit:1, // 1 bit, origin: 0=lower left, 1=upper left
intrLve:2; // 2 bits, interleaving flag
} descriptorBits;
};
60 //*************
} TGAHeader;
//*************
/* The TGAImage class
65 */
//********************************
class TGAImage : public Image {
//********************************
public:
70 TGAImage( const char *tgaName, unsigned int tgaWidth = 0, unsigned int tgaHeight = 0 );
~TGAImage();
75
Real getScaledDim( Coordinate coord )
{ return (dimension[coord] * scale[coord]); }
void setScale( Coordinate coord, Real fact )
{ scale[coord] = fact; }
Real getScale( Coordinate coord )
80 { return scale[coord]; }
85
// set or get pixel color of bitmap
void setPixelColor( const Color &color, unsigned int x_pos, unsigned int y_pos );
void getPixelColor( Color *color, unsigned int x_pos, unsigned int y_pos );
// set or get pixel color of bitmap considering scaling
void setColor( const Color &color, Real x, Real y )
{ setPixelColor( color, Round(x / scale[X]), Round(y / scale[Y]) ); }
90 void getColor( Color *color, Real x, Real y )
{ getPixelColor( color, Round(x / scale[X]), Round(y / scale[Y]) ); }
95
void loadTGA();
void saveTGA24();
private:
void readHeader();
Byte readByte();
void getMapEntry( Pixel *pxl );
100 void readPixel( Pixel *pxl );

FILE *openWriteFile();
void writeHeader( char *imageID );
void writePixel( Pixel &pxl );
105 void computeRunlengths( int cols, Pixel *pxlrow, int *runlength );
bool pixelEquals( Pixel &pxl1, Pixel &pxl2 );
FILE *imgFile;
110 Pixel *colorMap;
TGAHeader header;
char imageID[256];
Real scale[3];
115 int rle_count;
int rle_flag;
bool isRLEencoded;
bool isMapped;
bool isLoaded;
120 };
#endif /* __TGAIMAGE_H */

5
#include
#include "TGAImage.h"
#include "utils.h"
/* Constructor
*/
//*****************************************************************************************
TGAImage::TGAImage( const char *tgaName, unsigned int tgaWidth, unsigned int tgaHeight )
10 //*****************************************************************************************
: Image( tgaName, tgaWidth, tgaHeight )
{
isLoaded = false;
scale[X] =
15 scale[Y] =
scale[Z] = 1.0;
20 }
if( tgaWidth == 0 || tgaHeight == 0 )
loadTGA();
/* Destructor
*/
//**********************
25 TGAImage::~TGAImage()
//**********************
{
if( buffer != NULL )
{
30 if( !isLoaded )
saveTGA24();
}
}
35 /* Set pixel color
*/
//*******************************************************************************************
void TGAImage::setPixelColor( const Color &color, unsigned int x_pos, unsigned int y_pos )
//*******************************************************************************************
40 {
if( buffer == NULL ) return;
if( x_pos < dimension[X] && y_pos < dimension[Y] )
{
45 Real rgbVal;
unsigned int idx = y_pos * dimension[X] + x_pos;
// set channel data
50 for( const ColorChannel *i = RGBfirst; *i != ALPHA; i++ )
{
rgbVal = color.channel[*i] * 255.0;
buffer[idx].channel[*i] = (rgbVal > 255.0)? 255 : Round( rgbVal );
}
55 }
}
/* Get pixel color
*/
60 //*************************************************************************************
void TGAImage::getPixelColor( Color *color, unsigned int x_pos, unsigned int y_pos )
//*************************************************************************************
{
if( buffer != NULL )
65 {
unsigned int idx = (y_pos % dimension[Y]) * dimension[X] + x_pos % dimension[X];
70 }
}
for( const ColorChannel *i = RGBfirst; *i != ALPHA; i++ )
color−>channel[*i] = buffer[idx].channel[*i] / 255.0;
/* Load a tga image file
*/
75 //*************************
void TGAImage::loadTGA()
//*************************
{
int i;
80 unsigned int temp1, temp2;
int rows, cols, row, col, realrow, truerow, baserow;
int maxval;
rle_count = rle_flag =0;
85 colorMap = NULL;
if( (imgFile = fopen( name, "rb" )) == NULL )
{
fprintf( stderr, "Can’t open file %s\n", name );
90 return;
}
// read the Targa file header
readHeader();
95 dimension[Y] = rows = ( (int)header.height[0] ) + ( (int)header.height[1] ) * 256;
dimension[X] = cols = ( (int)header.width[0] ) + ( (int)header.width[1] ) * 256;
switch( header.imgType )
{
100 case TGA_Map:

case TGA_RGB:
case TGA_Mono:
case TGA_RLEMap:
case TGA_RLERGB:
105 case TGA_RLEMono:
break;
default: // error: unknown format
fprintf( stderr, "unknown image format!\n" );
110 goto closeReadFile;
}
if( header.imgType == TGA_Map ||
header.imgType == TGA_RLEMap ||
115 header.imgType == TGA_CompMap ||
header.imgType == TGA_CompMap4
)
{ // color−mapped image
if( header.colMapType != 1 )
120 {
// error: invalid map type
fprintf( stderr, "invalid map type!\n" );
goto closeReadFile;
}
125
isMapped = true;
// figure maxval from colMapDepth
switch ( header.colMapDepth )
130 {
case 8:
case 24:
case 32:
maxval = 255;
135 break;
case 15:
case 16:
maxval = 31;
140 break;
145 }
default: // error: unkown pixelsize of colormap
fprintf( stderr, "unknown pixelsize of colormap!\n" );
goto closeReadFile;
if( maxval > MAXMAXVAL )
{
// error: colormap depth too large
150 fprintf( stderr, "depth of colormap too large!\n" );
goto closeReadFile;
}
}
else
155 { // no colormap
isMapped = false;
// figure maxval from pixel depth
switch( header.pixelDepth )
160 {
case 8:
case 24:
case 32:
maxval = 255;
165 break;
case 15:
case 16:
maxval = 31;
170 break;
175 }
default: // error: unknown pixel depth
fprintf( stderr, "unknown pixel depth!\n" );
goto closeReadFile;
if( maxval > MAXMAXVAL )
{
// error: pixel depth too large
180 fprintf( stderr, "pixel depth too large!\n" );
goto closeReadFile;
}
}
185 // read colormap info if required
if( header.colMapType != 0 )
{
if( (colorMap = new Pixel[MAXCOLORS]) == NULL )
{
190 // error: can’t get colormap
fprintf( stderr, "can’t get colormap!\n" );
goto closeReadFile;
}
195 temp1 = header.colMapStart[0] + header.colMapStart[1] * 256;
temp2 = header.colMapLength[0] + header.colMapLength[1] * 256;
if( (temp1 + temp2 + 1) >= MAXCOLORS )
{
200 // error: too many colors

}
fprintf( stderr, "too many colors!\n" );
goto delColorMap;
205 for( i = temp1; i < (int)(temp1 + temp2); ++i )
getMapEntry( &colorMap[i] );
}
// check run−length encoding
210 if( header.imgType == TGA_RLEMap ||
header.imgType == TGA_RLERGB ||
header.imgType == TGA_RLEMono
)
isRLEencoded = true;
215 else
isRLEencoded = false;
// read the Targa file body and convert to portable format
if( !getPixelBuffer( cols, rows ) )
220 {
// error: can’t get buffer
fprintf( stderr, "can’t get buffer!\n" );
goto delColorMap;
}
225
truerow = 0;
baserow = 0;
for( row = 0; row < rows; ++row )
230 {
realrow = truerow;
235
if( header.descriptorBits.orgBit == 0 )
realrow = rows − realrow − 1;
for( col = 0; col < cols; ++col )
readPixel( &buffer[realrow * cols + col] );
if( header.descriptorBits.intrLve == TGA_IL_Four )
240 truerow += 4;
else if( header.descriptorBits.intrLve == TGA_IL_Two )
truerow += 2;
else
++truerow;
245
}
if( truerow >= rows )
truerow = ++baserow;
250 isLoaded = true;
255
260 }
// clean up ...
delColorMap:
if( colorMap != NULL ) delete[] colorMap;
closeReadFile:
fclose( imgFile );
return;
/* Reades the header of a tga image file
*/
//****************************
265 void TGAImage::readHeader()
//****************************
{
header.idLength = readByte();
header.colMapType = readByte();
270 header.imgType = readByte();
header.colMapStart[0] = readByte();
header.colMapStart[1] = readByte();
header.colMapLength[0] = readByte();
header.colMapLength[1] = readByte();
275 header.colMapDepth = readByte();
header.offsetX[0] = readByte();
header.offsetX[1] = readByte();
header.offsetY[0] = readByte();
header.offsetY[1] = readByte();
280 header.width[0] = readByte();
header.width[1] = readByte();
header.height[0] = readByte();
header.height[1] = readByte();
header.pixelDepth = readByte();
285 header.imgDescriptor = readByte();
290
}
if( header.idLength )
fread( imageID, 1, (int)header.idLength, imgFile );
/* Reads a byte from the image file
*/
//**************************
Byte TGAImage::readByte()
295 //**************************
{
Byte b;
if( fread( (char *)&b, 1, 1, imgFile ) != 1 )
300 return 0;

}
return b;
/* Reads a pixel of the color map
305 */
//*****************************************
void TGAImage::getMapEntry( Pixel *pxl )
//*****************************************
{
310 Byte j, k;
Byte red, green, blue, alpha;
// Read appropriate number of bytes, break into rgb & put in map
switch ( header.colMapDepth )
315 {
case 8: // grey scale, read and triplicate
red = green = blue = readByte();
alpha = 0;
break;
320
325
case 16: // 5 bits each of red green and blue
case 15: // watch for byte order
j = readByte();
k = readByte();
red = ( k & 0x7C ) >> 2;
green = ( ( k & 0x03 ) > 5 );
blue = j & 0x1F;
alpha = 0;
330 break;
case 32:
case 24: // 8 bits each of blue green and red
blue = readByte();
335 green = readByte();
red = readByte();
if ( header.colMapDepth == 32 ) alpha = readByte();
else alpha = 0;
340 break;
345
350 }
}
default:
return;
pxl−>channel[RED] = red;
pxl−>channel[GREEN] = green;
pxl−>channel[BLUE] = blue;
pxl−>channel[ALPHA] = alpha;
/* Reads a pixel of the image body
*/
//***************************************
355 void TGAImage::readPixel( Pixel *pxl )
//***************************************
{
static unsigned int l;
static Byte red, green, blue, alpha;
360 Byte j, k;
// check if run length encoded
if( isRLEencoded )
{
365 if( rle_count == 0 )
{ // have to restart run
Byte i;
i = readByte();
370 rle_flag = ( i & 0x80 );
if( rle_flag == 0 )
// stream of unencoded pixels
rle_count = i + 1;
375 else
// single pixel replicated
rle_count = i − 127;
// decrement count & get pixel
380 −−rle_count;
}
else
{ // have already read count & (at least) first pixel
−−rle_count;
385 if( rle_flag != 0 )
// replicated pixels
goto PixEncode;
}
}
390
// read appropriate number of bytes, break into RGB
switch( header.pixelDepth )
{
case 8: // Grey scale, read and triplicate
395 red = green = blue = l = readByte();
alpha = 0;
break;
case 16: // 5 bits each of red green and blue
400 case 15: // watch byte order

j = readByte();
k = readByte();
l = ( (unsigned int) k > 2;
405 green = ( ( k & 0x03 ) > 5 );
blue = j & 0x1F;
alpha = 0;
break;
410 case 32:
case 24: // 8 bits each of blue green and red
blue = readByte();
green = readByte();
red = readByte();
415
l = 0;
420 break;
}
if( header.pixelDepth == 32 ) alpha = readByte();
else alpha = 0;
default: return;
425 PixEncode:
if( isMapped )
{
pxl−>channel[RED] = colorMap[l].channel[RED];
pxl−>channel[GREEN] = colorMap[l].channel[GREEN];
430 pxl−>channel[BLUE] = colorMap[l].channel[BLUE];
pxl−>channel[ALPHA] = colorMap[l].channel[ALPHA];
}
else
{
435 pxl−>channel[RED] = red;
pxl−>channel[GREEN] = green;
pxl−>channel[BLUE] = blue;
pxl−>channel[ALPHA] = alpha;
}
440 }
/* Saves the buffer to a tga image file
*/
//***************************
445 void TGAImage::saveTGA24()
//***************************
{
int rows = dimension[Y];
int cols = dimension[X];
450 int row, col, i, realrow;
int *runlength;
if( (imgFile = openWriteFile()) == NULL )
{
455 fprintf( stderr, "can’t open file %s for writing!\n", name );
return;
}
if( (runlength = (int *)new int[cols]) == NULL )
460 {
fprintf( stderr, "can’t get runlength buffer!\n" );
goto closeWriteFile;
}
465 // set header data ...
header.colMapType = 0x00;
header.imgType = TGA_RLERGB;
header.colMapStart[0] =
header.colMapStart[1] = 0x00;
470 header.colMapLength[0] =
header.colMapLength[1] = 0x00;
header.colMapDepth = 0;
header.offsetX[0] =
header.offsetX[1] = 0x00;
475 header.offsetY[0] =
header.offsetY[1] = 0x00;
header.width[0] = dimension[X] % 256;
header.width[1] = (dimension[X] >> 8) % 256;
header.height[0] = dimension[Y] % 256;
480 header.height[1] = (dimension[Y] >> 8) % 256;
header.pixelDepth = 24;
header.descriptorBits.attBits = 0;
header.descriptorBits.rsrvd = 0;
485 header.descriptorBits.orgBit = 0;
header.descriptorBits.intrLve = 0;
490
// write out the Targa header
writeHeader( NULL );
// write out pixels
for( row = 0; row < rows; ++row )
{
realrow = row;
495 if ( header.descriptorBits.orgBit == 0 )
realrow = rows − realrow − 1;
computeRunlengths( cols, &buffer[realrow * cols], runlength );
500 for( col = 0; col < cols; )

{
if( runlength[col] > 0 )
{
// set runlength
505 fputc( 0x80 + runlength[col] − 1 , imgFile );
// write pixel
writePixel( buffer[realrow * cols + col] );
col += runlength[col];
}
510 else if( runlength[col] < 0 )
{
// set runlength
fputc( −runlength[col] − 1 , imgFile );
// write pixels
515 for ( i = 0; i < −runlength[col]; ++i )
writePixel( buffer[realrow * cols + col + i] );
col += −runlength[col];
}
520 else
goto delRunlengthBuffer;
}
}
525 // clean up ...
delRunlengthBuffer:
delete[] runlength;
closeWriteFile:
530 fclose( imgFile );
}
return;
535 /* Open new image file
*/
//********************************
FILE *TGAImage::openWriteFile()
//********************************
540 { char tgaFile[259];
545
}
strcpy( tgaFile, name );
strcat( tgaFile, ".tga" );
return fopen( tgaFile, "wb" );
/* Writes the header of a tga image file
550 */
//******************************************
void TGAImage::writeHeader( char *imgID )
//******************************************
{
555 int idLength;
if( imgID != NULL )
{
idLength = strlen( imgID );
560 if( idLength > 255 ) idLength = 255;
}
else idLength = 0;
fputc( idLength, imgFile );
565 fputc( header.colMapType, imgFile );
fputc( header.imgType, imgFile );
fputc( header.colMapStart[0], imgFile );
fputc( header.colMapStart[1], imgFile );
fputc( header.colMapLength[0], imgFile );
570 fputc( header.colMapLength[1], imgFile );
fputc( header.colMapDepth, imgFile );
fputc( header.offsetX[0], imgFile );
fputc( header.offsetX[1], imgFile );
fputc( header.offsetY[0], imgFile );
575 fputc( header.offsetY[1], imgFile );
fputc( header.width[0], imgFile );
fputc( header.width[1], imgFile );
fputc( header.height[0], imgFile );
fputc( header.height[1], imgFile );
580 fputc( header.pixelDepth, imgFile );
fputc( header.imgDescriptor, imgFile );
585 }
if( idLength )
fwrite( imgID, 1, (int)idLength, imgFile );
/* Writes a pixel to the image file − ignores alpha channel
*/
//****************************************
590 void TGAImage::writePixel( Pixel &pxl )
//****************************************
{
fputc( pxl.channel[BLUE], imgFile );
fputc( pxl.channel[GREEN], imgFile );
595 fputc( pxl.channel[RED], imgFile );
}
/* Computes the pixel runlengths of a pixelrow
*/
600 //******************************************************************************

605
void TGAImage::computeRunlengths( int cols, Pixel *pixelrow, int *runlength )
//******************************************************************************
{
int col, start;
// initialize all run lengths to 0. (This is just an error check.)
for( col = 0; col < cols; ++col )
runlength[col] = 0;
610 // find runs of identical pixels
for( col = 0; col < cols; )
{
start = col;
do {
615 ++col;
} while( col < cols &&
col − start < 128 &&
pixelEquals( pixelrow[col], pixelrow[start] )
);
620
}
runlength[start] = col − start;
// now look for runs of length−1 runs, and turn them into negative runs.
625 for( col = 0; col < cols; )
{
if( runlength[col] == 1 )
{
start = col;
630 while( col < cols &&
col − start < 128 &&
runlength[col] == 1 )
{
runlength[col] = 0;
635 ++col;
}
runlength[start] = − ( col − start );
}
640 else
col += runlength[col];
}
}
645 /* Compares two pixels − ignores alpha channel
*/
//*******************************************************
bool TGAImage::pixelEquals( Pixel &pxl1, Pixel &pxl2 )
//*******************************************************
650 {
return ( pxl1.channel[RED] == pxl2.channel[RED] &&
pxl1.channel[GREEN] == pxl2.channel[GREEN] &&
pxl1.channel[BLUE] == pxl2.channel[BLUE] );
}
655

#ifndef __GFXSCREEN_H
#define __GFXSCREEN_H
#include
5 #include
/* The GfxScreen class
*/
//******************
10 class GfxScreen {
//******************
public:
GfxScreen(){}
virtual ~GfxScreen() {}
15
// implement method of GfxNDCBuffer interface
double getAspectRatio() { return aspectRatio; }
// get screen properties
20 const XVisualInfo &getInfo() { return visualInfo; }
void printResolution();
void printVisualInfo();
protected:
25 void initScreen( Display *display );
// GfxScreen’s properties
XVisualInfo visualInfo;
Colormap colorMap;
30 Visual *visual;
double aspectRatio;
int screen;
int depth;
int x_res, y_res;
35
40
};
static const char *classStr[6];
#endif /* __GFXSCREEN_H */

#include
#include "GfxScreen.h"
5 // initialize static
const char *GfxScreen::classStr[] = { "StaticGray", "GrayScale", "StaticColor",
"PseudoColor", "TrueColor", "DirectColor" };
/* init screen
10 */
//***********************************************
void GfxScreen::initScreen( Display *display )
//***********************************************
{
15 int xMM, yMM;
screen = DefaultScreen( display );
visual = DefaultVisual( display, screen );
colorMap = DefaultColormap( display, screen );
20 depth = DefaultDepth( display, screen );
XMatchVisualInfo( display, screen, depth, visual−>c_class, &visualInfo );
x_res = XDisplayWidth( display, screen );
25 y_res = XDisplayHeight( display, screen );
xMM = XDisplayWidthMM( display, screen );
yMM = XDisplayHeightMM( display, screen );
// evaluate aspect ratio
30 aspectRatio = ((double)yMM * x_res)/((double)y_res * xMM);
}
/* Print resolution
*/
35 //**********************************
void GfxScreen::printResolution()
//**********************************
{
fprintf( stdout, "Resolution: %d x %d\n", x_res, y_res );
40 }
/* Print visual info
*/
//**********************************
45 void GfxScreen::printVisualInfo()
//**********************************
{
fprintf( stdout, "%−15s%X\n", "VisualId:", visualInfo.visualid );
fprintf( stdout, "%−15s%s\n", "Color class:", classStr[visualInfo.c_class] );
50 fprintf( stdout, "%−15s%d\n", "Color depth:", visualInfo.depth );
fprintf( stdout, "%−15s%X\n", "Red mask:", visualInfo.red_mask );
fprintf( stdout, "%−15s%X\n", "Green mask:", visualInfo.green_mask );
fprintf( stdout, "%−15s%X\n", "Blue mask:", visualInfo.blue_mask );
fprintf( stdout, "%−15s%d\n", "Colormap Size:", visualInfo.colormap_size );
55 fprintf( stdout, "%−15s%d\n", "Bits per RGB:", visualInfo.bits_per_rgb );
}

#ifndef __GFXGRAPHWINDOW_H
#define __GFXGRAPHWINDOW_H
#include "Image.h"
5 #include "GfxScreen.h"
/* The GfxWindow class
*/
//*************************************************
10 class GfxWindow : public Image, public GfxScreen
//*************************************************
{
public:
GfxWindow(unsigned int wdth, unsigned int hght, const char *windowName = "", const char *iconName = "")
;
15 virtual ~GfxWindow();
inline int getWidth();
inline int getHeight();
20 /**
* Implement method for Image interface
*/
void setPixelColor( const Color &color, unsigned int x_pos, unsigned int y_pos );
25 /**
* Get window properties
*/
Display *getDisplay() { return display; }
Window getWindow() { return window; }
30 GC getGC() { return gc; }
/**
* Window control
*/
35 inline void displayWindow();
void resizeWindow( unsigned int width, unsigned int height )
{ XResizeWindow( display, window, width, height ); }
40 void redraw()
{ XPutImage( display, window, gc, ximage, 0, 0, 0, 0, dimension[X], dimension[Y] ); }
/**
* Event handling
45 */
void registerCallback( unsigned long eventName, void(*func)(XEvent *) )
{ callback[eventName] = func; }
void enableEvent( unsigned long mask )
50 { XSelectInput( display, window, (inputMask |= mask) ); }
void disableEvent( unsigned long mask )
{ XSelectInput( display, window, (inputMask &= ~mask) ); }
55 void quitMainLoop()
{ quitLoop = true; }
inline void mainLoop();
60 protected:
// window properties
Display *display;
Window window;
XImage *ximage;
65 XSizeHints sizeHints;
XWindowAttributes attribs;
GC gc;
unsigned long inputMask;
bool quitLoop;
70
};
// callback table
void(*callback[LASTEvent])( XEvent * );
75 #endif /* __GFXGRAPHWINDOW_H */

#include
#include
5 #include "GfxWindow.h"
#include "utils.h"
// Constructor
//********************************************************************************************************
10 GfxWindow::GfxWindow( unsigned int wdth, unsigned int hght, const char *winName, const char *iconName )
//********************************************************************************************************
: Image( winName, wdth, hght ), GfxScreen()
{
XColor color;
15 Window root;
unsigned long border;
/* Open display and initialize screen ...
*/
20 if( (display = XOpenDisplay( NULL )) == NULL )
{
fprintf( stderr, "Can’t open display\n" );
exit( 1 );
}
25 initScreen( display );
root = RootWindow( display, getInfo().screen );
border = WhitePixel( display, getInfo().screen );
30 // create window
window = XCreateSimpleWindow( display, root, 100, 100, wdth, hght, 5, border, 0 );
// set size hints
sizeHints.x = 100;
35 sizeHints.y = 100;
sizeHints.width = wdth;
sizeHints.height = hght;
sizeHints.flags = (PPosition | PSize);
40 // register window
XSetStandardProperties( display, window, winName, iconName, None, NULL, 0, &sizeHints );
// create ximage
ximage = XCreateImage( display, visual, depth, ZPixmap, 0, (char *)buffer, dimension[X], dimension[Y],
45 32, dimension[X] * sizeof(Pixel) );
if( ximage == NULL )
{
fprintf( stderr, "Can’t create XImage\n" );
50 exit( 1 );
}
XInitImage( ximage );
// create graphics context
55 gc = XCreateGC( display, window, 0, NULL );
// set default color
color.red =
color.green =
60 color.blue = 0x0000;
XSetForeground( display, gc, color.pixel );
XSetWindowBackground( display, window, color.pixel );
65 // initialize callback table
for( unsigned long i = 0; i < LASTEvent; ++i )
callback[i] = NULL;
// care for no events
70 inputMask = NoEventMask;
}
// Destructor
//************************
75 GfxWindow::~GfxWindow()
//************************
{
XUnmapWindow( display, window );
XFreeGC( display, gc );
80 XCloseDisplay( display );
}
/* Get width of window
*/
85 //**************************
int GfxWindow::getWidth()
//**************************
{
XGetWindowAttributes( display, window, &attribs );
90 return attribs.width;
}
/* Get height of window
*/
95 //***************************
int GfxWindow::getHeight()
//***************************
{
XGetWindowAttributes( display, window, &attribs );
100 return attribs.height;

}
/**
* Implement methods for Image interface
105 */
//********************************************************************************************
void GfxWindow::setPixelColor( const Color &color, unsigned int x_pos, unsigned int y_pos )
//********************************************************************************************
{
110 Real rgbVal, rdRgbVal, alphaVal;
unsigned int idx;
if( x_pos < dimension[X] && y_pos < dimension[Y] )
{
115 idx = y_pos * dimension[X] + x_pos;
alphaVal = 0;
// set channel data
for( const ColorChannel *i = RGBfirst; *i != ALPHA; i++ )
120 {
rgbVal = color.channel[*i] * 0xFF;
rdRgbVal = Round( rgbVal );
alphaVal += rgbVal − rdRgbVal;
buffer[idx].channel[*i] = (unsigned char)((rgbVal > 0xFF)? 0xFF : rdRgbVal);
125 }
130
}
}
// use average of rounding error for alpha
buffer[idx].channel[ALPHA] = Round( (alphaVal / 3) * 0xFF );
if( x_pos == dimension[X]−1 )
XPutImage( display, window, gc, ximage, 0, 0, 0, 0, dimension[X], dimension[Y] );
135 /* display window
*/
//********************************
void GfxWindow::displayWindow()
//********************************
140 {
// show window
XMapWindow( display, window );
XFlush( display );
}
145
/* The main loop
*/
//***************************
void GfxWindow::mainLoop()
150 //***************************
{
XEvent event;
155
quitLoop = false;
while( !quitLoop )
{
XNextEvent( display, &event );
if( callback[event.type] != NULL )
160 callback[event.type]( &event );
}
}

#ifndef __OBJECT_H
#define __OBJECT_H
#include "PointMapper.h"
5 #include "Texture.h"
#include "Types.h"
/* The Object class
*/
10 //***************
class Object {
//***************
friend class Parser;
15 public:
Object();
virtual ~Object();
// *** texture setup ***
20 virtual void matchMappingMode( PointMapper::MappingMode modes[] ) = 0;
virtual void matchSurfaceDimension( Real dimension[] ) = 0;
// *** get object’s properties ***
const Color &getAmbience() { return ambience; }
25 const Vector &getNormal() { return normal; }
const Color &getColor() { return texture−>getColor(); }
const Material &getMaterial() { return texture−>getMaterial(); }
// *** object specific calculations ***
30 virtual bool test( const Vector &min, const Vector &max );
virtual bool intersect( const Ray &ray, Real *distance ) = 0;
virtual void setHitData( const Ray &ray, const Point &hitPnt );
protected:
35 virtual void detectNormal( const Point &hitPoint ) = 0;
// object’s properties
Matrix toObject;
Matrix toWorld;
40 Color ambience;
Texture *texture;
// corners of octree box
Vector minCorner;
45 Vector maxCorner;
50
};
// temporary member
Vector normal;
#endif /* __OBJECT_H */

5
#include "Object.h"
#include "BumpTexture.h"
#include "utils.h"
/* Constructor
*/
//*****************
Object::Object()
10 //*****************
{
// initialize transform matrices
toObject =
toWorld = identityMatrix;
15
20
// initialize points for object’s
// bounding box used by octree.
minCorner = nullVector;
maxCorner = oneVector;
/**
* Initialize object’s surface
*/
ambience = black;
25 texture = NULL;
}
/* Destructor
*/
30 //******************
Object::~Object()
//******************
{
if( texture != NULL )
35 {
texture−>releaseHandle();
40 }
}
if( !texture−>isReferenced() )
delete texture;
/* Prepair hit point to be used with object and texture calculations.
*/
45 //***************************************************************
void Object::setHitData( const Ray &ray, const Point &hitPnt )
//***************************************************************
{
Point hitPoint;
50
// transform point into object system
transformPoint( toObject, hitPnt, &hitPoint );
/**
55 * Set hit data used by texture to
* detect color, material and normal vector.
*/
texture−>setHitData( hitPoint, hitPoint );
60 /**
* Determine normal vector
*/
// detect object’s real normal vector
detectNormal( hitPoint );
65
// tilt normal vector by bump mapping
if( ((BumpTexture *)texture)−>isBumpy() )
((BumpTexture *)texture)−>getBumpNormal( normal, &normal );
70 // transform normal vector by inverse(!) matrix into world system
transformNormal( toObject, normal, &normal );
// ... and normalize again
normalizeVector( normal, normal );
75 /**
* texture data detection (color, material)
*/
// set normal vector of world system
// − may be needed by some textures (e.g. ReflectionTexture)
80 texture−>setRayAndNormal( ray, normal );
85
}
// detect texture data
texture−>detectTextureData();
/* Tests the object for being inside a cube specified by
* parameters min and max.
*/
//**********************************************************
90 bool Object::test( const Vector &min, const Vector &max )
//**********************************************************
{
Vertices vert;
unsigned int i;
95
// get the vertices of the cube enclosing the object
getVertices( minCorner, maxCorner, vert );
// and transform them into the world coordinate system
100 for( i = 0; i < 8; ++i )

105
transformPoint( toWorld, vert[i], &vert[i] );
// test the box enclosing the object for being inside the cell
if( testBox( vert, min, max ) ) return true;
// get the vertices of the cell
getVertices( min, max, vert );
// and transform them into the object’s coordinate system
110 for( i = 0; i < 8; ++i )
transformPoint( toObject, vert[i], &vert[i] );
115 }
// test cell for being inside the box
return testBox( vert, minCorner, maxCorner );

#ifndef __BOX_H
#define __BOX_H
#include "Object.h"
5 #include "Types.h"
/* The Box class
*/
//****************************
10 class Box : public Object {
//****************************
public:
Box();
~Box();
15
// *** texture setup ***
void matchMappingMode( PointMapper::MappingMode modes[] )
{ modes[X] = modes[Y] = PointMapper::MAP_LINEAR; }
20 void matchSurfaceDimension( Real dim[] )
{ dim[X] = dim[Y] = 1.0; };
// *** box calculations ***
void setHitData( const Ray &ray, const Point &hitPnt );
25 bool intersect( const Ray &ray, Real *dist );
private:
typedef enum {
FRONT, BACK,
30 RIGHT, LEFT,
BOTTOM, TOP
//***********
} BoxFace;
//***********
35
40
45
};
/* Theres no need for implementing the calculation of the normal vector.
* setHitData() uses the default vector instead.
*/
void detectNormal( const Point &hitPoint ) {}
static const Vector frontNormal;
#endif /* __BOX_H */

#include "Box.h"
#include "Texture.h"
#include "BumpTexture.h"
5 #include "utils.h"
// initialize front normal vector
const Vector Box::frontNormal = { 0.0, 0.0, −1.0 };
10 /* Constructor
*/
//***********
Box::Box()
//***********
15 : Object()
{
// define the box enclosing the box object
minCorner = nullVector;
maxCorner = oneVector;
20 }
/* Destructor
*/
25 //************
Box::~Box()
//************
{
}
30
/* Prepair hit point to be used with box and texture calculations.
*/
//*************************************************************
35 void Box::setHitData( const Ray &ray, const Vector &hitPnt )
//*************************************************************
{
Real swp;
BoxFace hitFace;
40 Point hitPoint, texPoint;
// transform point into object system
transformPoint( toObject, hitPnt, &hitPoint );
45 /**
* Determine box face hit by ray
* and correct rounding errors
*/
if( fabs(hitPoint.x) < RAYEPS ) {
50 hitPoint.x = 0.0;
hitFace = LEFT;
}
else if( fabs(hitPoint.x − 1.0) < RAYEPS ) {
hitPoint.x = 1.0;
55 hitFace = RIGHT;
}
else if( fabs(hitPoint.y) < RAYEPS ) {
hitPoint.y = 0.0;
hitFace = BOTTOM;
60 }
else if( fabs(hitPoint.y − 1.0) < RAYEPS ) {
hitPoint.y = 1.0;
hitFace = TOP;
}
65 else if( fabs(hitPoint.z) < RAYEPS ) {
hitPoint.z = 0.0;
hitFace = FRONT;
}
else if( fabs(hitPoint.z − 1.0) < RAYEPS ) {
70 hitPoint.z = 1.0;
hitFace = BACK;
}
/**
75 * Set hit data and surface dimension used by
* texture to detect color and normal vector.
*/
/**
* In Fact the box is a compound object. Thus for flat texture mapping
80 * the hit point has to be transformed uniformly to one face of the box.
* Hence the hit point will be transformed to the front face here ...
*/
texPoint = hitPoint;
85 if( hitFace != FRONT )
{
// move origin to center ...
translateVector( texPoint, −0.5, texPoint );
90 // rotate texture point to front face ...
switch( hitFace )
{
case LEFT: swp = texPoint.x;
texPoint.x = −texPoint.z;
95 texPoint.z = swp;
break;
case RIGHT: swp = texPoint.x;
texPoint.x = texPoint.z;
100 texPoint.z = −swp;

eak;
case BOTTOM: swp = texPoint.y;
texPoint.y = −texPoint.z;
105 texPoint.z = swp;
break;
case TOP: swp = texPoint.y;
texPoint.y = texPoint.z;
110 texPoint.z = −swp;
break;
115
}
case BACK: texPoint.x = −texPoint.x;
texPoint.z = −texPoint.z;
default: break;
// ... and move back.
120 translateVector( texPoint, 0.5, texPoint );
}
/**
* Set hit data for color detection according to texture dimension.
125 * Bump mapping is always done in 2D manner −> 3rd param (normal hit point)
* 2D => use point transformed to front face
* 3D => use real hit point
*/
texture−>setHitData( ((texture−>is2D())? texPoint : hitPoint), texPoint );
130
/**
* Determine normal vector
*/
// for bump mapping assume normal vector of the front face.
135 if( ((BumpTexture *)texture)−>isBumpy() )
((BumpTexture *)texture)−>getBumpNormal( frontNormal, &normal );
else
normal = frontNormal;
140 // rotate result normal to hit face.
switch( hitFace )
{
case LEFT: swp = normal.x;
normal.x = normal.z;
145 normal.z = −swp;
break;
case RIGHT: swp = normal.x;
normal.x = −normal.z;
150 normal.z = swp;
break;
case BOTTOM: swp = normal.y;
normal.y = normal.z;
155 normal.z = −swp;
break;
case TOP: swp = normal.y;
normal.y = −normal.z;
160 normal.z = swp;
break;
165
}
case BACK: normal.x = −normal.x;
normal.z = −normal.z;
default: break;
// transform normal by inverse matrix into world system
170 transformNormal( toObject, normal, &normal );
// ... and normalize again
normalizeVector( normal, normal );
/**
175 * texture data detection (color, material)
*/
// set normal − may be needed by some textures
texture−>setRayAndNormal( ray, normal );
texture−>detectTextureData();
180 }
/* Tests a ray for intersecting the box.
*/
185 //**************************************************
bool Box::intersect( const Ray &ray, Real *dist )
//**************************************************
{
Real t1, t2;
190 Real distFar = DBL_MAX;
bool hitsBox = true;
Ray local;
195
*dist = −DBL_MAX;
transformPoint( toObject, ray.origin, &local.origin );
transformVector( toObject, ray.direction, &local.direction );
if( local.direction.x == 0.0 )
200 hitsBox = (local.origin.x >= 0.0 && local.origin.x

205
else
{
t1 = −local.origin.x / local.direction.x;
t2 = (1.0 − local.origin.x) / local.direction.x;
if( t1 < t2 )
{
*dist = t1;
distFar = t2;
210 }
else
{
*dist = t2;
distFar = t1;
215 }
hitsBox = (distFar >= 0.0);
}
if( hitsBox )
220 {
if( local.direction.y == 0.0 )
hitsBox = (local.origin.y >= 0.0 && local.origin.y *dist ) *dist = t1;
if( t2 < distFar ) distFar = t2;
}
else
{
235 if( t2 > *dist ) *dist = t2;
if( t1 < distFar ) distFar = t1;
}
hitsBox = (*dist = 0.0);
}
240 }
if( hitsBox )
{
if( local.direction.z == 0.0 )
245 hitsBox = (local.origin.z >= 0.0 && local.origin.z *dist ) *dist = t1;
if( t2 < distFar ) distFar = t2;
255 }
else
{
if( t2 > *dist ) *dist = t2;
if( t1 < distFar ) distFar = t1;
260 }
hitsBox = (*dist = 0.0);
}
}
265 if( hitsBox && *dist RAYEPS);
*dist = distFar;
}
270
}
return hitsBox;

#ifndef __CONE_H
#define __CONE_H
#include "Object.h"
5 #include "Types.h"
/* The Cone class
*/
//*****************************
10 class Cone : public Object {
//*****************************
public:
Cone( Real radSml, Real radLrg, Real hght );
~Cone() {};
15
// *** setup cone’s texture ***
void matchMappingMode( PointMapper::MappingMode modes[] )
{
modes[X] = PointMapper::MAP_SPHERIC;
20 modes[Y] = PointMapper::MAP_LINEAR;
}
void matchSurfaceDimension( Real dim[] )
{
25 dim[X] = (radLarge + radSmall) * M_PI;
dim[Y] = surfLen;
}
// *** cone calculations ***
30 bool intersect( const Ray &ray, Real *dist );
private:
void detectNormal( const Point &hitPoint );
35 Real radSmall;
Real radLarge;
Real height;
Real length;
Real base;
40 Real surfLen;
bool invNormal;
};
45
#endif /* __CONE_H */

#include
#include "Cone.h"
#include "Texture.h"
5 #include "utils.h"
/* Constructor
*/
//**************************************************
10 Cone::Cone( Real radSml, Real radLrg, Real hght )
//**************************************************
: Object()
{
Real radDiff = (radLrg − radSml);
15
radSmall = radSml;
radLarge = radLrg;
height = hght;
length = height * radLarge / radDiff;
20 base = radLarge * radLarge / (length * length);
surfLen = sqrt( (radDiff * radDiff) / 4.0 + height * height );
// define the box enclosing the cone
minCorner.x = −radLarge;
25 minCorner.y = 0.0;
minCorner.z = −radLarge;
maxCorner.x = radLarge;
maxCorner.y = height;
30 maxCorner.z = radLarge;
}
/* Tests a ray for intersecting the cone.
*/
35 //***************************************************
bool Cone::intersect( const Ray &ray, Real *dist )
//***************************************************
{
Vector a, v;
40 Real n, b, c, d, y;
transformPoint( toObject, ray.origin, &a );
transformVector( toObject, ray.direction, &v );
45 a.y −= length;
n = v.x * v.x + v.z * v.z − base * v.y * v.y;
if( n != 0.0 )
{
50 b = −a.x * v.x − a.z * v.z + base * a.y * v.y;
c = a.x * a.x + a.z * a.z − base * a.y * a.y;
d = b * b − c * n;
if( d >= 0.0 )
55 {
d = sqrt( d );
*dist = (b − d) / n;
y = a.y + *dist * v.y;
60 if( *dist > RAYEPS && y = −length )
{
invNormal = false;
return true;
}
65
*dist = (b + d) / n;
y = a.y + *dist * v.y;
if( *dist > RAYEPS && y = −length )
70 {
invNormal = true;
return true;
}
}
75 }
return false;
}
/* Determines the normal vector in the point
80 * specified by setHitPoint()
*/
//*************************************************
void Cone::detectNormal( const Point &hitPoint )
//*************************************************
85 { normal = hitPoint;
normal.y −= length;
normal.y = − normal.y * base;
normalizeVector( normal, normal );
90 if( invNormal ) negateVector( normal, normal );
}

#ifndef __CYLINDER_H
#define __CYLINDER_H
#include "Object.h"
5 #include "Types.h"
/* The Cylinder class
*/
//*********************************
10 class Cylinder : public Object {
//*********************************
public:
Cylinder();
~Cylinder() {};
15
// *** setup cylinder’s texture ***
void matchMappingMode( PointMapper::MappingMode modes[] )
{
modes[X] = PointMapper::MAP_SPHERIC;
20 modes[Y] = PointMapper::MAP_LINEAR;
}
void matchSurfaceDimension( Real dim[] )
{
25 dim[X] = 2.0 * M_PI;
dim[Y] = 1.0;
}
// *** cylinder calculations ***
30 bool intersect( const Ray &ray, Real *dist );
private:
void detectNormal( const Point &hitPoint )
{
35 normal = hitPoint;
normal.y = 0.0;
if( invNormal )
{
normal.x = −normal.x;
40 normal.z = −normal.z;
}
}
45 };
bool invNormal;
#endif /* __CYLINDER_H */

#include
#include "Cylinder.h"
#include "Texture.h"
5 #include "utils.h"
/* Constructor
*/
//*********************
10 Cylinder::Cylinder()
//*********************
: Object()
{
// define the cube enclosing the cylinder
15 minCorner.x = −1.0;
minCorner.y = 0.0;
minCorner.z = −1.0;
maxCorner = oneVector;
}
20
/* Tests a ray for intersecting the cylinder.
*/
//*******************************************************
bool Cylinder::intersect( const Ray &ray, Real *dist )
25 //*******************************************************
{
Vector a, v;
Real n, b, d, c, y;
30 transformPoint( toObject, ray.origin, &a );
transformVector( toObject, ray.direction, &v );
n = v.x * v.x + v.z * v.z;
if( n != 0.0 )
35 {
b = −a.x * v.x − a.z * v.z;
c = a.x * a.x + a.z * a.z;
d = b * b − (c − 1.0) * n;
40 if( d >= 0.0 )
{
d = sqrt( d );
*dist = (b − d) / n;
y = a.y + *dist * v.y;
45
if( *dist > RAYEPS && y >= 0.0 && y RAYEPS && y >= 0.0 && y

#ifndef __PLANE_H
#define __PLANE_H
#include "Object.h"
5 #include "Types.h"
/* The Plane class
*/
//******************************
10 class Plane : public Object {
//******************************
public:
Plane();
~Plane() {}
15
// *** texture setup ***
void matchMappingMode( PointMapper::MappingMode modes[] )
{ modes[X] = modes[Y] = PointMapper::MAP_LINEAR; }
20 void matchSurfaceDimension( Real dim[] )
{ dim[X] = dim[Y] = 100; }
// *** plane calculations ***
bool intersect( const Ray &ray, Real *real );
25 bool test( const Vector &min, const Vector &max );
30
35
};
private:
void detectNormal( const Point &hitPoint )
{ normal = (invNormal)? inv_direction : direction; }
bool invNormal;
Vector direction;
Vector inv_direction;
#endif /* __PLANE_H */

#include
#include "Plane.h"
#include "BumpTexture.h"
5 #include "utils.h"
/* Constructor
*/
//***************
10 Plane::Plane()
//***************
: Object()
{
direction = baseVector[Z];
15
20 }
negateVector( direction, inv_direction );
minCorner =
maxCorner = nullVector;
/* Tests a ray for intersecting the plane.
*/
//****************************************************
25 bool Plane::intersect( const Ray &ray, Real *dist )
//****************************************************
{
Ray local;
Real a, b;
30
transformPoint( toObject, ray.origin, &local.origin );
transformVector( toObject, ray.direction, &local.direction );
if( local.direction.z != 0.0 )
35 {
*dist = −local.origin.z / local.direction.z;
if( *dist > RAYEPS )
{
40 invNormal = (local.direction.z > 0.0);
return true;
}
}
return false;
45 }
/* Tests the plane for being inside a cube specified by
* parameters min and max.
*/
50 //*********************************************************
bool Plane::test( const Vector &min, const Vector &max )
//*********************************************************
{
Vector localMin, localMax;
55
60 }
transformPoint( toObject, min, &localMin );
transformPoint( toObject, max, &localMax );
return (localMin.z * localMax.z

#ifndef __SPHERE_H
#define __SPHERE_H
#include "Object.h"
5 #include "Types.h"
/* The Sphere class
*/
//*******************************
10 class Sphere : public Object {
//*******************************
public:
Sphere();
~Sphere() {};
15
// *** texture setup ***
void matchMappingMode( PointMapper::MappingMode modes[] )
{ modes[X] = modes[Y] = PointMapper::MAP_SPHERIC; }
20 void matchSurfaceDimension( Real dim[] )
{
dim[X] = 2.0 * M_PI;
dim[Y] = M_PI;
}
25
// *** sphere calculations ***
bool intersect( const Ray &ray, Real *distance );
protected:
30 // determine normal at hit point
void detectNormal( const Point &hitPoint ) { normal = hitPoint; }
};
35
#endif /* __SPHERE_H */

#include
#include "Sphere.h"
#include "Texture.h"
5 #include "utils.h"
/* Constructor
*/
//*****************
10 Sphere::Sphere()
//*****************
: Object()
{
translateVector( nullVector, −1, minCorner );
15 translateVector( nullVector, 1, maxCorner );
}
/* Tests a ray for intersecting the sphere.
*/
20 //*****************************************************
bool Sphere::intersect( const Ray &ray, Real *dist )
//*****************************************************
{
Ray local;
25 Real dd, od, oo, discr, d;
transformPoint( toObject, ray.origin, &local.origin );
transformVector( toObject, ray.direction, &local.direction );
30 dotProduct( local.direction, local.direction, dd );
dotProduct( local.origin, local.direction, od );
dotProduct( local.origin, local.origin, oo );
// calculate the discriminant
35 discr = od * od − dd * (oo − 1.0);
// check for real solutions
if( discr >= 0.0 )
{
40 d = sqrt( discr );
*dist = (−od − d) / dd;
if( *dist RAYEPS ) return true;
}
else return true;
}
50 return false;
}

#ifndef __FREEFORMSURFACE_H
#define __FREEFORMSURFACE_H
#include
5 #include "Object.h"
#include "Texture.h"
#include "Types.h"
#define SURFACE_MAX_DEGREE 8
10 #define SURFACE_MAX_ITERATION 100
#define SURFACE_MAX_DIVIDE INT_MAX
/* The FreeformSurface class
*/
15 //****************************************
class FreeformSurface : public Object {
//****************************************
public:
// The Helper class
20 // Used to access the second dimension of the
// control point matrix by operator[].
//******************
class Helper {
//******************
25 friend class FreeformSurface;
public:
Point &operator[]( unsigned int idx_n ) { return points[idx_m * dim_n + idx_n]; }
30 private:
// Constructor
Helper( unsigned int _m, unsigned int _n, Point *p ) : points(p), idx_m(_m), dim_n(_n) {}
Point *points;
35 unsigned int idx_m;
unsigned int dim_n;
};
// Constructor
40 FreeformSurface( unsigned int _m, unsigned int _n );
virtual ~FreeformSurface();
45
// operator[] for contol point access.
Helper operator[]( unsigned int idx_m ) { return Helper( idx_m, n+1, cntlPoints ); }
/**
* Implement methods of Object interface
*/
void matchMappingMode( PointMapper::MappingMode modes[] )
50 { modes[X] = modes[Y] = PointMapper::MAP_EXTERN; }
void matchSurfaceDimension( Real dim[] )
{ dim[X] = dim[Y] = 1.0; }
55 // override method of Object
void setHitData( const Ray &ray, const Vector &hitPnt )
{
texture−>setExternMapping( X, hitU );
texture−>setExternMapping( Y, hitV );
60 // call general object calculations
Object::setHitData( ray, hitPnt );
}
65
bool intersect( const Ray &ray, Real *distance );
/**
* Search tree
*/
void buildSearchTree();
70 int getDivisions() { return divisions; }
// print out control point matrix
void dumpControlPoints( FILE *fptr = stdout );
75 protected:
typedef enum {
U_AXIS = 0, V_AXIS = 1
//********
} Axis;
80 //********
// expected calculation methods of surface
virtual void surfacePoint( Real u, Real v, Point *pnt ) = 0;
virtual void surfaceGradients( Real u, Real v, Vector *gu, Vector *gv ) = 0;
85 virtual bool isFlat( Axis *divAxis ) = 0;
virtual bool divide( Axis a, Real t, FreeformSurface **left, FreeformSurface **right ) = 0;
// Implement method expected by Object
void detectNormal( const Point &hitPoint )
90 { /* normal vector already evaluated in intersect() */ }
/**
* FreeformSurface’s properties
*/
95 Point *cntlPoints; // control points
unsigned int m, n; // degrees
Interval surfaceDomain[2]; // domain of u and v
Real hitU, hitV;
100 // criteria for dividing the surface

static const Real curvatureLimit;
static const Real lengthDiffLimit;
static const Real aspectRatioLimit;
105 private:
typedef struct __TreeNode {
Point baseVertex;
Vector base[3];
Vector normal[3];
110 Interval domain[2];
// precalculated values
Interval baseNormalDomain[3];
Real scaleU, scaleV;
115 Vector *planeNormal;
Real aspectRatio;
struct __TreeNode *left;
struct __TreeNode *right;
120 struct __TreeNode *parent;
//************
} TreeNode;
//************
125 typedef struct {
Real distance;
Vector normal;
Real hitU;
Real hitV;
130 //******************
} SurfaceHitData;
//******************
/**
135 * Search tree methods
*/
bool addToSearchTree( TreeNode **nodeHook, TreeNode *parent, Interval domain[] );
void getBoundingVolume( TreeNode *volumeNode, Interval alpha[] );
void chopSearchTree( TreeNode *node );
140
// iteration
bool doIteration( TreeNode &node, Ray &ray, Real t0, SurfaceHitData *hitData );
TreeNode *searchTreeRoot;
145 int divisions;
150
155 };
// internal logging
static int iterations;
static int divCounter;
#ifdef DEBUG_FULL
static FILE *debugInfo;
static int refCounter;
#endif
#endif /* __FREEFORMSURFACE_H */

#include "FreeformSurface.h"
#include "utils.h"
5 // initialize static members
const Real FreeformSurface::curvatureLimit = 1.2; // [1.0,inf]
const Real FreeformSurface::lengthDiffLimit = 0.06; // [0.0,inf]
const Real FreeformSurface::aspectRatioLimit = 1.0/4.0; // 1/n −> n out of [1,inf[
int FreeformSurface::divCounter = 0;
10 int FreeformSurface::iterations = 0;
#ifdef DEBUG_FULL
FILE *FreeformSurface::debugInfo = NULL;
int FreeformSurface::refCounter = 0;
15 #endif
/* Constructor
*/
//*********************************************************************
20 FreeformSurface::FreeformSurface( unsigned int _m, unsigned int _n )
//*********************************************************************
: Object()
{
m = _m;
25 n = _n;
surfaceDomain[U_AXIS].lower =
surfaceDomain[V_AXIS].lower = 0.0;
surfaceDomain[U_AXIS].upper =
surfaceDomain[V_AXIS].upper = 1.0;
30
// check for maximum degree
if( m > SURFACE_MAX_DEGREE )
fprintf( stderr, "m degree exceeds maximum! declining to %d\n", (m = SURFACE_MAX_DEGREE) );
if( n > SURFACE_MAX_DEGREE )
35 fprintf( stderr, "n degree exceeds maximum! declining to %d\n", (n = SURFACE_MAX_DEGREE) );
cntlPoints = new Point[(m+1)*(n+1)];
searchTreeRoot = NULL;
40 divisions = 0;
#ifdef DEBUG_FULL
// open file for debug info
if( debugInfo == NULL )
45 {
if( (debugInfo = fopen( "FreeformSurface.info", "a" )) == NULL )
fprintf( stderr, "Can’t open info file!\n" );
else refCounter++;
}
50 #endif
}
/* Destructor
*/
55 //************************************
FreeformSurface::~FreeformSurface()
//************************************
{
if( cntlPoints != NULL ) delete[] cntlPoints;
60
if( searchTreeRoot != NULL )
chopSearchTree( searchTreeRoot );
#ifdef DEBUG_FULL
65 −−refCounter;
if( refCounter == 0 )
{
fclose( debugInfo );
debugInfo = NULL;
70 }
#endif
}
/* Search the tree for patches intersected by the ray
75 */
//******************************************************************
bool FreeformSurface::intersect( const Ray &ray, Real *distance )
//******************************************************************
{
80 Real dot_d_n, dot_v_n;
Ray local;
Interval t[3], itrsct;
bool isHit;
85 Vector baseDiff;
Vector vctrTmp;
SurfaceHitData hitData;
// start at root
90 TreeNode *current = searchTreeRoot;
95
// transform ray into object system
transformPoint( toObject, ray.origin, &local.origin );
transformVector( toObject, ray.direction, &local.direction );
*distance = DBL_MAX;
// scan the search tree for intersections
while( true )
100 {

subVector( current−>baseVertex, local.origin, baseDiff );
// intersect box by ray
for( int i = 0; i < 3; ++i )
105 {
dotProduct( local.direction, current−>normal[i], dot_d_n );
if( dot_d_n == 0.0 ) dot_d_n = RAYEPS;
dotProduct( baseDiff, current−>normal[i], dot_v_n );
110 t[i].lower = (dot_v_n + current−>baseNormalDomain[i].lower) / dot_d_n;
t[i].upper = (dot_v_n + current−>baseNormalDomain[i].upper) / dot_d_n;
if( t[i].lower > t[i].upper )
swap( t[i].lower, t[i].upper );
115 }
// if intersection is valid ...
if( intersectInterval( t[0], t[1], itrsct ) && intersectInterval( itrsct, t[2], itrsct ) )
{
// if no subnodes exist ...
120 if( current−>left == NULL )
{
/**
* node is a leaf, thus try iteration.
*/
125 // Choose the starting point for iteration.
// This is done by the criterion
// tan(ray,normal) > aspectRatio
// The tangent is evaluated by
130 // sine(ray,normal) / cosine(ray,normal)
// and thus by
// abs( cross(ray,normal) ) / dot(ray,normal)
crossProduct( local.direction, *(current−>planeNormal), vctrTmp );
dotProduct( local.direction, *(current−>planeNormal), dot_d_n );
135 dotProduct( baseDiff, *(current−>planeNormal), dot_v_n );
isHit = false;
if( absVal( dot_d_n ) > RAYEPS )
{
140 if( vectorLength( vctrTmp ) / absVal( dot_d_n ) < current−>aspectRatio )
{
// start iteration using intersection point
isHit = doIteration( *current, local, (dot_v_n / dot_d_n), &hitData );
}
145 }
/* Due to the convex hull property, an intersection can’t occure nearer than the
* point of intersection with the parallelepiped. So if an intersection already
* exists that is nearer than the intersection with the parallelepiped it is
150 * waste of time to do the iteration.
*/
if( !isHit && *distance > itrsct.lower )
if( (isHit = doIteration( *current, local, itrsct.lower, &hitData)) == false )
isHit = doIteration( *current, local, itrsct.upper, &hitData );
155
if( isHit && hitData.distance > RAYEPS && hitData.distance < *distance )
{
*distance = hitData.distance;
normal = hitData.normal;
160 hitU = hitData.hitU;
hitV = hitData.hitV;
}
}
else
165 {
// it’s an inner node
current = current−>left;
continue;
}
170 }
// go up while current is right child
while( current != searchTreeRoot && current == current−>parent−>right )
current = current−>parent;
175 // jump to right child of parent
if( current != searchTreeRoot )
current = current−>parent−>right;
else
break;
180 }
185
}
return (*distance < DBL_MAX);
/* Find the intersection point using the newton iteration algorithm
*/
//************************************************************************************************
bool FreeformSurface::doIteration( TreeNode &node, Ray &ray, Real t0, SurfaceHitData *hitData )
190 //************************************************************************************************
{
Point P0, P1;
Vector diff, gu, gv, n0;
Real u0, v0, deltaU, deltaV;
195 Real dot_d_n, dot_diff_n;
bool secondTry = false;
bool u_exceeds = false, v_exceeds = false;
int iCount;
200 // determine start point

ayPoint( ray, t0, P0 );
subVector( P0, node.baseVertex, diff );
/**
205 * Calculate start parameter u0, v0
*/
Real solution1[3];
Real equSystem1[3][3] = { { node.base[0].x, node.base[1].x, node.base[2].x },
{ node.base[0].y, node.base[1].y, node.base[2].y },
210 { node.base[0].z, node.base[1].z, node.base[2].z } };
215
solution1[0] = diff.x;
solution1[1] = diff.y;
solution1[2] = diff.z;
if( !solveEquationSystem( (Real *)equSystem1, solution1, 3 ) )
return false;
deltaU = solution1[0] * node.scaleU;
220 deltaV = solution1[1] * node.scaleV;
u0 = node.domain[U_AXIS].lower + deltaU;
v0 = node.domain[V_AXIS].lower + deltaV;
225 /**
* Iteration loop
*/
for( iCount = 0; iCount < SURFACE_MAX_ITERATION; ++iCount )
{
230 /**
* Determine iteration update by newton algorithm
*/
surfacePoint( u0, v0, &P0 );
surfaceGradients( u0, v0, &gu, &gv );
235 crossProduct( gu, gv, n0 );
240
245
// intersect plane by ray
dotProduct( ray.direction, n0, dot_d_n );
if( dot_d_n == 0.0 ) break;
subVector( P0, ray.origin, diff );
dotProduct( diff, n0, dot_diff_n );
t0 = dot_diff_n / dot_d_n;
rayPoint( ray, t0, P1 );
subVector( P1, P0, diff );
Real solution[3];
Real equSystem[3][3] = { { gu.x, gv.x, n0.x },
250 { gu.y, gv.y, n0.y },
{ gu.z, gv.z, n0.z } };
solution[0] = diff.x;
solution[1] = diff.y;
255 solution[2] = diff.z;
if( !solveEquationSystem( (Real *)equSystem, solution, 3 ) )
return false;
260 deltaU = solution[0] * node.scaleU;
deltaV = solution[1] * node.scaleV;
/**
* Check update step for being small enough
265 */
if( absVal( deltaU ) < RAYEPS && absVal( deltaV ) < RAYEPS )
{
// save hit point info
hitData−>hitU = u0;
270 hitData−>hitV = v0;
hitData−>distance = t0;
normalizeVector( n0, n0 );
if( dot_d_n > 0 ) negateVector( n0, hitData−>normal );
275 else hitData−>normal = n0;
#ifdef ITERATION_INFO
if( iCount > iterations )
{
280 iterations = iCount;
fprintf( stderr, "max iterations: %d\n", iCount );
}
#endif
return true;
285 }
290
// update parameters
u0 += deltaU;
v0 += deltaV;
/**
* Check parameters for being out of bounds
*/
if( u0 < node.domain[U_AXIS].lower )
295 {
if( secondTry ) break;
u0 = node.domain[U_AXIS].lower;
u_exceeds = true;
}
300 else if( u0 > node.domain[U_AXIS].upper )

{
305 }
if( secondTry ) break;
u0 = node.domain[U_AXIS].upper;
u_exceeds = true;
if( v0 < node.domain[V_AXIS].lower )
{
if( secondTry ) break;
310 v0 = node.domain[V_AXIS].lower;
v_exceeds = true;
}
else if( v0 > node.domain[V_AXIS].upper )
{
315 if( secondTry ) break;
v0 = node.domain[V_AXIS].upper;
v_exceeds = true;
}
320 // note exceedance for a second try
secondTry = (u_exceeds || v_exceeds);
u_exceeds = v_exceeds = false;
}
return false;
325 }
/* Build a hierarchical bounding volume
* used for intersection calulation.
*/
330 //****************************************
void FreeformSurface::buildSearchTree()
//****************************************
{
divCounter = 0;
335
// chop search tree may exist
if( searchTreeRoot != NULL )
{
chopSearchTree( searchTreeRoot );
340 searchTreeRoot = NULL;
}
// build new search tree
addToSearchTree( &searchTreeRoot, NULL, surfaceDomain );
345 divisions = divCounter;
}
/* Add bounding volume of surface to search tree.
*/
350 //******************************************************************************************************
bool FreeformSurface::addToSearchTree( TreeNode **nodeHook, TreeNode *parent, Interval nodeDomain[] )
//******************************************************************************************************
{
Axis divAxis;
355 Interval alpha[3];
Real realTmp;
360
// determine node destination
if( nodeHook == NULL ) nodeHook = &searchTreeRoot;
// hook new node into search tree
if( (*nodeHook = new TreeNode) != NULL )
{
TreeNode &node = **nodeHook;
365 unsigned int i, j;
// fill tree node
getBoundingVolume( &node, alpha );
node.domain[U_AXIS] = nodeDomain[U_AXIS];
370 node.domain[V_AXIS] = nodeDomain[V_AXIS];
node.left =
node.right = NULL;
node.parent = parent;
375 /**
* Enclose whole surface into octree box
*/
if( parent == NULL )
{
380 Interval surfaceRange[3];
Real component[3];
unsigned int coord;
// initialize intervals
385 for( coord = X; coord

for( coord = X; coord surfaceRange[coord].upper )
surfaceRange[coord].upper = component[coord];
}
}
410 // set corners of octree box
minCorner.x = surfaceRange[X].lower;
minCorner.y = surfaceRange[Y].lower;
minCorner.z = surfaceRange[Z].lower;
415 maxCorner.x = surfaceRange[X].upper;
maxCorner.y = surfaceRange[Y].upper;
maxCorner.z = surfaceRange[Z].upper;
}
420 /**
* Precalculate values needed during iteration
*/
node.scaleU = (nodeDomain[U_AXIS].upper − nodeDomain[U_AXIS].lower) /
(alpha[U_AXIS].upper − alpha[U_AXIS].lower);
425 node.scaleV = (nodeDomain[V_AXIS].upper − nodeDomain[V_AXIS].lower) /
(alpha[V_AXIS].upper − alpha[V_AXIS].lower);
for( i = 0; i < 3; ++i )
{
430 dotProduct( node.base[i], node.normal[i], realTmp );
node.baseNormalDomain[i].lower = realTmp * alpha[i].lower;
node.baseNormalDomain[i].upper = realTmp * alpha[i].upper;
}
435 /**
* Divide surface if not flat enough
*/
if( !isFlat( &divAxis ) )
{
440
#ifdef DEBUG_FULL
if( debugInfo != NULL )
{
fprintf( debugInfo, "\n" );
445 dumpControlPoints( debugInfo );
fprintf( debugInfo, "domain_u=[%.6f %.6f]; domain_v=[%.6f %.6f];\n",
node.domain[U_AXIS].lower, node.domain[U_AXIS].upper,
node.domain[V_AXIS].lower, node.domain[V_AXIS].upper );
fprintf( debugInfo, "base=[%.6f %.6f %.6f];\n",
450 node.baseVertex.x, node.baseVertex.y, node.baseVertex.z );
fprintf( debugInfo, "alpha0=[%.6f %.6f]; alpha1=[%.6f %.6f]; alpha2=[%.6f %.6f];\n",
alpha[0].lower, alpha[0].upper, alpha[1].lower,
alpha[1].upper, alpha[2].lower, alpha[2].upper );
fprintf( debugInfo, "n0=[%.6f %.6f %.6f]; n1=[%.6f %.6f %.6f]; n2=[%.6f %.6f %.6f];\ntileTester\n",
455 node.base[0].x, node.base[0].y, node.base[0].z,
node.base[1].x, node.base[1].y, node.base[1].z,
node.base[2].x, node.base[2].y, node.base[2].z );
}
#endif
460
465
470
FreeformSurface *subLeft = NULL, *subRight = NULL;
bool leftOK, rightOK;
Interval splitLeft, splitRight;
Interval save;
// half surface along determined axis
if( divCounter < SURFACE_MAX_DIVIDE && divide( divAxis, 0.5, &subLeft, &subRight ) )
{
divCounter++;
// determine subintervals
splitLeft.lower = nodeDomain[!divAxis].lower;
splitRight.upper = nodeDomain[!divAxis].upper;
splitLeft.upper =
475 splitRight.lower = 0.5 * (nodeDomain[!divAxis].lower + nodeDomain[!divAxis].upper);
save = nodeDomain[divAxis];
// add left subsurface to search tree
nodeDomain[!divAxis] = splitLeft;
480 leftOK = subLeft−>addToSearchTree( &node.left, *nodeHook, nodeDomain );
// add right subsurface to search tree
nodeDomain[divAxis] = save;
nodeDomain[!divAxis] = splitRight;
485 rightOK = subRight−>addToSearchTree( &node.right, *nodeHook, nodeDomain );
}
490
}
if( subLeft != NULL ) delete subLeft;
if( subRight != NULL ) delete subRight;
return ( leftOK && rightOK );
#ifdef DEBUG_FULL
495 else
{
if( debugInfo != NULL )
{
fprintf( debugInfo, "\n" );
500 dumpControlPoints( debugInfo );

fprintf( debugInfo, "domain_u=[%.6f %.6f]; domain_v=[%.6f %.6f];\n",
node.domain[U_AXIS].lower, node.domain[U_AXIS].upper,
node.domain[V_AXIS].lower, node.domain[V_AXIS].upper );
fprintf( debugInfo, "base=[%.6f %.6f %.6f];\n",
505 node.baseVertex.x, node.baseVertex.y, node.baseVertex.z );
fprintf( debugInfo, "alpha0=[%.6f %.6f]; alpha1=[%.6f %.6f]; alpha2=[%.6f %.6f];\n",
alpha[0].lower, alpha[0].upper, alpha[1].lower,
alpha[1].upper, alpha[2].lower, alpha[2].upper );
fprintf( debugInfo, "n0=[%.6f %.6f %.6f]; n1=[%.6f %.6f %.6f]; n2=[%.6f %.6f %.6f];\ntileTester\n",
510 node.base[0].x, node.base[0].y, node.base[0].z,
node.base[1].x, node.base[1].y, node.base[1].z,
node.base[2].x, node.base[2].y, node.base[2].z );
}
}
515 #endif
return true;
}
return false;
}
520
/* Dump control points of surface
*/
//******************************************************
525 void FreeformSurface::dumpControlPoints( FILE *fptr )
//******************************************************
{
unsigned int i, j;
fprintf( fptr, "PM(:,:,1)=[" );
530 for( i = 0; i

**
* Build auxiliary plane to determine
* control point’s distance to base parallelogram.
*/
605 Real n0, a0;
Real dst;
Real d_min = 0.0, d_max = 0.0;
610
dotProduct( nrml[2], E1, n0 );
// determine plane distance for all control points
for( i = 0; i planeNormal = &(volumeNode−>normal[min]);
volumeNode−>baseVertex = E1;
}
/* Delete search tree recursively.
685 */
//*******************************************************
void FreeformSurface::chopSearchTree( TreeNode *node )
//*******************************************************
{
690 if( node−>left != NULL ) chopSearchTree( node−>left );
if( node−>right != NULL ) chopSearchTree( node−>right );
delete node;
}

#ifndef __BEZIER_H
#define __BEZIER_H
#include
5 #include "Types.h"
/* The Bezier mixin class
*/
//***************
10 class Bezier {
//***************
public:
static unsigned int factorial( int x )
{
15 register unsigned int result = 1;
20
}
while(x > 1) result *= x−−;
return result;
static Real bernstein( unsigned int n, unsigned int i, Real t )
{
Real fn = factorial( n );
Real fni = factorial( n−i );
25 Real fi = factorial( i );
30 }
};
Real tmp = fn / (fni * fi);
return (tmp * pow((1.0−t),(n−i)) * pow(t,i));
#endif /* __BEZIER_H */

#ifndef __BEZIERCURVE_H
#define __BEZIERCURVE_H
#include "Bezier.h"
5 #include "SimpleList.h"
#include "Types.h"
/* The BezierCurve class
*/
10 //**************************************************************
class BezierCurve : public SimpleList, public Bezier {
//**************************************************************
public:
BezierCurve( int deg = −1 );
15 ~BezierCurve();
20
Point *newControlPoint() {
return SimpleList::append();
}
bool deleteControlPoint( unsigned int pos ) {
return SimpleList::deleteItem( pos );
}
25 void curvePoint( Real t, Point *pnt );
void divide( Real t, BezierCurve **subLeft, BezierCurve **subRight );
/**
* Curve analysis
30 */
int getDegree() {
return (SimpleList::length() − 1);
}
35 bool exceedingPoints();
bool signChanges();
Real maxPointDistance();
Real guessLength();
Real guessCurvature();
40
private:
// override for protection
Point *append() { return NULL; }
bool deleteItem( unsigned int pos ) { return false; }
45 unsigned int length() { return 0; }
50 };
// BezierCurve’s properties
BezierCurve *right;
BezierCurve *left;
#endif /* __BEZIERCURVE_H */

5
#include
#include "BezierCurve.h"
#include "utils.h"
/* Constructor
*/
//************************************
BezierCurve::BezierCurve( int deg )
10 //************************************
: SimpleList()
{
// initialize subcurve pointers
right =
15 left = NULL;
20
}
// initialize for degree may given
for(; deg > −1; −−deg ) newControlPoint();
/* Destructor
*/
//****************************
BezierCurve::~BezierCurve()
25 //****************************
{
// delete subcurves may exist ...
if( right != NULL ) delete right;
if( left != NULL ) delete left;
30 }
/* Determine curve point at t
*/
//***************************************************
35 void BezierCurve::curvePoint( Real t, Point *pnt )
//***************************************************
{
int degree = getDegree();
40 pnt−>x = pnt−>y = pnt−>z = 0.0;
for( int i = 0; i x += p.x * b;
pnt−>y += p.y * b;
pnt−>z += p.z * b;
/* Divide curve at t
*/
55 //**********************************************************************************
void BezierCurve::divide( Real t, BezierCurve **subLeft, BezierCurve **subRight )
//**********************************************************************************
{
Point *points;
60 int pointIndex = 0, i;
double t1 = 1.0 − t;
int degree = getDegree();
if( degree > 0 )
65 {
// check for existance of subcurves
// and their degree for being not equal.
if( left != NULL && left−>getDegree() != degree )
{
70 delete left, right;
left = right = NULL;
}
if( right == NULL ) right = new BezierCurve( degree );
75 if( left == NULL ) left = new BezierCurve( degree );
// allocate point list on stack
points = (Point *)alloca( (degree+1) * sizeof(Point) );
80 // fill list with control points
for( i = 0; i pointIndex; −−i )
{
points[i].x = t1 * points[i−1].x + t * points[i].x;
95 points[i].y = t1 * points[i−1].y + t * points[i].y;
points[i].z = t1 * points[i−1].z + t * points[i].z;
}
100 }
pointIndex++;

105
}
}
*subLeft = left;
*subRight = right;
/* Check curve for inner control points exceeding
* bounds of start and end
*/
//************************************
110 bool BezierCurve::exceedingPoints()
//************************************
{
bool exceedsLeft, exceedsRight;
Vector a, b, p;
115 Vector ab, ap, bp;
Real tmp;
int degree = getDegree();
if( degree > 1 )
120 {
a = (*this)[0];
b = (*this)[degree];
125
subVector( b, a, ab );
// check all intermediate points for
// lying beyond the bounds
for( int i = 1; i < degree; ++i )
{
130 p = (*this)[i];
135
subVector( p, a, ap );
dotProduct( ap, ab, tmp );
exceedsLeft = (tmp < 0 );
subVector( p, b, bp );
dotProduct( bp, ab, tmp );
exceedsRight = (tmp > 0 );
140 if( exceedsLeft || exceedsRight ) return true;
}
}
return false;
}
145
/* Check for sign change in curvature
*/
//********************************
bool BezierCurve::signChanges()
150 //********************************
{
Point a;
Vector ap, ab;
Vector n;
155 int i, sgn;
Real tmp = 0.0;
int degree = getDegree();
if( degree > 2 )
160 {
a = (*this)[0];
// create auxiliary plane
subVector( (*this)[degree], a, ab );
165 if( vectorLength( ab ) == 0.0 ) return false;
// make sure vector ap is
// not multiple of vector ab
for( i = 1; tmp == 0.0; ++i )
170 {
if( i == degree ) return false;
subVector( (*this)[i], a, ap );
crossProduct( ap, ab, n );
175 tmp = vectorLength( n );
}
crossProduct( n, ab, n );
// determine sign of the first
180 // intermediate control point
subVector( (*this)[1], a, ap );
dotProduct( n, ap, tmp );
sgn = (tmp >= 0.0);
185 // ... and compare with sign
// of remaining control points
for( i = 2; i < degree; ++i )
{
subVector( (*this)[i], a, ap );
190 dotProduct( n, ap, tmp );
if( (int)(tmp >= 0.0) ^ sgn )
return true;
}
}
195 return false;
}
/* Deterine maximum point distance from a line
* which is running from start point to end point
200 */

*************************************
Real BezierCurve::maxPointDistance()
//*************************************
{
205 Vector a, tmp;
Vector ab, ap;
Real abLen, dist;
Real maxDist = 0.0;
int degree = getDegree();
210
if( degree > 1 )
{
a = (*this)[0];
subVector( (*this)[degree], a, ab );
215 abLen = vectorLength( ab );
// determine maximum distance of intermediate
// control points to line between boundary points.
for( int i = 1; i < degree; ++i )
220 {
subVector( (*this)[i], a, ap );
if( abLen > 0.0 )
{
225 crossProduct( ap, ab, tmp );
dist = vectorLength( tmp ) / abLen;
}
else
dist = vectorLength( ap );
230
235 }
if( dist > maxDist ) maxDist = dist;
}
}
return maxDist;
/* Guess curve length
*/
//********************************
240 Real BezierCurve::guessLength()
//********************************
{
Real len = 0.0;
Vector ab;
245 int degree = getDegree();
for( int i = 1; i

#ifndef __BEZIERSURFACE_H
#define __BEZIERSURFACE_H
#include
5 #include "FreeformSurface.h"
#include "Bezier.h"
/* The BezierSurface class
*/
10 //**************************************************************
class BezierSurface : public FreeformSurface, public Bezier {
//**************************************************************
public:
BezierSurface( unsigned int _m, unsigned int _n );
15 ~BezierSurface() {}
private:
// implement methods expected by FreeformSurface
void surfacePoint( Real u, Real v, Point *pnt );
20 void surfaceGradients( Real u, Real v, Vector *gu, Vector *gv );
bool isFlat( Axis *divAxis );
bool divide( Axis a, Real t, FreeformSurface **left, FreeformSurface **right );
};
25 #endif /* __BEZIERSURFACE_H */

5
#include "BezierSurface.h"
#include "BezierCurve.h"
#include "utils.h"
/* Constructor
*/
//*****************************************************************
BezierSurface::BezierSurface( unsigned int _m, unsigned int _n )
10 //*****************************************************************
: FreeformSurface( _m, _n )
{
// set domain of u and v for bezier surfaces
surfaceDomain[U_AXIS].lower =
15 surfaceDomain[V_AXIS].lower = 0.0;
surfaceDomain[U_AXIS].upper =
surfaceDomain[V_AXIS].upper = 1.0;
}
20 /* Calculate a point on a bezier surface
*/
//***************************************************************
void BezierSurface::surfacePoint( Real u, Real v, Point *pnt )
//***************************************************************
25 { Real b_m, b_n;
Vector tmp;
// initialize result vector
30 *pnt = nullVector;
for( unsigned int i = 0; i

}
/* Test surface for being flat enough for iteration.
*/
105 //********************************************
bool BezierSurface::isFlat( Axis *divAxis )
//********************************************
{
unsigned int i, j;
110 Real curv, len;
bool exceedingPnt[2] = { false, false };
bool signChange[2] = { false, false };
Real maxCurvature[2] = { 1.0, 1.0 };
Real minLength[2] = { DBL_MAX, DBL_MAX };
115 Real maxLength[2] = { 0.0, 0.0 };
/**
* Check for control points
* exceeding base boundaries
120 */
BezierCurve uCurve( m );
BezierCurve vCurve( n );
// check curves running along u−axis
125 for( i = 0; i maxLength[U_AXIS] ) maxLength[U_AXIS] = len;
if( len < minLength[U_AXIS] ) minLength[U_AXIS] = len;
}
// check curves running along v−axis
145 for( i = 0; i maxLength[V_AXIS] ) maxLength[V_AXIS] = len;
if( len < minLength[V_AXIS] ) minLength[V_AXIS] = len;
}
// evaluate split criteria
165 Real lengthDiff[2];
Real aspectRatio[2];
if( maxLength[U_AXIS] > RAYEPS && maxLength[V_AXIS] > RAYEPS )
{
170 lengthDiff[U_AXIS] = maxLength[U_AXIS] − minLength[U_AXIS];
lengthDiff[V_AXIS] = maxLength[V_AXIS] − minLength[V_AXIS];
aspectRatio[U_AXIS] = maxLength[U_AXIS] / maxLength[V_AXIS];
aspectRatio[V_AXIS] = maxLength[V_AXIS] / maxLength[U_AXIS];
175 if( lengthDiff[U_AXIS] > lengthDiffLimit || lengthDiff[V_AXIS] > lengthDiffLimit )
{
*divAxis = (lengthDiff[U_AXIS] > lengthDiff[V_AXIS])? U_AXIS : V_AXIS;
return false;
}
180
if( aspectRatio[U_AXIS] < aspectRatioLimit || aspectRatio[V_AXIS] < aspectRatioLimit )
{
*divAxis = (aspectRatio[U_AXIS] < aspectRatio[V_AXIS])? U_AXIS : V_AXIS;
return false;
185 }
if( maxCurvature[U_AXIS] > curvatureLimit || maxCurvature[V_AXIS] > curvatureLimit )
{
*divAxis = (maxCurvature[U_AXIS] > maxCurvature[V_AXIS])? U_AXIS : V_AXIS;
190 return false;
}
if( exceedingPnt[U_AXIS] || signChange[U_AXIS] )
{
195 *divAxis = V_AXIS;
return false;
}
if( exceedingPnt[V_AXIS] || signChange[V_AXIS] )
200 {

}
}
205 return true;
}
*divAxis = U_AXIS;
return false;
/* Do a surface split along given axis at parameter t.
*/
210 //**********************************************************************************************************
bool BezierSurface::divide( Axis divAxis, Real t, FreeformSurface **subLeft, FreeformSurface **subRight )
//**********************************************************************************************************
{
unsigned int i, j;
215 BezierCurve *subCurveLeft, *subCurveRight;
*subLeft = new BezierSurface( m, n );
*subRight = new BezierSurface( m, n );
220 if( *subLeft == NULL || *subRight == NULL ) return false;
/**
* Split surface along u−axis.
*/
225 if( divAxis == U_AXIS )
{
BezierCurve tmpCurve( n );
for( i = 0; i

5
#ifndef __OCTREE_H
#define __OCTREE_H
#include "Types.h"
#define MAXSPLITLEVEL 4
#define MAXCELLOBJ 4
// forward declarations
10 struct __Node;
struct __ObjectHit;
class Model;
class Object;
15 typedef struct {
Vector min;
bool flag;
Object **objectList;
struct __Node *next;
20 //********
} Cell;
//********
typedef struct __Node {
25 Cell cell[8];
Real length;
Vector center;
//********
} Node;
30 //********
/* The Octree struct
*/
typedef struct __Octree {
35 Node root;
Node *curNode;
Byte curNum;
Vector plane;
40 Vector min;
Vector max;
Real minLength;
//**********
45 } Octree;
//**********
/* octree creation
*/
50 void initOctree( Octree *octree );
bool buildOctree( Model *model );
bool getNodeList( Object **objectList, Node *node, Byte cellNr, Object **tmpList );
void getNodeMinCorner( const Node &node, Byte cellNr, Vector *v );
void split( Octree *octree, Node *node, Byte level, Byte cellNr, Object **tmpList );
55
/* octree usage
*/
void findPoint( const Octree &octree, const Ray &ray, Vector *v );
bool octreeIntersect( Model *model, const Ray &ray, struct __ObjectHit *hit );
60 void nextPoint( const Octree &octree, const Ray &ray, Vector *v );
void findNode( Octree *octree, const Vector &point );
/* octree destruction
*/
65 void deleteOctree( struct __Octree *octree );
void clearNode( Node *node );
#endif /* __OCTREE_H */

#include
#include
#include
5 #include
#include "Octree.h"
#include "Object.h"
#include "Model.h"
#include "utils.h"
10
/* Initialize the octree
*/
//**********************************
void initOctree( Octree *octree )
15 //**********************************
{
// initialize root cells
for( unsigned int i = 0; i < 8; ++i )
{
20 octree−>root.cell[i].min = nullVector;
octree−>root.cell[i].flag = false;
octree−>root.cell[i].objectList = NULL;
octree−>root.cell[i].next = NULL;
}
25 octree−>root.length = 0.0;
octree−>root.center = nullVector;
octree−>curNode = NULL;
octree−>curNum = 0;
30 octree−>plane =
octree−>min =
octree−>max = nullVector;
octree−>minLength = 0.0;
}
35
/* Build the octree.
*/
//*********************************
bool buildOctree( Model *model )
40 //*********************************
{
Object **tmpList;
Object **objectList;
ObjectNode *curObj;
45 Octree *octree = model−>octree;
Node *root = &octree−>root;
unsigned int objects = model−>scene.numOfObjects;
unsigned int objInside;
unsigned int i;
50
fprintf( stdout, "building octree ... " );
if( (tmpList = new Object *[objects + 1]) != NULL )
{
55 root−>length = (octree−>max.x − octree−>min.x) / 2;
octree−>minLength = root−>length;
translateVector( octree−>min, root−>length, root−>center );
translateVector( octree−>max, RAYEPS, octree−>max );
60 translateVector( octree−>min, −RAYEPS, octree−>min );
curObj = model−>scene.objects;
// test all objects for being inside the cube ...
for( objInside = 0; curObj != NULL; curObj = curObj−>next )
65 if( curObj−>object−>test( octree−>min, octree−>max ) )
tmpList[objInside++] = curObj−>object;
70
// terminate list
tmpList[objInside] = NULL;
if( (objectList = new Object *[objInside + 1]) != NULL )
{
// copy all objects being inside the cube ...
for( i = 0; i cell[i].flag = false;
root−>cell[i].next = NULL;
if( getNodeList( objectList, root, i, tmpList ) )
{
85 if( root−>cell[i].flag )
split( octree, root, 1, i, tmpList );
}
else break;
}
90
}
octree−>minLength /= 2;
delete[] objectList;
95 delete[] tmpList;
// all cells OK?
return (i == 8);
}
100 return false;

}
/* Determines all objects enclosed by the cell specified by the
* parameters node and cellNr.
105 */
//***********************************************************************************
bool getNodeList( Object **objectList, Node *node, Byte cellNr, Object **tmpList )
//***********************************************************************************
{
110 unsigned int objInside;
Vector maxCorner;
Cell *curCell = &node−>cell[cellNr];
getNodeMinCorner( *node, cellNr, &curCell−>min );
115 translateVector( curCell−>min, node−>length, maxCorner );
// test all objects for being inside the cube ...
for( objInside = 0; *objectList != NULL; objectList++ )
if( (*objectList)−>test( curCell−>min, maxCorner ) )
120 tmpList[objInside++] = *objectList;
// terminate list
tmpList[objInside] = NULL;
125 if( (curCell−>objectList = new Object *[objInside + 1]) != NULL )
{
// copy all objects being inside the cube ...
for( register unsigned int i = 0; i objectList[i] = tmpList[i];
130
}
curCell−>flag = (objInside > MAXCELLOBJ);
return true;
135 return false;
}
/* Determines the corner of an octree cell starting
* at the smallest coordinates.
140 */
//******************************************************************
void getNodeMinCorner( const Node &node, Byte cellNr, Vector *v )
//******************************************************************
{
145 *v = node.center;
if( (cellNr == 0) || (cellNr == 2) || (cellNr == 4) || (cellNr == 6) )
v−>x −= node.length;
if( (cellNr == 2) || (cellNr == 3) || (cellNr == 6) || (cellNr == 7) )
v−>y −= node.length;
150 if( (cellNr == 4) || (cellNr == 5) || (cellNr == 6) || (cellNr == 7) )
v−>z −= node.length;
}
155 /* Splits a cell if it contains too many objects.
* The cell is specified by the parameters node and cellNr.
*/
//************************************************************************************
void split( Octree *octree, Node *node, Byte level, Byte cellNr, Object **tmpList )
160 //************************************************************************************
{
Node *newNode;
Cell *curCell = &node−>cell[cellNr];
unsigned int i;
165
if( level length = node−>length / 2;
translateVector( curCell−>min, newNode−>length, newNode−>center );
if( newNode−>length < octree−>minLength )
175 octree−>minLength = newNode−>length;
// create objectLists for cells
for( i = 0; i < 8; ++i )
{
180 newNode−>cell[i].flag = false;
newNode−>cell[i].next = NULL;
185 }
if( !getNodeList( curCell−>objectList, newNode, i, tmpList ) )
break;
// all cells OK?
if( i == 8 )
{
190 // hook new subnode
curCell−>next = newNode;
// delete old objectList
delete[] curCell−>objectList;
195 curCell−>objectList = NULL;
200
for( i = 0; i < 8; ++i )
if( newNode−>cell[i].flag )
split( octree, newNode, level + 1, i, tmpList );

205 }
}
210
}
}
return;
delete newNode;
curCell−>flag = false;
/* Determines the intersection point of a ray and the octree cube.
*/
//******************************************************************
void findPoint( const Octree &octree, const Ray &ray, Vector *v )
215 //******************************************************************
{
Real dist;
Real distMax = 0.0;
220 if( ray.direction.x != 0.0 )
{
dist = (octree.plane.x − ray.origin.x) / ray.direction.x;
if( dist > distMax ) distMax = dist;
}
225
if( ray.direction.y != 0.0 )
{
dist = (octree.plane.y − ray.origin.y) / ray.direction.y;
if( dist > distMax ) distMax = dist;
230 }
if( ray.direction.z != 0.0 )
{
dist = (octree.plane.z − ray.origin.z) / ray.direction.z;
235 if( dist > distMax ) distMax = dist;
}
240
}
rayPoint( ray, distMax, *v );
/* Determines the first object being intersected by a ray.
*/
//*********************************************************************
bool octreeIntersect( Model *model, const Ray &ray, ObjectHit *hit )
245 //*********************************************************************
{
Vector min;
Vector max;
Vector point;
250 Real distance;
bool hitsObject = false;
Octree *octree = model−>octree;
Object **curObj;
255 hit−>distance = DBL_MAX;
while( octree−>curNode != NULL && !hitsObject )
{
curObj = octree−>curNode−>cell[octree−>curNum].objectList;
260 while( *curObj != NULL )
{
model−>statistics.intersectionCnt++;
if( (*curObj)−>intersect( ray, &distance ) )
265 if( distance < hit−>distance )
{
rayPoint( ray, distance, point );
min = octree−>curNode−>cell[octree−>curNum].min;
translateVector( min, octree−>curNode−>length, max );
270
if( (point.x − RAYEPS = min.x) &&
(point.y − RAYEPS = min.y) &&
(point.z − RAYEPS = min.z) )
{
275 hitsObject = true;
hit−>object = *curObj;
hit−>distance = distance;
}
}
280
}
curObj++;
if( !hitsObject )
285 {
nextPoint( *octree, ray, &point );
findNode( octree, point );
}
}
290
}
return hitsObject;
/* Determines the point in which a ray is leaving the current cell.
295 */
//******************************************************************
void nextPoint( const Octree &octree, const Ray &ray, Vector *v )
//******************************************************************
{
300 Vector min;

305
Vector max;
Vector add = { 0.0, 0.0, 0.0 };
Real dist;
Real distMin = DBL_MAX;
min = octree.curNode−>cell[octree.curNum].min;
translateVector( min, octree.curNode−>length, max );
if( ray.direction.x != 0.0 )
310 if( ray.direction.x < 0.0 )
distMin = (min.x − ray.origin.x) / ray.direction.x;
else
distMin = (max.x − ray.origin.x) / ray.direction.x;
315 if( ray.direction.y != 0.0 )
if( ray.direction.y < 0.0 )
{
dist = (min.y − ray.origin.y) / ray.direction.y;
if( dist < distMin ) distMin = dist;
320 }
else
{
dist = (max.y − ray.origin.y) / ray.direction.y;
if( dist < distMin ) distMin = dist;
325 }
if( ray.direction.z != 0.0 )
if( ray.direction.z < 0.0 )
{
330 dist = (min.z − ray.origin.z) / ray.direction.z;
if( dist < distMin ) distMin = dist;
}
else
{
335 dist = (max.z − ray.origin.z) / ray.direction.z;
if( dist < distMin ) distMin = dist;
}
340
rayPoint( ray, distMin, *v );
if( (fabs( v−>x − min.x ) < RAYEPS) || (fabs( v−>x − max.x ) < RAYEPS) )
add.x = (ray.direction.x > 0.0)? octree.minLength : −octree.minLength;
if( (fabs( v−>y − min.y ) < RAYEPS) || (fabs( v−>y − max.y ) < RAYEPS) )
345 add.y = (ray.direction.y > 0.0)? octree.minLength : −octree.minLength;
if( (fabs( v−>z − min.z ) < RAYEPS) || (fabs( v−>z − max.z ) < RAYEPS) )
add.z = (ray.direction.z > 0.0)? octree.minLength : −octree.minLength;
350 addVector( *v, add, *v );
}
/* Determines the cell of the octree enclosing
* the point specified by the parameter p.
355 */
//*************************************************
void findNode( Octree *octree, const Vector &p )
//*************************************************
{
360 Node *node;
octree−>curNode = NULL;
if( (p.x >= octree−>min.x) && (p.x max.x) &&
365 (p.y >= octree−>min.y) && (p.y max.y) &&
(p.z >= octree−>min.z) && (p.z max.z) )
{
node = &octree−>root;
do
370 {
if( p.x > node−>center.x )
if( p.y > node−>center.y )
if( p.z > node−>center.z )
octree−>curNum = 1;
375 else
octree−>curNum = 5;
else
if( p.z > node−>center.z )
octree−>curNum = 3;
380 else
octree−>curNum = 7;
else
if( p.y > node−>center.y )
if( p.z > node−>center.z )
385 octree−>curNum = 0;
else
octree−>curNum = 4;
else
if( p.z > node−>center.z )
390 octree−>curNum = 2;
else
octree−>curNum = 6;
octree−>curNode = node;
395 node = node−>cell[octree−>curNum].next;
400
}
}
} while( node != NULL );

* Deletes an octree.
*/
//************************************
void deleteOctree( Octree *octree )
405 //************************************
{
clearNode( &octree−>root );
delete octree;
}
410
/* Clears a node and its subnodes.
* Deletes all objects hooked in list.
*/
//*****************************
415 void clearNode( Node *node )
//*****************************
{
for( unsigned int i = 0; i < 8; ++i )
{
420 if( node−>cell[i].next != NULL )
{
clearNode( node−>cell[i].next );
delete node−>cell[i].next;
}
425 else
delete[] node−>cell[i].objectList;
}
}

#ifndef __PARSER_H
#define __PARSER_H
#include
5 #include "Types.h"
#include "Scanner.h"
#include "Model.h"
#include "SimpleList.h"
#include "PatchBuffer.h"
10 #include "Object.h"
#include "PointMapper.h"
#include "Noise.h"
#include "Texture.h"
#include "BumpTexture.h"
15 #include "BitmapTexture.h"
#include "ReflectionTexture.h"
#include "CheckerTexture.h"
#include "BrickTexture.h"
#include "MarbleTexture.h"
20 #include "WoodTexture.h"
#define MAX_NESTING_DEPTH 10
#define MAX_TEX_CHNL 2
25 typedef enum {
// critical errors
NO_SCANNER, NO_MODEL,
NO_OCTREE, NO_LIGHT,
NO_OBJECT, NO_TEXTURE,
30 NO_DEFINITION, NO_INVERSE_MATRIX,
NO_PATCH, NO_BUFFER,
CRITICAL_ERRORS,
35 // parse errors
END_EXPECTED = CRITICAL_ERRORS,
NUMBER_EXPECTED, REAL_EXPECTED,
COORD_EXPECTED,
OBJECT_EXPECTED, MISSING_KEYWORD,
40 MISSING_FILENAME, FILE_NESTING_TOO_DEEP,
BAD_VECTOR, SYNTAX_ERROR,
MISSING_NAME, LIGHT_INTENSITY,
SECOND_COLOR_EXPECTED, SPHERE_RAD,
PLANE_DISTANCE, CYLINDER_RAD,
45 CYLINDER_HEIGHT, CONE_SML_RAD,
CONE_LRG_RAD, CONE_HEIGHT,
MATERIAL_NOT_DEFINED, TEXTURE_NOT_DEFINED,
COLOR_NOT_DEFINED, BUFFER_NOT_DEFINED,
ILLEGAL_DEFINITION, BAD_FORMAT,
50 NUMBER_OUT_OF_BOUNDS, NO_FILE,
NO_SUCH_VERTEX, MISSING_BRACE,
PARSE_ERRORS,
55 // warnings
OCTREE_FAILED = PARSE_ERRORS,
OCTREE_REDEFINITION, SKIP_REDEFINITION,
EMPTY_BUFFER,
60 NUMBER_OF_MESSAGES
//**************
} ParseError;
//**************
65 typedef struct {
Texture::ParseInfo texture;
BumpTexture::ParseInfo bump;
// parse buffer
70 Color color[MAX_TEX_CHNL];
Material material[MAX_TEX_CHNL];
// pointers for current buffer cell
unsigned int colPtr;
unsigned int matPtr;
75
// texture specific data
union {
BitmapTexture::ParseInfo bitmap;
ReflectionTexture::ParseInfo reflection;
80 CheckerTexture::ParseInfo checker;
BrickTexture::ParseInfo brick;
MarbleTexture::ParseInfo marble;
WoodTexture::ParseInfo wood;
};
85
90
Symbol textureType;
//***************
} TextureData;
//***************
// default texture data
extern const TextureData defaultTextureData;
//*****************************************
95 typedef SimpleList VertexBuffer;
//*****************************************
typedef struct __DefNode {
union {
100 Color colorDef;

TextureData textureDataDef;
Material materialDef;
PatchBuffer *patchBuffer;
VertexBuffer *vertexBuffer;
105 };
Symbol type;
110
// definition identifier
char *ident;
struct __DefNode *left;
struct __DefNode *right;
//***********
} DefNode;
115 //***********
/* The Parser class
*/
//***************
120 class Parser {
//***************
public:
Parser( const char *fileName, Model *modelPtr, FILE *logging = NULL, int nesting = 1,
DefNode **def_hook = NULL );
125 ~Parser();
private:
// functions parsing definitions
void getModel();
130 void getScene();
void getView();
void getOctree();
void getLights();
void getObjects();
135
// functions parsing substructures
void getPointLight( PointLight *pntLght );
void getSpotLight( SpotLight *spotLght );
void getObjectData( Object *object );
140 void getTransform( Matrix *transformMatrix );
void getTurbulence( Noise::Turbulence * );
void getMapData( PointMapper::ParseInfo *mapData );
// parsing functions for substructures supporting predefinition
145 void getMaterial( Material *material, bool useDef = false );
void getTextureData( TextureData *textureData, bool useDef = false );
void getVertex( VertexBuffer *vertexBuff, bool useDef = false );
void getPatch( PatchBuffer *patchBuff, bool useDef = false);
void getColor( Color *color, bool useDef = false);
150
// auxilliary parsing functions
Vector getVector();
Real getReal();
int getNumber( int lowerBound = 1, int upperBound = −1 );
155 Coordinate getCoordinate();
160
// initializing functions
void buildModel();
void buildTexture( Object *object, TextureData *texData );
// function handling warnings and errors
void Error( ParseError, const char *ext = NULL );
// functions handling predefinitions
165 void setDef( Symbol type, const char *ident, DefNode **root );
DefNode *getDef( Symbol type, const char *ident, DefNode **root );
void delDefs( DefNode *root );
170
static const char *errorMessage[NUMBER_OF_MESSAGES];
// Parser’s properties
Scanner *scan;
Model *model;
int nestingDepth;
175 DefNode *defTreeRoot;
DefNode **defHook;
180 };
// logging
FILE *log;
#endif /* __PARSER_H */

#include
#include
#include
5 #include "Parser.h"
#include "Model.h"
#include "Octree.h"
#include "shade.h"
#include "utils.h"
10
#include "Object.h"
#include "Sphere.h"
#include "Plane.h"
#include "Box.h"
15 #include "Cylinder.h"
#include "Cone.h"
#include "BezierSurface.h"
// initialize default texture data
20 const TextureData defaultTextureData = { Texture::defaultData, BumpTexture::defaultData,
{white, black}, {defaultMaterial, defaultMaterial}, 0, 0,
PointMapper::defaultData, BUMPSYM
};
25 /* Initialize error translation table
*/
//*********************************************************
const char *Parser::errorMessage[NUMBER_OF_MESSAGES] = {
//*********************************************************
30 // critical errors
"Scanner not availible", "Can’t build model",
"Can’t build octree", "Can’t build light",
"Can’t build object", "Can’t build texture",
"Can’t build definition", "Can’t build inverse of transformation matrix",
35 "Can’t get patch", "Can’t get buffer",
// parse errors
"END expected",
"Number expected", "Real number expected",
40 "Coordinate expected",
"Object expected", "Missing keyword",
"Missing filename", "File nesting too deep",
"Bad vector", "Syntax error",
"Missing name", "Light intensity exprected",
45 "Second color definition expected", "Sphere radius expected",
"Plane distance expected", "Cylinder radius expected",
"Cylinder height expected", "Small cone radius expected",
"Large cone radius expected", "Cone height expected",
"Material not defined:", "Texture not defined:",
50 "Color not defined:", "Buffer not defined:",
"Invalid type in definition", "Bad format",
"Number out of bounds", "Can’t open file",
"No such vertex", "Missing curly brace",
55 // warnings
"failed building octree − using default intersection",
"octree redefinition − skip", "try to skip redefinition of",
"empty buffer"
};
60
/* Constructor
*/
//********************************************************************************************************
Parser::Parser( const char *fileName, Model *modelPtr, FILE *logging, int nesting, DefNode **def_hook )
65 //********************************************************************************************************
{
model = modelPtr;
nestingDepth = nesting;
defTreeRoot = NULL;
70 log = logging;
// disable buffering of stdout
setvbuf( stdout, NULL, _IONBF, 0 );
75 defHook = (def_hook == NULL)? &defTreeRoot : def_hook;
if( (scan = new Scanner( fileName )) == NULL )
Error( NO_SCANNER );
else
80 scan−>getSymbol();
85
}
fprintf( stdout, "parsing file ’%s’ ... \n", fileName );
// parse model definition
getModel();
// do initialization
buildModel();
90 /* Destructor
*/
//******************
Parser::~Parser()
//******************
95 { if( scan != NULL ) delete scan;
100 }
if( defTreeRoot != NULL )
delDefs( defTreeRoot );

* Starting point for recursive descent parsing
* of the scene definition file.
* | |
105 */
//************************
void Parser::getModel()
//************************
{
110 Symbol symbl;
Parser *subParser;
while( scan−>sym != EOFSYM )
{
115 switch( scan−>sym )
{
// := include
case INCLUDESYM: scan−>getSymbol();
// get include file
120 if( scan−>sym != STRINGSYM ) Error( MISSING_FILENAME );
)
if( nestingDepth < MAX_NESTING_DEPTH &&
(subParser=new Parser(scan−>string, model, log, nestingDepth+1, defHook))!=NULL
delete subParser;
125 else
Error( FILE_NESTING_TOO_DEEP );
130
scan−>getSymbol();
break;
// := def { ... definition ... }
case DEFSYM: scan−>getSymbol();
symbl = scan−>sym;
135 // get identifier
scan−>getSymbol();
if( scan−>sym != STRINGSYM ) Error( MISSING_NAME );
// set definition
140 setDef( symbl, scan−>string, defHook );
break;
// := scene { ... definition ... }
case SCENESYM: scan−>getSymbol();
145 getScene();
break;
150 }
}
}
default: Error( SYNTAX_ERROR );
/* Parse scene definition
* scene { | | | }
155 */
//************************
void Parser::getScene()
//************************
{
160 // check for scene block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
165 while( scan−>sym != CURLBRACERIGHT )
{
switch( scan−>sym )
{
// := view { ... definition ... }
170 case VIEWSYM: scan−>getSymbol();
getView();
break;
// := objects { ... definition ... }
175 case OBJECTSSYM: scan−>getSymbol();
getObjects();
break;
// := octree { ... definition ... }
180 case OCTREESYM: scan−>getSymbol();
getOctree();
break;
// := lights { ... definition ... }
185 case LIGHTSSYM: scan−>getSymbol();
getLights();
break;
default: Error( SYNTAX_ERROR );
190 }
}
// skip right curly brace
scan−>getSymbol();
}
195
/* Parse point of view definition
* := view { | | | | }
*/
//***********************

200 void Parser::getView()
//***********************
{
// check for view block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
205 // ... and skip
scan−>getSymbol();
while( scan−>sym != CURLBRACERIGHT )
{
210 switch( scan−>sym )
{
// := location
case LOCATIONSYM: scan−>getSymbol();
model−>scene.view.location = getVector();
215 break;
// := direction
case DIRECTIONSYM: scan−>getSymbol();
model−>scene.view.direction = getVector();
220 break;
// := up
case UPSYM: scan−>getSymbol();
model−>scene.view.up = getVector();
225 break;
// := right
case RIGHTSYM: scan−>getSymbol();
model−>scene.view.right = getVector();
230 break;
// := supersample
case SUPERSAMPLESYM: scan−>getSymbol();
if( scan−>sym != TRUESYM && scan−>sym != FALSESYM )
235 Error( MISSING_KEYWORD, "for mode: [true, false]" );
model−>scene.view.superSampling = (scan−>sym == TRUESYM);
scan−>getSymbol();
break;
240 default: Error( SYNTAX_ERROR );
}
}
// skip right curly brace
scan−>getSymbol();
245 }
/* Parse octree definition
* := octree { | }
*/
250 //*************************
void Parser::getOctree()
//*************************
{
Real size = 0.0;
255 Vector min = nullVector;
// check for octree block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
260 scan−>getSymbol();
while( scan−>sym != CURLBRACERIGHT )
{
switch( scan−>sym )
265 {
// := size
case SIZESYM: scan−>getSymbol();
size = getReal();
break;
270
275
// := location
case LOCATIONSYM: scan−>getSymbol();
min = getVector();
break;
default: Error( SYNTAX_ERROR );
}
}
// skip right curly brace
280 scan−>getSymbol();
// return on illegal size
if( size octree == NULL )
{
if( (model−>octree = new Octree) == NULL ) Error( NO_OCTREE );
initOctree( model−>octree );
290 model−>octree−>min = min;
translateVector( min, size, model−>octree−>max );
295 }
}
else Error( OCTREE_REDEFINITION );
/* Parse lights block
* := lights { | }
*/

300 //*************************
void Parser::getLights()
//*************************
{
Light *curLight;
305
310
315
// check for light block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
// get all light sources
while( scan−>sym != CURLBRACERIGHT )
{
if( (curLight = model−>addLight()) == NULL ) Error( NO_LIGHT );
switch( scan−>sym )
{
// := point { ... definition ... }
case POINTSYM: scan−>getSymbol();
320 getPointLight( (PointLight *)curLight );
break;
// := spot { ... definition ... }
case SPOTSYM: scan−>getSymbol();
325 getSpotLight( (SpotLight *)curLight );
break;
default: Error( SYNTAX_ERROR, "[illegal light source]");
}
330 }
// skip right curly brace
scan−>getSymbol();
}
335 /* Parse point light definition
* := point { (color) | | }
*/
//************************************************
void Parser::getPointLight( PointLight *light )
340 //************************************************
{
bool useDef;
// check for point light block begin ...
345 if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
// initialize
350 light−>location = nullVector;
light−>color = white;
// get point light data
while( scan−>sym != CURLBRACERIGHT )
355 {
// := use color
if( (useDef = (scan−>sym == USESYM)) )
{
scan−>getSymbol();
360 if( scan−>sym != COLORSYM ) Error( SYNTAX_ERROR, "[illegal use]" );
}
switch( scan−>sym )
{
365 // := color { ... definition ... }
case COLORSYM: scan−>getSymbol();
getColor( &light−>color, useDef );
break;
370 // := location
case LOCATIONSYM: scan−>getSymbol();
light−>location = getVector();
break;
375 default: Error( SYNTAX_ERROR );
}
}
// skip right curly brace
scan−>getSymbol();
380
}
light−>type = POINTLIGHT;
/* Parse spot light definition
385 * := spot { (color) | | | | }
*/
//**********************************************
void Parser::getSpotLight( SpotLight *light )
//**********************************************
390 {
bool useDef;
Real angle;
// check for spot light block begin ...
395 if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
// initialize with default

400 light−>location = nullVector;
light−>color = white;
light−>direction = baseVector[Z];
light−>spotBound = 0.0; // cosine of half of beam spread (here: 90 degrees)
405 // get all light sources
while( scan−>sym != CURLBRACERIGHT )
{
// := use color
if( (useDef = (scan−>sym == USESYM)) )
410 {
scan−>getSymbol();
if( scan−>sym != COLORSYM ) Error( SYNTAX_ERROR, "[illegal use]" );
}
415 switch( scan−>sym )
{
// := color { ... definition ... }
case COLORSYM: scan−>getSymbol();
getColor( &light−>color, useDef );
420 break;
// := location
case LOCATIONSYM: scan−>getSymbol();
light−>location = getVector();
425 break;
// := direction
case DIRECTIONSYM: scan−>getSymbol();
light−>direction = getVector();
430 normalizeVector( light−>direction, light−>direction );
// negate vector for faster calulation at run time
// [q.v.] shade.cpp −> shadowTest()
negateVector( light−>direction, light−>direction );
435 break;
// := angle [0,180]
case ANGLESYM: scan−>getSymbol();
angle = getReal();
440 if( angle < 0.0 || angle > 180.0 )
Error( NUMBER_OUT_OF_BOUNDS, "[0 180]" );
// determine spot bound
light−>spotBound = cos( DEGToRAD( angle / 2.0 ) );
445 break;
default: Error( SYNTAX_ERROR );
}
}
450 // skip right curly brace
scan−>getSymbol();
455
}
light−>type = SPOTLIGHT;
/* Parse objects block
* := objects { | | | | | | }
*/
//**************************
460 void Parser::getObjects()
//**************************
{
Symbol objType;
Vector size;
465 Object *curObject, *prototype;
VertexBuffer vertexBuff;
PatchBuffer patchBuff;
PatchItem patchItem;
470 unsigned int i, j, vertexIdx;
char msgBuff[30];
bool useDef;
PatchBuffer::iterator it;
475 // check for objects block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
480 // get all objects of scene
while( scan−>sym != CURLBRACERIGHT )
{
objType = scan−>sym;
scan−>getSymbol();
485
490
// check for object begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
switch( objType )
{
// := sphere { }
case SPHERESYM: curObject = new Sphere( /*size.x*/ );
495 break;
// := cone { size }
case CONESYM: // check for keyword ’size’ ...
if( scan−>sym != SIZESYM ) Error( MISSING_KEYWORD, "’size’" );

500 // ... and skip
scan−>getSymbol();
size.x = getReal();
size.y = getReal();
size.z = getReal();
505 curObject = new Cone( size.x, size.y, size.z );
break;
// := cylinder { }
case CYLINDERSYM: curObject = new Cylinder();
510 break;
515
// := box { }
case BOXSYM: curObject = new Box();
break;
// := plane { }
case PLANESYM: curObject = new Plane();
break;
520 // := bezier { (vertex) | vertex (patch) | patch }
case BEZIERSYM: if( (useDef = (scan−>sym == USESYM)) ) scan−>getSymbol();
if( scan−>sym != VERTEXSYM ) Error( MISSING_KEYWORD, "’vertex’" );
scan−>getSymbol();
vertexBuff.clear();
525 getVertex( &vertexBuff, useDef );
if( (useDef = (scan−>sym == USESYM)) ) scan−>getSymbol();
if( scan−>sym != PATCHSYM ) Error( MISSING_KEYWORD, "’patch’" );
scan−>getSymbol();
530 patchBuff.clear();
getPatch( &patchBuff, useDef );
535
// check patchbuffer
if( !(it = patchBuff.begin()).isOK() ) Error( NO_OBJECT, "[no patch]" );
// ititialize pointer to first bezierobject
prototype = NULL;
/**
540 * Create bezier surfaces
*/
do {
patchItem = it.get();
545 // alloc new bezier surface ...
curObject = new BezierSurface( patchItem.size.m − 1, patchItem.size.n − 1 );
if( curObject == NULL ) Error( NO_OBJECT );
// ... and fill with control points got from vertex buffer
550 for( i = 0; i < patchItem.size.m; ++i )
for( j = 0; j < patchItem.size.n; ++j )
{
// get vertex number from patch
vertexIdx = patchItem.patchData[i * patchItem.size.m + j];
555
// set vertex if number is valid
if( vertexIdx > 0 && vertexIdx sym != CURLBRACERIGHT ) Error( MISSING_BRACE );
scan−>getSymbol();
580 }
else
{ // copy data from prototype
curObject−>ambience = prototype−>ambience;
curObject−>texture = prototype−>texture;
585 curObject−>toObject = prototype−>toObject;
curObject−>toWorld = prototype−>toWorld;
// register texture reference
curObject−>texture−>registerHandle();
}
590
/**
* Build search tree
*/
if( log != NULL )
595 fprintf( log, "build search tree for patch %d ... ", it.getPos() + 1 );
((BezierSurface *)curObject)−>buildSearchTree();
if( log != NULL )

600 fprintf( log, "OK (%d divisions)\n",
((BezierSurface *)curObject)−>getDivisions() );
// add object to model
if( !model−>addObject( curObject ) )
605 {
delete curObject;
Error( NO_OBJECT );
}
} while( it.next() );
610 continue;
// := csg { ... definition ... }
case CSGSYM: break; // TODO: CSG object combination
615 default: Error( SYNTAX_ERROR, "[no such object]" );
}
if( curObject == NULL ) Error( NO_OBJECT );
620 // get generic object data
getObjectData( curObject );
// skip right curly brace − one object’s end
if( scan−>sym != CURLBRACERIGHT ) Error( MISSING_BRACE );
625 scan−>getSymbol();
// add object to model
if( !model−>addObject( curObject ) )
{
630 delete curObject;
Error( NO_OBJECT );
}
}
// skip right curly brace − objects block end
635 scan−>getSymbol();
}
/* Parse object data
* := (texture) | | |
640 */
//*********************************************
void Parser::getObjectData( Object *object )
//*********************************************
{
645 TextureData textureData = defaultTextureData; // initialize data buffer
bool objectDataEnd = false;
while( scan−>sym != CURLBRACERIGHT )//!objectDataEnd )
{
650 switch( scan−>sym )
{
// := use (texture)
case USESYM: scan−>getSymbol();
switch( scan−>sym )
655 {
case TEXTURESYM: scan−>getSymbol();
getTextureData( &textureData, true );
break;
660 default: Error( SYNTAX_ERROR, "[illegal use]" );
}
break;
// := ambience
665 case AMBIENCESYM: scan−>getSymbol();
for( const ColorChannel *i = RGBfirst; *i != ALPHA; i++ )
object−>ambience.channel[*i] = getReal();
break;
670 // := transform { ... definition ... }
case TRANSFORMSYM: scan−>getSymbol();
getTransform( &object−>toObject );
break;
675 // := texture { ... definition ... }
case TEXTURESYM: scan−>getSymbol();
getTextureData( &textureData );
break;
680 default: Error( SYNTAX_ERROR, "[illegal object data]" ); //objectDataEnd = true;
}
}
// evaluate inverse matrix
685 if( !invertMatrix( object−>toObject, &object−>toWorld ) )
Error( NO_INVERSE_MATRIX );
690 }
// hook appropriate texture object
buildTexture( object, &textureData );
/* Parse transformation block
* := transform { | | | }
695 */
//*****************************************************
void Parser::getTransform( Matrix *transformMatrix )
//*****************************************************
{

700 Vector vec;
Real sh1, sh2;
Coordinate coord;
// check for transform block begin ...
705 if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
while( scan−>sym != CURLBRACERIGHT )
710 {
switch( scan−>sym )
{
// := move
case MOVESYM: scan−>getSymbol();
715 vec = getVector();
negateVector( vec, vec );
translateMatrix( transformMatrix, vec );
break;
720 // := rotate
// . o O (rotate about − in this order!)
case ROTATESYM: scan−>getSymbol();
vec = getVector();
negateVector( vec, vec );
725 rotateMatrix( transformMatrix, vec );
break;
// := scale
// . o O (scale axis’ at )
730 case SCALESYM: scan−>getSymbol();
vec = getVector();
vec.x = (vec.x != 0.0)? 1.0 / vec.x : 1.0;
vec.y = (vec.y != 0.0)? 1.0 / vec.y : 1.0;
vec.z = (vec.z != 0.0)? 1.0 / vec.z : 1.0;
735 scaleMatrix( transformMatrix, vec );
break;
// := shear
case SHEARSYM: scan−>getSymbol();
740 coord = getCoordinate();
sh1 = getReal();
sh2 = getReal();
shearMatrix( transformMatrix, coord, sh1, sh2 );
break;
745
default: Error( SYNTAX_ERROR, "[illegal transformation]" );
}
}
// skip right curly brace
750 scan−>getSymbol();
}
/* Parse material definition
* := material { | | | | |
755 | }
*/
//************************************************************
void Parser::getMaterial( Material *material, bool useDef )
//************************************************************
760 { Real realVal;
DefNode *defMaterial;
Material tmp;
Material *materialPtr = (material == NULL)? &tmp : material;
765 const ColorChannel *i;
770
if( useDef )
{
if( scan−>sym != STRINGSYM ) Error( MISSING_NAME );
// try to get material from definition tree
if( (defMaterial = getDef( MATERIALSYM, scan−>string, defHook )) == NULL )
Error( MATERIAL_NOT_DEFINED, scan−>string );
775 *materialPtr = defMaterial−>materialDef;
scan−>getSymbol();
}
else
{
780 if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
scan−>getSymbol();
while( scan−>sym != CURLBRACERIGHT )
{
785 switch( scan−>sym )
{
// := ambient
case AMBIENTSYM: scan−>getSymbol();
for( i = RGBfirst; *i != ALPHA; i++ )
790 {
realVal = getReal();
if( realVal > 1.0 ) realVal = 1.0;
if( realVal < 0.0 ) realVal = 0.0;
materialPtr−>ambient.channel[*i] = realVal;
795 }
break;
// := diffuse
case DIFFUSESYM: scan−>getSymbol();

800 for( i = RGBfirst; *i != ALPHA; i++ )
{
realVal = getReal();
if( realVal > 1.0 ) realVal = 1.0;
if( realVal < 0.0 ) realVal = 0.0;
805 materialPtr−>diffuse.channel[*i] = realVal;
}
break;
// := specular
810 case SPECULARSYM: scan−>getSymbol();
for( i = RGBfirst; *i != ALPHA; i++ )
{
realVal = getReal();
if( realVal > 1.0 ) realVal = 1.0;
815 if( realVal < 0.0 ) realVal = 0.0;
materialPtr−>specular.channel[*i] = realVal;
}
break;
820 // := specularExp
case SPECULAREXPSYM: scan−>getSymbol();
realVal = getReal();
if( realVal < 1.0 ) realVal = 1.0;
materialPtr−>specularExp = realVal;
825 break;
// := reflect
case REFLECTSYM: scan−>getSymbol();
realVal = getReal();
830 if( realVal > 1.0 ) realVal = 1.0;
if( realVal < 0.0 ) realVal = 0.0;
materialPtr−>reflect = realVal;
break;
835 // := transparency
case TRANSPARENCYSYM: scan−>getSymbol();
realVal = getReal();
if( realVal > 1.0 ) realVal = 1.0;
if( realVal < 0.0 ) realVal = 0.0;
840 materialPtr−>transparency = realVal;
break;
// := index
case INDEXSYM: scan−>getSymbol();
845 realVal = getReal();
if( realVal < 1.0 ) realVal = 1.0;
materialPtr−>refractIndex = realVal;
break;
850 default: Error( SYNTAX_ERROR, "[illegal material data]" );
}
}
// skip right curly brace
scan−>getSymbol();
855 }
}
/* Parse texture data
* := texture { (color | material) | | | | | |
860 * | | | | | }
*/
//*********************************************************************
void Parser::getTextureData( TextureData *textureData, bool useDef )
//*********************************************************************
865 { DefNode *defTextureData;
TextureData tmp;
TextureData *textureDataPtr = (textureData == NULL)? &tmp : textureData;
Symbol symbl;
870 Vector size;
875
if( useDef )
{
if( scan−>sym != STRINGSYM ) Error( MISSING_NAME );
// try to get texture data from definition tree
if( (defTextureData = getDef( TEXTURESYM, scan−>string, defHook )) == NULL )
Error( TEXTURE_NOT_DEFINED, scan−>string );
880 *textureDataPtr = defTextureData−>textureDataDef;
scan−>getSymbol();
}
else
{
885 // check for texture block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
890 while( scan−>sym != CURLBRACERIGHT )
{
symbl = scan−>sym;
scan−>getSymbol();
895 // check for texture modifier begin ...
switch( symbl )
{
case BUMPSYM: case BITMAPSYM: case REFLECTIONSYM:
case CHECKERSYM: case BRICKSYM: case MARBLESYM: case WOODSYM:

900 // ... and skip
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
scan−>getSymbol();
905 }
default: break;
// check for size of some texture types
switch( symbl )
{
910 case BUMPSYM: case CHECKERSYM: case BRICKSYM: case WOODSYM:
915 default: break;
}
if( scan−>sym != SIZESYM ) Error( MISSING_KEYWORD, "’size’" );
scan−>getSymbol();
switch( symbl )
{
920 // := use (material | color)
case USESYM: //scan−>getSymbol();
switch( scan−>sym )
{
case MATERIALSYM:
925 scan−>getSymbol();
getMaterial(&(textureDataPtr−>material[textureDataPtr−>matPtr]),true
);
textureDataPtr−>matPtr = (textureDataPtr−>matPtr+1)%MAX_TEX_CHNL;
break;
930 case COLORSYM:
scan−>getSymbol();
getColor( &(textureDataPtr−>color[textureDataPtr−>colPtr]), true );
textureDataPtr−>colPtr = (textureDataPtr−>colPtr+1)%MAX_TEX_CHNL;
break;
935
default: Error( SYNTAX_ERROR, "[illegal use]" );
}
break;
940 case MATERIALSYM: //scan−>getSymbol();
getMaterial( &(textureDataPtr−>material[textureDataPtr−>matPtr]) );
textureDataPtr−>matPtr = (textureDataPtr−>matPtr+1)%MAX_TEX_CHNL;
break;
945 case COLORSYM: //scan−>getSymbol();
getColor( &(textureDataPtr−>color[textureDataPtr−>colPtr]) );
textureDataPtr−>colPtr = (textureDataPtr−>colPtr+1)%MAX_TEX_CHNL;
break;
950 // . o O (texture transformations)
// := transform { ... definition ... }
case TRANSFORMSYM: getTransform( &textureDataPtr−>texture.transform );
break;
955 // . o O (color turbulence)
// := turbulence { ... definition ... }
case TURBULENCESYM: getTurbulence( &textureDataPtr−>texture.turbulence );
break;
960 // . o O (bump mapping)
// := bump { size [] [] }
case BUMPSYM: textureDataPtr−>bump.bumpSize = getReal();
if( scan−>sym == FILESYM )
965 getMapData( &textureDataPtr−>bump.mapperInfo );
if( scan−>sym == TURBULENCESYM )
{
scan−>getSymbol();
970 getTurbulence( &textureDataPtr−>bump.turbulence );
}
break;
975 /**
* Textures
*/
// := bitmap { }
case BITMAPSYM: getMapData( &textureDataPtr−>bitmap );
980 textureDataPtr−>textureType = BITMAPSYM;
break;
// := reflection { }
case REFLECTIONSYM: getMapData( &textureDataPtr−>reflection );
985 textureDataPtr−>textureType = REFLECTIONSYM;
break;
// := checker { size ’X’ ’Y’ }
case CHECKERSYM: // get checker size
990 textureDataPtr−>checker.checkerSize = absVal( getReal() );
if( scan−>sym != XSYM ) Error( COORD_EXPECTED, "{X}" );
scan−>getSymbol();
textureDataPtr−>checker.quota[X] = absVal( getReal() );
if( scan−>sym != YSYM ) Error( COORD_EXPECTED, "{Y}" );
995 scan−>getSymbol();
textureDataPtr−>checker.quota[Y] = absVal( getReal() );
textureDataPtr−>textureType = CHECKERSYM;

1000
break;
// := brick { size }
case BRICKSYM: // get brick size
if( (size.x = getReal()) sym != TURBULENCESYM ) Error( MISSING_KEYWORD, "’turbulence’" );
scan−>getSymbol();
getTurbulence( &textureDataPtr−>marble.turbulence );
textureDataPtr−>textureType = MARBLESYM;
break;
// := wood { size }
1020 case WOODSYM: // get wood sharpness
textureDataPtr−>wood.sharpness = getReal();
if( scan−>sym != TURBULENCESYM ) Error( MISSING_KEYWORD, "’turbulence’" );
scan−>getSymbol();
getTurbulence( &textureDataPtr−>wood.turbulence );
1025
1030 }
textureDataPtr−>textureType = WOODSYM;
break;
default: Error( SYNTAX_ERROR, "[illegal texture data]" );
// check for texture’s block end
switch( symbl )
{
1035 case BUMPSYM: case BITMAPSYM: case REFLECTIONSYM:
case CHECKERSYM: case BRICKSYM: case MARBLESYM: case WOODSYM:
// skip right curly brace
if( scan−>sym != CURLBRACERIGHT ) Error( MISSING_BRACE );
1040 scan−>getSymbol();
default: break;
}
}
1045 // skip right curly brace
scan−>getSymbol();
}
}
1050 /* Parse vertex block
* := vertex { ( | ) ... }
*/
//****************************************************************
void Parser::getVertex( VertexBuffer *vertexBuff, bool useDef )
1055 //****************************************************************
{
int fileVertices;
char msgBuff[25];
Vector vertex;
1060 FILE *vertexFile;
DefNode *defVtxBuff;
if( useDef )
{
1065 if( scan−>sym != STRINGSYM ) Error( MISSING_NAME );
1070
// try to get vertexbuffer from definition tree
if( (defVtxBuff = getDef( VERTEXSYM, scan−>string, defHook )) == NULL )
Error( BUFFER_NOT_DEFINED, scan−>string );
// copy content of referenced vertexbuffer
if( defVtxBuff−>vertexBuffer−>length() && vertexBuff != NULL )
{
VertexBuffer::iterator it = defVtxBuff−>vertexBuffer−>begin();
1075 do{
*(vertexBuff−>append()) = it.get();
} while( it.next() );
}
scan−>getSymbol();
1080 }
else
{
// check for vertex block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
1085 // ... and skip
scan−>getSymbol();
while( scan−>sym != CURLBRACERIGHT )
{
1090 if( scan−>sym == FILESYM )
{ // get vertex definition from file
scan−>getSymbol();
if( scan−>sym != STRINGSYM ) Error( MISSING_FILENAME );
1095 if( vertexBuff != NULL )
{
// try to open vertex file
if( (vertexFile = fopen( scan−>string, "r")) == NULL ) Error( NO_FILE, scan−>string );

1100 if( log != NULL )
fprintf( log, "import vertices from file ’%s’ ... ", scan−>string );
/**
* Read vertices from file
1105 */
for( fileVertices = 0; !feof( vertexFile ); ++fileVertices )
{
if( fscanf( vertexFile, " %lf %lf %lf ", &vertex.x, &vertex.y, &vertex.z ) < 3 )
{
1110 snprintf( msgBuff, 25, "[%d vertices ok]", fileVertices );
fprintf( stderr, "\n\t" );
Error( BAD_FORMAT, msgBuff );
}
// save vertex
1115 *(vertexBuff−>append()) = vertex;
}
fclose( vertexFile );
if( log != NULL )
1120 fprintf( log, "got %d vertices\n", fileVertices );
}
// skip filename
scan−>getSymbol();
}
1125 else if( scan−>sym == LSS )
{ // get vertex definition
if( vertexBuff != NULL )
*(vertexBuff−>append()) = getVector();
else
1130 getVector();
}
else
Error( SYNTAX_ERROR );
}
1135 // skip right curly brace
scan−>getSymbol();
}
if( vertexBuff != NULL && vertexBuff−>length() == 0 )
Error( EMPTY_BUFFER, "[vertex]" );
1140 }
/* Parse patch block
* := patch { size ( | ’’) }
*/
1145 //*************************************************************
void Parser::getPatch( PatchBuffer *patchBuff, bool useDef )
//*************************************************************
{
int nrVertices, i;
1150 int filePatches;
char msgBuff[60];
FILE *patchFile;
Patch curPatch;
PatchSize patchSize;
1155 DefNode *defPchBuff;
1160
if( useDef )
{
if( scan−>sym != STRINGSYM ) Error( MISSING_NAME );
// try to get patchbuffer from definition tree
if( (defPchBuff = getDef( PATCHSYM, scan−>string, defHook )) == NULL )
Error( BUFFER_NOT_DEFINED, scan−>string );
1165 // copy content of referenced patchbuffer
patchBuff−>appendPatchBuffer( defPchBuff−>patchBuffer );
scan−>getSymbol();
}
1170 else
{
// check for patch block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
1175 scan−>getSymbol();
while( scan−>sym != CURLBRACERIGHT )
{
if( scan−>sym != SIZESYM ) Error( MISSING_KEYWORD, "’size’" );
1180 scan−>getSymbol();
// get patch dimensions
patchSize.m = getNumber( 1, SURFACE_MAX_DEGREE );
patchSize.n = getNumber( 1, SURFACE_MAX_DEGREE );
1185 nrVertices = patchSize.m * patchSize.n;
if( patchSize.m > patchSize.n )
swapXOR( patchSize.m, patchSize.n );
/**
1190 * Get patches from file
*/
if( scan−>sym == FILESYM )
{
scan−>getSymbol();
1195 if( scan−>sym != STRINGSYM ) Error( MISSING_FILENAME );
if( patchBuff != NULL )
{

try to open patch file
1200 if( (patchFile = fopen( scan−>string, "r")) == NULL )
Error( NO_FILE, scan−>string );
1205
if( log != NULL )
fprintf( log, "import patches from file ’%s’ ... ", scan−>string );
// read patches from file
for( filePatches = 0; !feof( patchFile ); ++filePatches )
{
// try to get new patch
1210 if( (curPatch = patchBuff−>getNewPatch( patchSize )) == NULL )
Error( NO_PATCH );
// read vertex order from file
for( i = 0; i < nrVertices; ++i )
1215 if( fscanf( patchFile, " %d ", &curPatch[i] ) < 1 )
{
snprintf( msgBuff, 60, "[%d patch(es) of size ok]",
filePatches, patchSize.m, patchSize.n );
fprintf( stderr, "\n\t" );
1220 Error( BAD_FORMAT, msgBuff );
}
}
fclose( patchFile );
if( log != NULL )
1225 fprintf( log, "got %d patches\n", filePatches );
}
// skip filename
scan−>getSymbol();
}
1230 else if( scan−>sym == LSS )
{
if( patchBuff != NULL )
// try to get new patch
if( (curPatch = patchBuff−>getNewPatch( patchSize )) == NULL )
1235 Error( NO_PATCH );
scan−>getSymbol();
// get patch data
1240 for( i = 0; i < nrVertices; ++i )
if( patchBuff != NULL )
curPatch[i] = getNumber( 0, INT_MAX );
else
getNumber( 0, INT_MAX );
1245
// check patchdef termination
if( scan−>sym != GTR )
{
if( scan−>sym == NUMBER )
1250 snprintf( msgBuff, 60, "[patch too long − size of expected]",
patchSize.m, patchSize.n );
else
snprintf( msgBuff, 60, "[end mark ’>’ expected]" );
1255 Error( BAD_FORMAT, msgBuff );
}
scan−>getSymbol();
}
else
1260 Error( SYNTAX_ERROR );
}
// skip right curly brace
scan−>getSymbol();
}
1265 if( patchBuff != NULL && patchBuff−>length() == 0 )
Error( EMPTY_BUFFER, "[patch]" );
}
/* Parse color definition
1270 * := color { | | }
*/
//***************************************************
void Parser::getColor( Color *color, bool useDef )
//***************************************************
1275 { DefNode *defColor;
Color tmp;
Color *colorPtr = (color == NULL)? &tmp : color;
1280 if( useDef )
{
if( scan−>sym != STRINGSYM ) Error( MISSING_NAME );
// try to get color from definition tree
1285 if( (defColor = getDef( COLORSYM, scan−>string, defHook )) == NULL )
Error( COLOR_NOT_DEFINED, scan−>string );
*colorPtr = defColor−>colorDef;
scan−>getSymbol();
1290 }
else
{
// check for color block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
1295 // ... and skip
scan−>getSymbol();
// initialize color

1300
*color = black;
while( scan−>sym != CURLBRACERIGHT )
{
switch( scan−>sym )
{
1305 // := red
case REDSYM: scan−>getSymbol();
colorPtr−>channel[RED] = getReal();
break;
1310 // := green
case GREENSYM: scan−>getSymbol();
colorPtr−>channel[GREEN] = getReal();
break;
1315 // := blue
case BLUESYM: scan−>getSymbol();
colorPtr−>channel[BLUE] = getReal();
break;
1320 default: Error( SYNTAX_ERROR, "[illegal color channel]" );
}
}
// skip right curly brace
scan−>getSymbol();
1325 }
}
/* Parse pixmap data
* := ’file’ | |
1330 */
//***********************************************************
void Parser::getMapData( PointMapper::ParseInfo *mapData )
//***********************************************************
{
1335 // check for keyword ’file’ ...
if( scan−>sym != FILESYM ) Error( MISSING_KEYWORD, "’file’" );
scan−>getSymbol();
// ... and get filename
if( scan−>sym != STRINGSYM ) Error( MISSING_FILENAME );
1340 strcpy( mapData−>filename, scan−>string );
scan−>getSymbol();
1345
// initialize scaling factors
mapData−>scale = oneVector;
// check for map scaling
// := ’scale’
if( scan−>sym == SCALESYM )
{
1350 scan−>getSymbol();
mapData−>scale.x = getReal();
mapData−>scale.y = getReal();
}
1355 // get map layout
// := ’tile’ | ’stretch’
switch( scan−>sym )
{
case TILESYM: mapData−>layout = PointMapper::LAYOUT_TILE;
1360 break;
case STRETCHSYM: mapData−>layout = PointMapper::LAYOUT_STRETCH;
break;
1365 default: Error( MISSING_KEYWORD, "for layout: [tile | stretch]" );
}
scan−>getSymbol();
}
1370
/* Parse turbulence definition
* := { | | | }
*/
//************************************************************
1375 void Parser::getTurbulence( Noise::Turbulence *turbulence )
//************************************************************
{
Real scale;
1380 // check for turbulence block begin ...
if( scan−>sym != CURLBRACELEFT ) Error( MISSING_BRACE );
// ... and skip
scan−>getSymbol();
1385 // initialize turbulence
*turbulence = Noise::defaultTurbulence;
// get turbulence properties
while( scan−>sym != CURLBRACERIGHT )
1390 {
switch( scan−>sym )
{
// := ’size’
case SIZESYM: scan−>getSymbol();
1395 turbulence−>size = getReal();
break;
// := ’scale’

case SCALESYM: scan−>getSymbol();
1400 scale = getReal();
turbulence−>scale = (scale != 0.0)? 1 / scale : 1.0;
break;
// := ’frequencies’
1405 case FREQUENCIESSYM: scan−>getSymbol();
turbulence−>frequencies = (int)getReal();
break;
// := ’exponent’
1410 case EXPONENTSYM: scan−>getSymbol();
turbulence−>exponent = getReal();
break;
default: Error( SYNTAX_ERROR, "[illegal turbulence data]" );
1415 }
}
// skip right curly brace
scan−>getSymbol();
}
1420
1425
/**
* Auxilliary parsing functions
*/
/* Parse a vector definition
* := ’’
*/
//**************************
1430 Vector Parser::getVector()
//**************************
{
Vector v;
1435 if( scan−>sym == LSS )
{
scan−>getSymbol();
v.x = getReal();
v.y = getReal();
1440 v.z = getReal();
if( scan−>sym == GTR ) scan−>getSymbol();
else Error( BAD_VECTOR );
}
else Error( BAD_VECTOR );
1445
}
return v;
/* Parse signed number or real number
1450 * := [+|−] . o O (NUMBER notified by scanner)
* := [+|−] . o O (REAL notified by scanner)
*/
//***********************
Real Parser::getReal()
1455 //***********************
{
Real realVal;
switch( scan−>sym )
1460 {
case PLUS: realVal = 1.0;
scan−>getSymbol();
break;
1465 case MINUS: realVal = −1.0;
scan−>getSymbol();
break;
1470 }
default: realVal = 1.0;
if( scan−>sym == REAL || scan−>sym == NUMBER )
{
realVal *= (scan−>sym == REAL)? scan−>real : scan−>number;
1475 scan−>getSymbol();
return realVal;
}
else Error( REAL_EXPECTED );
return 0;
1480 }
/* Parse a signed number and test for given bounds
* := [+|−] . o O (NUMBER notified by scanner)
*/
1485 //********************************************************
int Parser::getNumber( int lowerBound, int upperBound )
//********************************************************
{
char bounds[25];
1490 int numVal;
switch( scan−>sym )
{
case PLUS: numVal = 1;
1495 scan−>getSymbol();
break;
case MINUS: numVal = −1;

scan−>getSymbol();
1500 break;
}
default: numVal = 1;
1505 if( scan−>sym != NUMBER ) Error( NUMBER_EXPECTED );
numVal *= scan−>number;
// check bounds on valid interval
1510 if( lowerBound upperBound )
{
snprintf( bounds, 25, "[%d %d]", lowerBound, upperBound );
1515 Error( NUMBER_OUT_OF_BOUNDS, bounds );
}
}
scan−>getSymbol();
return numVal;
1520 }
/* Parses a coordinate definition
* := | |
*/
1525 //***********************************
Coordinate Parser::getCoordinate()
//***********************************
{
Symbol smbl = scan−>sym;
1530
scan−>getSymbol();
switch( smbl )
{
1535 case XSYM: return X;
case YSYM: return Y;
case ZSYM: return Z;
default: Error( COORD_EXPECTED, "{X,Y,Z}" );
}
1540 return X;
}
/**
* Initializing functions
1545 */
// Build model components and determine
// function for calculating intersections.
//**************************
void Parser::buildModel()
1550 //**************************
{
// hook whitted−shading for default
model−>trace = traceWhitted;
1555 /**
* Initialize octree − if defined
*/
if( model−>octree != NULL )
{
1560 Octree &octree = *model−>octree;
Vector &viewLocation = model−>scene.view.location;
octree.plane = viewLocation;
1565 if( viewLocation.x < octree.min.x )
octree.plane.x = octree.min.x;
else if( viewLocation.x > octree.max.x )
octree.plane.x = octree.max.x;
1570 if( viewLocation.y < octree.min.y )
octree.plane.y = octree.min.y;
else if( viewLocation.y > octree.max.y )
octree.plane.y = octree.max.y;
1575 if( viewLocation.z < octree.min.z )
octree.plane.z = octree.min.z;
else if( viewLocation.z > octree.max.z )
octree.plane.z = octree.max.z;
1580 if( buildOctree( model ) )
{
fprintf( stdout, "OK\n" );
// hook octree intersection function
1585 model−>intersect = octreeIntersect;
}
else
{
fprintf( stdout, "failed!\n" );
1590 Error( OCTREE_FAILED );
}
}
else
{
1595 // hook default intersection function
model−>intersect = Model::defaultIntersect;
}
}

1600
// Build texture according to texture data
//*****************************************************************
void Parser::buildTexture( Object *object, TextureData *texDat )
//*****************************************************************
1605 {
Texture *tex = NULL;
Real surfaceDim[3];
// get texture and set specific data ...
1610 switch( texDat−>textureType )
{
case BUMPSYM: // plain texture
tex = new BumpTexture();
break;
1615
1620
case BITMAPSYM: // Match mode for mapping hitpoints to 2D
object−>matchMappingMode( texDat−>bitmap.mappingMode );
tex = new BitmapTexture( texDat−>bitmap );
break;
case REFLECTIONSYM: // Match mode for mapping hitpoints to 2D
// Reflection mapping requires spherical mapping mode.
texDat−>reflection.mappingMode[X] =
texDat−>reflection.mappingMode[Y] =
1625 texDat−>reflection.mappingMode[Z] = PointMapper::MAP_SPHERIC;
tex = new ReflectionTexture( texDat−>reflection );
break;
case CHECKERSYM: // Match mode for mapping hitpoints to 2D
1630 object−>matchMappingMode( texDat−>checker.mapperInfo.mappingMode );
tex = new CheckerTexture( texDat−>checker );
break;
case BRICKSYM: tex = new BrickTexture( texDat−>brick );
1635 break;
case MARBLESYM: tex = new MarbleTexture( texDat−>marble );
break;
1640 case WOODSYM: tex = new WoodTexture( texDat−>wood );
break;
default: break;
}
1645 if( tex == NULL ) Error( NO_TEXTURE );
// set extra texture data for procedural textures
switch( texDat−>textureType )
{
1650 case CHECKERSYM: case BRICKSYM: case MARBLESYM: case WOODSYM:
((ProceduralTexture *)tex)−>setExtraColor( texDat−>color[MAX_TEX_CHNL − 1] );
((ProceduralTexture *)tex)−>setExtraMaterial( texDat−>material[MAX_TEX_CHNL − 1] );
1655 default: break;
}
// set object specific texture behavior
object−>matchSurfaceDimension( surfaceDim );
1660 object−>matchMappingMode( texDat−>bump.mapperInfo.mappingMode );
// set attributes of bump mapping
((BumpTexture *)tex)−>setBumpData( texDat−>bump );
1665 // set general texture properties
tex−>setupTextureSystem( texDat−>texture.transform );
tex−>setTurbulence( texDat−>texture.turbulence );
tex−>setBaseColor( texDat−>color[0] );
tex−>setBaseMaterial( texDat−>material[0] );
1670
for( unsigned int i = X; i setSurfaceDimension( (Coordinate)i, surfaceDim[i] );
// hook texture
1675 object−>texture = tex;
// register texture handle
object−>texture−>registerHandle();
}
1680 /* Print out error messages and warnings and exits on errors.
*/
//******************************************************
void Parser::Error( ParseError err, const char *ext )
//******************************************************
1685 { char empty = ’\0’;
const char *extPtr = (ext != NULL)? ext : &empty;
if( err < PARSE_ERRORS )
1690 {
if( err < CRITICAL_ERRORS )
fprintf( stderr, "critical error: %s %s\n", errorMessage[err], extPtr );
else
fprintf( stderr, "parse error: file ’%s’, near line %d: %s %s, found %s\n",
1695 scan−>getFileName(), scan−>getLine(), errorMessage[err], extPtr,
scan−>getSymbolStr( scan−>sym ) );
exit( 1 );

}
1700 else
fprintf( stdout, "warning: file ’%s’, near line %d: %s %s\n",
scan−>getFileName(), scan−>getLine(), errorMessage[err], extPtr );
}
1705 /**
* Functions handling predefinitions
*/
/* Try to parse a definition of demanded type and store it
1710 * in the binary tree used for definition management.
*/
//**********************************************************************
void Parser::setDef( Symbol type, const char *ident, DefNode **root )
//**********************************************************************
1715 {
int cmpVal;
if( *root != NULL )
{
1720 // scan tree of definitions
cmpVal = strcmp( (*root)−>ident, ident );
if( cmpVal > 0 ) setDef( type, ident, &(*root)−>right );
else if( cmpVal < 0 ) setDef( type, ident, &(*root)−>left );
else
1725 {
Error( SKIP_REDEFINITION, ident );
// skip identifier
scan−>getSymbol();
1730 // skip definition
switch( type )
{
case MATERIALSYM: getMaterial( NULL );
break;
1735
case TEXTURESYM: getTextureData( NULL );
break;
case VERTEXSYM: getVertex( NULL );
1740 break;
case PATCHSYM: getPatch( NULL );
break;
1745 case COLORSYM: getColor( NULL );
break;
default: Error( ILLEGAL_DEFINITION );
}
1750 }
}
else
{
// create new definition node ...
1755 if( (*root = new DefNode) == NULL ) Error( NO_DEFINITION );
(*root)−>left = (*root)−>right = NULL;
(*root)−>type = type;
// set identifier
1760 if( ((*root)−>ident = new char[ strlen( ident ) + 1 ]) == NULL )
Error( NO_DEFINITION );
else
strcpy( (*root)−>ident, ident );
1765 // skip identifier
scan−>getSymbol();
// parse definition
switch( type )
1770 {
case MATERIALSYM: (*root)−>materialDef = defaultMaterial;
getMaterial( &(*root)−>materialDef );
break;
1775 case TEXTURESYM: (*root)−>textureDataDef = defaultTextureData;
getTextureData( &(*root)−>textureDataDef );
break;
case VERTEXSYM: if( ((*root)−>vertexBuffer = new VertexBuffer()) == NULL )
1780 Error( NO_BUFFER, "[type: vertex]" );
getVertex( (*root)−>vertexBuffer );
break;
1785 case PATCHSYM: if( ((*root)−>patchBuffer = new PatchBuffer()) == NULL )
Error( NO_BUFFER, "[type: patch]" );
1790
1795 }
}
}
getPatch( (*root)−>patchBuffer );
break;
case COLORSYM: getColor( &(*root)−>colorDef );
break;
default: Error( ILLEGAL_DEFINITION );

* Searches in the binary tree for definition
1800 * of demanded type and identifier.
*/
//**************************************************************************
DefNode *Parser::getDef( Symbol type, const char *ident, DefNode **root )
//**************************************************************************
1805 {
int cmpVal;
1810
1815 }
if( *root == NULL ) return NULL;
cmpVal = strncmp( (*root)−>ident, ident, CHAR_LIMIT );
if( cmpVal > 0 ) return getDef( type, ident, &(*root)−>right );
else if( cmpVal < 0 ) return getDef( type, ident, &(*root)−>left );
else if( type == (*root)−>type ) return (*root);
else return NULL;
/* Deletes the binary tree used
* for definition management.
*/
1820 //**************************************
void Parser::delDefs( DefNode *root )
//**************************************
{
if( root−>left != NULL ) delDefs( root−>left );
1825 if( root−>right != NULL ) delDefs( root−>right );
switch ( root−>type )
{
case PATCHSYM: if( root−>patchBuffer != NULL )
1830 delete root−>patchBuffer;
break;
case VERTEXSYM: if( root−>vertexBuffer != NULL )
delete root−>vertexBuffer;
1835 break;
}
default: break;
1840 delete[] root−>ident;
delete root;
}

5
#ifndef __SCANNER_H
#define __SCANNER_H
#include
#define CHAR_LIMIT 15 /* character limit of keywords */
#define LINE_LIMIT 256 /* character limit of line */
typedef enum {
10 // keywords
AMBIENCESYM, AMBIENTSYM,
ANGLESYM,
ASPECTRATIOSYM, BEZIERSYM,
BITMAPSYM, BLUESYM,
15 BOXSYM, BRICKSYM,
BUMPSYM, CAMERASYM,
CHECKERSYM,
COLORSYM, CONESYM,
CSGSYM,
20 CYLINDERSYM, DEFSYM,
DIFFUSESYM, DIRECTIONSYM,
EXPONENTSYM, FALSESYM,
FILESYM,
FREQUENCIESSYM, GREENSYM,
25 INCLUDESYM, INDEXSYM,
LIGHTSSYM, LOCATIONSYM,
LOOKATSYM,
MARBLESYM, MATERIALSYM,
MOVESYM, OBJECTSSYM,
30 OCTREESYM,
PATCHSYM, PLAINSYM,
PLANESYM, POINTSYM,
REDSYM,
REFLECTSYM, REFLECTIONSYM,
35 RIGHTSYM, ROTATESYM,
SCALESYM, SCENESYM,
SHEARSYM,
SIZESYM, SPECULARSYM,
SPECULAREXPSYM, SPHERESYM,
40 SPOTSYM,
STRETCHSYM, SUPERSAMPLESYM,
TEXTURESYM,
TILESYM, TRANSFORMSYM,
TRANSPARENCYSYM, TRUESYM,
45 TURBULENCESYM,
UPSYM, USESYM,
VERTEXSYM, VIEWSYM,
WOODSYM, XSYM,
YSYM, ZSYM,
50 ZOOMSYM,
NUMBER_OF_KEYWORDS,
// special
55 UNKNOWNSYM = NUMBER_OF_KEYWORDS,
IDENTSYM, STRINGSYM,
NUMBER, REAL,
LSS, GTR,
MINUS, PLUS,
60 TIMES, SLASH,
CURLBRACELEFT, CURLBRACERIGHT,
EOFSYM,
NUMBER_OF_SYMBOLS
65 //**********
} Symbol;
//**********
/* The Scanner class
70 */
//****************
class Scanner {
//****************
typedef enum {
75 ALPHA, DIGIT, SPECIAL, OTHER
//************
} CharType;
//************
80 public:
Scanner( const char *file_name );
~Scanner();
85
void getSymbol();
int getLine() { return lineNr; }
const char *getFileName() { return fileName; }
const char *getSymbolStr( Symbol s ) { return symbolString[s]; }
90 // scanner results
Symbol sym;
const char *ident;
const char *string;
int number;
95 double real;
100
private:
void getChar();
void stringToUpper( char *str );

translation tables
static const char *symbolString[NUMBER_OF_SYMBOLS];
CharType chType[256];
105 FILE *file;
char fileName[LINE_LIMIT];
char lineBuffer[LINE_LIMIT];
int lineNr;
110 int lineLen;
int curPos;
unsigned char ch;
char idBuffer[CHAR_LIMIT + 1];
115 char strBuffer[LINE_LIMIT];
};
#endif /* __SCANNER_H */

#include
#include
#include
5 #include
#include
#include "Scanner.h"
10 /* Initialize translation table
*/
//**********************************************************
const char *Scanner::symbolString[NUMBER_OF_SYMBOLS] = {
//**********************************************************
15 // keyword strings ...
"AMBIENCE ", "AMBIENT ",
"ANGLE ",
"ASPECTRATIO ", "BEZIER ",
"BITMAP ", "BLUE ",
20 "BOX ", "BRICK ",
"BUMP ", "CAMERA ",
"CHECKER ",
"COLOR ", "CONE ",
"CSG ",
25 "CYLINDER ", "DEF ",
"DIFFUSE ", "DIRECTION ",
"EXPONENT ", "FALSE ",
"FILE ",
"FREQUENCIES ", "GREEN ",
30 "INCLUDE ", "INDEX ",
"LIGHTS ", "LOCATION ",
"LOOKAT ",
"MARBLE ", "MATERIAL ",
"MOVE ", "OBJECTS ",
35 "OCTREE ",
"PATCH ", "PLAIN ",
"PLANE ", "POINT ",
"RED ",
"REFLECT ", "REFLECTION ",
40 "RIGHT ", "ROTATE ",
"SCALE ", "SCENE ",
"SHEAR ",
"SIZE ", "SPECULAR ",
"SPECULAREXP ", "SPHERE ",
45 "SPOT ",
"STRETCH ", "SUPERSAMPLE ",
"TEXTURE ",
"TILE ", "TRANSFORM ",
"TRANSPARENCY ", "TRUE ",
50 "TURBULENCE ",
"UP ", "USE ",
"VERTEX ", "VIEW ",
"WOOD ", "X ",
"Y ", "Z ",
55 "ZOOM ",
// special strings ...
"unknown Symbol",
"identifier", "string",
"number", "real number",
60 "",
"−", "+",
"*", "/",
"{", "}",
"end of file"
65 };
/* Constructor
*/
70 //******************************************
Scanner::Scanner( const char *file_name )
//******************************************
{
register unsigned int c;
75 char specialChars[] = { ’’, ’−’, ’+’, ’*’, ’/’, ’#’, ’"’, ’{’, ’}’, EOF, ’\0’ };
char alphaChars[] = { ’_’, ’\0’ };
// initialize char type table
for( c = 0; c < 256; c++ )
80 if( isalpha( c ) ) chType[c] = ALPHA;
else if( isdigit( c ) ) chType[c] = DIGIT;
else chType[c] = OTHER;
for( c = 0; alphaChars[c]; c++ )
85 chType[(unsigned char)alphaChars[c]] = ALPHA;
for( c = 0; specialChars[c]; c++ )
chType[(unsigned char)specialChars[c]] = SPECIAL;
90 // try to open file
if( (file = fopen( file_name, "r" )) == NULL )
{
fprintf( stderr, "%s: File not found!\n", file_name );
exit( 1 );
95 }
strncpy( fileName, file_name, LINE_LIMIT − 1 );
fileName[LINE_LIMIT − 1] = ’\0’;
100 lineNr = lineLen = curPos = 0;

105 }
idBuffer[0] = strBuffer[0] = ’\0’;
ident = idBuffer;
string = strBuffer;
getChar();
/* Destructor
*/
//********************
110 Scanner::~Scanner()
//********************
{
if( file != NULL ) fclose( file );
}
115
/* Upper−case convertion
*/
//*****************************************
void Scanner::stringToUpper( char *str )
120 //*****************************************
{
for( ; *str; ++str )
if( *str >= ’a’ && *str = 0 ) lower = i+1;
if( cmpVal

do
{
digitVal = (unsigned char)(ch−’0’);
205 if( (number < INT_MAX/10) || (number == INT_MAX/10) && (digitVal

getChar();
break;
case ’*’: sym = TIMES;
305 getChar();
break;
case ’{’: sym = CURLBRACELEFT;
getChar();
310 break;
315
case ’}’: sym = CURLBRACERIGHT;
getChar();
break;
case ’/’: // check for block comment
getChar();
if( ch == ’*’ )
{
320 do {
for( getChar(); ch != ’*’; getChar() );
getChar();
} while( ch != ’/’ );
getChar();
325 goto begin;
}
else sym = SLASH;
break;
330 case ’#’: // line comment
cmpVal = lineNr;
for( getChar(); cmpVal == lineNr; getChar() );
goto begin;
335 case ’"’: for( getChar(), i = 0; ch != ’"’ && i < LINE_LIMIT − 1; getChar(), i++ )
strBuffer[i] = ch;
strBuffer[i] = ’\0’;
340 // check for string too long ...
if( ch != ’"’ )
{
fprintf( stderr, "Warning:%d: string too long − extra ignored!\n", lineNr );
while( ch != ’"’ ) getChar();
345 }
350
sym = STRINGSYM;
getChar();
break;
case (unsigned char)EOF:
sym = EOFSYM;
break;
355 default: sym = UNKNOWNSYM;
getChar();
}
break;
360 case OTHER: sym = UNKNOWNSYM;
getChar();
break;
}
}
365

#ifndef __SIMPLELIST_H
#define __SIMPLELIST_H
#ifndef NULL
5 #define NULL 0L
#endif
/* The SimpleList template
*/
10 template
//*******************
class SimpleList {
//*******************
typedef struct __ListItem {
15 type data;
__ListItem *next;
//************
} ListItem;
//************
20
public:
// The SimpleList iterator class
//*****************
class iterator {
25 //*****************
friend class SimpleList;
public:
// Constructor
iterator() : curItem(NULL), pos(−1) {}
30
// Iterator check
bool isOK() { return (curItem != NULL); }
// Switch to next item
35 //************
bool next()
//************
{
if(curItem != NULL) {
40 curItem = curItem−>next;
++pos;
}
return (curItem != NULL);
}
45
// Get data of current item
type &get() { return curItem−>data; }
// Get current list position
50 int getPos() { return pos; };
private:
// iterator’s properties
iterator( ListItem *item ) : curItem(item), pos(0) {}
ListItem *curItem;
55 int pos;
};
60
// Constructor
SimpleList() : items(0), first(NULL), last(NULL), hook(NULL) {}
// Destructor
//************************
virtual ~SimpleList() {
//************************
65 ListItem *tmp;
for( tmp=first; tmp!=NULL; tmp=first ) {
first = tmp−>next;
delete tmp;
70 }
}
// Append a new item
//***************
75 type *append()
//***************
{
ListItem *tmp;
80 // set tmp to new ListItem
if( hook == NULL )
{
if( (tmp = new ListItem) == NULL )
return NULL;
85 }
else
{
tmp = hook;
hook = hook−>next;
90 }
tmp−>next = NULL;
if( first == NULL )
95 first = last = tmp;
else
{
last−>next = tmp;
last = tmp;
100 }

105
}
++items;
return &tmp−>data;
// Delete item
//************************************
bool deleteItem( unsigned int pos )
//************************************
110 {
ListItem **itemRun = &first;
// search for n−th control point
while( *itemRun != NULL && pos−− )
115 itemRun = &((*itemRun)−>next);
if( *itemRun != NULL ) {
ListItem *keeper = (*itemRun)−>next;
120 // hang into recycle list
(*itemRun)−>next = hook;
hook = *itemRun;
// reconnect list
125 *itemRun = keeper;
−−items;
130
}
}
return true;
return false;
// SimpleList assignment
135 //****************************************
SimpleList &operator=( SimpleList &sl )
//****************************************
{
ListItem *tmp;
140 type *datPtr;
if( this != &sl )
{
clear();
145 for( tmp = sl.first; tmp != NULL; tmp = tmp−>next )
if( (datPtr = append()) != NULL )
*datPtr = tmp−>data;
}
return *this;
150 }
// Index data access
//***********************************
type &operator[]( unsigned int n )
155 //***********************************
{
ListItem *tmp = first;
// search for n−th control point
160 while( tmp != NULL && n−− )
tmp = tmp−>next;
165
}
return tmp−>data;
// Clear list
//*************
void clear()
//*************
170 {
if( last != NULL )
{
last−>next = hook;
hook = first;
175 first = last = NULL;
items = 0;
}
}
180 // Get number of items
unsigned int length() { return items; }
185
// Get iterator to first item of list
iterator begin() { return iterator(first); }
// Get data of first or last item
type &getFirst() { return first−>data; }
type &getLast() { return last−>data; }
190 private:
// list’s properties
unsigned int items;
ListItem *first, *last;
ListItem *hook;
195 };
#endif /* __SIMPLELIST_H */

5
#ifndef __PATCHBUFFER_H
#define __PATCHBUFFER_H
#include "SimpleList.h"
//********************
typedef int *Patch;
//********************
10 typedef struct {
unsigned int m;
unsigned int n;
//*************
} PatchSize;
15 //*************
typedef struct {
Patch patchData;
PatchSize size;
20 //*************
} PatchItem;
//*************
/* The PatchBuffer class
25 */
//***************************************************
class PatchBuffer : public SimpleList {
//***************************************************
public:
30 PatchBuffer() : SimpleList() {}
// destructor
~PatchBuffer() {
if( length() )
35 {
SimpleList::iterator it = begin();
do {
delete it.get().patchData;
40 } while( it.next() );
}
}
// get new patch
45 Patch getNewPatch( const PatchSize &size )
{
PatchItem *tmp = getNewPatchItem( size );
return ((tmp != NULL)? tmp−>patchData : NULL);
}
50
55
60
// append PatchBuffer
bool appendPatchBuffer( PatchBuffer *patchBuff )
{
PatchSize size;
if( patchBuff−>length() )
{
PatchItem *dest, *src;
SimpleList::iterator it = patchBuff−>begin();
do {
src = &it.get();
size = src−>size;
65 if( (dest = getNewPatchItem( size )) != NULL )
{
for( unsigned int i = 0; i < size.m*size.n; ++i )
{
dest−>patchData[i] = src−>patchData[i];
70 }
}
else return false;
} while( it.next() );
}
75 return true;
}
80
private:
Patch *append() { return NULL; }
PatchItem *getNewPatchItem( const PatchSize &size )
{
PatchItem *tmp = SimpleList::append();
85 if( tmp != NULL )
if( (tmp−>patchData = new int[size.m * size.n]) != NULL )
tmp−>size = size;
90 }
};
return tmp;
#endif /* __PATCHBUFFER_H */

#ifndef __TYPES_H
#define __TYPES_H
#include
5 #include
10
#ifndef NULL
#define NULL 0L
#endif
//********************
typedef double Real;
//********************
15 //****************************
typedef unsigned char Byte;
//****************************
typedef struct {
20 Real lower;
Real upper;
//************
} Interval;
//************
25
typedef struct {
Real data[4][4];
//**********
} Matrix;
30 //**********
typedef enum {
X, Y, Z
//**************
35 } Coordinate;
//**************
typedef enum {
/* Note:
40 * This order determines arrangement of color
* channels in the pixel buffer!
* (XImage want it this way!)
*/
BLUE, GREEN, RED, ALPHA
45 //****************
} ColorChannel;
//****************
typedef struct {
50 Real channel[3];
//*********
} Color;
//*********
55 //***********************************
typedef Color MaterialCoefficient;
//***********************************
typedef struct {
60 MaterialCoefficient ambient;
MaterialCoefficient diffuse;
MaterialCoefficient specular;
Real specularExp;
65 Real reflect;
Real transparency;
Real refractIndex;
//************
} Material;
70 //************
typedef struct {
Real x;
Real y;
75 Real z;
//**********
} Vector;
//**********
80 //**********************
typedef Vector Point;
//**********************
typedef struct {
85 Point origin;
Vector direction;
Color color;
//*******
} Ray;
90 //*******
95
//****************************
typedef Vector Vertices[8];
//****************************
//**************************
#define RAYEPS 1e−7
//**************************
100 #endif /* __TYPES_H */

#ifndef __UTILS_H
#define __UTILS_H
#include
5 #include "Types.h"
/* Round to nearest integer
*/
inline int Round( Real x )
10 {
return ((int)((x > 0.0)? (x + 0.5) : (x − 0.5)));
}
/* Determine floor value
15 */
inline int floorVal( Real x )
{
return ((int)x − (x < 0.0 && x != (int)x));
}
20
/* Determine absolute value
*/
template
inline type absVal( const type &a )
25 {
return (a < 0)? −a : a;
}
/* Return maximum value
30 */
template
inline type &maxVal( const type &a, const type &b )
{
return const_cast((a > b)? a : b);
35 }
/* Return minimum value
*/
template
40 inline type &minVal( const type &a, const type &b )
{
return const_cast((a < b)? a : b);
}
45 /* convert to/from radian meassure
*/
#define DEGToRAD(angle) (M_PI * (angle) / 180.0)
#define RADToDEG(angle) ((angle) * 180.0 / M_PI)
50 // blend values
#define blend(a,b,f) (a * f + (1.0 − f) * b)
/* regular swap
*/
55 template
inline void swap( type &a, type &b )
{
type tmp = a;
a = b;
60 b = tmp;
}
/* XOR swap
*/
65 inline void swapXOR( unsigned int &a, unsigned int &b )
{
a ^= b;
b ^= a;
a ^= b;
70 }
/**
* Color/Material calculations
*/
75 inline Color addColor( const Color &a, const Color &b )
{
Color tmp;
tmp.channel[RED] = a.channel[RED] + b.channel[RED];
80 tmp.channel[GREEN] = a.channel[GREEN] + b.channel[GREEN];
tmp.channel[BLUE] = a.channel[BLUE] + b.channel[BLUE];
85
}
return tmp;
inline Color subColor( const Color &a, const Color &b )
{
Color tmp;
90 tmp.channel[RED] = a.channel[RED] − b.channel[RED];
tmp.channel[GREEN] = a.channel[GREEN] − b.channel[GREEN];
tmp.channel[BLUE] = a.channel[BLUE] − b.channel[BLUE];
95 }
100
return tmp;
inline Color scaleColor( const Color &a, Real fact )
{
Color tmp;

tmp.channel[RED] = a.channel[RED] * fact;
tmp.channel[GREEN] = a.channel[GREEN] * fact;
tmp.channel[BLUE] = a.channel[BLUE] * fact;
105 return tmp;
}
inline Real grayValue( const Color &c )
{
110 return (c.channel[RED] + c.channel[GREEN] + c.channel[BLUE]) / 3.0;
}
inline void blendColor( const Color &a, const Color &b, Real f, Color *res )
{
115 res−>channel[RED] = blend( a.channel[RED], b.channel[RED], f );
res−>channel[GREEN] = blend( a.channel[GREEN], b.channel[GREEN], f );
res−>channel[BLUE] = blend( a.channel[BLUE], b.channel[BLUE], f );
}
120 inline void blendMaterial( const Material &a, const Material &b, Real f, Material *res )
{
blendColor( a.ambient, b.ambient, f, &res−>ambient );
blendColor( a.diffuse, b.diffuse, f, &res−>diffuse );
blendColor( a.specular, b.specular, f, &res−>specular );
125
130 }
res−>specularExp = blend( a.specularExp, b.specularExp, f );
res−>reflect = blend( a.reflect, b.reflect, f );
res−>transparency = blend( a.transparency, b.transparency, f );
res−>refractIndex = blend( a.refractIndex, b.refractIndex, f );
/**
* Interval arithmetics
*/
135 inline bool intersectInterval( const Interval &a, const Interval &b, Interval &intsct )
{
intsct.lower = (a.lower > b.lower)? a.lower : b.lower;
intsct.upper = (a.upper < b.upper)? a.upper : b.upper;
return (intsct.lower

Vector tmp;
tmp.x = a.y * b.z − a.z * b.y;
tmp.y = a.z * b.x − a.x * b.z;
205 tmp.z = a.x * b.y − a.y * b.x;
}
res = tmp;
210 inline Real vectorLength( const Vector &v )
{
return sqrt( v.x * v.x + v.y * v.y + v.z * v.z );
}
215 inline void translateVector( const Vector &v, Real dist, Vector &res )
{
res.x = v.x + dist;
res.y = v.y + dist;
res.z = v.z + dist;
220 }
225
230
inline void normalizeVector( const Vector &v, Vector &res )
{
register Real length = vectorLength( v );
}
res.x = v.x / length;
res.y = v.y / length;
res.z = v.z / length;
inline void rayPoint( const Ray &ray, Real dist, Vector &res )
{
res.x = ray.origin.x + dist * ray.direction.x;
res.y = ray.origin.y + dist * ray.direction.y;
235 res.z = ray.origin.z + dist * ray.direction.z;
}
/* functions initializing transform matrices
*/
240 void multiplyMatrix( const Matrix &matrix, const Matrix &multMatrix, Matrix *result );
void translateMatrix( Matrix *matrix, const Vector &transl );
void rotateMatrix( Matrix *matrix, const Vector &rotat );
void scaleMatrix( Matrix *matrix, const Vector &scale );
void shearMatrix( Matrix *matrix, Coordinate c, Real sh1, Real sh2 );
245 bool invertMatrix( const Matrix &matrix, Matrix *invMatrix );
bool solveEquationSystem( Real *matrix, Real sol[], int n );
/* functions transforming points
*/
250 void transformPoint( const Matrix &matrix, const Point &point, Point *result );
void transformVector( const Matrix &matrix, const Vector &vec, Vector *result );
void transformNormal( const Matrix &matrix, const Vector &normal, Vector *result );
/* octree utility functions
255 */
void getVertices( const Vector &min, const Vector &max, Vertices vert );
bool testVertices( Vertices vert, const Vector &min, const Vector &max );
bool testEdge( const Vector &p1, const Vector &p2, const Vector &min, const Vector &max );
bool testBox( Vertices vert, const Vector &min, const Vector &max );
260
/**
* Predefinitions
*/
// colors ...
265 extern const Color black;
extern const Color white;
extern const Material defaultMaterial;
// vectors ...
270 extern const Vector nullVector;
extern const Vector oneVector;
extern const Vector baseVector[3];
// matrices ...
275 extern const Matrix nullMatrix;
extern const Matrix identityMatrix;
// auxiliary pointer for color channels
extern const ColorChannel RGBorder[4];
280 extern const ColorChannel BGRorder[4];
extern const ColorChannel * const RGBfirst;
extern const ColorChannel * const BGRfirst;
285
#endif /* __UTILS_H */

#include
#include
#include
5 #include "utils.h"
/**
* Predefinitions
*/
10 // colors ...
const Color black = {{ 0.0, 0.0, 0.0 }};
const Color white = {{ 1.0, 1.0, 1.0 }};
const Material defaultMaterial = { {{ 0.2, 0.2, 0.2 }},
{{ 0.2, 0.2, 0.2 }},
15 {{ 0.1, 0.1, 0.1 }},
1.0, 0.0, 0.0, 1.0 };
// vectors ...
const Vector nullVector = { 0.0, 0.0, 0.0 };
20 const Vector oneVector = { 1.0, 1.0, 1.0 };
const Vector baseVector[] = { { 1.0, 0.0, 0.0 },
{ 0.0, 1.0, 0.0 },
{ 0.0, 0.0, 1.0 } };
25 // matrices ...
const Matrix nullMatrix = {{ { 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0 },
{ 0.0, 0.0, 0.0, 0.0 } }};
30
35
const Matrix identityMatrix = {{ { 1.0, 0.0, 0.0, 0.0 },
{ 0.0, 1.0, 0.0, 0.0 },
{ 0.0, 0.0, 1.0, 0.0 },
{ 0.0, 0.0, 0.0, 1.0 } }};
// auxiliary pointer for color channels
const ColorChannel RGBorder[] = { RED, GREEN, BLUE, ALPHA };
const ColorChannel BGRorder[] = { BLUE, GREEN, RED, ALPHA };
const ColorChannel * const RGBfirst = &RGBorder[0];
40 const ColorChannel * const BGRfirst = &BGRorder[0];
/* Multiplies a matrix by another one.
*/
45 //**************************************************************************************
void multiplyMatrix( const Matrix &matrix, const Matrix &multMatrix, Matrix *result )
//**************************************************************************************
{
int x, y, i;
50 Matrix tmp = nullMatrix;
for( x = 0; x < 4; ++x )
for( y = 0; y < 4; ++y )
for( i = 0; i < 4; ++i )
55 tmp.data[y][x] += matrix.data[y][i] * multMatrix.data[i][x];
}
*result = tmp;
60 /* Adds a translation to a system matrix.
*/
//*************************************************************
void translateMatrix( Matrix *matrix, const Vector &transl )
//*************************************************************
65 {
Matrix translMatrix = identityMatrix;
// initialize translation matrix
translMatrix.data[0][3] = transl.x;
70 translMatrix.data[1][3] = transl.y;
translMatrix.data[2][3] = transl.z;
75
}
multiplyMatrix( *matrix, translMatrix, matrix );
/* Adds a rotation about x, y, z (in this order) to a system matrix.
*/
//*******************************************************
void rotateMatrix( Matrix *matrix, const Vector &rot )
80 //*******************************************************
{
Matrix rotMatrix[3] = { identityMatrix, identityMatrix, identityMatrix };
Matrix rotation = identityMatrix;
Real angle[3] = { DEGToRAD( rot.x ), DEGToRAD( rot.y ), DEGToRAD( rot.z ) };
85 Real sinAngle, cosAngle;
if( angle[X] != 0.0 )
{
// initialize x rotation matrix
90 sinAngle = sin( angle[X] );
cosAngle = cos( angle[X] );
rotMatrix[X].data[1][1] =
rotMatrix[X].data[2][2] = cosAngle;
95 rotMatrix[X].data[1][2] = −sinAngle;
rotMatrix[X].data[2][1] = sinAngle;
100
}
rotation = rotMatrix[X];

if( angle[Y] != 0.0 )
{
// initialize y rotation matrix
sinAngle = sin( angle[Y] );
105 cosAngle = cos( angle[Y] );
rotMatrix[Y].data[0][0] =
rotMatrix[Y].data[2][2] = cosAngle;
rotMatrix[Y].data[0][2] = sinAngle;
110 rotMatrix[Y].data[2][0] = −sinAngle;
}
multiplyMatrix( rotation, rotMatrix[Y], &rotation );
115 if( angle[Z] != 0.0 )
{
// initialize z rotation matrix
sinAngle = sin( angle[Z] );
cosAngle = cos( angle[Z] );
120
125
}
rotMatrix[Z].data[0][0] =
rotMatrix[Z].data[1][1] = cosAngle;
rotMatrix[Z].data[0][1] = −sinAngle;
rotMatrix[Z].data[1][0] = sinAngle;
multiplyMatrix( rotation, rotMatrix[Z], &rotation );
// rotate matrix
130 multiplyMatrix( *matrix, rotation, matrix );
}
/* Adds a scaling factor to a system matrix.
*/
135 //********************************************************
void scaleMatrix( Matrix *matrix, const Vector &scale )
//********************************************************
{
Matrix sclMatrix = identityMatrix;
140
145
}
// initialize scaling matrix
sclMatrix.data[0][0] = scale.x;
sclMatrix.data[1][1] = scale.y;
sclMatrix.data[2][2] = scale.z;
multiplyMatrix( *matrix, sclMatrix, matrix );
/* Adds a shear to along a coordinate axis to a system matrix.
150 * Parameters sh1 and sh2 are used to define shear factors:
* c = X: sh1 −> Y, sh2 −> Z
* c = Y: sh1 −> Z, sh2 −> X
* c = Z: sh1 −> X, sh2 −> Y
*/
155 //*********************************************************************
void shearMatrix( Matrix *matrix, Coordinate c, Real sh1, Real sh2 )
//*********************************************************************
{
Matrix shMatrix = identityMatrix;
160
// initialize shear matrix
shMatrix.data[(c+1)%3][c] = sh1;
shMatrix.data[(c+2)%3][c] = sh2;
165 multiplyMatrix( *matrix, shMatrix, matrix );
}
/* Determines the inverse of the given matrix by the
* Gauss−Jordan algorithm.
170 */
//*************************************************************
bool invertMatrix( const Matrix &matrix, Matrix *invMatrix )
//*************************************************************
{
175 Real pivotValue, factor;
int pivotPos, column, row;
int maxValCol;
int perm[4] = { 0, 1, 2, 3 };
Matrix mat = matrix;
180
// initialize inverse matrix
*invMatrix = identityMatrix;
for( pivotPos = 0; pivotPos < 4; ++pivotPos )
185 {
// do partial pivoting if pivot element is zero.
if( absVal( mat.data[pivotPos][perm[pivotPos]] ) < RAYEPS )
{
// search right hand side for largest absolute value.
190 for( maxValCol = pivotPos, column = pivotPos + 1; column < 4; ++column )
if(absVal( mat.data[pivotPos][perm[maxValCol]] ) < absVal( mat.data[pivotPos][perm[column]]))
maxValCol = column;
// swap columns
195 swap( perm[maxValCol], perm[pivotPos] );
200 }
// Check new pivot element
// Return false if matrix is singular
if( absVal( mat.data[pivotPos][perm[pivotPos]] ) < RAYEPS ) return false;

deterimine value of pivot element
pivotValue = mat.data[pivotPos][perm[pivotPos]];
205 // scale row if pivot element not equals one
if( pivotValue != 1.0 )
{
// scale row dividing elements by original pivot value
for( column = pivotPos; column < 4; ++column )
210 mat.data[pivotPos][perm[column]] /= pivotValue;
for( column = 0; column < 4; ++column )
invMatrix−>data[pivotPos][column] /= pivotValue;
}
215 // reduce previous and successional elements of
// the pivot column to zero
for( row = 0; row < 4; ++row )
{
if( row == pivotPos ) continue;
220
factor = mat.data[row][perm[pivotPos]];
if( factor == 0.0 ) continue;
// subtract pivot row factor times from current row
225 for( column = pivotPos; column < 4; ++column )
mat.data[row][perm[column]] −= factor * mat.data[pivotPos][perm[column]];
for( column = 0; column < 4; ++column )
invMatrix−>data[row][column] −= factor * invMatrix−>data[pivotPos][column];
}
230 }
// swap rows of inverse matrix according to permutations by pivoting
for( column = 0; column < 4; ++column )
if( perm[column] != column )
235 {
for( int i = 0; i < 4; ++i )
{
swap( invMatrix−>data[perm[column]][i], invMatrix−>data[column][i] );
}
240 swap( perm[perm[column]], perm[column] );
}
245
}
return true;
/* Solves an equation system
* Parameters:
* mat − system matrix
* sol − solution vector, will hold system solution
250 * n − number of matrix columns/lines
*/
//**********************************************************
bool solveEquationSystem( Real mat[], Real sol[], int n )
//**********************************************************
255 {
Real pivotValue, factor;
int pivotPos, column, row;
int maxValCol;
int *perm;
260
// create working matrix on stack
Real *matrix = (Real *)alloca( n * n * sizeof(Real) );
memcpy( matrix, mat, n*n*sizeof(Real) );
265 // create and initialize permutaion table
perm = (int *)alloca( n * sizeof(int) );
for( column = 0; column < n; ++column )
perm[column] = column;
270 for( pivotPos = 0; pivotPos < n; ++pivotPos )
{
// do partial pivoting if pivot element is zero.
if( absVal( matrix[pivotPos * n + perm[pivotPos]] ) < RAYEPS )
{
275 // search right hand side for largest absolute value.
for( maxValCol = pivotPos, column = pivotPos + 1; column < n; ++column )
if(absVal( matrix[pivotPos*n + perm[maxValCol]] ) < absVal( matrix[pivotPos*n + perm[column]]))
maxValCol = column;
280 // swap columns
swap( perm[maxValCol], perm[pivotPos] );
// Check new pivot element
// Return false if system is near singular
285 if( absVal( matrix[pivotPos * n + perm[pivotPos]] ) < RAYEPS ) return false;
}
290
// deterimine value of pivot element
pivotValue = matrix[pivotPos * n + perm[pivotPos]];
// scale row if pivot element not equals one
if( pivotValue != 1.0 )
{
// scale matrix row dividing elements by pivot value
295 for( column = pivotPos; column < n; ++column )
matrix[pivotPos * n + perm[column]] /= pivotValue;
// scale component of solution vector
sol[pivotPos] /= pivotValue;
}
300

educe previous and successional elements of
// the pivot column to zero
for( row = 0; row < n; ++row )
{
305 if( row == pivotPos ) continue;
factor = matrix[row * n + perm[pivotPos]];
if( factor == 0.0 ) continue;
310 // subtract pivot row factor times from current row
for( column = pivotPos; column < n; ++column )
matrix[row * n + perm[column]] −= factor * matrix[pivotPos * n + perm[column]];
// do the same for solution vector
sol[row] −= factor * sol[pivotPos];
315 }
}
// swap rows of solution vector according to permutations by pivoting
for( column = 0; column < n; ++column )
320 if( perm[column] != column )
{
swap( sol[perm[column]], sol[column] );
swap( perm[perm[column]], perm[column] );
}
325
}
return true;
/* Transform a point by the given matrix
330 */
//*******************************************************************************
void transformPoint( const Matrix &matrix, const Point &point, Point *result )
//*******************************************************************************
{
335 Point p = point;
340 }
result−>x = matrix.data[0][0]*p.x + matrix.data[0][1]*p.y + matrix.data[0][2]*p.z + matrix.data[0][3];
result−>y = matrix.data[1][0]*p.x + matrix.data[1][1]*p.y + matrix.data[1][2]*p.z + matrix.data[1][3];
result−>z = matrix.data[2][0]*p.x + matrix.data[2][1]*p.y + matrix.data[2][2]*p.z + matrix.data[2][3];
/* Transform a vector by the given matrix
*/
//********************************************************************************
345 void transformVector( const Matrix &matrix, const Vector &vec, Vector *result )
//********************************************************************************
{
Vector v = vec;
350 result−>x = matrix.data[0][0] * v.x + matrix.data[0][1] * v.y + matrix.data[0][2] * v.z;
result−>y = matrix.data[1][0] * v.x + matrix.data[1][1] * v.y + matrix.data[1][2] * v.z;
result−>z = matrix.data[2][0] * v.x + matrix.data[2][1] * v.y + matrix.data[2][2] * v.z;
}
355 /* Transform a normal vector by the given matrix
*/
//***********************************************************************************
void transformNormal( const Matrix &matrix, const Vector &normal, Vector *result )
//***********************************************************************************
360 {
Vector n = normal;
result−>x = matrix.data[0][0] * n.x + matrix.data[1][0] * n.y + matrix.data[2][0] * n.z;
result−>y = matrix.data[0][1] * n.x + matrix.data[1][1] * n.y + matrix.data[2][1] * n.z;
365 result−>z = matrix.data[0][2] * n.x + matrix.data[1][2] * n.y + matrix.data[2][2] * n.z;
}
/* Determines the vertices of the eight corners of a block.
*/
370 //************************************************************************
void getVertices( const Vector &min, const Vector &max, Vertices vert )
//************************************************************************
{
vert[0] = min;
375 vert[1].x = min.x; vert[1].y = max.y; vert[1].z = min.z;
vert[2].x = min.x; vert[2].y = max.y; vert[2].z = max.z;
vert[3].x = min.x; vert[3].y = min.y; vert[3].z = max.z;
vert[4].x = max.x; vert[4].y = min.y; vert[4].z = min.z;
vert[5].x = max.x; vert[5].y = max.y; vert[5].z = min.z;
380 vert[6] = max;
vert[7].x = max.x; vert[7].y = min.y; vert[7].z = max.z;
}
/* Tests all vertices for being inside a block specified by the
385 * parameters min and max.
*/
//*************************************************************************
bool testVertices( Vertices vert, const Vector &min, const Vector &max )
//*************************************************************************
390 {
for( unsigned int i=0; i < 8; ++i )
{
if( vert[i].x >= min.x && vert[i].y >= min.y && vert[i].z >= min.z &&
vert[i].x

* The edge is specified by the parameters p1 and p2.
* The block is specified by the parameters min and max.
*/
//******************************************************************************************
405 bool testEdge( const Vector &p1, const Vector &p2, const Vector &min, const Vector &max )
//******************************************************************************************
{
Vector n;
Real x, y, z, t;
410
subVector( p2, p1, n );
if( n.x != 0.0 )
{
415 t = (max.x − p1.x) / n.x;
if( (t = 0.0) )
{
y = p1.y + t * n.y;
420 z = p1.z + t * n.z;
if( (y = min.y) && (z = min.z) )
return true;
}
425 t = (min.x − p1.x) / n.x;
if( (t = 0.0) )
{
y = p1.y + t * n.y;
430 z = p1.z + t * n.z;
if( (y = min.y) && (z = min.z) )
return true;
}
}
435
if( n.y != 0.0 )
{
t = (max.y − p1.y) / n.y;
440 if( (t = 0.0) )
{
x = p1.x + t * n.x;
z = p1.z + t * n.z;
if( (x = min.x) && (z = min.z) )
445 return true;
}
t = (min.y − p1.y) / n.y;
450 if( (t = 0.0) )
{
x = p1.x + t * n.x;
z = p1.z + t * n.z;
if( (x = min.x) && (z = min.z) )
455 return true;
}
}
if( n.z != 0.0 )
460 {
t = (max.z − p1.z) / n.z;
if( (t = 0.0) )
{
465 y = p1.y + t * n.y;
x = p1.x + t * n.x;
if( (y = min.y) && (x = min.x) )
return true;
}
470
t = (min.z − p1.z) / n.z;
if( (t = 0.0) )
{
475 y = p1.y + t * n.y;
x = p1.x + t * n.x;
if( (y = min.y) && (x = min.x) )
return true;
}
480 }
}
return false;
485 /* Tests all vertices for being inside a block or all edges
* for intersecting the block’s sides.
* The block is specified by the parameters min and max.
*/
//********************************************************************
490 bool testBox( Vertices vert, const Vector &min, const Vector &max )
//********************************************************************
{
return ( testVertices( vert, min, max ) ||
testEdge( vert[0], vert[1], min, max ) ||
495 testEdge( vert[0], vert[3], min, max ) ||
testEdge( vert[0], vert[4], min, max ) ||
testEdge( vert[5], vert[1], min, max ) ||
testEdge( vert[5], vert[4], min, max ) ||
testEdge( vert[5], vert[6], min, max ) ||
500 testEdge( vert[2], vert[1], min, max ) ||

testEdge( vert[2], vert[6], min, max ) ||
testEdge( vert[2], vert[3], min, max ) ||
testEdge( vert[7], vert[3], min, max ) ||
testEdge( vert[7], vert[6], min, max ) ||
505 testEdge( vert[7], vert[4], min, max ) );
}

Erklärung
1. Mir ist bekannt, dass die Diplomarbeit als Prüfungsleistung in das Eigentum des Freistaats Bayern
übergeht. Hiermit erkläre ich mein Einverständnis, dass die Fachhochschule Regensburg
diese Prüfungsleistung die Studenten der Fachhochschule Regensburg einsehen lassen darf, und
dass sie die Abschlussarbeit unter Nennung meines Namens als Urheber veröffentlichen darf.
2. Ich erkläre hiermit, dass ich diese Diplomarbeit selbständig verfasst noch nicht anderweitig für
andere Prüfungszwecke vorgelegt, keine anderen als die angegebenen Quellen und Hilfsmittel
benützt sowie wörtliche und sinngemäße Zitate als solche gekennzeichnet habe.
Regensburg, den 17. September 2004
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Unterschrift
211

Literaturverzeichnis
[1] Barth W., Stürzlinger W., Efficient Ray Tracing for Bezier and B.Spline Surfaces, Computer
& Graphics, Vol. 17, 1993
[2] Glassner, A. S., An Introduction to Ray Tracing, Academic Press, 1989
[3] Groth O., Texturierung in ein, zwei und drei Dimensionen für dreidimensionale Darstelllung.
Diplomarbeit, Fachhochschule Regensburg, 1998
[4] Hill F. S. Jr., Computer Graphics Using OpenGL, 2nd Edition, Prentice Hall, 2001
[5] Lugauer U., Rendering of Curved Surfaces with the Lane-Carpenter Algorithm. Diplomarbeit,
Fachhochschule Regensburg, 1998
[6] McReynolds T., Blythe D., Programming with OpenGL: Advanced Rendering, SIG-
GRAPH ’97
[7] Riepl A., Ein Objektorientiertes, rekursives Ray Tracing-Verfahren mit verschiedenen
Optimierungen. Diplomarbeit, Fachhochschule Regensburg, 1992
[8] Watt A., M. Watt, Advanced Animation and Rendering Techniques, Adison-Wesley Publ.
Co., 1992
212

Abbildungsverzeichnis
1.1 Grundlegende Funktionsweise des Ray Tracing . . . . . . . . . . . . . . . . 2
1.2 Schnittpunkt- und Normalenberechnung bei primitiven Objekten . . . . . . . 6
1.3 Die Transformation von Strahl und Normalenvektor . . . . . . . . . . . . . . 7
2.1 Verlauf von Bernstein-Polynomen vom Grad 3 . . . . . . . . . . . . . . . . . 12
2.2 Eigenschaften von Bézierkurven . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3 Geometrische Punktkonstruktion nach de Casteljau . . . . . . . . . . . . . . 15
2.4 Berechnungsschema nach de Casteljau . . . . . . . . . . . . . . . . . . . . . 15
2.5 Aufteilung einer kubischen Bézierkurve . . . . . . . . . . . . . . . . . . . . 16
2.6 Bikubische Bézierfläche mit Kontrollpolyeder . . . . . . . . . . . . . . . . . 17
2.7 Normalenberechnung bei Bézierflächen . . . . . . . . . . . . . . . . . . . . 19
2.8 Unterteilung von Bézierflächen . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.9 Die Newton-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.10 Problemfälle bei der Schnittpunktapproximation . . . . . . . . . . . . . . . . 21
2.11 Flächenumhüllung durch Parallelepiped . . . . . . . . . . . . . . . . . . . . 23
2.12 Bewertungskriterien für Bézierkurven . . . . . . . . . . . . . . . . . . . . . 24
2.13 Binärbaum zur Teilflächenorganisation . . . . . . . . . . . . . . . . . . . . . 25
2.14 Pseudocode zum Aufbau des Suchbaumes . . . . . . . . . . . . . . . . . . . 26
2.15 Pseudocode zum rekursiven Durchlauf des Suchbaumes . . . . . . . . . . . . 27
2.16 Annähernd tangential schneidender Strahl . . . . . . . . . . . . . . . . . . . 30
2.17 Unzureichende Approximation durch Grundfläche . . . . . . . . . . . . . . . 31
2.18 Pseudocode des Iterationsablaufs . . . . . . . . . . . . . . . . . . . . . . . . 32
2.19 Fehlerhafte Überschreitung der Flächengrenzen . . . . . . . . . . . . . . . . 33
2.20 Ein berühmtes Beispiel: Der Utah Teapot . . . . . . . . . . . . . . . . . . . 34
3.1 Integration eines Texturierungssystems . . . . . . . . . . . . . . . . . . . . . 36
3.2 Arten des Texture Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3 Die Mercator-Projektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
213

ABBILDUNGSVERZEICHNIS 214
3.4 Environment Mapping bei Animationen . . . . . . . . . . . . . . . . . . . . 39
3.5 Environment Mapping mit Kugel als Hüllkörper . . . . . . . . . . . . . . . . 39
3.6 Grenzen des Environment Mapping . . . . . . . . . . . . . . . . . . . . . . 40
3.7 Generierung von Rauschen . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.8 2D-Plot des generierten Rauschens . . . . . . . . . . . . . . . . . . . . . . . 43
3.9 Texturbeispiele: Karo- und Klotz-Textur . . . . . . . . . . . . . . . . . . . . 44
3.10 Generierung der Marmor-Textur . . . . . . . . . . . . . . . . . . . . . . . . 45
3.11 Generierung der Holz-Textur . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.12 Perturbation der Flächennormale . . . . . . . . . . . . . . . . . . . . . . . . 47
3.13 Texturbeispiel: Bump Mapping . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.14 Grenzen des Bump Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.1 Die Basisklasse der Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.2 Die Spitze der Textur-Klassenhierarchie . . . . . . . . . . . . . . . . . . . . 57
A.1 Ablauf des Ray Tracing-Prozesses . . . . . . . . . . . . . . . . . . . . . . . 62
A.2 Die Klassenhierarchie der Objekte . . . . . . . . . . . . . . . . . . . . . . . 63
A.3 Die Klassenhierarchie des Texturierungssystems . . . . . . . . . . . . . . . . 64
A.4 Die Klassenhierarchie der Bildformate . . . . . . . . . . . . . . . . . . . . . 65
C.1 Fertig erstelltes Bild der Beispiel-Szene . . . . . . . . . . . . . . . . . . . . 72