Anatomie d'un fichier Povray
pour utiliser Geomorph

Introduction
La structure d'ensemble du fichier d'une scène Povray / Geomorph
Les inclusions de fichiers et les déclarations de variables
Le fichier "global_setting.inc"
Les objets de base à définir dans un fichier Geomorph / Povray
La caméra
Le Soleil et la lumière
Le ciel
Les nuages
L'eau
Le sol
Le brouillard
Le terrain
L'ajout d'autres objets

Voyez aussi le guide des textures.

Introduction

Geomorph offre quelques scènes Povray prédéfinies permettant de produire des paysages avec un minimum de travail. Cependant, pour profiter d'une plus grande liberté dans la conception des paysages, il est nécessaire d'apprendre à éditer ses propres scènes Povray.

Maîtriser Povray n'est pas facile, mais il n'est pas nécessaire d'être un expert pour obtenir des résultats intéressants.

Modifier les scènes prédéfinies Geomorph est un bon point de départ. Cette page explique comment elles sont construites et à quoi vous devez porter attention.

Dans les faits, la création de paysages acceptables ne requiert qu'un sous-ensemble du langage Povray. Les textures sont probablement les éléments les plus importants dans la recherche du réalisme.

Après avoir lu cette page, les scènes prédéfinies de Povray et le guide des textures, si vous désirez allez plus loin, Ije recommande que vous preniez connaissance du tutoriel et de la référence Povray sur www.povray.org. Vous pouvez aussi rechercher des exemples sur la Toile. Quelques liens sont mentionnés sur cette page.

HintQuand vous modifiez un fichier Povray exécuté à partir de Geomorph, démarrez Geomorph à partir d'une console X, afin de lire les messages d'erreur Povray.

La structure d'ensemble du fichier d'une scène Povray / Geomorph

Un fichier de scène Povray est un fichier en format texte avec l'extension .pov.

Les exemples de cette page réfèrent au fichier mountains.pov, à moins d'avis contraire.

Le fichier est arbitrairement divisé en 3 parties:
  1. La première partie contient les fichiers "include" et les déclarations de variables.
  2. La seconde partie contient les déclarations des objets de base.
  3. La troisième partie, après une ligne de *, rappelle les objets de base d'une manière sommaire.
Dans la troisième partie, la ligne de * n'est pas un standard Povray, ce n'est qu'une façon d'améliorer la lisibilité des scènes Geomorph. Cette partie vous permet d'activer / désactiver rapidement les objets, ou des les déplacer, les mettre à l'échelle ou les tourner, sans avoir à parcourir l'ensemble du texte de la scène, qui peut être parfois long.

Les fichiers "include" et les déclarations de variables

Les fichiers "include" sont des définitions Povray conformes mais incomplètes, qui ne peuvent pas être exécutées seules. Le fichier d'une scène contient habituellement des fichiers "include" standard, trouvés là où le logiciel Povray est installé (quelque chose comme /usr/local/share/povray/include):

#include "colors.inc"    // Couleurs standard
#include "textures.inc"    // Textures standard
#include "skies.inc" // Ciels Povray standard

Le texte précédé de // est considéré comme un commentaire.

Geomorph fournit aussi ses propres textures, copiées à partir du répertoire où Geomorph est installé (/usr/local/share/geomorph/<version>/) vers le répertoire privé "geomorph" de l'utilisateur quand install-user est exécuté ou la première fois que Geomorph est démarré:

#include "maprock1.inc"    // Carte de textures rocheuses
#include "slope_patterns.inc"
#include "geomorph_txtr.inc" // Ce fichier n'est pas utlisé dans mountains.pov

Ces fichiers étant copiés dans votre répertoire "geomorph", vous pouvez en éditer les textures à votre guise.

Version 0.40 et ultérieures

Maintenant il suffit d'inclure geomorph.inc, qui inclut les trois fichiers. Ainsi la séquence d'appel sera:

