Raytracing mit POV-Ray: Erste Schritte

Erste Schritte

In diesem Kapitel werden wir Schritt für Schritt die erste Szene aufbauen. Das Ergebnis wird noch nicht so wahnsinnig spektakulär sein, dafür machen wir uns mit der Syntax und den wichtigsten Elementen einer POV-Ray-Szene vertraut. Noch ein ganz wichtiger Hinweis: Bei der Wiedergabe der Quelltexte wird zur besseren Orientierung eine Zeilennummerierung verwendet. Die Zeilennummern dürfen beim Nachprogrammieren jedoch nicht übernommen werden!

Ein paar Vorbereitungen

Viel braucht man nicht, um mit POV-Ray arbeiten zu können: POV-Ray selbst natürlich und einen Texteditor. Windows-Nutzer bekommen beides in einem Paket, hier empfiehlt es sich, die kleine Entwicklungsumgebung zu nutzen, die POV-Ray sozusagen mitliefert. (Obwohl der Weg über einen externen Editor, wie zum Beispiel Notepad, und die Kommandozeile natürlich auch geht.)

Linux-Nutzer können den Editor ihrer Wahl verwenden. Zu empfehlen sind beispielsweise Vim und Emacs (nicht nur für POV-Ray). Wer sich mit diesen Editoren ein wenig auskennt, kann sie für POV-Ray-Zwecke so einstellen (für (X)Emacs gibt es einen speziellen Modus für povray, pov-mode.el), dass der gleiche Komfort wie bei Windows erreicht wird - wenn nicht sogar mehr.

In das Editor-Fenster tragen wir als erste Zeile ein (Zur Erinnerung: ohne Zeilennummer!):

#include "colors.inc"

Das ist ein so genanntes Include-Statement wie es auch in anderen Programmiersprachen vorkommt. Es weist POV-Ray an, den Inhalt der angegebenen Datei, in diesem Fall colors.inc, in unserer Szene mit zu berücksichtigen. colors.inc ist eine Include-Datei, die POV-Ray mitbringt. In ihr sind Farben definiert, auf die wir nun ganz bequem über einen Farbnamen zugreifen können.

POV-Ray bietet eine ganze Reihe von Include-Dateien, die unter anderem Formen, Farben und Texturen enthalten. Man kann sie als eine Art Bibliothek ansehen, in der man sich mit bereits vorgefertigen Modulen versorgen kann. Wir werden im Laufe der Zeit noch weitere Include-Dateien kennenlernen.

Tipp: Um zu erfahren, was die Include-Dateien alles so mitbringen, kann man sie sich natürlich anschauen. Wer sich ein wenig mit POV-Ray auskennt, kann sich dort jede Menge Anregungen holen.

Natürlich kann man auch selbst Include-Dateien schreiben und so eigene Bibliotheken zusammenstellen, die sich in verschiedenen Szenen verwenden lassen.

So, nun sollten wir unsere Szenen-Datei erstmal speichern. POV-Ray-Szenen erhalten die Dateiendung .pov. Wir könnten unsere Datei also z. B. ersteszene.pov nennen.

Die Kamera wird aufgestellt

So, nun wird es langsam ernst. Um überhaupt etwas sehen zu können, brauchen wir ein Auge, das unsere Szene betrachtet. In der Welt der 3D-Software spricht man in diesem Zusammenhang oft von der Kamera. Wir setzen also unseren Quelltext fort und definieren eine Kamera:

camera {
    ultra_wide_angle
    angle 75
    location <2, 3, -4>
    look_at <0, 1, 2>
}

Eine Kamera braucht zunächst einen Standpunkt. Der wird über die location-Anweisung definiert. Die drei Zahlen in den spitzen Klammern legen die x-, y- und z-Koordinaten im dreidimensionalen Raum fest. Zu den wichtigen Themen Koordinaten und Koordinatensystem kommen wir später noch. Hier nur so viel: Um unsere Kamera aufzustellen, gehen wir vom Ursprung unserer 3D-Welt (im Punkt 0, 0, 0) zwei Schritte nach rechts, drei nach oben und vier zurück.

Die look_at-Anweisung definiert dann den Punkt, auf den die Kamera blickt. Die angle-Anweisung gibt den Blickwinkel an. Das Schlüsselwort "ultra_wide_angle" bewirkt, dass der Wert nach angle höher als 180° sein kann. Dies eignet sich wenn man z.B. eine Landschaft durch ein Fischauge betrachten will. Diese beiden Werte können sie aber getrost weglassen, da sie im Gegensatz zu den Anweisungen "location" und "look_at" optional sind.

Probieren Sie's aus: Wenn Sie später mit der Szene so weit fertig sind, ändern Sie einfach die location- und look_at Koordinaten. Sie erleben dann eine ganz neue Sicht der Dinge

