Les pydrivers
Les pydrivers
Définition
Voilà pour la théorie (issue du glossaire du clan) :
Contraction de python et de ipo
driver, cette fonctionnalité a été implémentée
dans Blender à partir de la version 2.42. Elle permet de
contrôler une courbe IPO au moyen d'une expression en python,
on peut de cette façon mettre en jeu le nombre de frame de
l'animation, le numéro de la frame courante, ou bien la courbe
speed d'un path pour controler une rotation, un déplacement,
etc, d'un objet, d'un matériau, ...
Cette fonctionnalité
permet l'expansion des capacités des IPO drivers, l'appel de
scripts complets en python étant également possible.
Usage
Sous cet aspect un peu barbare, les pydrivers peuvent être d'une grande utilité (surtout en animation) dès que l'on sait les utiliser. Vous connaissez bien sûr les contraintes 'Copy Location', 'Copy Rotation' et 'Copy Size', celles-ci sont bien utiles cependant elles ont une limite, l'objet qui copie ne pourra pas le faire avec un facteur supérieur à 1, avec les pydrivers c'est possible. De plus les pydrivers servant à contrôler des courbes IPO on peut s'en servir pour controler des Shapes Keys ou autres (exemple : le déplacement d'un objet controle la rotation d'un autre).
Mise en place
Première chose logique, les pydrivers se mettent en place dans la fenêtre d'édition des courbes IPO :
choisissez
la courbe que vous voulez controler via le pydriver avec un clic
gauche sur son nom :
et
appelez le panneau des 'Transform Properties' avec la touche [N] :
cliquez
sur 'Add', ce qui rajoute un IPO driver, pour indiquer que cet IPO
driver sera un pydriver il suffit de cliquer sur le petit serpent
vert (un python justement) :
vous
pouvez alors remarquer que l'espace où il y'avait marqué
'OB:' change, et c'est dans ce nouvel espace que nous allons inscrire
notre expression en python qui sera le pydriver.
Forme
Un pydriver a une structure de base très simple, elle se compose de 3 parties que je nomme :
élément de référence - donnée de référence - facteur
Cette structure se retrouve dans tous les pydrivers, la compléxité venant ensuite de l'expression python.
Quelques explications :
Élément de référence : l'élément de référence est l'objet, le mesh, le material ou bien la courbe IPO qui servira à controler notre objet, material ou curve sur lequel (laquelle) nous mettons en place notre pydriver.
Les éléments de références sont déclarés de cette manière : Blender.***.Get('+++')
--> Blender : afin de déclarer que nous allons utiliser des commandes issues de l'API Python intégrée à Blender
--> *** : c'est à cet emplacement que nous allons mettre le type de l'élément de référence, voici les principaux : Object, Material, Mesh, Curve
--> Get('+++') : le Get (obtenir en anglais) est là pour dire qu'on prend cet élément, le nom de l'élément de référence (pas le type) devant être mis entre les ' '. Il est à noter que l'utilisation de « » à la place de ' ' n'a aucune importance mais il est très important de respecter les majuscules dans le nom de l'élément. Les points séparant les commandes sont aussi très importants et souvent sources d'erreurs difficiles à dénicher.
Exemple : Blender.Object.Get('Empty')
Donnée de référence : la donnée de référence est ce que le pydriver va prendre en compte comme changement de l'élément de référence, cela peut être la localisation, la rotation, la taille ou même l'emit du material
La donnée de référence est à déclarer juste après l'élément de référence, un point séparant les 2 parties, lorsque cette donnée fait référence à un déplacement, un changement de taille ou une rotation il est nécessaire de faire suivre sans espace l'axe utile en majuscule.
Voici les principaux :
type : Object/Mesh
LocX |
RotX |
SizeX |
LocY |
RotY |
SizeY |
LocZ |
RotZ |
SizeZ |
type : Material
R |
G |
B |
spec |
hard |
amb |
emit |
alpha |
ref |
Exemple : Blender.Material.Get('clay').R
Facteur : cette partie est la seule qui n'est pas obligatoire mais la plupart du temps le pydriver prend son intérêt grâce à elle, en effet le facteur va permettre de changer à volonté l'influence, par exemple, on peut multiplier par 2 l'effet de la donnée de référence.
Pour cet élément je pense qu'un exemple suffira : si le pydriver sert à copier un déplacement d'un Empty on a : Blender.Object.Get('Empty').LocX, le déplacement sera exactement conforme à celui de l'Empty mais si on ajoute *2 à la fin de l'expression le déplacement sera alors le double de celui de l'Empty
*X,
est la façon la plus simple d'écrire un facteur, vous
pouvez bien sur remplacer ce X par une expression du genre
Blender.Object.Get('Empty').SizeZ d'ailleurs vous pouvez noter
que cela revient à faire le produit entre 2 pydrivers.
En utilsant le terme de facteur je réalise un abus de langage, en effet cette partie n'est pas forcément un produit, les principaux opérateur mathématiques étant gérés ainsi que les priorités entre les opérateurs : +, -, *, /, et % (congruance).
Exemple : Blender.Material.Get('Material.001').emit + Blender.Object.Get('Empty').SizeY/5,73
Fonctions trigonométriques
Les fonctions trigonométriques sont parfaitement gérées par l'API Python, il suffit de les introduire par math puis de spécifier la fonction : sin, cos ou tan. Le nombre particulier Pi est également en mémoire on l'appelle en écrivant math.pi.
Exemple : math.sin(Blender.Object.Get('Empty').LocZ)*math.pi
Formes contractées
On se rend vite compte que les expressions deviennent vite longues, c'est pourquoi les développeurs de l'API on mis en place des formes abrégées de certaines expressions (note : elles ne fonctionnent que dans le cadre de pydrivers) :
Forme complète |
Forme abrégée |
Blender |
b |
Blender.Object.Get(' ') |
ob |
Blender.Material.Get(' ') |
ma |
Blender.Mesh.Get(' ') |
me |
math |
m |
Expressions particulières
Il existe des expressions ayant une forme particulière, voici un descriptif des principales :
Forme complète |
Forme abrégée |
Description |
Blender.Get('staframe') |
b.Get('staframe') |
récupère le numéro de la première frame de l'anim |
Blender.Get('endframe') |
b.Get('endframe') |
récupère le numéro de la dernière frame de l'anim |
Blender.Get('curframe') |
b.Get('curframe') |
récupère le numéro de la frame courante |
Blender.Noise.random() |
n.random() |
Rend une valeur aléatoire (note : il ne faut rien mettre entre les parenthèses) |
Une des formes les plus particulières est celle de l'expression servant à récuperer la valeur d'une courbe IPO à un moment donné, voici sa structure (élément + donnée de référence) :
Blender.Ipo.Get('***').getCurve('+++').evaluate(---)
--> *** : à cette endroit il faut entrer le nom 'IP:' de la courbe
--> +++ : à cette endroit il faut entrer le type de courbe (LocX, dRotZ, Speed, ...)
--> --- : à cette endroit il faut entrer le numéro de la frame à laquelle est fait l'extrapolation de la valeur de la courbe, pour avoir une extrapolation se faisant à chaque frame il suffit d'entrer b.Get('curframe')
.Blends d'exemple
Ce premier exemple comprend la mise en place de plusieurs pydrivers simples : exemple 1
Ce second exemple montre une utilisation plus évoluée des pydrivers, une balle tournant en accord avec son déplacement le long d'une curve : exemple 2
Utilisation d'un script Python
Les pydrivers ne peuvent être composés que d'une expression d'une ligne mais il y a un moyen pour augmenter cela, en effet il est possible d'appeler un script complet en Python.
Voilà la méthode :
le script doit obligatoirement se nommer pydrivers.py
le script doit être ouvert dans l'éditeur de texte de Blender
l'expression à utiliser pour l'import du script est : pydrivers sa forme abrégée étant p
Exemple :
si le script ressemble à cela
myvar = 10.0
def myfunction(arg):
# do something fancy here
return float_val
L'expression à mettre en pydriver sera : p.myvar * p.myfunction(6)+m.pi
Webographie
Voici quelques liens fort utiles :
la page de Blender.org présentant les pydrivers : http://www.blender.org/development/release-logs/blender-242/python-scripting
la partie du wiki expliquant comment mettre en place des pydrivers (en anglais) : http://wiki.blender.org/index.php/Release_Notes/Notes242/PythonTools
la page qui explique la technique que j'ai adapté pour l'exemple de la balle (en anglais) : http://www.opendimension.org/blender_en/rolling_along_path.php
d'autres fichiers d'exemple : http://projects.blender.org/tracker/index.php?func=detail&aid=4155&group_id=9&atid=127
la page où vous pourrez trouver le tuto de mcblyver qui m'a fait découvrir les pydrivers ainsi qu'un .blend d'exemple : http://www.twilight.ch/mcblyver/Tutos/
Et surtout il y a ce lien INDISPENSABLE pour approfondir ses connaissances sur les pydrivers, la référence de la totalité des expressions de l'API Python de Blender : http://www.blender.org/documentation/244PythonDoc/API_intro-module.html
Conclusion
Désormais vous savez comment mettre en place des pydrivers, vous pouvez donc animer des trains d'engrenages ou autres de manière plus automatique.
Bien sûr ce tuto n'explique que les bases, à vous d'approfondir et de faire des tests, si vous trouvez des astuces intéressantes n'hésitez pas à en faire part.
Ce tuto n'est pas totalement fermé, il se peut que je fasse des mises à jour si je trouve des éléments qui valent le coup de vous être expliqués.
Remerciement à mcblyver qui m'a fait découvrir les pydrivers et à Zelouille pour avoir relu et testé ce tuto.
-Traven-
tutoriel rédigé pour le Blender Clan par Traven, le 16/08/2007