Chatbada

Ce tutoriel est destiné à comprendre l'utilisation de valueAtTime et d'en voir une application concrète.

valueAtTime est une fonction qui permet de récuperer une valeur et de la décaler dans le temps.

Par exemple on pourrait récuperer la position d'un calque et l'attribuer à un autre avec un décalage de temps.

-Expression1:

p=thisComp.layer("tete").transform.position;

r=thisComp.layer("reglage").effect("Retard")("Curseur");

ret=thisComp.frameDuration;

p.valueAtTime(time-ret*index*r)

-Expression2:

r=thisComp.layer("reglage").effect("Retard")("Curseur");

value-(index)/(0.07*r)

-Expression3:

thisComp.layer("reglage").effect("couleur carre")("Couleur")

-Expression4:

x1=clamp (transform.position[0], 0,450);

y1= clamp (transform.position[1], 0,150);

[x1,y1]

Créez un solide de 50*50 pixels, et nommez le tete. L'ayant sélectionné, double-cliquez sur l'outil Elipse, cela lui créera un masque rond.

Animez le à votre guise, pour ma part, j'ai créé 4 points clefs de position.

Ensuite créez un solide de 60*30 pixels sur lequel on va créer une flèche avec l'outil plume (g). on le place au dessus de "tête" dans la fenêtre de composition

Appliquez à chacun l'effet "Remplir" (cela servira après, lorsque l'on voudra ajuster les couleurs des solides.)

Passons aux choses sérieuses:

Pour que la flèche suive la boule il faut déja récupérer la position de la boule.

On va créer une variable "p" pour contenir cette valeur.

Sélectionnez le solide "tete" et appuiez sur "p" pour faire apparaitre la position du claque.

Sélectionnez le solide "fleche" , appuiez sur "p" et "alt"-clic sur le chrono de la propriété de position de la flèche.

Tapez "p=" prennez l'escargot et tirez le jusqu'a la propriété de position du solide tête, vous obtiendrez:

p= thisComp.layer("tete").transform.position;   //"p" récupère les coordonnées de position du solide "tête"

p;                                                                       // On applique la valeur "p" à la flèche

Si on prévisualise, les deux calques feront la même chose. Maintenant nous allons créer une variable de retard, et l'applique à la flèche.

Effacez la deuxième ligne et tapez à la place:

ret= time-1                                                     //on crée une variable "ret" qui vaut seconde de retard; time ayant la seconde comme unité

p.valueAtTime(x);                                      // et on applique cette valeur "p" à la flêche, à l'instant x (time - 1 seconde), .

Si vous prévisualisez, vous verrez maintenant la flèche suivre le rond, avec une seconde de retard. Le valueAtTime permet de créer ce décalage temporel.

Nous allons maintenant créer un décalage, que l'on va pouvoir régler et animer dans le temps, et qui plus est va s'auto-incrémenter au fur et à mesure que l'on va dupliquer les flèches.

p= thisComp.layer("tete").transform.position;   //"p" récupère les coordonnées de position du solide "tête"

r=thisComp.frameDuration;                            //on crée une variable "r" qui vaut la durée d'une image  1/25s (frameDuration est le nombre d'image/secondes)

p.valueAtTime(time-ret*index);                          // et on applique cette valeur "p" à la flêche, avec un retard de 1/25 de sec* par l'index du calque (position du calque dans la timeline).

Maintenant, en ayant sélectionné le calque flèche, dupliquez le calque plusieurs fois (ctrl-D ou pomme D)

Si on prévisualise, on a toutes les flèches qui se suivent à la queue leuleu. Mais ce retard est trop faible et encore non ajustable.

Supprimez toutes les flèches sauf une, et créons la variable qui va bien.

Tout d'abord créez un calque d'effet, que vous nommerez "reglage". On va ajouter dessus un paramètre glissière :( Effets=> Options pour expressions =>  Paramètre glissière) que l'on va renommer "Retard".

On va ajouter une ligne à notre expression:

Tapez "ret=" et prennez l'escargot et tirez le jusqu'au nom de l'effet du calque d'effet "reglage", vous obtiendrez:

r=thisComp.layer("reglage").effect("Retard")("Curseur");      //la valeur de "r" est maintenant réglable et animable avec le curseur d'effet.

et l'on modifie l'expression afin d'y incorporer la variable fraichement créée:

p.valueAtTime(time-ret*index*r)     //Le retard précédement créé est maintenant multiplié par la valeur "r" que l'on va pouvoir animer et modifier à volonté grâce au curseur.

Bref, au final nous obtenons cette expression  :

p= thisComp.layer("tete").transform.position;

r=thisComp.frameDuration;

r=thisComp.layer("reglage").effect("Retard")("Curseur");

p.valueAtTime(time-ret*index*r)

Nous pourrons donc ensuite dupliquer autant de fois que nécessaire le calque "flèche". Chacune des flèches se suivra avec un retard réglé avec le curseur du calque d'effet. (Si nous n'avions pas créé de curseur, ou si nous avions rentré une valeur numérique directement à la place, nous serions  obligé en cas de modification de ce retard, d'aller changer cela sur chaque calque dupliqué.. ce qui pourrait être très fastidieux.

Nous allons rendre transparentes les flèches au fur et à mesure des copies. On  va chercher à controler le niveau de transparence en même temps que le retard. Effacez une fois encore toutes les flèches sauf une, et ouvrez la propriété d'opacité en appuyant sur "t".

"alt"-clic sur le chrono de la propriété de transparence, et entrez les deux lignes suivantes.

r=thisComp.layer("reglage").effect("Retard")("Curseur");                 //Ici on ré-utilise notre variable "r" qui permet la liaison avec  le paramètre curseur

value-index/(0.07*r)                                                                       //Value permet ici de récuperer la valeur de transparence de la comp etde lui soustraire l'index, afin que la valeur diminue à chaque                                                                                                             copie, eton divise ce chiffre par une toute petite valeur afin que la tansparence decroisse pas trop vite.