Quelques mots sur l'animation avec POV-Ray
1. la Variable Clock
POV-Ray gère une variable réelle déclarée automatiquement identifiée par le nom clock. C'est la clé pour créer automatiquement des séries de fichiers images. En lignes de
commandes, la variable clock est mise en oeuvre par l'option +k. Par exemple, +k3.4 dans la ligne de commande met la valeur de clock à 3.4. La même chose peut se faire dans le fichier INI en utilisant Clock=3.4.
Si on n'initialise pas clock, que la boucle d'animation n'est pas utilisée (cf plus loin), la variable clock vaut par défaut 0.0, de telle façon qu'on peut écrire du code POV en vue d'une animation, tout en effectuant du rendu pour une image pendant l'étape de modélisation du project.
L'exemple le plus simple pour comprendre est d'imaginer un objet qui se déplace à vitesse constante sur l'axe des x. On aura l'instruction
translate <clock, 0, 0>
dans la déclaration de notre objet et ensuite la boucle d'animation assigne progressivement des valeurs croissantes à clock. C'est très facile tant qu'il n'y a qu'un seul élément ou aspect de la scène qui change, mais cela devient plus délicat pour contrôler de multiples changements simultanément dans la même scène.
Le principe alors est d'utiliser des values normalisées de clock, et de faire varier les autres variables dans la scène proportionnellement à clock. Ainsi, quand clock change, on le borne dans l'intervalle de 0.0 à 1.0, et on l'utilise comme un multiplicateur pour les autres valeurs.
Ainsi les autres valeurs prennent les valeurs désirées, et clock reste entre 0 et 1 pour chaque application. Prenons un simple exemple
#include "colors.inc"
camera {
location <0, 3, -6>
look_at <0, 0, 0>
}
light_source { <20, 20, -20> color White } plane {
y, 0
pigment { checker color White color Black } }
sphere {
<0, 0, 0> , 1 pigment {
gradient x color_map {
[0.0 Blue ] [0.5 Blue ] [0.5 White ] [1.0 White ] }
scale .25
}
rotate <0, 0, -clock*360>
translate <-pi, 1, 0>
translate <2*pi*clock, 0, 0>
}
Supposons qu'une série de trames soit construite avec clock allant progressivement de 0.0 à 1.0, le code ci-dessus produira une balle rayée qui roule de gauche à droite sur l'écran. Deux objectifs sont à réaliser:
1. Translater la balle d'un point A à un point B
2. Tourner la balle d'exactement la bonne proportion de son mouvement linéaire pour effectuer un roulement et non un glissement vers sa position finale.
Commençant par le second objectif, on démarre avec la sphère à l'origine (sinon on a une rotation de type "orbite" et non sur "elle même". Pour une animation d'un tour complet on tourne de 360 degrés, ce qui donne (360*clock)pour déterminer la rotation à chaque trame.
Puisque clock va de 0 à 1, la rotation de la sphère va de 0 degré à 360.
Puis on utilise la première translation pour placer la sphère à son point de départ. On ne pouvait le faire avant, sinon on aurait fait tourner l'origine. Donc pour effectuer la translation, on doit compenser en déplaçant la sphère au point de départ. Puis on effectue la translation de la sphère d'une distance proportionnelle à clock (2*pi* r*clock : la plus grande circonférence de la sphère multipliée par la value courante de clock). De cette façon on a synchronisé la rotation de la sphère avec sa translation.
En plus de la possibilité de coordonner de multiples aspects des changements en fonction du temps, l'autre bonne raison pour utiliser des valeurs normalisées de clock est qu'on peut ainsi réaliser une séquence de 10 trames de GIF animées, or 300 trames AVI. Les valeurs de clock sont proportionnelles au nombre de trames, donc le même code POV marchera quelle que soit la longueur de la séquence.
2. Variables Dépendant de Clock et Animations Multi-Etapes
Maintenant si on veut que la balle roule de gauche à droite pour la première moitié de
l'animation, puis change de direction de 135 degrés et roule de droite à gauche, et vers l'arrière de la scène. On doit utiliser les directives conditionnelles de POV - Ray, et tester la value de clock pour déterminer quand on a atteint la moitié, puis commencer une nouvelle séquence dépendant d'une nouvelle horloge clock. Mais à chaque étape on veut rester dans l'intervalle de 0 à 1 (). Si on suppose qu'on garde les mêmes caméra, lumière, et plan, et faisons aller clock de 0 à 2! On remplace déclaration de la sphère avec :
#if ( clock <= 1 )
sphere { <0, 0, 0> , 1 pigment {
gradient x color_map {
[0.0 Blue]
[0.5 Blue]
[0.5 White ] [1.0 White ] }
scale .25
}
rotate <0, 0, -clock*360>
translate <-pi, 1, 0>
translate <2*pi*clock, 0, 0>
}
#else
// (if clock is > 1, we're on the second phase) // we still want to work witha value from 0 - 1
#declare ElseClock = clock - 1;
sphere { <0, 0, 0> , 1 pigment {
gradient x color_map {
[0.0 Blue]
[0.5 Blue]
[0.5 White ] [1.0 White ] }
scale .25 }
rotate <0, 0, ElseClock*360>
translate <-2*pi*ElseClock, 0, 0>
rotate <0, 45, 0>
translate <pi, 1, 0>
}
#end
Notons que cela cause un brusque changement de rotation quand la balle change de direction.
Mais passons pour l'instant et restons simples.
La seule différence avec le premier code est que clock va de 0 à 2, alors qu'on veur rester avec des valeurs normalisées. Donc quand clock dépasse 1.0, POV passé à la seconde phase, et on déclare une autre variable Elseclock qui va de 0 à 1 pendant que clock va de 1 à 2. Donc même s'il n'y a qu'une horloge clock, on crée autant de variables pour que lors de scènes complexes, clock puisse être le coordinateur commun qui orchestre tous les mouvements
3. Le mot clé "Phase"
Le mot clé phase peut être utilise sur des éléments de texture, en particulier ceux qui ont des paramètres de couleur, pigment, ou des cartes de normales or de texture. Ces cartes ont la forme suivante. Par exemple:
color_map { [0.00 White ] [0.25 Blue ] [0.76 Green ] [1.00 Red ] }
La valeur réelle au début de chaque crochet permet la transformation des valeurs de couleur pour certaines zones des objets auxquels on applique la texture. L'application prend ses valeurs dans l'intervalle 0 à1.
Phase décale les valeurs de couleur dans cette application d'une valeur réelle spécifiée après le mot clé phase. Si on utilise une valeur de clock normalisée, cette valeur peut remplacer la
valeur réelle associée avec phase, et le motif va continûment glisser pendant l'animation. Soit l'exemple avec un motif utilisant un gradient des normales.
#include "colors.inc"
#include "textures.inc"
background { rgb<0.8, 0.8, 0.8> } camera {
location <1.5, 1, -30>
look_at <0, 1, 0>
angle 10 }
light_source { <-100, 20, -100> color White } // flag
polygon {
5, <0, 0>, <0, 1>, <1, 1>, <1, 0>, <0, 0>
pigment { Blue } normal {
gradient x phase clock
scale <0.2, 1, 1>
sine_wave }
scale <3, 2, 1>
translate <-1.5, 0, 0>
}
// flagpole cylinder {
<-1.5, -4, 0>, <-1.5, 2.25, 0>, 0.05 texture { Silver_Metal }
}
// polecap sphere {
<-1.5, 2.25, 0>, 0.1 texture { Silver_Metal } }
Ce programme crée un simple drapeau bleu avec un motif de gradient de normales. Le gradient utilise une ondulation de type sinus de telle façon que le drapeau roule d'arrière en avant comme s'il était soumis au vent. L'intérêt ici est le mot clé phase. Il prend la valeur de la variable clock qui augmente lentement vers la valeur 1.0, ce qui cause les plissements hauts et bas du drapeau selon une ondulation sur l'axe des x. Effectivement, l'animation des trames crées par ce code donne un drapeau qui ondule sous l'effet du vent.
Ce n'est qu'un simple exemple d'animation par "phase dépendant de clock". Avec la phase agissant sur les motifs et les textures la variété des animations est grande bien que l'objet ne bouge effectivement pas.
4. Ne pas utiliser Jitter ou Crand
Jitter représente une petite perturbation aléatoire du lancer de rayon établie pour diffuser de faibles erreurs d'aliassage. En randomisant le placement de pixels erronés, l'erreur devient moins perceptible par l'oeil, car l'œil et le cerveau sont enclins à mieux discerner les motifs réguliers que les distorsions aléatoires
Ce concept, qui marche très bien pour les images fixes devient un cauchemar pour les animations. Puisqu'il est aléatoire par nature, il est différent pour chaque trame. Le résultat donne des pixels qui sautent dans la scène, spécialement où l'aliassage est présent.
Pour cette raison, on met jitter à off pour les lumières surfaciques et les options anti-aliasing quand on prépare une scène pour une animation. Cette règle générale s'applique aux éléments de texture aléatoires, tels que crand.
5. Fichiers INI
Les éléments du fichier INI, Initial_Frame et Final_Frame. Permettent de calculer un certain nombre de trames, chacune d'entre elles ayant son propre numéro. Un exemple suffit pour comprendre. Ajoutons ces lignes au fichier INI
Initial_Frame = 1 Final_Frame = 20
Et on crée alors une boucle qui génère 20 trames distinctes. Ces spécifications font concaténer automatiquement un numéro de trame à la fin du nom de fichier de sortie. De plus, par défaut, cela fait varier clock de 0 à 1 en incréments proportionnels au nombre de trames. C'est très pratique, puisque que nous fassions une séquence de cinq trames de GIF animé ou une
séquence MPEG de 300 trames, on a une valeur de clock qui part de la même valeur de départ et finit à la même valeur de fin.
De la même façon, pour faire varier clock , par exemple, de 0.0 à 2.0, on ajoute au fichier INI les lignes
Initial_Clock = 0.0 Final_Clock = 2.0
Si on suppose qu'on produit une séquence de 100 trames, et qu'on détecte un problème visuel entre les trames 51 à 75. Si on ne veut recalculer que ces 25 trames au lieu de la séquence entière, nous ne pouvons écrire Initial_Frame = 51, et Final_Frame = 75. En effet, bien que l'on calcule les trames numérotées de 51 à 75, elles ne s'intègrent pas dans la séquence, parce que clock commencera à sa valeurinitiale pour la trame 51, et aboutira à sa valeur finale avec la trame 75..
On a besoin de deux commandes INI
Subset_Start_Frame = 51 Subset_End_Frame = 75
Ajoutées aux commandes précédentes, elles font aller clock avec des valeurs proportionnelles aux trames 1 à 100, mais en ne calculant que la partie de la sequence de la 51e à 75e trame.
Ce ne sont que des bases pour l'animation. (lire le livre de référence section pour plus de détails).
Bonne chance !
