Utilisation simple
Maintenant que vous avez vu toutes les options disponibles, on va pouvoir les oublier.
En général, comme je vous l'ai dit, une seule option est nécessaire : le nombre total d'image.
On va donc commencer avec le strict minimum, c'est à dire l'option
+KFF30 en ligne de commande, pour dire qu'on veut au total 30 images.
Ensuite, on crée notre scène, sans oublier que la variable
clock variera de 0 à 1...
Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| camera {
location <0,2,-3>
look_at <0,0,0>
}
light_source {
<5,15,-10>
rgb <1,1,1>
}
difference {
sphere {
<0,0,0>
1
pigment { rgb <0,1,0> }
}
box {
<10,10,10>
<-10,1-2*clock, -10>
pigment { rgb <1,0,0> }
}
} |
Et si vous lancez le rendu... Magique ! POV-Ray enchaîne les rendus, et vous pouvez voir votre pastèque se faire gracieusement découper...
Ou alors vous voyez des images apparaître lentement devant vous, donnant une mauvaise impression d'animation trop saccadée.
Et oui, POV-Ray ne fait que créer les images, il ne les anime pas tout seul.
Pour cela, n'importe quel programme d'animation fera l'affaire (Ulead Gif Animator, Windows Movie Maker, ...).
Je vous conseille
ImageMagick, qui est très léger, et compatible Windows, Linux ou Mac. Bon, il fonctionne en ligne de commande, donc certains pourront ne pas apprécier, mais au moins il marche bien.
Je ne vais pas vous faire un cours sur ImageMagick, ce serait un peu trop long ; je vais juste vous dire quelle commande utiliser pour convertir vos images en une animation.
Code : Autre1
| convert monimage*.png -delay 4 monanimation.gif |
Le
-delay 4 indique que chaque image de l'animation apparaitra 4 centièmes de seconde, soit 25 images par seconde en tout. C'est relativement élevé, et permet d'avoir une animation assez fluide ; mais parfois, 25 images par seconde peut être trop, car cela alourdi l'animation. Vous pouvez alors mettre une valeur plus élevée, comme 10, ce qui donnera 10 images par seconde...
Cette commande transformera toutes les images
.png dont le nom commence par
monimage. Vous pouvez remplacer le
.png par l'extension de vos images, si celles-ci sont dans un autre format.
En principe, voici le résultat (cliquez pour voir l'animation) :
Utilisation complexe
Bon, rassurez-vous, complexe est un bien grand mot pour ce que nous allons faire...
Voici l'animation finale que vous devriez obtenir (ici encore, cliquez pour voir l'anmation) :
Même si l'image en elle-même n'est pas particulièrement jolie, le point essentiel est que l'animation n'est pas aussi simple que la précédente : il se déroule en 3 phases (première chute, seconde chute, troisième chute). Il va donc falloir découper notre animation en trois...
Code : Autre1
| #declare time = clock * 3; |
On utilisera
time au lieu de
clock, plus adapté à nos besoins.
On aurait aussi bien pu utiliser
clock directement en le réglant avec
+KF3, mais il est conseillé de prendre une variable intermédiaire.
Ensuite, on va créer nos 6 carrés, avec des polygones (j'espère que vous vous souvenez du passage sur la 2D
).
Tout d'abord, le carré du bas reste immobile tout au long de l'animation :
Code : Autre1
2
3
4
5
6
7
8
| polygon { // bas
5
<0,0,0>
<1,0,0>
<1,0,1>
<0,0,1>
<0,0,0>
} |
Ensuite, le carré de face commence par tourner autour de l'axe
x, puis s'arrête :
Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
14
| polygon { // face
5
<0,0,0>
<1,0,0>
<1,1,0>
<0,1,0>
<0,0,0>
#if (time < 1)
// Phase 1
rotate <-90*time*time, 0, 0>
#else
rotate <-90, 0, 0>
#end
} |
La rotation est proportionnelle à
time*time et non simplement à
time, ce qui permet de donner l'impression que le cube tombe à cause de la gravité.
Le carré situé sur le haut effectue une rotation, puis une autre et enfin s'arrête au sol.
Mais voilà, si on continue simplement à tout faire tourner autour de l'axe x, le carré passera sous le sol !
Il va donc falloir ruser...
Nous avons déjà fait quelque chose qui ressemblait, il y a longtemps : translater l'objet vers l'origine, le tourner, puis le re-translater comme si de rien n'était.
Voici donc la suite :
Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| polygon { // haut
5
<0,1,0>
<1,1,0>
<1,1,1>
<0,1,1>
<0,1,0>
#if (time < 1)
// Phase 1
rotate <-90*time*time, 0, 0>
#else
rotate <-90,0,0>
#if (time < 2)
// Phase 2
translate <0,0,1>
rotate <-90*(time-1)*(time-1), 0, 0>
translate <0,0,-1>
#else
// Phase 3
translate <0,0,1>
rotate <-90,0,0>
translate <0,0,-1>
#end
#end
} |
Les trois derniers polygones sont donc simplement une répétition de cela :
Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
| polygon { // dos
5
<0,0,1>
<1,0,1>
<1,1,1>
<0,1,1>
<0,0,1>
#if (time < 1)
// Phase 1
rotate <-90*time*time, 0, 0>
#else
rotate <-90,0,0>
#if (time < 2)
// Phase 2
translate <0,0,1>
rotate <-90*(time-1)*(time-1), 0, 0>
translate <0,0,-1>
#else
// Phase 3
translate <0,0,1>
rotate <-90,0,0>
translate <0,0,1>
rotate <-90*(time-2)*(time-2), 0, 0>
translate <0,0,-2>
#end
#end
}
polygon { // côté gauche
5
<0,0,0>
<0,0,1>
<0,1,1>
<0,1,0>
<0,0,0>
#if (time < 1)
// Phase 1
rotate <-90*time*time, 0, 0>
#else
rotate <-90,0,0>
#if (time < 2)
// Phase 2
translate <0,0,1>
rotate <-90*(time-1)*(time-1), 0, 0>
translate <0,0,-1>
#else
// Phase 3
translate <0,0,1>
rotate <-90,0,0>
translate <0,0,-1>
rotate <0,0,90*(time-2)*(time-2)>
#end
#end
}
polygon { // côté droit
5
<0,0,0>
<0,0,1>
<0,1,1>
<0,1,0>
<0,0,0>
#if (time < 1)
// Phase 1
rotate <-90*time*time, 0, 0>
#else
rotate <-90,0,0>
#if (time < 2)
// Phase 2
translate <0,0,1>
rotate <-90*(time-1)*(time-1), 0, 0>
translate <0,0,-1>
#else
// Phase 3
translate <0,0,1>
rotate <-90,0,0>
translate <0,0,-1>
rotate <0,0,-90*(time-2)*(time-2)>
#end
#end
translate <1,0,0>
} |
Mettez le tout dans une union à laquelle vous donnez la couleur rouge, ajoutez une source de lumière quelque part et voilà !
Bien entendu, il faudra encore indiquer, en ligne de commande ou dans un fichier
.ini, le nombre d'images :
+KFF30 par exemple.
Bon, le positionnement des polygones n'était pas toujours évident, je vous l'accorde (surtout pour les trois derniers...
). Mais l'important est que vous compreniez comment on peut séparer des phases dans une animation.
Lorsque vous ferez des animation bien plus complexes, comme un homme qui marche ou une caméra qui explore un monde, vous serez vite obligé de faire comme cela...
Animez-vous !
bestben
Gyscos
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+