#declare rock_color = 0.5*(<0.72,0.66,0.4>) ;
#declare rock_turbulence=0.2;
...
#include "geomorph.inc"

Les variables globales de Povray sont aussi habituellement déclarées au début du fichier de définition de scène *.pov, mais elles peuvent l'être à n'importe quel endroit. Par exemple, mountains.pov contient ces déclarations:

#declare rock_color = 0.5*(<0.72,0.66,0.4>) ;
#declare rock_turbulence=0.2;
#declare rock_scale=0.05;
#declare rock_normal=1.5;
#declare sky_density=0.6;
#declare forest_color_density=0.8;
#declare water_density=0.35;
#declare fog_distance=10;
#declare fog_transparency=0.1;
#declare fog_altitude=0.15;

"rock_color" est utilisé dans "maprock1.inc". "maprock1.inc" fournit des variations de gradient par bandes, à partir de la couleur de référence donnée par "rock_color" (pensez à des roches sédimentaires).

Les autres variables sont utilisées dans "slope_pattern.inc" ou dans le fichier *.pov courant, comme paramètres à la définition des objets de base.

La plupart des variables dans les fichiers "include" de Geomorph ne sont pas obligatoires. Lorsqu'elles ne sont pas définies par l'utilisateur, le fichier "include" les initialise à une valeur par défaut. Cette initialisation est introduite par le mot-clé "#ifndef".

Naturellement, une variable utilisée dans un fichier "include" doit être déclarée avant l'instruction "#include", pas après!

Les variables Povray requièrent quelques précisions. Il peut s'agir de scalaires (ex. 10, 0.1,...) ou de vecteurs (<0.72, 0.66, 0.4>). Le séparateur décimal est obligatoirement le point. Un vecteur signifie, selon le contexte, les coordonnées <x,y,z>, ou les couleurs <rouge,vert,bleu>. Tout scalaire ou vecteur peut être remplacé par une formule. Par exemple, 0.5*<1.0,1.0,1.0> équivaut à <0.5,0.5,0.5>; cette syntaxe est utile pour réduire ou augmenter globalement la densité d'une couleur. la déclaration doit se terminer par un point-virgule.

En ce qui a trait aux vecteurs <x,y,z>, souvenez-vous que X est l'axe gauche - droit, Y est l'axe bas - haut, et Z l'axe avant - arrière.
The Povray axis

Le fichier "global_setting.inc"

Si vous n'initialisez pas la variable Display_gamma dans votre fichier povray.ini, et si vos résultats ne sont ni trop sombres ni trop clairs, vous pouvez passer à la prochaine section.

À partir de la version 0.23 de Geomorph, un fichier "global_settings.inc" est partagé par toutes les scènes Povray prédéfinies dans Geomorph. Les scènes prédéfinies vérifient si le fichier existe, et si c'est le cas, exécutent la directive "#include".

Ce fichier, dans la version 0.40, ne contient que la variable assumed_gamma initialisée à la valeur de la variable Display_gamma trouvée dans povray.ini, si cette variable existe. Autrement, global_settings.inc ne contient que des commentaires.

Le gamma est une propriété de votre système d'affichage. Le guide de référence Povray (voir www.povray.org) explique comment l'évaluer.

La variable assumed_gamma fonctionne avec le paramètre Display_gamma de votre fichier .INI (/home/<you>/.povray/3.6/povray.ini).

Povray ajuste la densité de l'image de sortie selon la relation entre assumed_gamma et Display_gamma.

Vous n'avez pas à utiliser Display_gamma et assumed_gamma si vous êtes satisfait de la densité des images que vous produisez.

Cependant, après une première installation de Geomorph 0.23, ou une mise à jour des fichiers dans le répetoire /home/<vous>/geomorph, assumed_gamma sera actif. Si vous n'initialisez pas Display_gamma dans votre fichier povray.ini, un gamma de 2.2 est assumé par Povray. Cette valeur est assez élevée et vos paysages risquent d'être trop clairs.

Voici en gros ce que vous pouvez faire:
Les objets de base requis dans une scène Geomorph / Povray

