Povray/Tutorials/RealisticSky

De TartareFR
Aller à la navigation Aller à la recherche

Un ciel clair d'azur d'été

Le monde vu de l'intérieur d'une hémisphère du type "cloche à fromage" avec un brouillard réaliste à l'horizon fait avec une "color_map{gradient <0,1,0> ..." tirant la couleur bleu foncé au zénith à blanc au niveau d'horizon. Le tout agrandi par "scale 10000".

Le seul problème : Nous devons placer le soleil dans cette hémisphère, autrement nous ne voyons seulement le composant "ambient" de toutes les textures !

sphere{<0,0,0>,1 hollow
 texture{
  pigment{gradient <0,1,0>
          color_map{
           [0.0 color White]
           [0.8 color rgb<0.1,0.25,0.75>]
           [1.0 color rgb<0.1,0.25,0.75>] }
         } // end pigment
  finish {ambient 1 diffuse 0}
  } // fin de la texture
 scale 10000
 }

Nous obtenons la même résultat sans ces restrictions par l'utilisation de "sky_sphere" avec ce "pigment" .

sky_sphere{
 pigment{ gradient <0,1,0>
          color_map{
          [0.0 color rgb<1,1,1>        ]
          [0.8 color rgb<0.1,0.25,0.75>]
          [1.0 color rgb<0.1,0.25,0.75>]}
        } // end pigment
 } // end of sky_sphere -----------------
Un ciel clair d'azur d'été
Fichier POVRay correspondant

de beaux Nuages mais avec un horizon minable

Dans un monde à l'intérieur d'un hémisphère du type "cloche à fromage" nous ne pouvons pas utiliser une texture avec des nuages parce que les nuages sont en collision avec l'horizon très irréaliste !

Malheureusement presque tout les ciels couvert de nuages créés avec "sky_sphere" souffriront de cette maladie !


Un ciel avec de beaux nuages mais un horizon minable
Fichier POVRay correspondant

Un ciel partiellement couvert avec horizon réaliste

Le ciel est formé d'un plan bleu décoré avec quelques nuages. Les nuages deviennent plus petites vers l'horizon - cela est réaliste ! Cet effet, on ne peut pas le simuler avec une "sky_sphere" !

Un brouillard realiste ("fog") recouvre la ligne noire l'intersection entre le plan du sol et le plan du ciel. d'horizon

Le seul problème : Nous devons placer le soleil dans cette hémisphère, autrement nous ne voyons seulement le composant "ambient" de toutes les textures !

Un ciel partiellement couvert avec horizon réaliste
Fichier POVRay correspondant

Un autre ciel partiellement couvert

Le ciel est formé d'un plan bleu décoré avec quelques nuages. Les nuages deviennent plus petites vers l'horizon - réaliste ! Un brouillard realiste ("fog") recouvre la ligne noire d'horizon entre le plan du sol et le plan du ciel.

Le seule problème ici : Nous devons placer le soleil sous ce plan!

plane{<0,1,0>,1 hollow
       texture{
        pigment{ bozo turbulence 0.92
          color_map {
           [0.00 rgb <0.2, 0.3, 1>*0.5]
           [0.50 rgb <0.2, 0.3, 1>*0.8]
           [0.70 rgb <1,1,1>]
           [0.85 rgb <0.25,0.25,0.25>]
           [1.0 rgb <0.5,0.5,0.5>]}
          scale<1,1,1.5>*2.5
          translate<1.0,0,-1>
          }// end of pigment
        finish {ambient 1 diffuse 0}
        }// end of texture
        scale 10000
     }// end of plane

fog { fog_type   2
      distance   50
      color      White
      fog_offset 0.1
      fog_alt    1.5
      turbulence 1.8
    }
Un ciel partiellement couvert avec horizon réaliste
Fichier POVRay correspondant


Un ciel avec 2 couches de nuages

Pour cela on a besoin de 3 plans placés les uns sur les autres. Au niveau le plus haut : Un plan avec un ciel bleu, avec "finish{ ambient 1 diffuse 0)" pour éviter des ombres sur le bleu du ciel.

Au-dessous de ce pemier plan, un second plan avec une structure de nuages partiellement transparente. Ce plan forme les nuages 'hauts. Sous ce plan un troisième plan avec une structure de nuages plus transparente. Ces nuages ont une autre direction, cela peut être simuler avec des échelles differentes pour x et z. Cela est une version plus clair les "T_Clouds" de Darin Dugger dans le fichier include "e;skies.inc";. Est aussi modifiée pour permettere l'usage de fog - cela n'est pas possible avec l'objet original "O_T_Cloud2"

Un ciel avec 2 couches de nuages
Fichier POVRay correspondant


Liasse de plans avec texture de nuages

Ici plusiers de plans s'empilent l'un sur l'autre et sont coloriés avec un motif semitransparent de nuages que saffaiblisent vers les couches supérieures et vers les couches de base. L'idée original pour cette méthode j'ai trouvé ici :

Stacked Sky Planes macro "stsky.inc" de Jaime Vives Piqueres, 2000 ici http://www.ignorancia.org/ Voir "techniques" >> "Stacked Planes".

