Artisan Numérique

/bureau/3d/povray/ PovRay, Fabriquer des escaliers...

PovRay est un merveilleux outil qui permet la modélisation et d'illumination de scénes 3D. Mais dés qu'il s'agit de faire du répétitif comme créer un escalier ou poser une porte, on se retrouve rapidement à refaire les mêmes choses et à se perdre dans une jungle de coordonnées. C'est à ce stade que les macros viennent nous sauver la mise.

Illumination, Architecture et Outils

Pour lever tout malentendu je ne suis un pas un pro de la 3D, loin de là. Je suis de ceux qui en ont besoin ponctuellement pour modéliser avant de construire. Et là, c'est une maison que j'ai eu besoin de modéliser pour avoir une idée précise des travaux que j'allais devoir y faire faire. Il ne s'agit donc pas de 3D créative mais de 3D technique, avec des côtes, des pièces, etc.

J'ai pas mal écumer les possibles dans ce domaine et avant d'en revenir une fois de plus à POVRAY, j'ai testé trois autres joujoux libres : Blender, Art Of Illusion et Sweethome 3D.

SweetHome3D est un peu différent des deux autres car totalement spécialisé en architecture et sans aucune capacité d'illumination (raytracing). Ecrit en Java et donc molti-plate forme, il permet, à l'instar d'un Architecte3D sous Windows, de construire une maison à partir d'un plan au sol. Le résultat est qu'à une vitesse impressionnante un logis complet avec murs, meubles, portes, etc est modélisable. Et avec des compétences proche du rien du tout. C'est donc un très bon outil que je garde pour faire une pré-modélisation des volumes.

Pré-Modélisation car pour l'instant ce jeune outil souffre de quelques limitations. Il n'y a pas d'export vers un outil d'illumination à un format standard, on doit donc se contenter d'une vue OpenGL qui fait penser à la première version du jeu "Alone In The Dark" (celui de 92 ;-). Ensuite il n'est vraiment fonctionnel que pour un logis de plein pied.

Blender et Art of Illusion sont de véritables outils de modélisation et d'illumination 3D. Ils partagent un tronc commun de fonctionnalités basiques mais si AOI a le mérite d'être abordable par un débutant et d'être multi-plateforme (lui aussi en Java), Blender est clairement plus évolué. Ce dernier dispose d'un tas de fonctions avancées et la possibilité d'utiliser Python comme langage de script. Mais l'inconvénient de la puissance est la complexité de son interface qu'il n'est pas évident de maîtriser tant elle est spécifique à lui seul. Mais même si ce n'est pas ce que j'ai utilisé, je conçoit très bien l'enthousiasme de la communauté de fans de Blender. Mais clairement, cela demande un investissement de départ qui n'est rentable que si la 3D est une passion (ou un travail ;-)

Arrive enfin POVRay (Power Of Vision Ray Tool). Ici changement de décor, pas d'interface graphique, juste un langage de description des scènes que l'on édite avec un simple éditeur texte (ou le plugin Eclipse PovClipse). Le binaire povray est juste invoqué, en ligne de commande, pour transformer le langage en un rendu visuel. L'outil, à mon niveau de compréhension, permet de faire les mêmes choses qu'avec Art Of Illusion ou Blender, mais me convient beaucoup plus avec son langage formel qui doit j'imagine répondre à mon âme de développeur de base.

En conclusion, j'utilise conjointement SweetHome pour tracer les plans et POVRay pour mettre tout cela en lumière. C'est mon choix, et celui de Blender pour quelqu'un d'un modelage "manuel" est totalement justifié. J'en profite d'ailleurs pour vous donner un pointeur vers un excellent wiki dédié à l'utilisation architecturale de Blender.

Un scène de base

Pour ceux qui n'ont jamais utilisé POVRay, le net foisonne de tutoriels. Je ne reviens donc pas sur les fondamentaux, à savoir placement d'un soleil, d'un ciel, d'un sol, ou encore l'indispensable maîtrise des CSG.

L'objectif est ici de monter un escalier. Le genre de chose qui est typiquement rasoir à fabriquer, avec un bloc (box) par marches, répété autant de fois qu'il le faut avec obligation de ne pas se planter sur les coordonnées sous peine d'avoir des marches qui s'effondrent.

Pour commencer, créons un fichier test.pov et plaçons-y le code suivant :

global_settings {  assumed_gamma 1.0 }
#default{ finish{ ambient 0.1 diffuse 0.9 }}

#include "colors.inc"
#include "textures.inc"

// camera 
camera {location <0.0 ,="" 1.0="" ,-3.0="">
        look_at  <0.0 ,="" 1.0="" 0.0="">}

// soleil
light_source{<1500,2500,-2500> color White}

// ciel
sky_sphere {
    pigment {
    granite
    turbulence 0.2
    color_map {
      [0.4 rgbt <0,0,0,1>] 
      [0.95 rgb <0.7,0.7,0.8>]
      [1.0 rgb <0.7,0.7,0.8>]
        }
    }
}

// Brume
fog
{
  fog_type 2
  distance 5
  color rgbt <0.796078, 0.694118,="" 0.627451,="" 0.1="">
  fog_offset 0.01
  fog_alt 0.08
  turbulence 0.8
}

// Sol
plane{ 
    <0,1,0>, 0
    texture{
        pigment {color rgb <0.85,0.6,0.4>}
        normal  {bumps 0.75 scale 0.025  }
    }
}

Nous avons ici une caméra, le soleil, le ciel, un peu de brume pour adoucir l'horizon, le sol et une petite ambiance rappelant "Le Prisonnier" ;-). Reste maintenant à effectuer l'illumination de la scéne :