La création d'un paysage requiert généralement:
À part les arbres et les objets similaires, les nuages, l'eau, le sol et la brume ou le brouillard peuvent être considérés optionnels, et même le ciel si vous désirez un arrière-plan noir!

La caméra

La caméra est déclarée de cette façon:

#declare maincamera =
camera
{
    location    <0,  0, -0.1>    // <X Y Z>
    angle     gl_angle
    up        y                  // which way is +up <X Y Z>
    right        aspect_ratio*x             // which way is +right <X Y Z> and aspect ratio
    look_at    <0, 0, 0>     // point center of view at this point <X Y Z>
}

Elle est rappelée ainsi:

camera {maincamera
        translate <0+tr_x,0.05+tr_y,tr_z>
        rotate <rot_x,0+rot_y,0+rot_z> }

Les variables gl_angle, aspect_ratio, tr_x, tr_y, tr_z, rot_x, rot_y et rot_z sont déclarées dans le fichier camera.inc. Ce fichier est régénéré à partir de la caméra active dans l'aperçu Geomorph à chaque fois que le bouton Povray est cliqué . Un nouveau fichier écrase le fichier courant, alors il est inutile de l'éditer.

Voici un exemple de camera.inc:

#declare gl_angle = 28;
#declare aspect_ratio =  1.3333300;
#declare tr_x = -0.0000000;
#declare tr_y =  0.0700000;
#declare tr_z = -0.9250000;
#declare rot_x = 11;
#declare rot_y = 0;
#declare rot_z = 0;

Le Soleil et la lumière

Une scène possède habituellement au moins une source lumineuse. Cependant, une source lumineuse n'a pas de dimension par elle-même. Elle est invisible lorsque la caméra est pointée vers elle. Nous devons lui donner une forme à partir d'un autre objet.

Dans les scènes Povray fournies par Geomorph, la source lumineuse principale se voit attribuer une forme de sphère afin de simuler le Soleil. Ainsi, lors d'une scène en contrejour comme un coucher de soleil, vous verrez le disque solaire, comme dans l'exemple de droite, provenant de sunseta.pov.

Voici comment la lumière est généralement produite dans une scène Povray de Geomorph:

#declare light=<1,0.97,0.94>; // Couleur de la lumière (<rouge, vert, bleu>)
#declare sun= sphere {<0,1,0>,100
         pigment{rgb 3*light} // Habituellement blanc, mais peut être coloré même avec un tel niveau de luminosité lorsque certaines composantes sont nulles ou presque
         finish {ambient 1} // La couleur de la sphère sera produite d'elle-même plutôt que par réflexion des autres sources lumineuses
         }
#declare Sun =
light_source
{
  0*x // Position de la source lumineuse (déplacée plus bas)
  color rgb light  // Couleur
  looks_like {sun} // Donne au Soleil la forme de "sun" (sphère)
}

Le Soleil est déplacé à sa position finale à la fin du fichier. Dans mountains.pov, il est placé dans la partie sud-ouest du ciel:

light_source {Sun  translate <2000,2000,-1000>}

Si vous désirez que le Soleil suive la caméra, afin que ses rayons pointent dans une direction constante par rapport à la caméra, indépendamment de la rotation du terrain, vous pouvez le tourner en utilisant les paramètres de la caméra rot_x, rot_y and rot_z:

light_source {Sun  translate <2000,2000,-1000> rotate <rot_x, rot_y, rot_z> }

Dans sunseta.pov, le pigment du Soleil est rgb <1,0.8,0.7>, et il est déplacé à <-6550, 720, 15000>.

Le ciel

Le ciel est essentiellement un gradient de couleur sur l'axe Y (vertical). Povray prévoit une déclaraton sky_sphere à cette fin. Un gradient est une sorte de "pigment" dans le langage Povray. Le gradient est appliqué sur l'objet sky_sphere. Un exemple provenant de mountains.pov est montré à droite (rotation X=355°, angle de vue=55°). Ainsi, dans une scène Geomorph, le ciel peut être déclaré en 2 étapes:

