créer des animations : Les interpolators

Pré requis : Utilisation de DEF et USE, ROUTE

Les noeuds de type interpolator permettent de faire évoluer dans le temps la couleur, une position, une rotation (Orientation) d'un objet dans la scène. Ils créent ainsi des animations. Les noeuds concernés sont :

• ColorInterpolator 

• CoordinateInterpolator 

• NormalInterpolator 

• OrientationInterpolator 

• PositionInterpolator 

• ScalarInterpolator 

Tous les interpolators sont définis comme suit :

eventIn SFFloat set_fraction
exposedField MFFloat key [...]
exposedField MF<type> keyValue [...]
eventOut [S|M]F<type> value_changed

keyvalue

Cette évolution est définie par une série de points (ou valeurs) clés de l'animation (KeyFrame).

Pour un PositionInterpolator, la série de points clés sera des positions. Lorsqu'on applique un PositionInterpolator à un champ Position, la valeur de ce champs devra donc passer par tous les points clés définis (on défini ainsi le chemin de l'objet dans l'espace).

Le type de keyvalue dépend du type d'interpolator. Pour une position ce sera une série de points dans l'espace (MFVec3f), pour une couleur, une série de couleurs (MFColor) etc.

le nombre de keyvalue est illimité, c'est le nombre d'étape dans l'animation.

key

Pour définir une animation, il faut aussi définir le temps que va mettre la valeur pour passer d'une valeur clé à une autre.

Plus le temps entre deux valeurs key est petit, plus la valeur évolue rapidement vers la valeur clés suivante (Plus l'objet se déplacera vite, dans le cas d'un PositionInterpolator).

key est exprimé en Float (valeur décimale). 

set_fraction et value_changed

L'unité de temps pour l'animation n'est pas forcément la seconde. En fait, l'animation est cadencée par l'événement set_fraction. set_fraciton définit à quel moment doit se trouver l'animation dans le tableau des key.
Le chiffre envoyé dans set_fraction lance de calcul de la nouvelle valeur (une interpolation entre les keyvalues) .
Le calcul de la valeur est placé dans value_changed et l'eventOut est lancé.

Exemple de calcul :

Prenons un PositionInterpolator :
key = [0, 1, 2, 4] 
keyvalue = [0 0 0, 2 0 0, 4 2 0, 0 0 0]    

On envoie set_fraction= 1.5
Le système répère les entre quelles keys on se trouve. Ici entre la valeur 1 et 2.
Ce sont les valeurs (keyvalue) (2 0 0) et (4 2 0) qui sont concernées.
Du point de vues des key, on se trouve exactement entre les deux (1.5 est juste entre 1 et 2)
On va donc calculer une interpolation entre les deux keyvalue. Ici, on sera tout juste entre les deux :
value_changed = 3 1 0

L'interpolation est linéraire :
pour Key1 et key2 les deux clés concernées
pour Value1 et Value2, les deux keyvalues concernées
pour fraction, le valeur de set_fraction

Interpol = (key2-key1) / (fraction-key1)
Valeur = Value 1 + (Value2-Value1) / interpol

Utilisation

Souvent, un TimeSensor est utilisé pour cadencé l'animation
La commande ROUTE est utilisée pour recopier l'eventOut (value_changed) dans le champ destination.

On peut créer des animations simples à la main.

Pour l'animation d'une voiture, par exemple, le plus difficile est en fait de combiner un PositionInterpolator (la position de la voiture) et un RotationInterpolator (son orientation par rapport à la route). 

Pour ces animations plus complexes ou plus réalistes, mieux vaut passer par un logiciel qui créera les animations pour vous. Les modeleurs les plus complets proposent ces fonctions; vous les trouverez dans la rubrique Outils.

Vous trouverez un exemple dans les spécifications du noeud PositionInterpolator.

Retour aux cours VRML