Nun wird es Zeit, sich ein wenig mit der Syntax von POV-Ray vertraut zu machen. Wenn Sie noch nie programmiert haben, wird Sie das Ganze vielleicht ein wenig verwirren, aber das Grundsystem ist leicht zu durchschauen.

Jedes Objekt in POV-Ray wird durch ein spezielles Schlüsselwort (in diesem Fall camera) definiert, auf das ein Block folgt, der von geschweiften Klammern umschlossen wird. Alles, was in diesem Block steht, wirkt sich auf das jeweilige Objekt aus. Wie wir später noch sehen werden, lassen sich Blöcke ineinander verschachteln.

Koordinaten werden mit spitzen Klammern umschlossen, für spezielle Fälle gibt es aber auch Kurzschreibweisen. Auch darauf werden wir noch eingehen.

Wie Sie den Quelltext formatieren, ob Sie einrücken, Leerzeilen, etc. setzen, ist POV-Ray ziemlich egal. In Ihrem eigenem Interesse sollten Sie sich aber - wie in der Programmierung überhaupt - eine übersichtliche Formatierung angewöhnen. Dass es hier z.B. nach dem include-Statement mit der Zeile 3 weitergeht, weist darauf hin, dass im Originalquelltext eine Leerzeile eingefügt wurde.

Wenn auch die Formatierung für POV-Ray eher nebensächlich ist, die Schreibweise der einzelnen Wörter im Quellcode ist es auf keinen Fall! Hier müssen Sie sehr pingelig sein. Achten Sie genau auf Groß- und Kleinschreibung und auf jedes einzelne Zeichen. Ein vergessenes Komma oder ein zu viel gesetztes Semikolon (ein beliebtes Zeichen in anderen Programmiersprachen) erzeugen einen Fehler und führen dazu, dass die Szene nicht gerendert werden kann.

Natürlich lassen sich auch in POV-Ray-Skripten Kommentare einfügen, d. h. Passagen, die vom Programm selbst ignoriert werden, die aber der Erläuterung der eigenen Quelltexte dienen. Verwenden Sie einen doppelten Schrägstrich, so wird alles dahinter bis zum Ende der Zeile als Kommentar gewertet. Die Zeile 6 könnte dann z.B. so aussehen:

    location <2, 3, -4> // Standpunkt der Kamera

Längere Passagen lassen sich mit /* und */ umschließen. Alles, was dazwischen steht wird als Kommentar gewertet.

Tipp: Machen Sie von Kommentaren Gebrauch! Nicht übermäßig - aber dort, wo etwas nicht auf den ersten Blick offensichtlich ist. Andere und vor allem Sie selbst werden über Kommentare dankbar sein, wenn Sie sich Ihren Quellcode nach längerer Zeit mal wieder vornehmen. Ein guter Einsatzzweck für Kommentare ist außerdem, Teile des Codes "auszuschalten". Nehmen wir an, Sie wollen zwei Kameras testen. Definieren Sie beide, und kommentieren sie Sie anschließend wechselweise aus. So können Sie Effekte "löschen", ohne gleich den Code - den man vielleicht noch mal gebrauchen kann - ganz entfernen zu müssen.

Zur Syntax von POV-Ray sollte soviel an dieser Stelle genügen. Nun wird es darum gehen, dass wir etwas zu sehen bekommen.

Wir bauen die ersten Objekte

Als erstes sichtbares Objekt konstruieren wir eine Kugel. Dazu ergänzen wir unseren Quelltext wie folgt:

sphere {
    <0, 1, 2>, 2
    pigment { color Yellow }
}

Mit dem Bezeichner sphere wird eine Kugel definiert. Die Koordinaten in Zeile 9 bestimmen die Position des Mittelpunkts der Kugel, die Zahl hinter dem geklammerten Ausdruck bezeichnet den Radius, in diesem Fall also zwei Einheiten. Ganz wichtig: Vergessen Sie nicht das Komma hinter der schließenden spitzen Klammer, sonst meldet POV-Ray einen Fehler.

Die Anweisung in Zeile 10 weist der Kugel eine Farbe zu. Da wir ganz am Anfang unseres Skripts die Datei colors.inc eingebunden haben, können wir auf die dort definierte Farbe Yellow, also Gelb, zurückgreifen.

Damit unsere Szene nicht gar so langweilig wirkt, definieren wir gleich noch ein zweites Objekt, das auch sehr häufig verwendet wird: eine Ebene.

plane {
    <0, 1, 0>, -1
    { checker color White, color Blue }
}