#declare sky_gradient =
        pigment {
            gradient y
            color_map {
                [0 color rgb sky_density*<0.8,0.8,1>] // Ligne d'horizon brumeuse
                [0.15 color sky_density*(<0.1,0.3,1>)] // Début du bleu pur
                [1.0 color sky_density*(<0.1,0.2,1>)] // Bleu pur
            }
        }

Dans cet exemple, le plan bleu au bas de l'image n'est pas un plan. C'est le haut du gradient (valeur 1.0), contigu à son début (valeur 0.0, la "ligne d'horizon brumeuse").

Après la ligne de *, le gradient peut être rappelé de cette façon:
After the * row, the gradient could be recalled like this:

sky_sphere {pigment {sky_gradient scale <1.0, 1.0, 1.0> }
    pigment {clouds scale <1.0,0.4,1.0> rotate <0.0,-10,0.0>}} // La prochaine section explique les nuages

Une instruction "scale" sans effet (valeurs à 1.0) est proposée pour faciliter l'ajustement du ciel. La valeur Y peut être augmentée pour élargir la bande brumeuse à l'horizon (par exemple, <1.0, 2.0, 1.0>). Il n'y a pas d'intérêt à changer l'échelle des axes X ou Z, parce que ce gradient est défini sur l'axe Y.

Dans la plupart des scènes prédéfinies de Geomorph, l'objet sky_sphere est spécifié directement, sans directive #declare.

Les nuages

Il y a deux façons de définir des nuages de base.

Dans les deux cas, les nuages sont produits par un pigment avec un arrière-plan transparent, superposé à l'objet sky_sphere.

Vous pouvez ajouter le pigment l'objet sky_sphere, ou le définir sur un plan.

Version "plan"

 Version "sky_sphere"

Souvent la version "plan" est plus convaincante.

Dans mountains.pov, les nuages sont appliqués à l'objet sky_sphere:

#declare clouds =
        pigment {
                granite
                turbulence 0.2
                color_map {
                [0.4 rgbt <0,0,0,1>] // Le "t" dans rgbt réfère à "transmettre" - cette couleur est totalement transparente et sans aucune teinte
 //              [0.7 rgbt <0,0,0,1>] // Remplacez la ligne précédente par celle-ci pour des nuages plus petits
                [0.95 rgb <0.7,0.7,0.8>] // Un blanc cassé légèrement bleuté
                [1.0 rgb <0.7,0.7,0.8>]
                }
        }
sky_sphere {pigment {sky_gradient scale y*1.0}
    pigment {clouds scale <1.0,0.4,1.0> rotate <0.0,-10,0.0>}}

Le mot-clé "granite" réfère à un motif de bruit aléatoire. À très faible échelle, il en résulte une structure granuleuse qui peut simuler le granite. À grande échelle, les grains sont comparables à des nuages.

Les nuages sont agrandis sur les dimensions X et Z pour plus de réalisme. Autrement, ils auraient l'air d'étranges cumulus, très rapprochés de l'observateur. Lorsque les nuages sont appliqués sur un plan, cette mise à l'échelle n'est généralement pas nécessaire.

L'instruction rotate est utilisée pour placer la partie la plus intéressante du ciel où vous la désirez dans l'image.

La technique du plan est utilisée dans desert.pov.

Quand vous utilisez la technique du plan, attendez-vous à augmenter l'échelle de la texture d'une façon importante, par exemple 20000, ou même 100000. De plus, une texture sur un plan ne réagit pas de la même façon aux sources lumineuses qu'elle ne le fait sur un objet sky_sphere. Vous aurez probablement besoin d'augmenter le paramètre "ambient" pour accentuer les nuages. Aucune structure ne réagit de façon réaliste aux sources lumineuses, du moins pas comme des nuages.

