Aide pour After Effect, techniques, expressions.

jeudi 26 mars 2009

pouet pouet

Aller, un petit truc truc simple !













L'idée est la suivante :
Qu'importe la méthode pour bouger le carré, il se déforme tout seul quand il touche le sol.
Pour ça, nous allons non pas bouger le carré lui même, mais un Null.
Ensuite, on dira ceci au carré :
Tu suis le Null dans sa position, mais si ta position en Y atteint une certaine valeur, tu ne bouges sur Y.
On va déjà faire ça.
Créez un Null, et un petit carré. Rajoutez à ce petit carré un paramètre glissière, et nommez le "sol". Mettez y 350 (ma compo fait 480x360, je vous rappelle que 350, c'est en bas).

Dans le point d'ancrage du carré, corrigez Y pour qu'il soit en bas. Si votre carré fait 50x50, vous aurez donc [25,50].

Dans la position du carré, on va écrire ça :

N=thisComp.layer("Nul 1").transform.position; //position du Null
sol=effect("sol")("Curseur"); //valeur de "sol"

Y=Math.min(N[1],sol); // On dit que Y vaut la valeur minimum entre le y du Null, et la valeur de sol. Ainsi, quand le y du Null vaut plus que 350 (plus bas donc), Y garde la valeur du sol.

[N[0],Y] // On veut que le carré ait la valeur de x du Null pour x, et Y pour y.

Bougez votre Null, le carré ne descendra pas sous la valeur du sol.
C'était quand même pas sorcier.

Passons à la déformation.
Voilà ce qu'on va dire au carré.
Plus tu es loin du Null, plus ton échelle sur X augmente, et plus ton échelle sur Y diminue.
Tout d'abord, rajoutez un paramètre glissière au carré, et nommez le "facteur", avec 3 comme valeur.

Écrivez dans l'échelle du carré :

p=position;
N=thisComp.layer("Nul 1").transform.position;
w=width;
F=effect("facteur")("Curseur");

Même pas mal.
Ensuite :

dist=p[1]-N[1];

Voilà, comme ça, on a une variable qui donne la distance verticale entre le carré et le Null. J'aurais même pu écrire dist=length(p,N), puisque de toute manière, ils ont toujours le même X.

Ca fonctionne car quand le carré est en l'air, dist vaut forcément 0 puisqu'il suit le Null. Mais quand il est au sol, c'est à ce moment que le Null se sépare du carré, et que dist prend une valeur non nulle.

x=linear(dist,-w/2,0,F*100,100);
y=linear(dist,-w/2,0,100/F,100);


Ca a l'air compliqué comme ça, mais en fait, non.
C'est simple, on veut ceci:
Plus le Null est loin, plus la déformation se fait.
Quand Null s'éloigne du carré, son Y est plus grand que celui du carré. Donc dist devient négatif.
C'est pour cela que j'ai choisi -w/2 comme distance de déformation : la moitié de la hauteur du carré. Ainsi, il suffit que le Null descende "d'un demi carré" pour que la déformation se fasse au maximum. C'est une valeur subjective, mais elle a le mérite d'être fonction de la taille du carré. On aurait pu aussi metre 2, 25 ou 250.
Et donc, quand dist=-w/2, et bien x=300, car nous avons mis 3 dans la valeur facteur.
Donc si on multiplie X par 3, on va diviser Y par 3.
D'où le
100/F, qui divise bien 100 par 3.

Et évidemment, la dernière ligne :

[x,y]

Et voilà, vous pouvez tester, ça fonctionne, plus le "facteur" est grand, plus la déformation sera grande (3 c'est déjà pas mal)

Vous remarquerez une finesse, le carré fait de légère rotation. Nous voulons évidemment que les rotations se fassent uniquement en l'air, et non quand le carré est au sol.

Pour la rotation :

haut=100;
bas=300;
F=ease(position[1],haut,bas,60,0);
wiggle(2,F)

En dessous de 300, la rotation vaut 0, et elle augmente quand y va de 300 jusqu à 100. Au delà de 100, elle se maintient.

Il ne reste plus qu'à bruiter tout ça, avec gout.



Pour que la hauteur du son varie, j'ai activé le remappage temporel pour chaque son, en mettant ça dans l'expression :

seedRandom(index,true);
max=thisComp.layer("Nul 1").effect("son max")("Curseur");
min=thisComp.layer("Nul 1").effect("son min")("Curseur");
R=random(min,max);
(time-inPoint)*R

max vaut 1.5 et min vaut 0.5
Ainsi, chaque son va à sa propre vitesse.
Pourquoi time-inPoint ?
time est fonction de la compo, pas de chaque calque.
Ainsi, si un calque commence à la seconde 5, à sa première image, time vaudra 5.
donc comme on veut partir de 0, on rajoute - inPoint (qui vaut la valeur du temps au début du calque)
C'est un moyen simple pour avoir la valeur de temps en partant de 0 au début du calque.

Petite astuce :
Sur ces deux animations, le mouvement du Null a été fait par dessin de trajectoire, et en m'appliquant à la souris pour faire un truc qui ressemble à quelque chose.
Toutefois, il n'est pas évident sur ce type de mouvement de s'arrêter en bas au bon endroit:
Si vous descendez trop, le carré va rester trop longtemps écrasé. Et si vous ne descendez pas assez, il ne vas pas être écrasé assez longtemps.
Voilà comment j'ai fait :
J'ai fait mon mouvement, ensuite j'ai sélectionné toutes les clefs de position crées, et je les ai déplacées pour que les clefs du bas soit au bon endroit.

dimanche 22 mars 2009

plein et délier

Comme je suis généreux, on va voir encore un petit truc... Franchement vous allez voir, c'est vraiment pas mal.
Certains d'entre vous connaisse peut etre l'effet "tracé dynamique" ("write on" en anglais je crois)
On anime un point dans sa position, et ça dessine un trait. On peut évidemment attacher ce point à un objet pour que ce dernier laisse un tracé, etc, ça sert à plein de choses.

Mais ici, on va faire un truc chouette, on va gérer les pleins et les déliers. Telle une plume, selon la direction du dessin, l'épaisseur sera différente. On évite ainsi le feutre rond qui ne change jamais de taille.













Voilà ce que nous allons faire :
Il faut que le diamètre varie selon la direction du tracé.
Donc tout le problème est là, trouver l'angle qui définit la direction du tracé.

C'est parti,
Créez un solide plein pot dans la compo, et ajouter l'effet "tracé dynamique".
Comme nous allons faire varier le diamètre DANS LE TEMPS, dans "tracé dans le temps", choisissez "épaisseur"

Rajoutez 3 paramètres glissières "angle", "min" et "max"
angle va représenter l'angle de la plume. Rentrez par 40 degré.
Dans min, mettez 3, et 20 pour max.

Nous allons maintenant créer une expression dans "épaisseur" dans l'effet "tracé dynamique".

taillemax=effect("max")("Curseur");
taillemin=effect("min")("Curseur");
angleplume=effect("angle")("Curseur");

J'explique meme pas, ça serait une insulte pour vous.
On passe au coeur du problème, la direction du tracé.
Voilà comment on va faire :
Nous allons récupérer 2 positions :
-Celle à l'image N
-celle à l'image N-1
En créant un vecteur qui va d'un point à l'autre, on a bien la direction !
C'est parti.

pos=effect("Tracé dynamique")("Position");
d=thisComp.frameDuration;
posd=pos.valueAtTime(time-d);

Alors...
pos, c'est la position du point à l'image courante.
On crée d, qui correspond à la valeur temporelle d'une image. Par exemple, si vous ètes à 25i/s, d=1/25
Enuite, posd correspond à la position, mais une image avant (time-d).

vecteur=sub(pos,posd);
Hop, ça c'est le vecteur.

vari=radiansToDegrees(Math.atan2(vecteur[1],vecteur[0]));

Exactement ce qu'on a vu dans le post précédent, on trouve l'angle en décomposant le vecteur.
Ici, vous remarquez une nuance, au lieu d'avoir Math.atan (coté opp/coté adj), j'ai Math.atan2(coté opp, coté adj), on peut faire les deux.
Voilà, on a récupéré la direction
du tracé !

taille=Math.sin(degreesToRadians(vari + angleplume));

Et là, on chope le sinus de l'angle. on part de l'angle de la plume ecrit dans le paramètre glissère (40 là)+la variation dans le temp de la direction. On ainsi taille qui varie de -1 à 1.
On va utiliser sa valeur absolue pour que ça varie de 0 à 1.
Dernière ligne :

Math.abs(taille)*taillemax + taillemin

C'est ici qu'on a la valeur de l'épaisseur. On multiplie donc la valeur absolue de taille (qui varie entre 0 et 1) à taillemax, le tout additionné à taillemin, qui est l'épaisseur minimum.
Ainsi, selon l'angle, taillemax se rajoutera à taillemin, addition de 0 à 20 ici.

Et voilà !!!

vous pouvez également animer les valeurs taillemin et taillemax dans le temps, ça marche.
Vous pouvez rajouter un wiggle à la position ou à l'épaisseur, etc.
Il y a différentes façon de créer une trajectoire.
Avec des clefs, en s'accrochant à un objet sur lequel on a effectué un dessin de trajectoire, en collant un masque dans la position qui se transforme en position, etc.

Merci la trigo.

look me in 2d

Alors alors, comment faire pour qu'un calque en regarde un autre, ou du moins que sa rotation soit fonction de la position d'un autre.
Tout d'abord, reregardons ça:






















Imaginez que notre objet est sur le point 0, et que l'objet cible soit sur le point "tan", ou du moins sur l'axe de la ligne verte, ça revient au meme.
On cherche donc l'angle A.
Et bien on a cette formule :
tan(A)=coté opposé / coté adjacent.

Par coté adjacent, on parle du coté qui appartient à l'angle, est qui n'est pas la ligne verte (la ligne du cosinus donc, de 0 à 1)
Et par coté opposé, et bien c'est l'autre segment, celui qui n'appartient pas à l'angle (et toujours différent de la ligne verte), la ligne qui va donc de 1 à tan.

Passons à la pratique :

a=position;
b=thisComp.layer("Rouge sombre uni 1").transform.position;

Ca c'est simple, ce sont les deux variables de position. Celle du calque, et celle de la cible.

V=sub(b,a);

Là on crée le vecteur qui correspond à la ligne verte, la ligne qui va de a vers b.

radiansToDegrees ( Math.atan2 ( V[1],V[0] ))

Math.atan2 : il ne s'agit pas de la tangente, mais de la tangente dans le sens inverse.
Quand vous écrivez Math.tan(angle), ça vous donne la tangente de l'angle.
Math.atan2(tan), ça vous donne l'angle de la tangente.
Même chose pour avec Math.acos et Math.asin.
Petite finesse avec atan2, les deux "coté" sont séparés par une virgule.

Donc dans Math.atan2(), on doit inscrire la tangente, c'est donc coté opposé/coté adjacent.
C'est très simple, il suffit de prendre les composantes sur x et y du vecteur.
Reregardez le dessin, surtout la ligne verte. Le coté adjacent et le coté opposé corresponde bien aux composantes x et y de la ligne verte.
On note donc V[0] (sur x) et V[1] (sur y).
Et comme d'habitude, radiansToDegrees, car Math.atan2 donne un angle en radians.

Un petit exemple mixant plein de choses qu'on a vu, j'ai jamais dit que c'était joli.













On verra plus tard le coup de la taille qui change, mais vous avez les outils pour le faire.

samedi 21 mars 2009

je mords pas

Si un post ne vous parait pas clair, ou si vous avez un besoin particulier pour une animation, n'hésite pas à laisser vos commentaires.
En général, les expressions naissent d'un besoin pratique, donc certains de vos besoins peuvent créer de nouveaux types de réponses.
Attention, pour les questions dont les réponses sont déjà sur le blog, j'envoie des décharges dans vos ports USB.

Comment faisiez vous avant les expressions ?... Franchement, c'était galère.
Maintenant, c'est galère aussi, mais pour d'autres raisons.

Et n'oubliez pas :
Si il y a quelque chose que je n'explique pas dans un post, ou bien que je survole, c'est que ça été forcément expliqué en long en large et en travers dans un post précédent.

on fait une tomate ?

Il y a tellement de choses à faire avec la trigo, je ne sais pas par quoi continuer...(en fait, si, mais bon...)
Nous avons vu que nous pouvions faire évoluer un objet sur une trajectoire circulaire, ou bien en spirale si on fait évoluer le diamètre dans le temps.
Nous avons vu, au tout début du blog, que la fonction INDEX permet que chaque calque ait une constante différente de ces voisins en fonction de sa position dans la timeline.

Nous allons mixer ensemble trigo et index. (ça fait indigo !)
Plaçons plein de calques sur un cercle, ou un arc de cercle :










Ici, on fait évoluer le diamètre, l'angle, et la taille de l'arc.

Vous allez voir, c'est pas bien compliqué.

On commence par les classiques Null : un "plafond" et un "sol"( le sol en dessous évidemment merci).
Nous allons utiliser le Null "plafond" comme calque de contrôle.
Rajoutez 2 paramètres angle "angle" et "arc"
Rajoutez également un paramètre glissière "diamètre".

Rentrez d'ores et deja 120 dans arc, et 50 dans diamètre. Qu'importe les valeurs, pourvu que ça ne soit pas 0.

Créez un calque, qui sera le centre (ça peut aussi être un Null, ou meme le calque "plafond"(pensez à le passer en 3d si tout ça est en 3d), pour être invisible)
Créez un petit calque tout mignon, et ouvrez sa position, et c'est parti.

origine=thisComp.layer("centre").transform.position;
plafond=thisComp.layer("plafond").index;
I=index-plafond; nombre=thisComp.layer("sol").index-plafond-1;
angle=thisComp.layer("plafond").effect("angle")("Angle");
arc=thisComp.layer("plafond").effect("arc")("Angle");
diametre=thisComp.layer("plafond").effect("diametre")("Curseur");

Ça impressionne plein de gens, mais pas vous !
On a juste créé les variables que vous connaissez, on a vu récemment le coup de l'index entre plafond et sol, nombre, pour connaitre le nombre de calques, et les 3 variables du calque de contrôle.

pos=linear(I,1,nombre,0,1); // j'ai appelé la variable "pos" pour la position du calque dans la timeline. Je ne peux pas utiliser "position", c'est déjà pris.
Ca aussi vous connaissez. On attribut à chaque calque un nombre entre 0 et 1 en fonction de la position entre plafond et sol.

x= Math.cos ( degreesToRadians ( angle+arc*pos ) )*diametre;
y= Math.sin (
degreesToRadians ( angle+arc*pos ) )*diametre;
[x,y]+origine

Et voilà les dernières lignes.
On va juste voir "x", puisque pour "y", c'est la même chose à part le Math.sin.
Alors :
( angle+arc*pos ) Ca, c'est notre angle, en degré, de chaque calque. Il est donc égale à l'angle général, plus l'arc. Cette arc est multiplié par "pos", qui va de 0 à 1.
Donc on comprend que si angle vaut 25, et que arc vaut 90, pour le premier calque, l'angle total vaut 25, puisque 90*0=0, et le dernier calque vaudra 115.

Comme cet angle est en degré, on rajoute
degreesToRadians pour que Math.cos lise bien un angle en radian à l'interieur de la parenthèse. Comme les cos et sin vont de -1 à 1, on multiplie le tout par le diamètre, pour avoir la distance voulue jusqu'au centre.

Voilà, comme ça, vous pourrez postuler chez TF1...



Dans mes 2 exemples, les variables angle, arc et diamètre sont animées. Ces variables ne sont pas forcément à animer, elles peuvent également être des variables d'ajustement. Imaginer la vidéo "qui veut gagner des expressions", avec une camera au mileu des lumières. Vous n'allez donc que placer les lumières que la camera verra. Ensuite, en fonction des mouvements de camera et de sa focale, vous allez pouvoir régler l'espacement et le nombre de lumière en un rien de temps. Vous pourrez ainsi ajuster votre scène à loisir.

Dans l'animation avec les petits carrés, ils sont bien autour du centre, mais la rotation ne change pas. On peut biensur faire en sorte qu'ils soient tous orientés vers le centre. Au moins, on a le choix, contrairement à la technique "décalage du point d'ancrage et utilisation de la rotation".
Si votre calque est en 3d, vous vous en doutez, ils vous suffit d'utiliser lookAt dans l'orientation.

Et kesako si votre calque est un calque 2d, et que pour diverses raisons, vous ne pouvez pas le passer en 3d ? Comment orienter votre calque ?

Il y a toujours la solution de l'orientation automatique, mais celle ci ne fonctionne que quand le calque se déplace.

Nous verrons dans le prochain post comment faire pour qu'un calque 2d soit orienté par rapport à un autre calque.

vendredi 20 mars 2009

c'est pas compliqué pourtant...

une autre petite parenthèse, voilà une petite animation qu'à présent vous savez tous faire :












Allez, au boulot.
Juste un petit truc qu'on n'a pas encore vu (je crois)

calque.propriété.speed

Je vous laisse chercher.

Allez hop, une petite variante.

jeudi 19 mars 2009

gestion multi couleurs

Je fais une parenthèse pendant la trigo, voilà un post que j'avais oublié de poster.


On a vu comment gérer une meme couleur sur plusieurs calques à la fois ici :
http://lefreelancesaucisse.blogspot.com/2008/03/expressions-gestion-dune-couleur.html

Voyons comment gérer plusieurs couleurs pour plusieurs calques.
Par exemple, on veut créer plein de petits carrés, chaque carré prenant une couleur au hasard parmi nos 3 couleurs définies au préalable.












Créez un Null de control que nous appellerons "control couleurs"
Ajouter lui 3 effets "paramètre couleur"
Appliquez leur à chacun la couleur de votre choix.
Ajoutez également un paramètre glissière, votre ami de longue date. Appelez le "nombre"
Mettez 3 dans la valeur de "nombre", qui correspond donc au nombre de couleurs. Évidemment, si vous changez le nombre de couleurs, ce nombre doit changer aussi. Attention ! Si vous avez 4 couleurs, et que vous mettez 10, toutes les expressions vont s'annuler, car AE va vous dire qu'il n y a pas de 10eme effet dans le calque de contrôle.

Créez votre petit calque carré. Appliquez lui l'effet "remplir"
Nous allons créer une expression pour la couleur appliquée à "remplir"

Ce que nous voulons, c'est que le carré prenne une des 3 couleurs au hasard.
Déterminons deja le nombre de couleur:

max=thisComp.layer("control couleurs").effect("nombre")("Curseur");

Ensuite, on va définir le nombre qui va varier de 1 à 3, pour choisir un des 3 effets au hasard:

seedRandom(5,true);
R=random(1,max);


seedRandom(x,y), vous connaissez. x définit quelle présérie de chiffres aléatoires va etre utilisée, y (égale à true ou false) définit si le random sera fixe (true) ou bien changera à chaque frame (false) Là j'ai mis 5 comme j'aurais pu mettre 2, 15265, ou Math.PI. Qu'importe, c'est juste un nombre. Tous les calques auront donc ce 5, mais comme ce sont des calques différents, il n'auront pas la meme suite de chiffres.
Ainsi, R varie de 1 à 3.
La dernière ligne :

thisComp.layer("control couleurs").effect(R)("Couleur")

notez le R. Pour écrire cette phrase, faites comme d'habitude, prenez votre corde, et aller chercher par exemple la couleur du 1er effet "paramètre couleur"
Vous aurez ainsi une ligne qui ressemble à ça :

thisComp.layer("control couleurs").effect("Paramètre couleurs")("Couleur")
Dans la parenthèse de effect, vous avez, comme d'habitude, le nom de l'effet.
Nous l'avons donc remplacer par R, sans les "" donc. R joue ainsi le rôle d'index :
Va cherche l'effet qui est en R position.
Ainsi, il va chercher la couleur qui est dans l'effet 1,2 ou 3.

Si vous testez ça, vous vous rendrez compte que vous n'aurez quasiment jamais un carré de la 3eme couleur. C'est normal :
Imaginez une segment qui va de 1 à 3. AE va arrondir la valeur du random pour avoir une valeur entière...peu de chance d'avoir le chiffre 3 !

donc on va plutot écrire ça :

R=Math.ceil ( random(0,max));

Pour rappel, Math.ceil(x) donnc la valeur entière supérieure à x.
Math.ceil(1.2)=2
Math.ceil(3.9)=4
etc
Donc là, on force R à avoir la valeur entière supérieure. C'est pour cela que j'ai remplacé (1,max) par (0,max).
Ainsi, les 3 valeurs ont autant de chance de tomber que les autres :
de 0 à 1, R=1
de 1.01 à 2, R=2
de 2.01 à 3, R=3

L'expression finale :

max=thisComp.layer("control couleurs").effect("nombre")("Curseur")

seedRandom(5,true);

R=Math.ceil ( random(0,max));

thisComp.layer("control couleurs").effect(R)("Couleur")

si on écrit :
seedRandom(index,true);

Chaque calque changera de couleur quand il changera de position dans la timeline, ou dès qu'on rajoutera un calque dans la composition.

Et voilà !

Petite précision tout de même:
Une succession de valeurs aléatoires ne signifie pas homogénéité. Ca n'est pas la meme chose.
Pour chaque calque, chaque couleur a autant de chance de sortir qu'une autre, même si elle vient de sortir. Vous pouvez donc vous trouver avec 4 calques verts, ou bien 1 rouge et 3 bleus.
C'est comme pile ou face.
pile/face/pile/face/
pile face n'est pas plus probable que
pile/pile/pile/face/
pile
Ces 2 séries ont toutes les deux 1 chance sur 32 de sortir.

L'homogénéité sera visible avec un grand nombre de calques.

Ce principe ne sert évidemment pas qu'à remplir des calques, il peut aussi servir pour teinter des calques, ou je ne sais quoi...

mercredi 18 mars 2009

trigolo, oscillation

On a vu rapidement le début de l'utilisation de la trigo dans les expressions dans AE.
voyons à présent une autre utilisation citée précédemment, l'oscillation.

Comme nous l'avons vu, quand une valeur évolue de manière linéaire, son cos et son sin oscillent entre -1 et 1. Je parle de valeur et non d'angle, car finalement, on se fiche qu'il s'agisse d'un angle ou pas. Un angle est une valeur, donc n'importe quelle valeur a son cos et son sin.

Alors voilà, nous voulons faire osciller un petit baton de droite à gauche, comme ceci :










On le comprend, la valeur de rotation ici correspond au cos (ou au sin) d'un angle qui évolue de manière linéaire. Nous allons donc créer la valeur d'un angle fictif :

cercle=Math.PI*2;
hop, on a crée un constante qui correspond au périmètre du cercle (c'est une bonne habitude pour etre précis dans ce qu'on fait) freq=2;
ça, ça va etre le nombre de tour à la seconde que fait notre angle.
amp=40;
ça, ça va etre l'amplitude non pas de cet angle, mais de celui que nous appliquerons au final au haricot bio.
Math.cos(time*cercle*freq)*amp
et ça, c'est la dernière phrase.
Dans le Math.cos, on a bien notre angle en radian qui évolue, qui effectue un tour de périmètre (cercle) tous les tours (time), multiplié par 2 (freq), le tout, multiplié par amp.

Attention !!
amp multiplie bien l'ensemble du Math.cos, et non pas à l'interieur de la parenthèse. Souvenez vous, le cos et le sin n'évoluent que de -1 à 1. Avec le amp à 40, le haricot bio va de -40 à 40.

Maintenant, nous voulons que le haricot bio soit freiné par l'air, et s'arrète au bout d'un certain temps.
La base est exactement la meme, il va juste falloir que le Math.cos tende vers 0.

Il y a plein de moyens de faire ça. En gros, on veut un truc comme ça :

Math.cos(time*cercle*freq)*amp*DEC
On veut donc que DEC aille de 1 à 0. Il y a différente façon de faire ça, le control va s'effectuer sur la façon dont on va de 1 à 0.
On peut par exemple créer un paramètre glissière qu'on va faire varier de 1 à 0, en jouant sur la courbe pour avoir l'effet voulu.

Je le montre meme pas, vous savez le faire ça.
Je vous montre un autre moyen, avec Math.exp. Cette fonction ici est assez légitime, car comme vous le savez, b=Math.exp(a), avec a qui évolue linéairement, b augmente en accélérant.

On peut par exemple vouloir que la décélération soit de plus en plus rapide. En d'autre terme, plus le haricot sera lent, plus il est freiné :
cercle=Math.PI*2;
freq=4;
amp=80;

dec=Math.max(2-Math.exp(time/2.5),0);
Math.cos(time*cercle*freq)*amp*dec

voyons la ligne rouge.
On veut donc que dec aille de 1 à 0. On veut qu'il reste quelques temps autour de 1, puis que ça chute vers 0 accélère.

Math.exp(time) augmente de en accélérant. Pour rappelle, Math.exp(0)=1
donc 1-Math.exp(time) demarre à 0, et diminue en accélérant.
On veut partir de 1, donc :
2-Math.exp(time) demarre à 1, et diminue en accélérant.
On veut s'arrêter à 0, donc :
Math.max( 2-Math.exp(time) , 0 ) une fois que 2-Math.exp(time) passe sous 0, on reste à 0.

J'ai divisé time par 2.5 pour ralentir le freinage. Cette valeur peut biensur être un paramètre glissière pour etre réglable à souhait.












et voilà !!!

un exemple, ou les vitesses de vibration et de freinage sont en fonction de la taille de la boule, comme dans la vraie vie bio.

mardi 17 mars 2009

la trigolo

Aller on s'y met, on passe à la trigonométrie.

Derrière ce mot barbare se cache vos pires souvenirs du collège. Oui je dis bien collège et non lycée, car dans mes souvenirs, il s'agit du programme de 4eme, honte à vous donc.
Commençons par ce petit dessin :























Petite précision avant tout. Le dessin ci dessus est celui que vous verrez partout.
Toutefois, le point [0,0] de la composition d'AE est en haut à gauche. Ca veut dire que Y augmente de valeur en descendant. Donc inversé le 1 et le -1 de l'axe verticale dans votre tete quand vous etes dans aE.
Alors alors, kénécé...
Nous allons voir la trigonométrie uniquement dans la partie qui nous interesse, celle qui s'applique à After Effect.
La trigonométrie nous dit ceci :
-A chaque angle correspond un sinus, un cosinus et une tangente.
-le cosinus et le sinus sont compris entre -1 et 1
-cos(A)+sin(A)=1

Comme vous le voyez sur le dessin, à l'angle A correspond un cosinus environ égale à 0,4, un sinus environ égale à 0,9, et une tangente environ égale à 2.
Pour le moment nous allons nous intéresser au cosinus et au sinus.
Le cercle ayant un rayon de 1, on comprend pourquoi sin et cos varient de -1 à 1. Et en faisant augmenter l'angle à vitesse constante, vous comprenez ainsi que le cos et le sin vont osciller de -1 à 1. vous comprenez également instinctivement que lorsque l'angle A est proche de 90° (barre verte verticale) le sin s'attarde autour de 1, puis replonge brusquement vers 0 puis -1.
C'est pour cela qu'on parle par exemple de courbe sinusoïdale. L'allé-retour est arrondi aux extrémité, il en va exactement de même pour le cosinus.
Grace à ce dessin, vous comprenez également que le sin et le cos soient des vases communicants.
Quand sin=1, alors cos=0, et inversement.

Mais alors concrètement, dans after effect, à quoi ça va nous servir ?
Très concrètement, à trois choses :

-traduire un angle en position.
-traduire une position en angle.
-créer un phénomène oscillatoire.

Comment ça traduire un angle en positon ???
Et bien oui, regarder le dessin. On comprend que pour l'angle A correspond un point sur le cercle, de coordonnées [cos,sin]
Et inversement, si on a un point de coordonnée [x,y], on peut donc trouver son angle par rapport à un autre objet.

Passons à un peu de pratique, et voyons un point important.
Vous ètes habitués aux angles en degrés, de 0 à 360. C'est d'ailleurs la mesure utilisée par AE pour les rotations.
MAIS pour la trigonométrie, on utilise non pas les degrés, mais les radians.
Alors avant de dire beurk, voyons ce que c'est.

Comme vous savez, le périmètre d'un cercle se trouve par cette "formule" : Pi*R*2, ou R est le rayon.
Ici, notre cercle a un rayon de 1, donc son périmètre vaut 2*Pi.
Voilà comment fonctionnent les radians.
L'angle A vaut la section du périmètre du cercle délimité par l'angle.
On comprend donc que si A=90 en degré, on a donc un 1/4 de cercle, l'angle A vaut donc Pi/2 en radian.
180 degré=Pi
270 degré=(3*pi)/2
etc

Mais ne vous inquiétez pas, vous n'aurez pas à les calculer, AE a une fonction qui sert à ça.
L'important est de le savoir pour ne pas faire d'erreur, c'est un grand classique.

Ca veut dire que quand on écrit cos(A), A doit etre en radian.

Et comme souvent, A sera en dégré (car récupéré sur la valeur de rotation d'un calque), on écrira ça :
cos ( degreesToRadians ( A ) )
Et quand on voudra faire l'inverse, on utilisera RadiansToDegrees, on verra dans quel cas.

Un peu de pratique pour détendre tout le monde.
Créez un petit calque carré.
Dans sa postion, écrivez ceci :

vitesse=2*Math.PI*time;
diametre=50;
x=Math.cos(vitesse)*diametre;
y=Math.sin(vitesse)*diametre;
[x,y]+value

Et hop, un petit carré qui tourne autour d'un centre, mais sans rotation, il s'agit de sa position. D'ailleurs comme le voyez, il reste droit comme un i.
Explication :

vitesse=2*Math.PI*time; on définit la variable, selon le temps ici. comme 2*Pi vaut un tour complet, on comprend quand quand time=1, ça fait 1 tour, quand time=3, ça fait 3 tours.

diametre=50; Comme cos et sin varient de -1 à 1, on comprend qu'il faille augmenter la valeur, sinon notre carré va tourner autour du cercle de base, qui va de -1 à 1, c'est tout petit.

x=Math.cos(vitesse)*diametre;
y=Math.sin(vitesse)*diametre;
[x,y]+value

La suite est sans histoire. J'ai rajouté +value, car sinon, le carré tournerait autour du coin supérieur gauche de votre composition, puisqu'il évoluerait dans les 2 dimensions de -50 à 50.
le +value permet donc de le placer où l'on veut, ou même de l'animer.

Et là vous vous dites "hey cool, je peux aussi changer au cours le diamètre pour créer une spirale !!"

oui oui, vous pouvez, faites donc.