Il y a un fichier include file pour ces nuages : PovrayTutoRealisticSky06.inc Note: Le fichier include fait seulement les nuages. Vous devez ajuter un fond bleu du ciel (par ex. avec sky_sphere{ ... } ). L'handicap de cette méthode : si on regarde du niveau des nuages ou vers l'horizon, on peut voir les lacunes entre les plans.

Liasse de plans avec texture de nuages
Fichier POVRay correspondant
Fichier Include correspondant

Nuages avec ombre sur le sol

Pour obtenir cet effet le solei doit être positionné au-dessous du plan plus 'haut avec la couleur bleu et sur le plan transparent avec les nuages blancs.

Pour faciliter de trouver une position du solei précisement entre les nuages on peut utiliser une sphère avec un texture miroitant et avec phong par ex. "Polished_Chrome".

Nuages avec ombre sur le sol
Fichier POVRay correspondant

Nuages massifs par media

Avec un media, nous pouvons faire de vrais nuages: avec une structure massive et à travers lesquels on peut "voler dans les nuages" ! Ici une "density" nuageuse est limité mollement par une "density" du type "boxed". Pour plus de details sur "media" voir mon tutoriel Conception du Intérieur des Objets transparents avec POV-Ray.
box{ <-1,-1,-1>,<1,1,1>
  texture{
    pigment{ rgbf 1} // color Clear
  } // end of texture
  interior{
   media{
    method 3
    //intervals 2
    samples 10,10
    absorption 1
    emission 0.5
    scattering{ 0.8,<1,1,1>*0.5}
    density{ bozo
             color_map {
              [0.00 rgb 0]
              [0.50 rgb 0.01]
              [0.65 rgb 0.1]
              [0.75 rgb 0.5]
              [1.00 rgb 0.2]
             } // end color_map
             turbulence 0.85
             scale  0.75
             translate<1, 0.75,2>
           } // end density
    density{  boxed // or: spherical
              color_map {
               [0.0 rgb 0]    // border
               [0.1 rgb 0.05]
               [1.0 rgb 1]    // center
              } // end color_map
             scale <1,1,1>*1
           } // end density
   } // end media
  } // end interior
 hollow
 scale<1,0.5, 1> translate<0,0.5,0>
scale 15 translate<0,02,30>
}
Nuages avec ombre sur le sol
Fichier POVRay correspondant


Ciel étoilé

Pour créer un ciel de nuit avec des millions d'étoiles nous pouvons utiliser les textures des ciels parsemés d'étoiles (de Jeff Burton) avec les templates "Starfield1, Starfield2, ..., Starfield6", que nous trouvons dans le fichier include standard "stars.inc. Nous devons utiliser ces textures avec une échelle appropriée (dépendant des dimensions de l'image).
#include "stars.inc"
sphere{ <0,0,0>, 1
        texture{ Starfield1 scale 0.25
               } // end of texture
        scale 10000
      }
}


Projection cylindrique et sphérique de l'environnement

Skydomes et Skymaps avec des images de panorama à 360°.

