Da POV-Ray hier schon mal das eine oder andere Mal erwähnt wurde und ich wie gesagt damit arbeite, möchte ich das Programm einmal genauer vorstellen.
Es handelt sich dabei um einen Standalone-Freeware-Raytracer, der zum einen nach Konversion normale Mesh-Objekte aus externen Modellier-Programmen (wie z.B. Wings 3D) rendern kann.
Doch wie fast jeder Standalone-Raytracer verfügt auch POV-Ray über eine Script-Sprache, mit der sich zunächst einmal einzelne Testszenen erstellen und rendern lassen. Als wohl gängigstes Klischee im Raytracing-Bereich seien hier mal die berüchtigten spiegelnden Kugeln auf Schachbrett-Boden erwähnt.
Hier mal ein Screenshot der POV-Ray-Version für Windows; der integrierte Texteditor ermöglicht dank Syntax-Highlightning recht komfortables Arbeiten:
POV-Rays Skriptsprache kann aber weitaus mehr als nur einfache geometrische Objekte in Szene zu setzen. Allein schon die Tatsache, dass diese Sprache (SDL = Scene Description Language) sich syntaktisch an C++ anlehnt lässt die Mächtigkeit erahnen.
Und in der Tat erlaubt POV-Ray neben prozeduralem Texturieren und den gängigen Raytracing-Funktionen auch noch prozedurales Modellieren mit fast unbegrenzten Möglichkeiten. Neben CSG-Konstrukten, welche mit boolschen Operationen (Zusammenfügen, Wegnehmen und Schnittmenge) arbeiten lassen sich mit komplexeren mathematischen Funktionen Objekte wie etwa \"Isosurfaces\" und Julia-Fraktale generieren. Auch kann man mit eingebauten und selbst geschriebenen Makros anhand mathematischer Regeln Mesh-Objekte erzeugen - letztere lassen sich, wenn man sie als Textdatei abspeichert mit dem ebenfalls kostenlosen Konverter
Poseray sogar ins OBJ-Format zwecks Verwendung in weiteren 3D-Programmen transferieren.
Im Folgenden habe ich mal drei kurze Demo-Szenen vorbereitet, von denen ich jeweils zuerst den Quelltext und danach die daraus erzeugten Bilder zeigen werde. Jeder der dieselbe POV-Ray-Version hat wie ich, sollte im Grunde dieselben Ergebnisse durch bloßes Kopieren und Rendern der Demo-Skripte erzielen können. Alle Objekte und Texturen sind vollkommen prozedural, es kommen nur Elemente zum Einsatz die bereits in POV-Ray und seinen Preset-Include-Dateien vorhanden sind.
Das erste Script - eine ganz banale Einführung:
// Einfache Demo-Szene mit Farbverlauf-texturierter Kugel
// von Tolayon
//=========================================================
camera {
location <5, 3, -5>
look_at <0, 3, 0>
rotate 45*y
angle 45
}
// Weißes Licht
//-------------
light_source {
<60, 40, -80>
color rgb 1
}
// Blauer Hintergrund
//-------------------
background {
color rgb <0.35, 0.4, 0.55>
}
// Einfache Farbe für den Boden
//-----------------------------
#declare Ground_Text =
texture {
pigment {
color rgb <0.85, 0.7, 0.7>
}
}
// Farbverlauf für die Kugel
//--------------------------
#declare Spher_Text =
texture {
pigment {
gradient y
color_map {
[0 color rgb <0.33, 0, 0.66>]
[1 color rgb <0.66, 0, 0.33>]
}
}
scale 2
translate 1*y
}
// Boden mit oben definierter Textur
//----------------------------------
plane {
y, -1
texture { Ground_Text }
}
// Kugel mit oben definierter Textur
//----------------------------------
sphere {
<0, 0, 0>, 1
texture { Spher_Text }
scale 3
translate <0, 1.65, 10>
}
Das dazu gehörige Bild:
_________________________________________________________
Die zweite Szene ist eine Erweiterung des obigen Scripts; Boden und Hintergrund haben nun komplexere Texturen, der Schatten ist dank Area-Light weicher, die Oberflächen-Eigenschaften der Kugel wurden erweitert und zwei Würfel erstellt, die sich in selbiger Kugel widerspiegeln:
// Erweiterte Demo-Szene mit Farbverlauf-texturierter Kugel
// von Tolayon
//=========================================================
camera {
location <5, 3, -5>
look_at <0, 3, 0>
rotate 45*y
angle 45
}
// Weißes Licht mit weichem Schatten
//----------------------------------
light_source {
<60, 40, -80>
color rgb 1
area_light
<8, 0, 0> <0, 0, 8>
4, 4
adaptive 0
jitter circular orient
}
// Preset-Himmel
//--------------
#include \"colors.inc\"
#include \"skies.inc\"
sky_sphere { S_Cloud1 rotate 45*y }
// Zum Horizont passender Bodennebel
//----------------------------------
fog {
fog_type 2
distance 177
color rgb <0.847, 0.749, 0.847>
fog_offset 0.1
fog_alt 0.2
turbulence 0.8
}
// Steinmuster für den Boden
//--------------------------
#declare Ground_Text =
texture {
pigment {
granite
color_map {
[0 color rgb <0.1, 0.05, 0.05>]
[0.65 color rgb <0.9, 0.8, 0.75>]
}
}
// Bump-Map für den Boden,
// selbes Muster wie Textur
//-------------------------
normal {
pigment_pattern {
granite
color_map {
[0 color rgb 0]
[0.65 color rgb 1]
}
}
0.5
} // Ende Bump-Map
finish {
ambient 0.175
diffuse 0.75
specular 0.15
roughness 1
}
}
// Farbverlauf für die Kugel
//--------------------------
#declare Spher_Text =
texture {
pigment {
gradient y
color_map {
[0 color rgb <0.33, 0, 0.66>]
[1 color rgb <0.66, 0, 0.33>]
}
}
// Oberflächen-
// Beschaffenheit
//---------------
finish {
ambient 0.1
diffuse 0.75
specular 0.8
roughness 0.015
reflection 0.175
}
scale 2
translate 1*y
}
// Boden mit oben definierter Textur
//----------------------------------
plane {
y, -1
texture { Ground_Text scale 3.25 }
}
// Kugel mit oben definierter Textur
//----------------------------------
sphere {
<0, 0, 0>, 1
texture { Spher_Text }
scale 3
translate <0, 1.65, 10>
}
// Würfel, die sich in Kugel spiegeln
//-----------------------------------
#declare Cube =
box {
<-1, -1, -1> <1, 1, 1>
pigment {
color rgb <0.05, 0.25, 0>
}
scale 3
}
object { Cube translate <9, 1.5, -9> }
object { Cube translate <-9, 1.5, -9> }
Gerade hier sagt das entsprechende Bild mehr als tausend Worte:
_________________________________________________________
Kommen wir nun zu einer einfachen Demonstration von prozeduralem Modellieren - ein abstraktes säulenartiges Objekt sowie ein Ring aus einzelnen Ringsegmenten:
// Demo-Szene mit einfacheren CSG-Objekten
// von Tolayon
//===========================================
global_settings { max_trace_level 20 }
camera {
location <0, 3, -5>
look_at <0, 3, 0>
}
light_source {
<60, 40, -80>
color rgb 1
area_light
<8, 0, 0> <0, 0, 8>
4, 4
adaptive 0
jitter circular orient
}
sky_sphere {
pigment {
gradient y
color_map {
[0 color rgb <0.1, 0, 0.7>]
[1 color rgb <0.05, 0.1, 0.3>]
}
scale 100
}
}
// Zum Horizont passender Bodennebel
//----------------------------------
fog {
fog_type 2
distance 200
color rgb <0.1, 0, 0.7>
fog_offset 0.1
fog_alt 0.2
turbulence 0.8
}
// Berüchtigtes Schachbrett-Muster
//--------------------------------
#declare Checker =
texture {
pigment {
checker
color rgb <0.7, 0.675, 0.65>
color rgb <0.5, 0.45, 0.4>
}
finish {
ambient 0.2
diffuse 0.75
specular 0.85
roughness 0.5
reflection 0.075
}
}
// Metall-Texturen für die
// zusammengebauten Objekte
//-------------------------
#declare Gold_Silver =
texture {
pigment { color rgb <0.675, 0.675, 0.55> }
finish {
ambient 0.1 diffuse 0.6
specular 0.9 metallic
roughness 0.0005
reflection { 0.55 metallic }
}
}
#declare Copper =
texture {
pigment { color rgb <0.65, 0.35, 0.15> }
finish {
ambient 0.2 diffuse 0.65
specular 0.85 metallic
roughness 0.001
reflection { 0.5 metallic }
}
}
// Säulenartiges CSG-Objekt
//-------------------------
#declare Pillaroid =
difference {
intersection {
sphere {
<0, 1, 1>, 1.2
scale <1, 4, 1>
}
sphere {
<0, 1, 0>, 4
}
}
cylinder {
<0, 2, -1.01>
<0, 2, 1.01>, 0.433
}
}
// Ring aus Einzelringen
//----------------------
#declare Segm_Torus =
torus {
0.8, 0.1
rotate 90*x
translate -8*x
}
#declare Meta_Torus =
union {
#local Incr = 0;
#local Num = 250;
#while (Incr < Num)
object {
Segm_Torus
rotate (Incr*360/Num)*y
}
#local Incr = Incr+1;
#end
}
// Boden mit Schachbrett-Muster
//-----------------------------
plane {
y, -1
texture { Checker rotate -42*y }
}
// Erstes vordefiniertes Objekt
//-----------------------------
object {
Pillaroid
texture { Gold_Silver }
scale 1.5
translate <0, -1.5, 15>
}
// Zweites vordefiniertes Objekt
//------------------------------
object {
Meta_Torus
texture { Copper }
translate <0, -0.1, 15>
}
// Würfel, die sich in Objekten spiegeln
//--------------------------------------
#declare Cube =
box {
<-1, -1, -1> <1, 1, 1>
pigment {
color rgb <0.05, 0.25, 0>
}
scale 3
}
object { Cube translate <-12, 1.5, -9> }
object { Cube translate <12, 1.5, -9> }
Und so sieht das Ganze aus:
Zu guter Letzt noch der offizielle Link, wo man POV-Ray runterladen kann und weitere Ressourcen vorfindet:
POVRay.org