Eine Ebene - erzeugt mit dem Bezeichner plane - erstreckt in alle Richtungen bis ins Unendliche. Die Koordinatendefinition gibt die Lage der Ebene daher in etwas anderer Weise an, als dies bei den übrigen Objekten der Fall ist. Es wird einfach nur eine 1 an der x-, y- oder z-Stelle gesetzt. Damit markiert man die Flächennormale. Eine Normale ist, vereinfacht gesagt, das senkrechte Lot auf einer Fläche. Die 1 an der y-Position in unserem Beispiel markiert ein Lot, das in y-Richtung, also von oben nach unten, auf unserer Ebene steht. Damit haben wir eine Fläche, die quasi zu unseren Füßen liegt - ein Fußboden sozusagen. Mit der Zahl hinter dem geklammerten Ausdruck lässt sich die Ebene verschieben. In unserem Fall um eine Einheit nach unten.

Unserem Boden weisen wir eine besondere "Bemalung" zu: Wir bedienen uns eines "Klassikers" der 3D-Animation - das Schachbrettmuster. Das wird mit dem Bezeichner checker eingeleitet. Die beiden color-Angaben definieren die Farben der Schachfelder: weiß und blau.

Licht an!

Wenn Sie es vor lauter Ungeduld nicht mehr abwarten konnten und den bisherigen Quellcode schon mal haben rendern lassen, dann dürften Sie ein ziemlich enttäuschendes Ergebnis erhalten haben: eine düstere Szene ohne jegliche Dreidimensionalität.

Vielleicht haben Sie sich aber auch gewundert, dass überhaupt etwas zu sehen ist. Schließlich haben wir noch kein Licht in unserer Szene definiert, und ohne Licht sieht man ja bekanntlich gar nichts. Dass wir schon ein sichtbares, wenn auch wenig ansehnliches Ergebnis haben, liegt an den Standardeinstellungen von POV-Ray, die im Hintergrund vorgenommen werden, ohne dass wir dafür eine Zeile Code schreiben müssen. Und so definiert POV-Ray standardmäßig ein so genanntes ambientes Licht, das diesen Dämmereindruck bewirkt. Was genau dieses ambiente Licht ist, und welche anderen Lichtarten es gibt, werden wir später noch genauer erfahren.

Um unserer Szene eine etwas freundlichere Optik zu verschaffen, begnügen wir uns für den Augenblick damit, eine einfache Punktlichtquelle zu definieren. Eine Punktlichtquelle strahlt ihr Licht gleichmäßig in alle Richtungen ab. Wir fügen also an unseren bisherigen Quelltext noch folgende Zeilen an:

light_source {
    <3, 5, -4>
    color White
}

Die Definition dieser Lichtquelle ist denkbar einfach: Die Koordinaten geben den Standort der Lichtquelle an. Da die Punktlichtquelle in alle Richtungen strahlt, sind keine Richtungsangaben oder Ähnliches erforderlich. Die Farbdefinition beschreibt die Farbe des Lichts. Um einen guten Eindruck der Szene zu bekommen, ist die Lichtfarbe Weiß sicher keine schlechte Wahl. Farbige Lichter verändern die Eigenfarben der Objekte und können für spezielle Effekte eingesetzt werden.

Von der Textdatei zum fertigen Bild

Vermutlich haben Sie schon herausgeknobelt, wie man ein sichtbares Ergebnis - sprich ein Bild - unserer bisherigen Bemühungen erreicht. Trotzdem sollen hier noch einige Erklärungen zum Starten des Render-Vorgangs gegeben werden.

Unter Windows ist die Angelegenheit denkbar einfach. Im POV-Ray-Editor gibt es einen Run-Button, den man anklickt, um das Rendern der Szene zu starten.

Unter Linux verwendet man den Befehl povray auf der Kommandozeile unter Zuhilfenahme einiger Optionen. Mit diesen Befehlszeilenargumenten sollten sich auch Windows-Nutzer befassen, denn sie lassen sich auch in der Windows-Version einsetzen.

Vorausgesetzt Sie befinden sich im Verzeichnis, in dem Ihre .pov-Datei liegt, könnte ein Kommando unter Linux so aussehen:

povray ersteszene.pov +W800 +H600 +P

Als erstes Argument übergeben wir dem Kommando povray den Namen der zu rendernden Datei (ersteszene.pov). Die Reihenfolge der Argumente danach ist eigentlich egal. Wir definieren Breite und Höhe der Bildschirmausgabe (in Pixeln) mit den Argumenten +W800 bzw. +H600. +P sorgt dafür, dass das Bild nach dem Rendern nicht sofort wieder verschwindet, sondern solange auf dem Bildschirm angezeigt wird, bis wir es durch einen Mausklick (egal wo) wegklicken.

Wollen Sie eine qualitativ etwas bessere Ausgabe, dann schalten Sie Antialiasing ein, z.B. mit +A0.3. Der so genannte Treppcheneffekt wird dann reduziert. Es gibt noch sehr viel mehr Optionen, die das Verhalten von POV-Ray steuern. Detaillierte Ausführungen dazu finden Sie in der POV-Ray-Referenz unter [1].