Voyez aussi le tutoriel de F. Lohmüller pour créer des nuages "assez bons". Dans cette autre référence (en français!), Gilles Tran explique comment créer des nuages d'un réalisme surprenant, si vous êtes prêt à y consacrer des heures et des heures de traitement.

 L'eau

L'étendue d'eau la plus simple est un plan avec une texture transparente et "bossue", c'est-à-dire donnée par le motif "bump".

//    Eau sombre
#declare water = plane {y, 0
    texture {
        pigment {color rgbt<0.0,water_density*0.15,water_density*0.35,0.2>}
       normal {bumps 0.1 translate clock scale 3*<2.5,1,1> rotate <0,-30,0>}
       finish {specular 0.9 roughness 0.05
             reflection .5 ambient 0.1 diffuse 0.3 }
    }
}

Notez la composante "t" dans la couleur, spécifiant le degré de transparence. Notez aussi la variable water_density, initialisée dans la première partie du fichier.

Il y a d'autres façon d'imiter l'eau. Voyez les exemples de Fr. Lohmüller. Certains utilisent aussi des isosurfaces. Christoph Hormann montre ici comment cette méthode se compare à d'autres. L'eau peut aussi être créée à partir d'un terrain Geomorph, si vous pouvez choisir un point de vue et une organisation de scène qui masque la nature finie du terrain.

Le sol

Un plan de sol améliore l'apparence de certaines scènes. Par exemple, un tel plan avec une texture sablonneuse et ondulée imite assez bien un plancher océanique ou un sol de désert. Dans le cas du déser, le plan crée la ligne d'horizon.
 
Il n'y a pas de plan de sol dans mountains.pov, mais vous pouvez en trouver un dans desert.pov (ci-contre) ou dans sea_and_rocks.pov.

La syntaxe est similaire à celle du plan d'eau:

#declare sea_bottom = plane {y, 0 }

... rappelé par cette déclaration, après la ligne de *:

object {sea_bottom texture {shore_granite}}

Ces deux lignes peuvent être remplacées par:

plane {y,0 texture {shore_granite}}

Le brouillard

Un léger brouillard au niveau de la ligne d'horizon améliorera l'apparence de plusieurs paysages.

Ce type de brume légère ainsi que le brouillard épais résultant d'une météo défavorable sont tous les deux produits par l'instruction Povray "fog", en utilisant le type de brouillard "ground fog". La différence entre les deux n'est qu'une question de hauteur, de densité et de distance de l'observateur.

Dans mountains.pov, la légère brume à l'horizon est :

#declare Haze =
fog
{
  fog_type   2   // 1 est un brouillard uniforme, 2 est un brouillard de sol (ground fog)
  distance fog_distance
  color      rgbt <0.6,0.6,0.8,fog_transparency > // Voile bleuté
  fog_offset fog_altitude
  fog_alt fog_altitude
  turbulence 0.8
}

Notez les variables fog_distance, fog_transparency et fog_altitude, déclarées au début du fichier.

Ce voile est rappelé après la ligne de * à l'aide de cette commande:

fog {Haze}

Lors de la mise au point d'une scène, vous préférerez probablement mettre en commentaires cette instruction (// fog {Haze}) pour raccourcir le temps de rendu.

Le terrain

Lorsque le bouton Povray est cliqué, l'image en cours d'édition est écrite dans le fichier test.png. Toutes les scènes Povray prédéfinies offertes avec Geomorph appellent ce fichier. Vous n'aurez généralement pas à vous en préoccuper.

Dans la version 0.23 de Geomorph, un seul terrain peut être inséré dans une scène Povray à partir de l'interface graphique, en passant par test.png. Cependant, vous pouvez éditer le fichier .pov pour placer des terrains additionnels à la main. Cela peut être utile, par exemple, pour juxtaposer des sols très différents en termes de formes et de textures, comme une plage sablonneuse avec des rochers à l'arrière-plan. Vous pourriez aussi avoir besoin de "remplir" l'horizon à l'arrière-plan avec des montagnes. (cette technique est discutée ici), ou simuler des étendues d'eau en superposant une image de relief transparente au relief en cours d'édition (un "water field"...).