povray +W320 +H240 +Q9 -QR +A +AM1 +A0.200 -J +R6 -UA +Iscene/$SCENE.pov -Oresultat.jpg

La résolution 320x240 n'est pas le fruit du hasard. La caméra étant par défaut en 4/3, cela évite les déformations. Il est cependant possible de changer le ration de la caméra.

Un escalier

Passons au vif du sujet. Si nous voulions modeler un escalier disons de 2m avec 7 marches, il faudrait définir 7 boites (box), empilées les unes sur les autres, avec la bonne hauteur, et la bonne composante Y pour que cela ressemble à quelque chose. Quelque chose du genre :

 // Définition locale de mon escalier
 #local escalier =
 union {
   box { <0,0,0><2,0.2,1> }
   box { <0,0.2,0><1.8,0.4,1> }
   box { <0,0.4,0><1.6,0.6,1> }
   texture {
      pigment{color rgb<1,0.65,0>}
      finish { phong 1 }
   }
 }

// insertion de l'objet escalier dans la scène
object {
   escalier 

   // Juste pour le centrer sur la scène 
   rotate<0,45,0>
   translate<-1,-0,1>
}

Déjà 3 marches et la fatigue me gagne... Sans compter que si l'on change un paramètres, genre la hauteur des marches, il faut tout recommencer...

L'avantage du système métrique est que nous pouvons utiliser directement les mesures en mètres dans POVRay. Une coordonnées en 1.5 signifie donc 1m50.

Boucles

Heureusement le langage de POVRay est un peu plus évolué que cela. Il est possible d'y faire des boucles !! Nous pouvons donc ré-écrire définition d'escalier en replaçant l'ancien bloc union par cela :

union {
     #local marches=5;
     #local hauteur=1.5;
     #local longueur=2;
     #local largeur=1;

     #local hauteur_marche=hauteur/marches;
     #local index=0;
     #while (index < marches)
        box { <0, 0="" hauteur_marche*index,="">  }
        #local index=index+1;
     #end 
     texture {
        pigment{color rgb<1,0.65,0>}
        finish { phong 1 }
     }
     rotate<0,45,0>
     translate<-1,-0,1>
   }

Un peu d'explication s'impose. Les 4 premières directives #local définissent les paramètres de notre escalier. Ce sont des variables locales au bloc (ici celui de l'union).

Les deux variables suivantes sont d'abord la hauteur calculée d'une marche en fonction des variables précédentes. On partira du principe que le giron est égal à la hauteur. Ensuite il s'agit de l'index qui incrémenté permettra de modeler chaque marche.

S'en suit une classique boucle #while qui ne se terminera que lorsqu'index atteindra le nombre de marches désiré. Notez la structure du #while...#end. C'est ce qui définit le corps de notre boucle. Le #local index=... avant le #end est l'incrémentation de notre compteurs.

Il ne reste plus que la ligne box qui définit bêtement les coordonnées d'une marche en fonction des paramètres et du compteur.

Alors la grandes améliorations par rapport à la version "manuelle", c'est que tout ici est totalement paramétrable. Si je change la hauteur, la largeur ou tout paramètre de mon escalier, je n'ai rien d'autre à modifier qu'un nombre. Maintenant que se passe t-il si je veux faire un deuxième escalier ?

Les macros

La solution est de créer une macro fabrique d'escaliers. Pour cela nous allons remplacer la définition de notre escalier au complet (de #local escalier = à la fin de la définition de l'union) par le code suivant :

#macro fabrique_escalier(hauteur, longueur, largeur, marches)
   union {
     #local hauteur_marche=hauteur/marches;
     #local index=0;
     #while (index < marches)
        box { <0, 0="" hauteur_marche*index,="">  }
        #local index=index+1;
     #end 
     texture {
        pigment{color rgb<1,0.65,0>}
        finish { phong 1 }
     }
   }
#end

Comme vous le voyez, la seule chose qui a réellement changé c'est le début. Notre ancienne déclaration local est transformée en déclaration de macro et les paramètres locaux sont devenus les paramètres de cette macro. Pour le reste, le corps de la déclaration de l'union n'a rigoureusement pas changé.

Alors cette macro marche comme une fonction standard. Elle a comme vous le voyez des paramètres, mais aussi un résultat de retour : l'union. En effet, comme dans le reste de la déclaration POV, tout ce qui est définit comme objet est considéré comme faisant parti de la scène. La seule différence c'est qu'ici la scène, c'est la valeur de retour de la macro.

Maintenant ne reste plus qu'à appeler cette macro. Pour cela, enlevez l'ancienne définiton object{..} en ajoutons deux escaliers (autant en profiter ;-) :

// insertion de l'objet escalier dans la scène
object {
   fabrique_escalier(1.5,2,1,5) 

   rotate<0,45,0>
   translate<0,-0,1>
}
object {
   fabrique_escalier(1.5,2,0.5,7) 

   rotate<0,135,0>
   translate<0,-0,1>
   pigment { Red }
}

Et voilà ! Après on peut faire des escaliers qui soit creux (là ce sont plutôt des podiums), avec plateau, en hélice, etc.

Conclusion

Le langage de définition de POV dispose de toutes les structures de base (mais vraiment de base ;-) : boucles, conditions, fonctions/macros, etc. Et cette souplesse apportées est particulièrement pratique en architecture où ce sont souvent les éléments "standards" qu'il faut introduire. J'ai par exemple une macro qui fabrique un pan de toiture, une qui pose une porte, une fenêtre, etc.