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.
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.
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...
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.
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.
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.
jeudi 5 février 2009
restons groupés et en ligne, merci. Et que ça soit joli aussi merci
Alors bon, oui je sais, j'ai promis le graal, le sésame, la trigonométrie, promis, bientôt.
Mais je fais un rapide détour par les vecteurs.
Souvenez vous, on a vu comment placer une image devant un spot pour que cette dernière soit projetée comme une vulgaire diapositive dont personne n'a plus besoin. On avait utiliser les vecteurs pour ça.
Voyons aujourd'hui une autre utilisation des vecteurs :
Comme vous l'aurez compris, comment faire pour que des calques soient entre deux calques, qu'ils y restent, qu'ils soient tous équidistants, et qu'ils s'adaptent selon leur nombre.
Ouais, tout ça...
C'est parti :
Commençons simple, créez deux solides oranges, ils seront les cibles. Mettez les légèrement en transparence, pour que l'on puisse voir en dessous, comme des coquins.
Créez un Null que vous allez appeler "plafond", et placez le sous les deux calques.
Créez un autre Null, nommez le "sol", et placez le tout en bas.
Nous allons voir l'utilité de ces deux calques.
Créez un petit calque rouge par exemple. Placez le entre plafond et sol.
Créez une expression pour sa position :
a=thisComp.layer("A").transform.position;
b=thisComp.layer("B").transform.position;
plafond=thisComp.layer("plafond").index;
nombre=thisComp.layer("sol").index-plafond-1;
c'est ultra simple : a et b sont les positions respectives des deux calques principaux, plafond est l'index du plafond, et nombre sera le nombre de calques placés entre plafond et sol.
En effet, s'il y a 5 calque entre plafond et sol, plafond aura 3 comme index, et sol aura 3+5+lui=9 comme index. donc 9-3-1=5, on a bien le nombre de calques.
J'ai crée les calques plafond et sol pour pouvoir avoir autant de calques que je veux dans la composition. Tant que mes calques rouges resteront entre plafond et sol, tout ira bien.
Voilà comment on va procéder.
Tous les calques partiront de a.
On va crée un vecteur V qui va de a vers b.
Donc si un calque par de a, et qu'on rajoute le vecteur, le calque sera sur b.
Si on fait a+V/2, le calque sera donc entre a et b, pile au milieu.
Donc, on va diviser la taille de V en autant de fois qu'il faut, donc en autant de calques présents.
écrivez à la suite :
V=sub(b,a);
donc ça, pas de problème, vous vous souvenez, on crée un vecteur qui va de a vers b.
I=index-plafond;
On utilise I comme nouvel index de calque, pour que ce dernier soit relatif à la position de "plafond" dans la composition.
increment=linear(I,0,nombre+1,0,1)
C'est ici que tout se joue.
La position du calque dépend de sa position dans la composition. Selon sa position, on va lui appliquer a+V*x, ou x varie donc de 0 à 1 (de 0% à 100% du vecteur donc)
La variable est donc la position dans la timeline, I.
Disons que N est le nombre de calques à placer.
I va donc varier de 1 à N, mais nous allons la faire varier de 0 à N+1, et nous allons voir pourquoi.
Donc, quand I=0, increment vaut 0. Et quand I vaut le nombre total de calques (le dernier calque de la liste donc), incrément vaut 1.
la dernière ligne :
a+V*increment
On rajoute donc V*increment à "a".
Donc quand increment vaut 1, on rajoute la valeur entière de V à a, on tombe donc sur b.
C'est pour cela que j'ai écrit increment=linear(I,0,nombre+1,0,1) et non increment=linear(I,1,nombre,0,1), car sinon, le premier calque aurait été à la meme position que le calque a, puisque on aurait eu a+V*0, et pareil pour dernier calque avec a+V*1.
Donc en écrivant increment=linear(I,0,nombre+1,0,1), les valeurs 0 et 1 pour incrément ne sont pas utilisées, puisque I ne peut varier que de 1 à nombre.
l'expression en entier :
a=thisComp.layer("A").transform.position;
b=thisComp.layer("B").transform.position;
plafond=thisComp.layer("plafond").index;
nombre=thisComp.layer("sol").index-plafond-1;
V=sub(b,a);
I=index-plafond;
increment=linear(I,0,nombre+1,0,1)
a+V*increment
une question que certains peuvent se poser:
on avait vu comment simplement placer un calque entre deux autres, c'était simple :
(a+b)/2
Alors pourquoi ne pas utiliser la meme technique en faisant varier "2" ?
Diviser par 3, on se rapproche de a, diviser par 1.5, on se rapproche de b.
Et bien car ça ne marche pas pour la situation suivante : quand b est à gauche de a.
Vous pouvez tester. En effet, si un calque a pour expression (a+b)/3, quand b passe à gauche de a, le calque ne restera pas collé à a, il ira vers b. Tout va s'inverser au moment de la bascule.
Et c'est bien normal, puisque quand on dit (a+b), on ne fait aucune différence entre les deux, alors que pour ce coup là, on en a besoin.
voilà, c'était simple non ?
Mais je fais un rapide détour par les vecteurs.
Souvenez vous, on a vu comment placer une image devant un spot pour que cette dernière soit projetée comme une vulgaire diapositive dont personne n'a plus besoin. On avait utiliser les vecteurs pour ça.
Voyons aujourd'hui une autre utilisation des vecteurs :
Comme vous l'aurez compris, comment faire pour que des calques soient entre deux calques, qu'ils y restent, qu'ils soient tous équidistants, et qu'ils s'adaptent selon leur nombre.
Ouais, tout ça...
C'est parti :
Commençons simple, créez deux solides oranges, ils seront les cibles. Mettez les légèrement en transparence, pour que l'on puisse voir en dessous, comme des coquins.
Créez un Null que vous allez appeler "plafond", et placez le sous les deux calques.
Créez un autre Null, nommez le "sol", et placez le tout en bas.
Nous allons voir l'utilité de ces deux calques.
Créez un petit calque rouge par exemple. Placez le entre plafond et sol.
Créez une expression pour sa position :
a=thisComp.layer("A").transform.position;
b=thisComp.layer("B").transform.position;
plafond=thisComp.layer("plafond").index;
nombre=thisComp.layer("sol").index-plafond-1;
c'est ultra simple : a et b sont les positions respectives des deux calques principaux, plafond est l'index du plafond, et nombre sera le nombre de calques placés entre plafond et sol.
En effet, s'il y a 5 calque entre plafond et sol, plafond aura 3 comme index, et sol aura 3+5+lui=9 comme index. donc 9-3-1=5, on a bien le nombre de calques.
J'ai crée les calques plafond et sol pour pouvoir avoir autant de calques que je veux dans la composition. Tant que mes calques rouges resteront entre plafond et sol, tout ira bien.
Voilà comment on va procéder.
Tous les calques partiront de a.
On va crée un vecteur V qui va de a vers b.
Donc si un calque par de a, et qu'on rajoute le vecteur, le calque sera sur b.
Si on fait a+V/2, le calque sera donc entre a et b, pile au milieu.
Donc, on va diviser la taille de V en autant de fois qu'il faut, donc en autant de calques présents.
écrivez à la suite :
V=sub(b,a);
donc ça, pas de problème, vous vous souvenez, on crée un vecteur qui va de a vers b.
I=index-plafond;
On utilise I comme nouvel index de calque, pour que ce dernier soit relatif à la position de "plafond" dans la composition.
increment=linear(I,0,nombre+1,0,1)
C'est ici que tout se joue.
La position du calque dépend de sa position dans la composition. Selon sa position, on va lui appliquer a+V*x, ou x varie donc de 0 à 1 (de 0% à 100% du vecteur donc)
La variable est donc la position dans la timeline, I.
Disons que N est le nombre de calques à placer.
I va donc varier de 1 à N, mais nous allons la faire varier de 0 à N+1, et nous allons voir pourquoi.
Donc, quand I=0, increment vaut 0. Et quand I vaut le nombre total de calques (le dernier calque de la liste donc), incrément vaut 1.
la dernière ligne :
a+V*increment
On rajoute donc V*increment à "a".
Donc quand increment vaut 1, on rajoute la valeur entière de V à a, on tombe donc sur b.
C'est pour cela que j'ai écrit increment=linear(I,0,nombre+1,0,1) et non increment=linear(I,1,nombre,0,1), car sinon, le premier calque aurait été à la meme position que le calque a, puisque on aurait eu a+V*0, et pareil pour dernier calque avec a+V*1.
Donc en écrivant increment=linear(I,0,nombre+1,0,1), les valeurs 0 et 1 pour incrément ne sont pas utilisées, puisque I ne peut varier que de 1 à nombre.
l'expression en entier :
a=thisComp.layer("A").transform.position;
b=thisComp.layer("B").transform.position;
plafond=thisComp.layer("plafond").index;
nombre=thisComp.layer("sol").index-plafond-1;
V=sub(b,a);
I=index-plafond;
increment=linear(I,0,nombre+1,0,1)
a+V*increment
une question que certains peuvent se poser:
on avait vu comment simplement placer un calque entre deux autres, c'était simple :
(a+b)/2
Alors pourquoi ne pas utiliser la meme technique en faisant varier "2" ?
Diviser par 3, on se rapproche de a, diviser par 1.5, on se rapproche de b.
Et bien car ça ne marche pas pour la situation suivante : quand b est à gauche de a.
Vous pouvez tester. En effet, si un calque a pour expression (a+b)/3, quand b passe à gauche de a, le calque ne restera pas collé à a, il ira vers b. Tout va s'inverser au moment de la bascule.
Et c'est bien normal, puisque quand on dit (a+b), on ne fait aucune différence entre les deux, alors que pour ce coup là, on en a besoin.
voilà, c'était simple non ?
samedi 31 janvier 2009
diaporama alpha turbo prime 2
Ouais je sais, ça devait arriver plus tôt, mais comme pas eu le temps, bah me revoilà.
Alors alors, on prend les mêmes, et on recommence. Ce coup ci, on veut que tous nos calques aient la même échelle. Mais plutôt que de choisir la largeur ou la longueur et donc avoir des problèmes avec les calques verticaux et horizontaux, on va faire en sorte que tous les calques soient visuellement de la même taille.
Nous allons donc accorder leur diapason non pas sur leur dimension sur x ou y, mais sur leur aire.
Allons y:
La base est la même que pour le post précédent.
Créez un Null "controle", avec un paramètre glissière "aire"
Pour cette valeur de "aire", mettons pour le moment 80.
Créez un solide de 350x100 (par exemple), ouvrez lui son échelle.
La fin sera la même que l'autre post, puisque la finalité est la même, à savoir imposer une taille en pixel à un calque sans se préoccuper de sa taille initiale.
On commence facile :
A=Math.abs ( thisComp.layer("controle").effect("aire")("Curseur") ) *1000;
A vaudra donc la valeur positive de "aire". Petit rappel du post regroupant la plupart des "Math.", Math.abs renvoie la valeur absolue (donc positive).
Et multiplié par 1000. Pourquoi par 1000 ? Et bien imaginons un calque "normal" d'une taille de 600*500. Son aire vaut donc 300 000. Donc on se rend compte que l'aire, c'est vite grand (tout est relatif), et qu'on aura souvent des multiples de 1000. Donc plutôt que d'écrire 300 000 dans "aire", autant écrire 300, c'est plus claire.
Ça, ç'est fait.
Ensuite, il faut que l'on définisse le rapport hauteur/largeur de notre calque:
R=width/height; (le rapport largeur/hauteur ici donc)
Donc si notre calque est large, R vaudra un chiffre supérieur à 1, s'il est carré, R=1, et s'il est étroit, 0 < R < 1
Comme l'échelle est uniforme, il suffit de trouver x par exemple.
Trouvons donc la formule qui donne x en fonction de R, avec l'aire A donnée.
x * y = A
x / y = R donc y = x / R
donc
x * ( x / R ) = A
x² / R = A
x² = A * R
x = racine carrée de A * R
et voilà, ça donne ça dans AE:
W=Math.pow ( A*R , 0.5 );
Même chose, petit rapel, Math.pow(a,b) donne a à la puissance b.
Et quand la puissance vaut 0.5, il s'agit de la racine carrée.
J'aurais également pu écrire ça:
W=Math.SQRT1_2(A*R);
Ceux qui se rappelle quelques trucs en maths comprennent donc pourquoi on a rajouté "Math.abs" à la valeur de aire. Sinon, on aurait pu avoir une valeur négative à l'intérieur de la racine carrée; et j'ai vu des after effect se desinstaller tout seul pour moins que ça...
Un moyen mémotechnique :
racine carrée de -1 = caca.
Et maintenant qu'on a la valeur en x, hop :
s=(100/width)*W;
Exactement la même chose que pour l'autre post.
la dernière ligne :
[s,s]
Et voilà. Avec cette expression ( je faix exprès de pas tout mettre à la fin, comme ça, hop, pas de copier coller des fénéants, du moins pas d'un coup, c'est déjà ça de gagner), tous vos calques auront la même aire, qu'importe leur taille ou leur forme.
Mais, mais, mais.... Comme vous devez le savoir, visuellement, moins un calque est carré, moins il parait grand à surface équivalente. Donc on a tendance à agrandir les calques étroits, pour qu'ils paraissent aussi important que les plus carrés.
Il faut donc ajouter une correction à tout ça.
Et là, c'est un peu moins drole, je dois l'avouer.
Alors alors...
Nous devons créer une valeur qui va nous dire à quel point un calque n'est pas carré.
Je propose ça :
calque carré = 1
moins un calque est carré, plus la valeur tend vers 0.
Comment on fait ça ? mmh?
Tout d'abord, rajoutez un paramètre glissière à votre Null controle, et appelez le "correction"
Après la 1ere ligne "A=..."
rajoutez ça :
C=thisComp.layer("controle").effect("correction")("Curseur");
Ensuite, après votre ligne "R=machin" :
rect=R;
if (R>1) {rect=1/R}
Alors kénécé...
rect=R, ça c'est facile, on demande que rect soit égale à R, j'ai le droit.
if (R>1) {rect=1/R} Je crois pas que l'on ait dejà vu le "if"
C'est assez simple :
if (condition) {fais ça}
Notez bien les parenthèses pour la condition, et les accolades pour l'opération à effectuer.
Donc là, si R est plus grand que 1 (donc si notre calque est large) rect vaut 1/R.
Pourquoi je fais ça ?
Et bien parce que l'on veut avoir une valeur qui dit à quel point notre calque n'est pas rectangulaire. Et nous voulons la meme valeur pour les calques larges ET étroits.
Or pour un calque de 400x40, R vaut donc 10.
Et rappelez vous, nous voulons une valeur entre 0 et 1.
Donc si on a un calque étroit, R vaut entre 0 et 1, logique. Et si R=5 à cause d'un calque large, et bien on change la valeur pour 1/R, qui sera forcément entre 0 et 1.
Ainsi, un calque de 400x40 aura un valeur de 0.1, de même qu'un calque de 40x400.
C'est bien ce que l'on voulait faire, trouver une valeur de rectanglitude (et pourquoi pas d'abord), sans se préoccuper de savoir s'il est horizontal ou vertical.
ensuite, on n'a plus qu'à créer la valeur de correction à appliquer à la formule finale :
Nous allons donc utiliser la valeur C, celle de "correction" du Null de controle. En effet, vous pourrez ainsi modifier le taux de correction, puisque ce dernier est visuel, et donc subjectif/circonstantiel:
correction=linear ( rect , 0 , 1 , 1+C/100 , 1 );
vous connaissez dejà linéaire, je ne réexplique pas.
Donc, ici, quand rect=0, correction vaut 1+C/100
quand rect vaut=1, correction vaut 1.
la dernière ligne :
s=(100/width)*W*correction;
[s,s]
La seule différence est le rajout de *correction. Et là, vous comprenez parfaitement la ligne "linear" : Quand rect vaut 1, donc que le calque est carré, correction vaut 1, donc il ne modifie pas la formule.
Quand rect est différent de 1, donc entre 0 et 1, il tend vers 1+C/100.
J'ai divisé par 100 la valeur du paramètre glissère, car étant donné que correction va multiplier l'ensemble, il faut rester dans des petits chiffres.
Sinon, si on met 120 dans le paramètre glissère, on va avoir une échelle corrigée par un joli *121, et c'est pas joli.
Et voilà. Vous pouvez tester, vous verrez qu'en faisant varier la valeur de correction dans le Null de controle, les calques les plus étroits/larges grandissent plus que les plus carrés.
et voilà.
bon aller...l'expression en entier :
A=Math.abs ( thisComp.layer("controle").effect("aire")("Curseur") ) *1000;
C=thisComp.layer("controle").effect("correction")("Curseur");
R=width/height;
rect=R;
if (R>1) {rect=1/R}
correction=linear(rect,0,1,1+C/100,1);
W=Math.pow ( A*R, .5 );
s=(100/width)*W
*correction;
[s,s]
Alors alors, on prend les mêmes, et on recommence. Ce coup ci, on veut que tous nos calques aient la même échelle. Mais plutôt que de choisir la largeur ou la longueur et donc avoir des problèmes avec les calques verticaux et horizontaux, on va faire en sorte que tous les calques soient visuellement de la même taille.
Nous allons donc accorder leur diapason non pas sur leur dimension sur x ou y, mais sur leur aire.
Allons y:
La base est la même que pour le post précédent.
Créez un Null "controle", avec un paramètre glissière "aire"
Pour cette valeur de "aire", mettons pour le moment 80.
Créez un solide de 350x100 (par exemple), ouvrez lui son échelle.
La fin sera la même que l'autre post, puisque la finalité est la même, à savoir imposer une taille en pixel à un calque sans se préoccuper de sa taille initiale.
On commence facile :
A=Math.abs ( thisComp.layer("controle").effect("aire")("Curseur") ) *1000;
A vaudra donc la valeur positive de "aire". Petit rappel du post regroupant la plupart des "Math.", Math.abs renvoie la valeur absolue (donc positive).
Et multiplié par 1000. Pourquoi par 1000 ? Et bien imaginons un calque "normal" d'une taille de 600*500. Son aire vaut donc 300 000. Donc on se rend compte que l'aire, c'est vite grand (tout est relatif), et qu'on aura souvent des multiples de 1000. Donc plutôt que d'écrire 300 000 dans "aire", autant écrire 300, c'est plus claire.
Ça, ç'est fait.
Ensuite, il faut que l'on définisse le rapport hauteur/largeur de notre calque:
R=width/height; (le rapport largeur/hauteur ici donc)
Donc si notre calque est large, R vaudra un chiffre supérieur à 1, s'il est carré, R=1, et s'il est étroit, 0 < R < 1
Comme l'échelle est uniforme, il suffit de trouver x par exemple.
Trouvons donc la formule qui donne x en fonction de R, avec l'aire A donnée.
x * y = A
x / y = R donc y = x / R
donc
x * ( x / R ) = A
x² / R = A
x² = A * R
x = racine carrée de A * R
et voilà, ça donne ça dans AE:
W=Math.pow ( A*R , 0.5 );
Même chose, petit rapel, Math.pow(a,b) donne a à la puissance b.
Et quand la puissance vaut 0.5, il s'agit de la racine carrée.
J'aurais également pu écrire ça:
W=Math.SQRT1_2(A*R);
Ceux qui se rappelle quelques trucs en maths comprennent donc pourquoi on a rajouté "Math.abs" à la valeur de aire. Sinon, on aurait pu avoir une valeur négative à l'intérieur de la racine carrée; et j'ai vu des after effect se desinstaller tout seul pour moins que ça...
Un moyen mémotechnique :
racine carrée de -1 = caca.
Et maintenant qu'on a la valeur en x, hop :
s=(100/width)*W;
Exactement la même chose que pour l'autre post.
la dernière ligne :
[s,s]
Et voilà. Avec cette expression ( je faix exprès de pas tout mettre à la fin, comme ça, hop, pas de copier coller des fénéants, du moins pas d'un coup, c'est déjà ça de gagner), tous vos calques auront la même aire, qu'importe leur taille ou leur forme.
Mais, mais, mais.... Comme vous devez le savoir, visuellement, moins un calque est carré, moins il parait grand à surface équivalente. Donc on a tendance à agrandir les calques étroits, pour qu'ils paraissent aussi important que les plus carrés.
Il faut donc ajouter une correction à tout ça.
Et là, c'est un peu moins drole, je dois l'avouer.
Alors alors...
Nous devons créer une valeur qui va nous dire à quel point un calque n'est pas carré.
Je propose ça :
calque carré = 1
moins un calque est carré, plus la valeur tend vers 0.
Comment on fait ça ? mmh?
Tout d'abord, rajoutez un paramètre glissière à votre Null controle, et appelez le "correction"
Après la 1ere ligne "A=..."
rajoutez ça :
C=thisComp.layer("controle").effect("correction")("Curseur");
Ensuite, après votre ligne "R=machin" :
rect=R;
if (R>1) {rect=1/R}
Alors kénécé...
rect=R, ça c'est facile, on demande que rect soit égale à R, j'ai le droit.
if (R>1) {rect=1/R} Je crois pas que l'on ait dejà vu le "if"
C'est assez simple :
if (condition) {fais ça}
Notez bien les parenthèses pour la condition, et les accolades pour l'opération à effectuer.
Donc là, si R est plus grand que 1 (donc si notre calque est large) rect vaut 1/R.
Pourquoi je fais ça ?
Et bien parce que l'on veut avoir une valeur qui dit à quel point notre calque n'est pas rectangulaire. Et nous voulons la meme valeur pour les calques larges ET étroits.
Or pour un calque de 400x40, R vaut donc 10.
Et rappelez vous, nous voulons une valeur entre 0 et 1.
Donc si on a un calque étroit, R vaut entre 0 et 1, logique. Et si R=5 à cause d'un calque large, et bien on change la valeur pour 1/R, qui sera forcément entre 0 et 1.
Ainsi, un calque de 400x40 aura un valeur de 0.1, de même qu'un calque de 40x400.
C'est bien ce que l'on voulait faire, trouver une valeur de rectanglitude (et pourquoi pas d'abord), sans se préoccuper de savoir s'il est horizontal ou vertical.
ensuite, on n'a plus qu'à créer la valeur de correction à appliquer à la formule finale :
Nous allons donc utiliser la valeur C, celle de "correction" du Null de controle. En effet, vous pourrez ainsi modifier le taux de correction, puisque ce dernier est visuel, et donc subjectif/circonstantiel:
correction=linear ( rect , 0 , 1 , 1+C/100 , 1 );
vous connaissez dejà linéaire, je ne réexplique pas.
Donc, ici, quand rect=0, correction vaut 1+C/100
quand rect vaut=1, correction vaut 1.
la dernière ligne :
s=(100/width)*W*correction;
[s,s]
La seule différence est le rajout de *correction. Et là, vous comprenez parfaitement la ligne "linear" : Quand rect vaut 1, donc que le calque est carré, correction vaut 1, donc il ne modifie pas la formule.
Quand rect est différent de 1, donc entre 0 et 1, il tend vers 1+C/100.
J'ai divisé par 100 la valeur du paramètre glissère, car étant donné que correction va multiplier l'ensemble, il faut rester dans des petits chiffres.
Sinon, si on met 120 dans le paramètre glissère, on va avoir une échelle corrigée par un joli *121, et c'est pas joli.
Et voilà. Vous pouvez tester, vous verrez qu'en faisant varier la valeur de correction dans le Null de controle, les calques les plus étroits/larges grandissent plus que les plus carrés.
et voilà.
bon aller...l'expression en entier :
A=Math.abs ( thisComp.layer("controle").effect("aire")("Curseur") ) *1000;
C=thisComp.layer("controle").effect("correction")("Curseur");
R=width/height;
rect=R;
if (R>1) {rect=1/R}
correction=linear(rect,0,1,1+C/100,1);
W=Math.pow ( A*R, .5 );
s=(100/width)*W
*correction;
[s,s]
mercredi 28 janvier 2009
diaporama
Alors voilà, vous devez faire un diaporama, avec par exemple, plein de photos. On vous a filé les photos, comme d'hab, les qualités sont très variables, mais surtout, les tailles sont toutes différentes. Y'a des trucs en 400x300, d'autres en 1200x600, etc. (pour le moment, je ne parle pas de rapport hauteur/largeur, mais bien de nombre de pixels).
Et pour votre diaporama, qu'importe son type, il faut normaliser un peu tout ça. Alors oui, on pourrait modifier toutes les photos dans photoshop, en réduire certaines, en agrandir d''autres..C'est pas l'idéal, et pas très malléable.
Voilà donc comment faire en sorte que ça soit after qui gère tout :
On veut que toutes les photos soient affichées à la même taille dans la composition d'after effect. Donc en gros, plus le fichier est grand, plus l'échelle sera petite.
La manip est la suivante : On réduit le calque à la taille d'un solide de 1x1 pixels, puis on va l'agrandir à la taille que l'on veut.
Comment réduire à 1x1 des calques qui sont tous différents avec une même expression ?
Imaginons dans notre cas que nous voulons que les largeurs des photos soient toutes les mêmes, ici d'une valeur de 250 pixels :
(100 / largeur ) * 250
En divisant 100 (l'échelle 1:1 d'after) par la valeur de la largeur du calque, on le réduit à son unité en quelque sorte. Et en le multipliant par 250, on lui donne la valeur que l'on veut.
Un exemple intuitif : Imaginons un calque qui fasse 100 pixels de large :
(100 / 100)*250
On voit bien que 100/100 nous donne 1, donc 250*1=250.
Si notre calque de base faisait 500 (donc 2 fois la taille finale):
(100/500)=0.2 , 0.2*250=50
le calque sera donc à 50%, 50% de 500, ça fait bien 250.
Bon, après avoir rejoint Einstein sur ce coup là, voyons l'expression.
Créez un Null que vous appelez "controle", et ajouter un paramètre glissière que vous appelez "taille"
Et écrivez ceci pour l'échelle de chaque calque:
t=thisComp.layer("controle").effect("taille")("Curseur");
s=(100 / width)*t ;
[s,s]
Je me souviens plus si j'en ai dejà parlé, mais "width", c'est évidemment la valeur de la largeur du calque.
Ainsi, avec le parametre glissiere "taille", vous pouvez définir la largeur cible de tous les calques.
Si vous préférez gérer la hauteur, remplacez "width" par "height".
Et là, vous allez me dire : ouais c'est cool ton truc, mais les images les plus rectangulaires font franchement petites à coté des images plus carré. Et si on a des images verticales ET horizonales, on peut pas vraiment choisir si on normalise la largeur et la hauteur !!
Et vous aurez raison. C'est pour cela que le prochain post, on verra comment faire pour que n'importe quel calque, qu'importe son rapport hauteur/largeur, soit harmonieux avec tous les autres calques.
Mais c'est un poil plus compliqué quand meme... faut pas déconner.
Ca sera pour demain ! C'est ça qui est chouette.
Bonne soirée
Et pour votre diaporama, qu'importe son type, il faut normaliser un peu tout ça. Alors oui, on pourrait modifier toutes les photos dans photoshop, en réduire certaines, en agrandir d''autres..C'est pas l'idéal, et pas très malléable.
Voilà donc comment faire en sorte que ça soit after qui gère tout :
On veut que toutes les photos soient affichées à la même taille dans la composition d'after effect. Donc en gros, plus le fichier est grand, plus l'échelle sera petite.
La manip est la suivante : On réduit le calque à la taille d'un solide de 1x1 pixels, puis on va l'agrandir à la taille que l'on veut.
Comment réduire à 1x1 des calques qui sont tous différents avec une même expression ?
Imaginons dans notre cas que nous voulons que les largeurs des photos soient toutes les mêmes, ici d'une valeur de 250 pixels :
(100 / largeur ) * 250
En divisant 100 (l'échelle 1:1 d'after) par la valeur de la largeur du calque, on le réduit à son unité en quelque sorte. Et en le multipliant par 250, on lui donne la valeur que l'on veut.
Un exemple intuitif : Imaginons un calque qui fasse 100 pixels de large :
(100 / 100)*250
On voit bien que 100/100 nous donne 1, donc 250*1=250.
Si notre calque de base faisait 500 (donc 2 fois la taille finale):
(100/500)=0.2 , 0.2*250=50
le calque sera donc à 50%, 50% de 500, ça fait bien 250.
Bon, après avoir rejoint Einstein sur ce coup là, voyons l'expression.
Créez un Null que vous appelez "controle", et ajouter un paramètre glissière que vous appelez "taille"
Et écrivez ceci pour l'échelle de chaque calque:
t=thisComp.layer("controle").effect("taille")("Curseur");
s=(100 / width)*t ;
[s,s]
Je me souviens plus si j'en ai dejà parlé, mais "width", c'est évidemment la valeur de la largeur du calque.
Ainsi, avec le parametre glissiere "taille", vous pouvez définir la largeur cible de tous les calques.
Si vous préférez gérer la hauteur, remplacez "width" par "height".
Et là, vous allez me dire : ouais c'est cool ton truc, mais les images les plus rectangulaires font franchement petites à coté des images plus carré. Et si on a des images verticales ET horizonales, on peut pas vraiment choisir si on normalise la largeur et la hauteur !!
Et vous aurez raison. C'est pour cela que le prochain post, on verra comment faire pour que n'importe quel calque, qu'importe son rapport hauteur/largeur, soit harmonieux avec tous les autres calques.
Mais c'est un poil plus compliqué quand meme... faut pas déconner.
Ca sera pour demain ! C'est ça qui est chouette.
Bonne soirée
Inscription à :
Articles (Atom)