POV-Ray legt - soweit nichts an den Standardeinstellungen geändert wurde - bei jedem Render-Vorgang eine Bild-Datei mit dem Render-Ergebnis im selben Verzeichnis ab, wo auch die .pov-Datei liegt. Die Bild-Datei hat den gleichen Namen wie die .pov-Datei und wird in der Regel bei jedem neuen Render-Vorgang aktualisiert, d. h. überschrieben. Standardmäßig wird unter Windows eine BMP-Datei erzeugt, unter Linux eine PNG-Datei. Das Grafikformat lässt sich aber auch über die Befehlzeilen-Argumente verändern.

So oder so ähnlich sollte nun unsere erste POV-Ray-Szene aussehen:

Die erste POV-Ray-Szene

Das Koordinatensystem

Mit der ersten Szene sind bereits grundlegende Prinzipien von POV-Ray erklärt worden. Die tatsächlichen Möglichkeiten bezüglich Formen, Texturen, Licht, etc. wurden jedoch nicht einmal ansatzweise angerissen. Bevor es damit weitergeht, wollen wir uns in diesem Abschnitt jedoch mit einer elementaren Grundvoraussetzung für das Arbeiten in POV-Ray (wie überhaupt mit 3D-Software) auseinandersetzen: dem dreidimensionalen Koordinatensystem. Sollte Ihnen das alles schon geläufig sein, können Sie gerne zum nächsten Kapitel übergehen. Interessant ist vielleicht aber auch für Fortgeschrittene die Konstruktion eines 3D-Koordinatensystems am Ende dieses Abschnitts.

Beim Erstellen von 3D-Bildern sowohl auf einem Blatt Papier als auch am Computerbildschirm stößt man auf ein elementares Problem. Beide, Papier und Monitor, sind flach, sprich ohne Tiefe, und damit nur zweidimensional. Auch bei POV-Ray-Szenen handelt es sich daher in Wirklichkeit nicht um echte Dreidimensionalität, sondern um eine zweidimensionale Darstellung des Raumes, die den Eindruck von Räumlichkeit erweckt, weil sie den Gesetzen der Perspektive folgt. Eigentlich würde es auch bei POV-Ray, und anderer 3D-Software, genügen, mit einem zweidimensionalen Koordinatensystem zu arbeiten.

Allerdings stellt man schnell fest, dass es einfacher ist räumliche Szenen zu erzeugen, wenn man tatsächlich in drei Koordinaten denkt - nämlich so, wie man sich die Szene in der Realität vorzustellen hat. Der Computer rechnet bzw. projiziert die 3D-Koordinaten dann auf die zweidimensionale Darstellung am Bildschirm um.

Das dreidimensionale Koordinatensystem fügt der x- und y-Achse des altbekannten zweidimensionalen Systems noch eine z-Achse hinzu. Wichtig: Alle Achsen stehen senkrecht aufeinander. POV-Ray verwendet standardmäßig das so genannte linkhändige Koordinatensystem. Das bedeutet: Hebt man die linke Hand so in die Höhe, dass der Daumen nach rechts zeigt (also so, wie wenn man etwas greifen würde), dann zeigt der Daumen in Richtung der positiven x-Achse. Nun lässt sich der Zeigefinger ausstrecken, der nach oben weist - in Richtung der positiven y-Achse. Der ausgestreckte Mittelfinger weist von einem weg - in Richtung der positiven z-Achse.

Dort, wo sich die drei Achsen schneiden, ist der so genannte Ursprung mit den Koordinaten 0, 0, 0. Von dort aus wird gezählt. Läuft man entlang der z-Achse ein "paar Schritte nach hinten", also in negative z-Richtung, lässt sich das Koordinatensystem wie folgt betrachten: Rechts vom Ursprung wachsen die x-Koordinaten immer weiter in den positiven Bereich, links davon immer weiter in den negativen. Oberhalb des Ursprungs werden die y-Koordinaten immer größer, unterhalb immer kleiner. Je größer die z-Koordinaten werden, desto mehr läuft man - bildlich gesprochen - in den Raum (in den Bildschirm) hinein, je kleiner (negativer) sie werden desto mehr läuft man heraus.

Natürlich gilt diese Vorstellung nur bei einem linkshändigen Koordinatensystem, unter der Voraussetzung, dass der Betrachter in negative z-Richtung gewandert ist und von dort auf den Ursprung schaut. Das Problem bei 3D-Systemen ist, dass letzlich alles relativ ist - je nachdem wie man Koordinatensystem und Betrachtungsstandpunkt definiert.

Zurück zu Raytracing mit POV-Ray |

Hoch zum Inhalt |

Vor zu Körper