Un skydome est une hémisphère ou sphère (si nous voulons simuler l'espace) avec une texture d'un image de panorama à 360° du ciel ("skymap") projetée ("mapped") sur la face interne de cette hémisphère ou sphère. Nous pouvons réaliser cela en POV-Ray avec image_map et sky_sphere.

Pour utiliser une photo de panorama à 360° pour une skymap dans un skydome (avec POV-Ray 3.6/3.7) nous avons besoin de corriger le gamma de l'image ou photo avec la macro suivante.

// Macro pour corriger les images
// pour image_map avec assumed_gamma = 1.0 ;
#macro Correct_Pigment_Gamma(Orig_Pig, New_G)
  #local Correct_Pig_fn =
      function{ pigment {Orig_Pig} }
  pigment{ average pigment_map{
   [function{ pow(Correct_Pig_fn(x,y,z).x, New_G)}
               color_map{[0 rgb 0][1 rgb<3,0,0>]}]
   [function{ pow(Correct_Pig_fn(x,y,z).y, New_G)}
               color_map{[0 rgb 0][1 rgb<0,3,0>]}]
   [function{ pow(Correct_Pig_fn(x,y,z).z, New_G)}
               color_map{[0 rgb 0][1 rgb<0,0,3>]}]
   }}
#end //
// "image_map" avec gamma corrigé:
//    Correct_Pigment_Gamma(
//    pigment{ image_map{ jpeg "colors.jpg"}}
//    , Correct_Gamma)
//------------------------------------------------
sky_sphere{
   Correct_Pigment_Gamma( // gamma correction
     pigment{
     image_map{ jpeg "sky_map_p_04_5200x1300.jpg"
                map_type 2    //  cylindrical
                interpolate 2 //  bilinear
                once //
              } //  end of image_map
      scale<1,1.02,1> rotate<0,0.00,0>
    } // end of pigment
    , 2.2) //, New_Gamma
} // end of sky_sphere --------------------
PovrayTutoRealisticSky10Image.jpg

On peut trouver plus des photos de panorama à 360° de ciels sur blenderartists.org

Projection cubique de l'environnement

Skyboxes et cubemaps avec des images de panorama à 360°.

C'est une autre méthode d'environment mapping les techniques de la projection de l'environnement, aussi appelée "cubic environment mapping" ou "panorama cube mapping". C'est une méthode très habituele dans le jeus 3D video. Un skybox est un cube grand avec un image de 360° du ciel e du sol ("skymap") projetée ("mapped") sur la face interne de ce cube avec des vues de 90°x90° sur chaque face du cube. Cette méthode de "environment mapping" peut eviter le problème des distorsions extrêmes aux pôles d'une sphère avec "spherical mapping". Un programme gratuit pour afficher et explorer un environnement en Skybox est le SkyboxViewer par Gerd Platl.

Nous pouvons réaliser un skybox en POV-Ray par uv_mapping d'un image_map sur un box. Nous utilisons le uv_mapping pour projeter une texture dans le plan XY de <0,0> à <1,1> sur le surface du cube. L'image s'enroule around autour du cube de la manière comme dans les images ci-contre.

Pour utiliser un photo de panorama à 360° pour une skymap dans un skybox (avec POV-Ray 3.6/3.7) nous avons besoin de corriger le gamma de l'image ou photo avec la macro suivante :

// Macro pour corriger les images
// pour image_map avec assumed_gamma = 1.0 ;
#macro Correct_Pigment_Gamma(Orig_Pig, New_G)
  #local Correct_Pig_fn =
      function{ pigment {Orig_Pig} }
  pigment{ average pigment_map{
   [function{ pow(Correct_Pig_fn(x,y,z).x, New_G)}
               color_map{[0 rgb 0][1 rgb<3,0,0>]}]
   [function{ pow(Correct_Pig_fn(x,y,z).y, New_G)}
               color_map{[0 rgb 0][1 rgb<0,3,0>]}]
   [function{ pow(Correct_Pig_fn(x,y,z).z, New_G)}
               color_map{[0 rgb 0][1 rgb<0,0,3>]}]
   }}
#end //
// "image_map" avec gamma corrigé:
//    Correct_Pigment_Gamma(
//    pigment{ image_map{ jpeg "colors.jpg"}}
//    , Correct_Gamma)
//------------------------------------------------
box{ <-1, -1, -1>,< 1, 1, 1>
 texture{ uv_mapping
   Correct_Pigment_Gamma( // gamma correction
     pigment{
     image_map{ jpeg "Cubemap_2_2048x1536.jpg"
                map_type 0    // planar
                interpolate 2 // bilinear
                once //
              } //  end of image_map
    } // end of pigment
    , 2.2) //, New_Gamma
    finish { ambient 1 diffuse 0 }
 } // end of texture
scale 10000
} // end of skybox
Image de la Skybox
Enroulemenet de l'image sur le cube
Enroulemenet de l'image sur le cube


Environnement HDRI

Le monde au-dedans d'une sphère - l'environnement simulé.

Un HDRI - High Dynamic Range Image si peut utiliser au lieu du light_source et ambient. Ce type d'images contiene 32 bit par pixel e couleur et c'est beaucoup plus d'information détaillée que une image normale avec normalement 8 bit par pixel e couleur. C'est-à-dire les parties éclaires sont plus claires, les parties dans l'ombre sont plus sombre et c'est plus de variation entre les deux. Une "light probe image" est un "high dynamic range image" les conditions de l'illumination d'un point dans l'espace ! Chaque "light probe image" représente complètement un panorama de 360 × 360 degré , ou 4pi radians stéréo. Cettes images on peut utiliser pour illuminer scènes de rendering avec "image-based lighting". Bien sûr cela est seulement un autre "truc sale et de mauvaise qualité" pour un "vrai" fan de raytracing, comme c'est une simulation d'un environnement que n'existe pas vraiment ! Mais jetez un regard sur l'exemple dans les images ici : vous pouvez voir - l'effet est fantastique!

Depuis version 3.7 POV-Ray connaît HDRI ( avec l'extension .hdr ) .

Il est une bonne idée de utiliser aussi la "radiosity" pour images hdr pour obtenir une vue plus réaliste. Pour "radiosity" nous devons mettere les composants de finish "ambient" et "diffuse" à zero. Il est aussi une bonne idée de ne pas definir "ambient" et "diffuse" dans les textures utiliées dans notre scènes mais declarer généralement ces valeurs comme default. Toutes les sources de lumière nous devons éteindre, seulement quelque flash pour éclaircir parties d'ombre nous pouvons utiliser avec images hdr - il faut rappeler que l'image hdr fait la lumiere dans la scène ! Pour l'illumination HDRI nous devons declarer :

// hdr environment -----------------------
sky_sphere{
  pigment{
    image_map{ hdr "building_probe.hdr"
               gamma 1.1
               map_type 1 interpolate 2}
      }// end pigment
      rotate <0,40,0> //
} // end sphere with hdr image -----------

Des exemples de "HDRI high dynamic range images" ou "light probe images" on peut trouver sur Light Probe Image Gallery.