Forum > 3D Programme im Detail
POV-Ray -- Raytracing und mehr
Tolayon:
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:
--- Zitat ---
// Einfache Demo-Szene mit Farbverlauf-texturierter Kugel
// von Tolayon
//=========================================================
camera {
location
look_at
rotate 45*y
angle 45
}
// Weißes Licht
//-------------
light_source {
color rgb 1
}
// Blauer Hintergrund
//-------------------
background {
color rgb
}
// Einfache Farbe für den Boden
//-----------------------------
#declare Ground_Text =
texture {
pigment {
color rgb
}
}
// Farbverlauf für die Kugel
//--------------------------
#declare Spher_Text =
texture {
pigment {
gradient y
color_map {
[0 color rgb ]
[1 color rgb ]
}
}
scale 2
translate 1*y
}
// Boden mit oben definierter Textur
//----------------------------------
plane {
y, -1
texture { Ground_Text }
}
// Kugel mit oben definierter Textur
//----------------------------------
sphere {
, 1
texture { Spher_Text }
scale 3
translate
}
--- Ende Zitat ---
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:
--- Zitat ---
// Erweiterte Demo-Szene mit Farbverlauf-texturierter Kugel
// von Tolayon
//=========================================================
camera {
location
look_at
rotate 45*y
angle 45
}
// Weißes Licht mit weichem Schatten
//----------------------------------
light_source {
color rgb 1
area_light
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
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.65 color rgb ]
}
}
// 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 ]
[1 color rgb ]
}
}
// 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 {
, 1
texture { Spher_Text }
scale 3
translate
}
// Würfel, die sich in Kugel spiegeln
//-----------------------------------
#declare Cube =
box {
pigment {
color rgb
}
scale 3
}
object { Cube translate }
object { Cube translate }
--- Ende Zitat ---
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:
--- Zitat ---
// Demo-Szene mit einfacheren CSG-Objekten
// von Tolayon
//===========================================
global_settings { max_trace_level 20 }
camera {
location
look_at
}
light_source {
color rgb 1
area_light
4, 4
adaptive 0
jitter circular orient
}
sky_sphere {
pigment {
gradient y
color_map {
[0 color rgb ]
[1 color rgb ]
}
scale 100
}
}
// Zum Horizont passender Bodennebel
//----------------------------------
fog {
fog_type 2
distance 200
color rgb
fog_offset 0.1
fog_alt 0.2
turbulence 0.8
}
// Berüchtigtes Schachbrett-Muster
//--------------------------------
#declare Checker =
texture {
pigment {
checker
color rgb
color rgb
}
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 }
finish {
ambient 0.1 diffuse 0.6
specular 0.9 metallic
roughness 0.0005
reflection { 0.55 metallic }
}
}
#declare Copper =
texture {
pigment { color rgb }
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 {
, 1.2
scale
}
sphere {
, 4
}
}
cylinder {
, 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
}
// Zweites vordefiniertes Objekt
//------------------------------
object {
Meta_Torus
texture { Copper }
translate
}
// Würfel, die sich in Objekten spiegeln
//--------------------------------------
#declare Cube =
box {
pigment {
color rgb
}
scale 3
}
object { Cube translate }
object { Cube translate }
--- Ende Zitat ---
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
The Animaniac:
Wozu wird das verwendet, kenne das nur vom Namen her?
Tolayon:
Wie gesagt als Software-Renderer für Raytracing; obendrein noch zum alleinigen Erstellen kompletter Inhalte und Szenen - je nachdem wie gut man sich damit auskennt.
Es braucht natürlich schon ein gewisses Abstraktions-Vermögen um bildliche Vorstellungen in der Script-Sprache umzusetzen, welche wiederum ein Bild ergeben soll das den ursprünglichen Vorstellungen möglichst genau entspricht.
Da man eine visuelle Kontrolle nur nach ersten Test-Rendern hat, kann man auch Objekte und Szenen in anderen Programmen zusammenstellen, dann in das POV-Ray-Format konvertieren und dort rendern lassen.
Was Qualität und Geschwindigkeit angeht:
Aus heutiger Sicht kann POV-Ray da nicht mehr ganz mit aktuellen und vor allen Dingen kostenpflichtigen High-End-Raytracern mithalten; dennoch liefert es Ergebnisse die man je nach Einstellung schon nahe an fotorealistisch ansiedeln würde.
Ein echtes Manko ist die Render-Geschwindigkeit: Abhängig davon, wie groß das Bild ist und welche Effekte man einsetzt um eine möglichst realistische Darstellung zu erzielen, kann es selbst auf modernen Computern bis zu mehreren Wochen (!) dauern bis das Bild fertig ist.
Die letzte stabile Vollversion (3.6 die auch ich habe) unterstützt dabei noch keine multiplen Prozessorkerne - das kann erst POV-Ray 3.7 das derzeit noch als Beta existiert.
Mr Ronsfield:
Das ist sicher für seinen anwendungsbereich eine sehr gute anwendung!
Aber die Szene mit der Kugel, da brauch ich in C4D ca 5 min für. Und das Rendern würde vielicht 20 min dauern!
Da kommt mir POV-Ray etwas umständlich vor :(
Aber für jeden das mit dem er am besten klar kommt :]
Selius:
@ Mr Ronsfield
Nun ich will dir nicht wiedersprechen aber die Szene mit der würde sogar ich mit meinen geringen Ressourcen in weniger als einer Minute rendern und das in einer top Auflösung. ;)
Navigation
[0] Themen-Index
[#] Nächste Seite