Voici comment le relief principal est déclaré dans les scènes Povray fournies avec Geomorph:

#declare hf =
height_field
{
    png "test.png"
       smooth // Nicer!
    scale < 1.0, 0.3, 1.0 > // Voir les explications plus bas
    translate <-.5, 0.0, -.5> // Le relief est centré dans la scène
}
Version 0.40 et ultérieures

Le terrain doit maintenant être déclaré de la façon suivante:

#declare hf =
height_field
{
    png main_terrain
...

"main_terrain" est une variable créée dans geomorph.inc. Elle contient le nom du terrain en cours d'édition, si celui-ci a été enregistré, ou test.png, sinon. Le fichier déclare aussi des variables contenant des cartes secondaires, comme "water_map", "background_map", "ground_map" et "crater_map", pour certaines scènes les requérant.

Pourquoi une échelle de < 1.0, 0.3, 1.0>? Une image de relief est générée dans une boîte de 1 x 1 x 1. La commande scale diminue la hauteur de la boîte à 0,3, autrement le relief aurait l'air trop élevé et non naturel.

La translation est requise pour centrer le relief dans l'image, autrement le coin Sud-Ouest de l'image apparaîtrait au centre.

La directive "#declare" permet de rappeler le terrain en utilisant cette syntaxe: "object {hf texture{my_texture}}" à la fin du fichier .pov:

object {hf scale <1.0,1.0,1.0> translate y*0 texture {forest_rock_snow translate y*-0.35 scale 0.7 } }

Notez que le relief et sa texture peuvent être mis à l'échelle et déplacés séparément. Naturellement, une échelle de 1.0 et une translation de 0 comme celles indiquées ici sont sans effet. Ces instructions sont proposées pour montrer rapidement quels paramètres peuvent être édités pendant la mise au point de la scène.

La texture du relief, comme mentionné précédemment, est probablement le facteur de réalisme le plus important. Une page entière est consacrée aux textures offertes par Geomorph.

Exemples de scènes avec plus d'un terrain

Utilisation d'un terrain distant pour "remplir" la ligne d'horizon
desert_mountains_1.jpg+desert_mountains_2.jpg=desert_mountains_3.jpg

Utilisation d'une "carte des eaux"
+=


L'ajout d'autres objets

Des outils de modélisation externes peuvent être utilisés pour ajouter des objets à un paysage Geomorph / Povray.

Povtree est une interface Java au script Povray "tomtree". Il produit des arbres dans des fichiers "include", qui peuvent être énormes si vous générez des ramilles, des feuilles et des fleurs. Par exemple, l'arbre nu utilisé dans ce paysage Geomorph a requis un fichier de 3.8 MB . L'inclusion du fichier se fait de la façon suivante dans la scène modifiée desert.pov:

#include "olivier4.inc" // La sortie de Povtree
...
(corps du fichier .pov)
...
************************************************
object {TREE translate <0.55,0.3,-1.5> scale <0.2, 0.23, 0.2>}

La structure d'arbre résultante est #déclarée comme TREE dans olivier4.inc.

Il y a aussi Jpatch, un programme Java pour concevoir des objets avec une forme arbitraire et les exporter dans des fichiers "include" Povray. Il semble inspiré de sPatch, un programme Windows dont j'ai eu de la difficulté à me passer il y a quelques années.

Les deux programmes requièrent la machine virtuelle Java de Sun v. 1.4 ou plus récente, qui, n'étant pas un environnement libre, doit être téléchargée par les utilisateurs de la plupart des distributions Linux.

Positionner un objet externe sur un relief exige un bon travail d'essais et erreurs, mais constitue un bon exercice pour se familiariser avec le système de coordonnées Povray ;-).

Haut

Écrit en août 2005, modifié en janvier 2007

Contact:    Patrice St-Gelais

Retour à l'index de la documentation

SourceForge.net Logo