mercredi 22 octobre 2014
DES NEWS
Je reviens très bientôt avec un nouveau script dédié au compositing, et un peu plus tard avec CIRCLE MAKER puissance 10.
vendredi 4 juillet 2014
CONNECT
Bonjour à tous,
après circle maker, voici Connect !
Petit outil très simple qui sert à faire un trait plus ou moins épais entre deux calques.
Le trait peut également être élastique.
-La distance Max indique la distance jusqu'à laquelle le trait va se déformer.
-La distance d'équilibre indique la taille à laquelle le trait n'est pas déformé. En dessous, il sera bombé, au dessus, il s'étire. Donc si vous voulez que le trait ne soit que bombé, la distance d'équilibre doit être égale à la distance max, et si vous voulez au contraire que le trait ne puisse que s'étirer, la distance d'équilibre doit être égale à 0.
La valeur d'élasticité peut être augmentée pour marquer l'effet.
Connect v1
après circle maker, voici Connect !
Petit outil très simple qui sert à faire un trait plus ou moins épais entre deux calques.
Le trait peut également être élastique.
-La distance Max indique la distance jusqu'à laquelle le trait va se déformer.
-La distance d'équilibre indique la taille à laquelle le trait n'est pas déformé. En dessous, il sera bombé, au dessus, il s'étire. Donc si vous voulez que le trait ne soit que bombé, la distance d'équilibre doit être égale à la distance max, et si vous voulez au contraire que le trait ne puisse que s'étirer, la distance d'équilibre doit être égale à 0.
La valeur d'élasticité peut être augmentée pour marquer l'effet.
Connect v1
mercredi 4 juin 2014
CIRCLE MAKER V1.11
Petite mise à jour de Circle Maker, il y avait un bug dans la position du cercle quand le controleur était en 3d. Le lien dans le post précédent est mis à jour.
mardi 27 mai 2014
CIRCLE MAKER v1
Bonjour à tous.
Aujourd'hui, petite nouveauté, je ne vais pas décrire comment faire ceci ou cela, mais plutôt vous faire un petit cadeau.
Voici CIRCLE MAKER V1, un petit script concocté par votre serviteur qui vous permettra de créer un cercle avec des calques et d'animer ces derniers avec tout plein de petits paramètres.
Libre à vous d'utiliser ce script comme bon vous semble, il y a beaucoup de possibilités.
Le script fonctionne avec lec versions française et anglaise d'After Effects, testé sous CS6 et CC.
Voici une video qui décrit l'ensemble des paramètres. Les carrés ne sont biensur qu'un exemple, remplaçable par n'importe lesquels de vos calques ou de vos composiitons.
N'hésitez pas à envoyer vos commentaires, questions, ou si vous repérez des bugs ! (en principe il n'y en a pas...)
mardi 25 mars 2014
Laissez-moi là
Bonjour à tous.
Cela fait très longtemps que rien n'a été écrit sur ce blog, non pas par manque d'envie, mais par manque de contenu. En effet, en général un article sort de terre quand un travail demande de trouver une nouvelle astuce. Et cela faisant donc longtemps que je n'avais pas du remettre un peu les mains dans le cambouis.
Je reviens donc avec une petite astuce pour, en quelque sorte, animer un lien de position.
En d'autre terme, c'est comme si on coupait un lien de parent-enfant entre 2 objets, mais uniquement pour la position.
L'idée est la suivante :
-suis la même position qu'un autre calque, plus un décalage spatial si nécessaire.
-Si on te dit de ne plus avoir ce lien, garde la dernière position que tu avais avant qu'on t'ait dit d'arrêter.
Voilà en gros comment faire :
On a 2 carrés, le rouge est le parent, le vert est l'enfant. Attention !! Il ne faut pas créer de lien de parenté !
Tout se passe donc sur le carré vert.
On rajoute à ce dernier un modificateur "Paramètre case", qui permet d'avoir une value intégrale (entière) de 0 (non) ou de 1 (oui). Appelons le "oui non".
Quand la valeur est égale à 0, le carré ne suivra pas, quand la valeur est égale à 1, il le suit.
On ouvre la position du carré vert, et c'est parti :
target=thisComp.layer("Parent");
I=effect("oui non")("Case");
"Case", c'est ainsi que j'ai nommé mon effet "Paramètre case".
Maintenant, on va chercher la clef "case" la plus proche de nous.
N=I.nearestKey(time);
Ni=N.index;
C'est assez simple, on a créé une autre variable Ni qui contient l'index de la clef la plus proche.
if ( N.time>time) { Ni=Ni-1};
Ngood=I.key(Ni);
Grace à ces 2 lignes, on fait en sorte que la clef la plus proche soit forcément celle qui soit derrière nous, c'est à dire dans le passé. Cela nous servira uniquement dans le cas où on souhaite recréer le lien de parent après l'avoir cassé.
Nt=Ngood.time;
Nt vaut donc la position de la clef "non" qui est juste derrière nous.
if ( I==1) { target.position + value }
else {
target.position.valueAtTime(Nt) +value }
Si I=oui, ajoute à ta positon la position du carré rouge.
Si I=non, ajoute à ta position la position du carré au moment où I t'as dit non.
REMARQUE : il faut mettre une clef "oui" ou "non" à l'image 0 de la composition, sinon ça bug.
Et voilà. C'est assez basique et écrit rapidement, je verrai comment cela peut être affiné.
Cela fait très longtemps que rien n'a été écrit sur ce blog, non pas par manque d'envie, mais par manque de contenu. En effet, en général un article sort de terre quand un travail demande de trouver une nouvelle astuce. Et cela faisant donc longtemps que je n'avais pas du remettre un peu les mains dans le cambouis.
Je reviens donc avec une petite astuce pour, en quelque sorte, animer un lien de position.
En d'autre terme, c'est comme si on coupait un lien de parent-enfant entre 2 objets, mais uniquement pour la position.
L'idée est la suivante :
-suis la même position qu'un autre calque, plus un décalage spatial si nécessaire.
-Si on te dit de ne plus avoir ce lien, garde la dernière position que tu avais avant qu'on t'ait dit d'arrêter.
Voilà en gros comment faire :
On a 2 carrés, le rouge est le parent, le vert est l'enfant. Attention !! Il ne faut pas créer de lien de parenté !
Tout se passe donc sur le carré vert.
On rajoute à ce dernier un modificateur "Paramètre case", qui permet d'avoir une value intégrale (entière) de 0 (non) ou de 1 (oui). Appelons le "oui non".
Quand la valeur est égale à 0, le carré ne suivra pas, quand la valeur est égale à 1, il le suit.
On ouvre la position du carré vert, et c'est parti :
target=thisComp.layer("Parent");
I=effect("oui non")("Case");
"Case", c'est ainsi que j'ai nommé mon effet "Paramètre case".
Maintenant, on va chercher la clef "case" la plus proche de nous.
N=I.nearestKey(time);
Ni=N.index;
C'est assez simple, on a créé une autre variable Ni qui contient l'index de la clef la plus proche.
if ( N.time>time) { Ni=Ni-1};
Ngood=I.key(Ni);
Grace à ces 2 lignes, on fait en sorte que la clef la plus proche soit forcément celle qui soit derrière nous, c'est à dire dans le passé. Cela nous servira uniquement dans le cas où on souhaite recréer le lien de parent après l'avoir cassé.
Nt=Ngood.time;
Nt vaut donc la position de la clef "non" qui est juste derrière nous.
if ( I==1) { target.position + value }
else {
target.position.valueAtTime(Nt) +value }
Si I=oui, ajoute à ta positon la position du carré rouge.
Si I=non, ajoute à ta position la position du carré au moment où I t'as dit non.
REMARQUE : il faut mettre une clef "oui" ou "non" à l'image 0 de la composition, sinon ça bug.
Et voilà. C'est assez basique et écrit rapidement, je verrai comment cela peut être affiné.
vendredi 24 février 2012
proxy et import final
Rien de bien méchant, juste une petite astuce permettant d'optimiser la production d'animation.
Vous connaissez déjà tous les outils, mais voici l'idée.
Vous avez une compo avec plein d'images importées. Pour le moment, vous bossez avec les images basse résolution, pour éviter que ça rame. Mais à la fin, vous allez utiliser les images en haute définition, qui seront bien plus grandes que les basses définition.
Du coup, en remplaçant vos imports, cela va changer l'échelle de vos images.
On récupère donc la technique utilisée dans "toujours à la hauteur".
On crée un paramètre glissière sur notre calque, que l'on va appeler "taille".
Puis, dans l'échelle :
t=effect("taille")("Curseur");
s=(t/width)*100;
[s,s]
Du coup, c'est la valeur de "taille" qui définira la taille du calque, et rien d'autre. Remplacer votre 400x500 par un 2000x2500, le calque ne change pas de taille dans la compo.
Bien pratique ma foi.
jeudi 17 novembre 2011
répète pour voir ?
On m'a demandé comment faire pour qu'un son se déclenche automatique à un évènement, et puisse se répéter à chaque fois que cet évènement se produit, sans devoir recopier 200 fois le calque son en question.
C'est une question intéressante, dont la réponse dépend de votre situation.
Je vais donc essayer d'être le plus clair possible. Pour mon exemple, l'évènement en question sera le passage de la ligne de temps sur un marker de composition.
Comme vous le savez, quand vous appuyer sur la touche * et qu'aucun calque n'est sélectionné, cela vous crée un marker de composition. Si un calque était sélectionné, cela crée un marker SUR le calque.
Pour votre fichier son, il faut bien évidemment activer le remappage temporel, et écrire ceci pour l'expression :
T=thisComp.marker.nearestKey(time).time;
time-T
Et si vous placez vos marqueurs sur le calque, ça donne :
T=marker.nearestKey(time).time;
time-T
Oui, c'est tout...
Alors, expliquons un peu le pourquoi du comment.
On demande à T de trouver le marker le plus proche, et d'en enregistrer sa position temporel, ou en d'autres termes, à quel moment il se situe. Par exemple 1s20f, 0s12f, etc.
Tant que le temps est avant le marker, time-T vaut donc moins de 0, la soustraction reste donc bloquée à 0. Et des que time dépasse le marker, il part de 0, donc c'est comme si le calque était lu depuis le début.
Il faut donc que les markers aient au moins un espacement égal à la longueur du son, sinon le son joué en cours sera coupé pour reprendre depuis le début.
J'affinerai ce post plus tard pour illustrer des gestions un peu plus fines.
vendredi 24 juin 2011
Sélecteur graphique
De retour après pas mal de temps, j'ai donc pris le temps d'écrire ce nouveau post, qui ouvre une toute nouvelle dimension à l'animation; nous allons développer un outil assez puissant.
Je souhaite développer une idée très utilisée dans beaucoup de domaine : le sélecteur graphique. De quoi s'agit-il ? C'est très simple, le principe est de traduire une ligne droite en courbe. Tout le truc est évidemment de choisir la courbe que l'on souhaite.
Nous avions déjà vu ce principe sur de nombreux posts, j'en ai déjà parlé en long en large et en travers.
L'idée était d'utiliser une variable qui va de 0 à 1 (et linéaire), et d'altérer cette valeur pour en modifier la progression, selon ce tableau récapitulatif :
Nous avions déjà vu ce principe sur de nombreux posts, j'en ai déjà parlé en long en large et en travers.
L'idée était d'utiliser une variable qui va de 0 à 1 (et linéaire), et d'altérer cette valeur pour en modifier la progression, selon ce tableau récapitulatif :
Maintenant, imaginons que nous voulons créer notre propre courbe, sans être bloqué par ces courbes mathématiques. Ensuite, nous allons nous en servir pour dispatcher des valeurs différentes à différents calques.
Nous allons utiliser la fonction valueAtTime.
Il y a une infinité d'applications, je vais donc en développer quelques unes.
Mais voyons déjà la structure.
Créez un Null avec un paramètre glissière.
Appelez le "courbe".
Allez dans courbe,, et animez la valeur, en mettant une clef à l'image 0 égale à 0, et une clef à 1 seconde égale à 1. Le choix de faire une courbe sur une seconde est arbitraire, mais pratique car on va de 0 à 1, et cela permet de ne pas se tromper entre chaque projet. "Comment j'ai fait ma courbe ce coup-ci déjà ?".
Passez cette ligne en easeInOut (F9), et dessiner la courbe qui vous plait.
Créez un petit carré, placez le en bas à gauche, et animer le sur X pour qu'il se déplace de gauche à droite.
On va dire qu'il se déplace sur X de 50 à 200 par exemple.
Ouvrer l'expression de la position, et écrivez :
courbe=thisComp.layer("Nul 1").effect("courbe")("Curseur");
hauteur=-200;
Quand le carré sera sur x=50, le cube sera en bas. Quand il sera à x=200, Y montera de 200 (hauteur = -200 car Y=0 est en haut).
Ensuite :
graphTime=linear(value[0],50,200,0,1);
Ici, on définit notre sélecteur, qui va nous permettre de prendre la valeur qui nous intéresse sur la courbe. Le 0 et le 1 de la fin correspondent donc au temps.
graph=courbe.valueAtTime(graphTime);
On a donc créer une valeur graph qui va prendre la courbe à un moment défini par la valeur de X.
La dernière ligne :
[value[0] , graph*hauteur+300]
Le graph va donc jouer son rôle d'interrupteur pour la hauteur, et 300 nous permet juste de mettre le carré vers le bas.
Voyez l'animation. Quand le carré avance, il monte en suivant une trajectoire qui ressemble à votre courbe.
Certains d'entre vous ont peut être une sensation de déjà-vu, puisqu'au final, on aurait pu dans ce cas utiliser simplement un linear(value,a,b,x,y) pour faire varier Y selon X, mais nous n'aurions pas eu la maîtrise des valeurs intermédiaires.
Ca n'a pas l'air comme ça, mais l'outil est surpuissant. Changer la forme de la courbe, et l'animation du carré changera sur Y.
L'outil est particulièrement pratique pour gérer plusieurs calques à la fois.
Un exemple que je ne vais pas développer mais qui parait évident : Faire un coverflow.
Car toute la question du coverflow est : de quelle façon mes calques s'avancent, reculent, grandissent. Vous pouvez ainsi tout contrôler facilement. Les calques ont une variable qui définisse leur distance par rapport au centre du coverflow, et la courbe vous permet de les faire commencer à grandir tout doucement au début, quand ils sont encore loin, puis de les faire grandir d'un coup, pour que celui du centre ait une taille bien plus grande que ceux d'à côté.
Ces applications pourraient être définies comme directes. En effet, l'utilisation de la courbe se retrouve plus ou moins visuellement dans l'animation, ici en trajectoire.
Mais on peut aller bien plus loin que cela, en créant par exemple des populations différentes. Soyons chiants 2 secondes, cela est comparable aux courbes que vous pouvez voir dans des magazines économiques par exemple. On vous montre une courbe des revenus moyens, et de la population qui est dans cette tranche. Résultat, la courbe est au plus haut sur le salaire médian, et très basse aux 2 extrémités.
Nous allons voir un exemple où l'on fait un peu la même chose, mais en moins chiant, pour ceux qui sont restés, merci à eux.
Nous allons reprendre l'animation des mouches que nous avons vu ici.
Les mouches suivent donc en retard, nous allons dessiner ce retard.
Voici ce que j'ai écrit pour chaque mouche :
target=thisComp.layer("Orange uni 1").transform.position;
courbe=thisComp.layer("Nul 1").effect("courbe")("Curseur");
retard=thisComp.layer("Nul 1").effect("retard")("Curseur");
seedRandom(index,true);
R=random(0,1);
graph=courbe.valueAtTime(R);
W=wiggle(2,10);
target.valueAtTime(time-graph*retard)+W-value
On comprend donc grace au random que chaque mouche va se voir attribuer une valeur aléatoire sur la courbe entre T0 et T1.
1er exemple :
Avec cette courbe, étant donné que la distribution des randoms est homogène entre 0 et 1, on comprend que les mouches auront plus de chance d'avoit une valeur proche de 1 que de 0.
On obtient donc cette animation :
La plupart des mouches ont un retard important.
2ème courbe :
Ici c'est l'inverse, la plupart des mouches auront un retard proche de 0, sauf certaines qui auront une valeur aléatoire attribuée dans la partie droite de la courbe.
En gros, nous avons créé un linear(value,a,b,x,y) beaucoup plus puissant, car nous contrôlons les valeurs intermédiaires.
Voilà, à vous de trouver comment cela peut vous servir. Le dernier exemple est assez parlant, car la simple utilisation du random aurait donné une distribution très homogène. Ici, on a pu créer un vilain petit canard très en retard.
Il vous suffit de changer la forme de la courbe pour voir toutes les mouches changer de position en prendre en compte la nouvelle distribution des retards.
Les applications sont infinies, et permettent de grandes finesses d'animation.
vendredi 18 février 2011
composition 2d en 3d
Oui je sais, une éternité sans post... C'est ainsi.
Petite astuce du jour. Vous avez une photographie, vous avez découpé différentes parties (1er plan, 2ème plan...), et voulez bouger votre caméra pour que l'on s'aperçoive que les différents éléments de la photo sont sur des plans différents.
Comme ça, ça n'a pas l'air bien compliqué, le truc, c'est que si on place les plans sur différentes valeurs de Z, ils n'auront plus le bon rapport de taille entre eux. Nous allons remédier à cela.
Comme tous ces calques seront en 3d, et que cette impression de 3d ne va apparaître que lorsque la caméra va se déplacer, il faut commencer par orienter nos calques dans le cas où la caméra ne serait pas face aux calques :
Donc dans l'orientation des calques :
a=thisComp.layer("Caméra 1").transform.position.valueAtTime(0);
Petite astuce du jour. Vous avez une photographie, vous avez découpé différentes parties (1er plan, 2ème plan...), et voulez bouger votre caméra pour que l'on s'aperçoive que les différents éléments de la photo sont sur des plans différents.
Comme ça, ça n'a pas l'air bien compliqué, le truc, c'est que si on place les plans sur différentes valeurs de Z, ils n'auront plus le bon rapport de taille entre eux. Nous allons remédier à cela.
Comme tous ces calques seront en 3d, et que cette impression de 3d ne va apparaître que lorsque la caméra va se déplacer, il faut commencer par orienter nos calques dans le cas où la caméra ne serait pas face aux calques :
Donc dans l'orientation des calques :
a=thisComp.layer("Caméra 1").transform.position.valueAtTime(0);
lookAt(position,a)
Maintenant, pour pouvoir déplacer les calques sur l'axe Z de la caméra :
Créer un paramètre glissière sur le calque que vous nommerez "distance camera"
Puis, dans la position :
cam=thisComp.layer("Caméra 1").transform.position.valueAtTime(0);
V=sub(position,cam);
dist=effect("distance camera")("Curseur")/100;
value+V*dist
J'ai déjà expliqué tout ça, donc je ne m'attarde pas. Juste au sujet de "dist", j'ai divisé la valeur par 100 car notre vecteur doit être multiplié par 1 ou -1 pour que le calque soit collé à la caméra ou 2 fois plus loin. Le paramètre glissière sera ainsi plus simple à utiliser, et ça va nous aider pour l'échelle.
Voilà, vous pouvez tester, votre calque se déplace bien sur l'axe de la profondeur de la caméra quand vous modifiez le paramètre glissière.
Passons à l'échelle :
Quand le paramètre glissière est à 0, notre objet est à la bonne taille, son échelle est donc bien de 100. Si notre calque est collé à la caméra, il doit théoriquement avoir une échelle de 0. Si le paramètre glissière vaut 100, le calque sera donc 2 fois plus loin, il doit donc être 2 fois plus gros, etc.
On a donc :
dist=effect("distance camera")("Curseur");
s=dist+100;
[s,s,s]
Et voilà, c'est tout.
mardi 18 mai 2010
accordeon 2
Tout d'abord, cet article est destiné à ceux qui ont lu (et compris) l'article précédent sur l'accordéon, car je m'y réfère.
Voyons à présent la version 2 de l'accordéon, avec un retard sur chaque plaque, dans un sens où dans l'autre.
Imaginez que vous tenez ses plaques dans les mains et que vous lâchiez toutes les plaques sauf la 1ere. Elle vont toutes tomber en paquet, et se défaire en partant du haut, au fur et à mesure que la résistance de la 1ere plaque fasse son effet. Ca c'est le cas où les plaques vont s'ouvrir en partant de la 1ere plaque.
L'autre cas est si vous poser les plaques sur une table, et que vous tirer la dernière plaque. C'est cette dernière qui se dépliera en 1ère, les autres suivants. L'inverse donc.
Nous allons donc prévoir ces 2 possibilités.
Cette option nous impose un changement de méthode.
Dans la version précédente, nous utilisions l'angle de la plaque précédente pour trouver l'angle de la plaque courante. Si nous voulions on retard, il suffirait d'utiliser une phrase du type :
ThisComp.layer(thisLayer,-1).rotationY.valueAtTime(time-d);
Le problème, c'est que l'on veut pouvoir avoir le retard dans un sens où dans l'autre. Cela veut dire que d va donc varier selon le sens, mais de manière compliquée, puisque la 1ère plaque à démarrer ne sera pas la même, et que tout va s'inverser....Vraiment pas pratique.
Nous allons donc utiliser une autre approche, dont vous connaissez la base.
Nous allons utiliser l'index relatif de chaque calque pour connaître sa position dans la liste, et en définir son propre retard.
Nous aurons donc la structure que vous connaissez:
-controle
-plaque 1
-plaque clone 1
-plaque clone 2
-plane clone n
-sol
Commençons par le calque "controle", et voyons ce dont on a besoin en plus:
-random
-angle
-inverse
-sens
-retard
-courbe
Seuls les 3 premiers viennent du 1er accordéon, les 3 autres sont nouveaux.
-sens va nous dire qu'elle est la 1ère plaque à démarrer (la 1ère ou la dernière de la liste). Pour cette valeur, vous pouvez d'ailleurs copier l'effet "inverse", puisqu'on veut également une valeur qui aille de -1 à 1.
-retard sera le retard en nombre d'image entre chaque plaque (environ, vous verrez pourquoi)
-courbe va nous permettre de ne pas avoir un retard linéaire.
Créez donc également votre null "sol" qui sera sous toutes les plaques dans la timeline.
La différence se situera au niveau de la rotation sur Y, l'expression sur la position ne change pas.
Commençons par l'expression de la 1ere plaque, celle qui est différente des autres:
angle=thisComp.layer("controle").effect("angle")("Curseur"); H=thisComp.layer("controle").effect("random")("Curseur");
seedRandom(index,true);
hasard=random(-H,H);
inverse=thisComp.layer("controle").effect("inverse")("Curseur"); sens=thisComp.layer("controle").effect("sens")("Curseur"); nombre=thisComp.layer("sol").index-thisComp.layer("carton_start").index; retard=thisComp.layer("controle").effect("retard (frame)")("Curseur")*thisComp.frameDuration;
Les rouges sont les nouveaux venus.
nombre vaut bien le nombre de plaques.
Nous allons à présent définir la position de cette plaque, selon la valeur de sens.
Elle sera ou en 1ère position, ou en dernière:
pos=0;
if (sens==-1) {pos=nombre};
Quand sens=1 (le "==" est le égal dans le monde des conditions. Le simple "=" enregistre une valeur dans une variable, à ne pas confondre), pos=0, ça sera le 1er calque.
Quand sens=-1, il sera en dernier, pos vaudra nombre+1=le nombre de plaques, car nous avons définit la valeur de nombre -cette plaque.
Bref, la dernière ligne :
(angle.valueAtTime(time-retard*pos)+hasard)*inverse;
Rien de bien compliqué. On comprendra donc que le retard vaudra ou 0, et bien retard*le nombre de plaque, et sera donc bien en dernier.
Passons à présent aux autres plaques, plus compliqué. En effet, ça sera moins binaire (ou 1er ou dernier).
Nous allons créer une variable "retardMax" qui sera égale au retard entre la derniere plaque et la 1ère. Puis, chaque plaque aura une position de 0 à 1 (dans un sens ou dans l'autre justement), et se verra appliqué un retardMax*cette position.
Allons y:
angle=thisComp.layer("controle").effect("angle")("Curseur"); H=thisComp.layer("controle").effect("random")("Curseur");
seedRandom(index,true);
hasard=random(-H,H);
inverse=thisComp.layer("controle").effect("inverse")("Curseur"); nombre=thisComp.layer("sol").index-thisComp.layer("carton_start").index; retardMax=thisComp.layer("controle").effect("retard (frame)")("Curseur")*thisComp.frameDuration*nombre; sens=thisComp.layer("controle").effect("sens")("Curseur"); courbe=thisComp.layer("controle").effect("courbe")("Curseur");
Tout pareil que la 1ère plaque, on a juste rajouté courbe.
Notez également une différence pour le retard. Cette fois-ci, la variable vaut la totalité du retard.
direction=1;
if (thisComp.layer(thisLayer,-1).rotationY<0 0="" color:="" direction="-1}; <br /> <br /><span style=" rgb="">Direction fera en sorte que chaque plaque soit dans le sens opposé à la plaque précédente.
posBase=index-thisComp.layer("carton_start").index+1;
posSens=posBase;
posSens est la valeur qui nous allons utiliser à terme. Quand sens=1, on ne change rien, on garde l'ordre initial.
if (sens==-1) { posSens=nombre-posBase+1};
Quand sens=-1, c'est l'inverse.
Reprenons notre exemple de 5 plaques. Pour la 5ème:
posSens=5-5+1=1
Pour la 4ème:
posSens=5-4+1=2
On est bon, ça marche !
retardN=linear(posSens,1,nombre,0,1);
On applique maintenant la transformation de la valeur pour aller de 0 à 1. Le N de retard vaut pour Normal, car voici la ligne suivante:
retardCourbe=Math.pow(retardN,courbe);
Cela nous permet d'avoir une retard exponentiel ou logarithmique. Dans le calque controle, la valeur de "courbe" ira de 0 à l'infini, mais dans la pratique, on ira pas au delà de 10, ça ne sert à rien.
On se refusera d'ailleurs les valeurs négatives. Pour une puissance, c'est bof. Pour éviter les messages d'erreurs et les désactivations massives d'expressions, nous allons empêcher "courbe" de prendre des valeurs négatives.
Ecrivez ça dans "courbe" du calque de controle :
Math.abs(value)
Ca évitera les désagréments.
Revenons à la rotationY de notre plaque. La dernière ligne:
(angle.valueAtTime(time-retardMax*retardCourbe)+hasard)*inverse*direction;
C'est long, mais pas compliqué :
on multiplie le retardMax par la valeur qui va de 0 à 1. Le tout multiplier par inverse et direction pour le sens des plaques.
Et voilà, c'est terminé.
C'est encore améliorable, car il y a une faiblesse:
Si vous mettez une valeur trop grande dans le random, vous aurez d'une part des calques qui se chevauchent au départ, et on peut également avoir des sautes de plaque qui passe d'un angle positif à un angle négatif, vous comprendrez vite pourquoi.
Donc restez raisonnable !
samedi 15 mai 2010
Yvette et son accordéon, et son orchestre
Me revoici avec de nouvelles petites idées, aujourd'hui, nous allons voir comment faire un système d'accordéon:
L'idée, comme d'habitude, est de rendre le maximum de choses automatiques. La seule variable que nous allons animer sera l'angle d'ouverture.
La base est très simple, mais c'est en affinant le travail que ça va un peu se complexifier, juste un peu...
Commençons par faire une version toute simple, où toutes les plaques tournent en même temps.
Allons y :
Commençons par créer notre éternel calque Null de controle, et ajoutons y quelques paramètres glissière:
-random (pour que l'angle entre chaque plaque puisse différer)
-angle (l'angle général)
-inverse ( nous permettra d'inverser le sens de chaque plaque)
Dans tous les cas, la 1ere plaque sera différente des suivantes, commençons par celle là:
Créez votre calque, des dimensions que vous souhaitez, passez le en mode 3d, et écrivez ceci dans sa rotation Y:
angle=thisComp.layer("controle").effect("angle")("Curseur");
H=thisComp.layer("controle").effect("random")("Curseur");
inverse=thisComp.layer("controle").effect("inverse")("Curseur");
Et oui, vous reconnaissez votre ami la trigo. Le trait rouge est la 1ere plaque, le trait bleu est la 2eme. Quand l'angle de la plaque rouge change, on comprend que le point P de la plaque bleu va se déplacer sur le cercle trigo. La taille du cercle sera donc fonction de la taille du calque précédent.
Ouvrez sa position, et écrivez :
papa=thisComp.layer(thisLayer,-1);
angle=degreesToRadians ( papa.rotationY);
depart=papa.position; taille=papa.width;
Nous avons ainsi défini à la 1ere ligne la plaque référence, c'est à dire le calque juste au dessus.
Nous avons donc besoin de l'angle qu'il prend, sa position, et sa taille (respectivement l'angle sur le cercle, les coordonnées du centre du cercle et le diamètre du cercle.)
Il est important de prendre l'angle de la plaque et non l'angle défini dans le calque controle, car l'angle de la plaque n'est pas le même puisque nous avons rajouter la valeur "hasard".
La suite, vous connaissez, on a déjà fait ça 100 fois:
X=Math.cos(-angle)*taille;
Z=Math.sin(-angle)*taille;
[X,0,Z]+depart
Et voilà, c'est bon pour la position.
Vous pouvez tester, ça marche. La plaque suit bien la 1ere plaque dans sa rotation.
Passons à présent à la rotation sur l'axe Y. C'est quasiment la même chose que pour la 1ere plaque:
angle=thisComp.layer(thisLayer,-1).rotationY*-1; H=thisComp.layer("controle").effect("random")("Curseur");
seedRandom(index,true);
hasard=random(-H,H);
angle+hasard
Où sont les différences ? Remarquez le *-1 à la 1ere ligne. On donne à la valeur "angle" l'inverse de la plaque du dessus. Si la plaque 1 est à 20°, cette plaque sera à -20° (+la valeur du hasard)
J'ai donc enlevé la variable "inverse" puisque la 1ere plaque la contient, et que chaque plaque va successivement prendre la valeur inverse à la précédente.
Et voilà !
Vous pouvez dupliquer cette plaque autant que vous voulez et animer la valeur "angle" du calque controle, ça fonctionne.
Vous pouvez créer un Null 3d que vous placez sur le même point que la 1ere plaque, et la mettre en parent de toutes les plaques. Vous pourrez ainsi orienter votre accordéon comme bon vous semble.
Dans le prochain article, nous allons reprendre tout ça à zero, et faire en sorte que l'on puisse définir un retard dans le dépliage, d'un coté ou de l'autre:
Un peu plus compliqué...
L'idée, comme d'habitude, est de rendre le maximum de choses automatiques. La seule variable que nous allons animer sera l'angle d'ouverture.
La base est très simple, mais c'est en affinant le travail que ça va un peu se complexifier, juste un peu...
Commençons par faire une version toute simple, où toutes les plaques tournent en même temps.
Allons y :
Commençons par créer notre éternel calque Null de controle, et ajoutons y quelques paramètres glissière:
-random (pour que l'angle entre chaque plaque puisse différer)
-angle (l'angle général)
-inverse ( nous permettra d'inverser le sens de chaque plaque)
Dans tous les cas, la 1ere plaque sera différente des suivantes, commençons par celle là:
Créez votre calque, des dimensions que vous souhaitez, passez le en mode 3d, et écrivez ceci dans sa rotation Y:
angle=thisComp.layer("controle").effect("angle")("Curseur");
H=thisComp.layer("controle").effect("random")("Curseur");
inverse=thisComp.layer("controle").effect("inverse")("Curseur");
Pas de fourberie pour le moment. Créons à présent la variable random:
seedRandom(index,true);
hasard=random(-H,H);
La dernière ligne :
(angle+hasard)*inverse;
Et voilà. La multiplication par inverse nous permet d'inverser le sens de la 1ere plaque, et de toutes les suivantes comme nous le verrons plus tard. Ha oui, j'oubliais, il faut qu'on s'occupe du point d'ancrage ! En effet, nous ne voulons pas que le calque tourne en son centre, mais sur sa tranche. Ecrivons donc ceci dans le point d'ancrage :
[0,value[1],0].
On pourrait faire ça sans expression en mettant 0 pour X, mais ainsi, si on change la taille du calque, la valeur en Y restera centrée. On sait jamais...
[0,value[1],0].
On pourrait faire ça sans expression en mettant 0 pour X, mais ainsi, si on change la taille du calque, la valeur en Y restera centrée. On sait jamais...
A ce propos, nous comprenons donc que la valeur inverse devra être égale à 1 ou -1. Comme c'est pas très pratique de rentrer ou 1 ou -1 (on est obligé de passer par le clavier pour rentrer la valeur), on va faire en sorte de que la valeur soit rentrable à la souris. Nous allons faire en sorte que lorsque la valeur est positive, elle vaut 1, et quand elle est négative, elle vaut -1.
Ouvrez donc l'effet "inverse" de votre calque de controle, et écrivez ça dedans :
inverse=1;
if ( value<0 inverse="-1">
Et voilà, ainsi, il suffit de faire glisser le curseur vers le positif ou le négatif pour avoir la valeur voulue.
Passons à présent à la 2eme plaque, qui sera un clone de toutes les suivantes. Il s'agit bien entendu d'un calque de taille équivalente ( à priori). Même opération pour le point d'ancrage !
Nous allons commencer par nous occuper de la position de cette plaque, qui est fonction de la plaque précédente. Un petit schéma vu de haut va nous éclairer:
Et oui, vous reconnaissez votre ami la trigo. Le trait rouge est la 1ere plaque, le trait bleu est la 2eme. Quand l'angle de la plaque rouge change, on comprend que le point P de la plaque bleu va se déplacer sur le cercle trigo. La taille du cercle sera donc fonction de la taille du calque précédent.
Ouvrez sa position, et écrivez :
papa=thisComp.layer(thisLayer,-1);
angle=degreesToRadians ( papa.rotationY);
depart=papa.position; taille=papa.width;
Nous avons ainsi défini à la 1ere ligne la plaque référence, c'est à dire le calque juste au dessus.
Nous avons donc besoin de l'angle qu'il prend, sa position, et sa taille (respectivement l'angle sur le cercle, les coordonnées du centre du cercle et le diamètre du cercle.)
Il est important de prendre l'angle de la plaque et non l'angle défini dans le calque controle, car l'angle de la plaque n'est pas le même puisque nous avons rajouter la valeur "hasard".
La suite, vous connaissez, on a déjà fait ça 100 fois:
X=Math.cos(-angle)*taille;
Z=Math.sin(-angle)*taille;
[X,0,Z]+depart
Et voilà, c'est bon pour la position.
Vous pouvez tester, ça marche. La plaque suit bien la 1ere plaque dans sa rotation.
Passons à présent à la rotation sur l'axe Y. C'est quasiment la même chose que pour la 1ere plaque:
angle=thisComp.layer(thisLayer,-1).rotationY*-1; H=thisComp.layer("controle").effect("random")("Curseur");
seedRandom(index,true);
hasard=random(-H,H);
angle+hasard
Où sont les différences ? Remarquez le *-1 à la 1ere ligne. On donne à la valeur "angle" l'inverse de la plaque du dessus. Si la plaque 1 est à 20°, cette plaque sera à -20° (+la valeur du hasard)
J'ai donc enlevé la variable "inverse" puisque la 1ere plaque la contient, et que chaque plaque va successivement prendre la valeur inverse à la précédente.
Et voilà !
Vous pouvez dupliquer cette plaque autant que vous voulez et animer la valeur "angle" du calque controle, ça fonctionne.
Vous pouvez créer un Null 3d que vous placez sur le même point que la 1ere plaque, et la mettre en parent de toutes les plaques. Vous pourrez ainsi orienter votre accordéon comme bon vous semble.
Dans le prochain article, nous allons reprendre tout ça à zero, et faire en sorte que l'on puisse définir un retard dans le dépliage, d'un coté ou de l'autre:
Un peu plus compliqué...
mercredi 12 mai 2010
jeudi 6 mai 2010
le cycle de la vie
J'aimerais bien savoir pourquoi il y a un pique de visites tous les mercredis ?
Il y a un centre aéré qui fait un atelier "AE winn3rs, pate-à-sel loos3rs ?"
Il y a un centre aéré qui fait un atelier "AE winn3rs, pate-à-sel loos3rs ?"
mardi 27 avril 2010
modèle de début et de fin.
Bonjour à tous, ça faisait longtemps (beaucoup de boulot, et pas de cas d'expression qui vaille le coup)
J'ai eu un commentaire me demandant ceci :
"Comment faire pour caler cette animation de disparition en fonction de la fin du calque (sachant qu'ils n'ont bien sûr pas tous la même durée...)"
Alors oui, ça parait beau comme ça, et vous pensez bien que je m'étais posé la question. Mais malheureusement, c'est plus compliqué que prévu, voilà pourquoi :
Nous avons vu ici comment faire pour qu'une animation se lance quand le début d'un calque se fait sentir. C'était simple, il suffit d'utiliser un valueAtTime pour décaler le temps.
Mais si on veut gérer le début ET la fin, se pose de gros problèmes de logique.
Tout d'abord, cela veut dire qu'il faut définir qui sont les clefs de début, et qui sont les clefs de fin.
C'est une notion très arbitraire, et en rien after effect ne peut le deviner.
L'autre soucis, c'est que pour le début, il suffit de faire un décalage. Là, il faut faire ce décalage, puis arreter la lecture des clefs, puis reprendre la lecture à un moment donné (quand la fin se fait proche).
Ca complique beaucoup les choses, et c'est à se demander si l'energie de la reflexion est rentable comparer à une technique plus manuelle.
Pour un travail, j'ai du trouver une solution, car le fichier after effect était voué à être utiliser par quelqu'un qui ne connait pas du tout after effect, et donc les longueurs de composition allait être variable.
J'ai donc du chercher un moyen de lancer une animation à un moment donné, puis l'arreter, plus la relancer pour l'animation de fermeture.
Je ne donnerai aucune explication, je balance juste l'expression que j'ai utilisé dans un remappage temporel (c'est de toute façon le même principe que pour le remappage de clef).
Je n'ai pas fait le ménage, donc il y a plein de lignes ou de chiffres qui correspondent à ma situation à moi, et ne rentre en aucune façon dans la theorie.
Ce système très très cuisiné vaux le coup quand on a vraiment beaucoup de chose à automatiser...
Donc voilà, pour les plus courageux !
one=comp("prog 1_rush_vendredi").marker.key("fin").time
+
comp("prog 2_rush_vendredi").marker.key("fin").time
+
comp("prog 3_rush_vendredi").marker.key("fin").time
+
comp("prog 4_rush_vendredi").marker.key("fin").time
+
thisComp.layer("prog 1_vendredi").inPoint;
two=comp("source").marker.key("fin").time+one;
ouverture=5;
fermeture=10;
tps=time-inPoint;
x=time;
if (time>ouverture && time
if (time>=one && time
if ( time>one+2 ) { x=fermeture };
if (time>=two) { x=time-two+fermeture};
x
tout le début correspond au fait que ce calque doit démarrer apres 5 calques qui eux mêmes ont exactement la meme chose, c'est à dire un début et une fin totalement aléatoire !
Je vous avais prévenu.
J'ai eu un commentaire me demandant ceci :
"Comment faire pour caler cette animation de disparition en fonction de la fin du calque (sachant qu'ils n'ont bien sûr pas tous la même durée...)"
Alors oui, ça parait beau comme ça, et vous pensez bien que je m'étais posé la question. Mais malheureusement, c'est plus compliqué que prévu, voilà pourquoi :
Nous avons vu ici comment faire pour qu'une animation se lance quand le début d'un calque se fait sentir. C'était simple, il suffit d'utiliser un valueAtTime pour décaler le temps.
Mais si on veut gérer le début ET la fin, se pose de gros problèmes de logique.
Tout d'abord, cela veut dire qu'il faut définir qui sont les clefs de début, et qui sont les clefs de fin.
C'est une notion très arbitraire, et en rien after effect ne peut le deviner.
L'autre soucis, c'est que pour le début, il suffit de faire un décalage. Là, il faut faire ce décalage, puis arreter la lecture des clefs, puis reprendre la lecture à un moment donné (quand la fin se fait proche).
Ca complique beaucoup les choses, et c'est à se demander si l'energie de la reflexion est rentable comparer à une technique plus manuelle.
Pour un travail, j'ai du trouver une solution, car le fichier after effect était voué à être utiliser par quelqu'un qui ne connait pas du tout after effect, et donc les longueurs de composition allait être variable.
J'ai donc du chercher un moyen de lancer une animation à un moment donné, puis l'arreter, plus la relancer pour l'animation de fermeture.
Je ne donnerai aucune explication, je balance juste l'expression que j'ai utilisé dans un remappage temporel (c'est de toute façon le même principe que pour le remappage de clef).
Je n'ai pas fait le ménage, donc il y a plein de lignes ou de chiffres qui correspondent à ma situation à moi, et ne rentre en aucune façon dans la theorie.
Ce système très très cuisiné vaux le coup quand on a vraiment beaucoup de chose à automatiser...
Donc voilà, pour les plus courageux !
one=comp("prog 1_rush_vendredi").marker.key("fin").time
+
comp("prog 2_rush_vendredi").marker.key("fin").time
+
comp("prog 3_rush_vendredi").marker.key("fin").time
+
comp("prog 4_rush_vendredi").marker.key("fin").time
+
thisComp.layer("prog 1_vendredi").inPoint;
two=comp("source").marker.key("fin").time+one;
ouverture=5;
fermeture=10;
tps=time-inPoint;
x=time;
if (time>ouverture && time
if (time>=one && time
if ( time>one+2 ) { x=fermeture };
if (time>=two) { x=time-two+fermeture};
x
tout le début correspond au fait que ce calque doit démarrer apres 5 calques qui eux mêmes ont exactement la meme chose, c'est à dire un début et une fin totalement aléatoire !
Je vous avais prévenu.
lundi 15 mars 2010
random VS wiggle
J'ai eu un commentaire me demandant comment avoir un random moins violent.
J'en profite donc pour bien expliquer la différence.
Random permet d'avoir une valeur aléatoire comprise entre x et y, et ce à chaque image. La valeur prise à l'image 5 n'est ni fonction de la valeur à l'image 4, ni à la 6. C'est en ça qu'il se différencie de wiggle.
Le wiggle peut être aussi chaotique que désiré (le chanceux), il possède ce qu'on appelle une corrélation.
Prenons une image :
Prenez une feuille, et dessinez des points, où chacun a sa propre abscisse (x), et une valeur en ordonnée aléatoire (y). Vous obtenez le résultat d'un random.
Reliez tous ces points par une ligne passant par chaque point (sans revenir en arrière), et vous obtenez un wiggle.
Aussi grande que puisse être la différence entre l'ordonnée de 2 points, la valeur wiggle passera nécessairement par toutes les valeurs intermédiaires.
Le wiggle a une corrélation de 100%.
Le random à une corrélation de 0%.
Et ça n'est pas parce que vous avez une composition à 25 images/s, et que vous avez écrit wiggle(25,a) qu'il n'y a pas de lien entre les valeurs. Certes, il prendra bien une nouvelle valeur (une nouvelle crête) à chaque image, mais le lien existe bien. Entre les images, le wiggle prend bien les valeurs intermédiaires.
Il y a plusieurs façon d'en avoir la preuve :
-le motion blur
-un remappage temporel grâce à la technique que nous avons vu ici. En effet, si vous appelez la valeur d'une variable au temps 5.36s, vous aurez bien une valeur intermédiaire.
J'en profite donc pour bien expliquer la différence.
Random permet d'avoir une valeur aléatoire comprise entre x et y, et ce à chaque image. La valeur prise à l'image 5 n'est ni fonction de la valeur à l'image 4, ni à la 6. C'est en ça qu'il se différencie de wiggle.
Le wiggle peut être aussi chaotique que désiré (le chanceux), il possède ce qu'on appelle une corrélation.
Prenons une image :
Prenez une feuille, et dessinez des points, où chacun a sa propre abscisse (x), et une valeur en ordonnée aléatoire (y). Vous obtenez le résultat d'un random.
Reliez tous ces points par une ligne passant par chaque point (sans revenir en arrière), et vous obtenez un wiggle.
Aussi grande que puisse être la différence entre l'ordonnée de 2 points, la valeur wiggle passera nécessairement par toutes les valeurs intermédiaires.
Le wiggle a une corrélation de 100%.
Le random à une corrélation de 0%.
Et ça n'est pas parce que vous avez une composition à 25 images/s, et que vous avez écrit wiggle(25,a) qu'il n'y a pas de lien entre les valeurs. Certes, il prendra bien une nouvelle valeur (une nouvelle crête) à chaque image, mais le lien existe bien. Entre les images, le wiggle prend bien les valeurs intermédiaires.
Il y a plusieurs façon d'en avoir la preuve :
-le motion blur
-un remappage temporel grâce à la technique que nous avons vu ici. En effet, si vous appelez la valeur d'une variable au temps 5.36s, vous aurez bien une valeur intermédiaire.
vendredi 19 février 2010
suivi d'objet
Animer un objet dans After Effect est une chose, animer une caméra en est une autre.
C'est parfois compliqué, fourbe, ingrat, ça fait pas ce qu'on veut, bref.
Nous allons en partie régler le problème pour un cas bien particulier, celui du suivi d'un objet dont le mouvement est important et plus ou moins chaotique, comme une mouche par exemple.
Nous allons essayer d'imiter le comportement d'un vrai caméraman.
Que fait le caméraman ? Il essaye tant bien que mal de suivre la trajectoire de l'objet pour le garder dans son cadre, en étant parfois en retard sur l'objet en question ou parfois un peu en avance s'il a anticipé.
Dans l'exemple, il s'agit d'un gros wiggle 3d bien large (le cercle fait 100 de large, le wiggle se déplace en tout sur 2000). Les particules sont là pour avoir un élément fixe pour que vous puissiez différencier le mouvement de la caméra et celui de l'objet.
Nous allons donc créer une expression sur le point ciblé de la caméra. La caméra en elle-même restera fixe.
Pour créer le caméraman parfait, il suffit logiquement de coller la position de l'objet au point ciblé par la caméra, et l'objet restera donc toujours au centre de l'image. Mais ça n'est pas ce que nous voulons faire.
Créez votre petite scène, et rajoutez un Null objet que nous appellerons "target cam". C'est à lui que nous allons appliquer l'expression et non à la caméra. Vous verrez un peu plus tard pourquoi.
Ajoutez 3 paramètres glissière à ce Null, et nommez les "amplitude", "tendance" et decalage".
amplitude définira le nombre d'images maximum de décalage dans le temps. (mettez 20 par exemple)
tendance nous permettra de définir si la camera sera plus souvent en retard ou en avance. (mettez -1 pour le moment)
decalage contiendra la valeur de décalage temporel à chaque image.
Écrivons l'expression dans "decalage" :
amp=effect("amplitude")("Curseur");
tendance=effect("tendance")("Curseur");
Expliquons un peut le processus avant de se lancer dans l'écriture de l'expression.
"decalage" va contenir un wiggle qui va faire varier le décalage temporel, selon l'amplitude.
Pour le moment, si on écrit juste "wiggle(0.2,amp), on va avoir une valeur qui va varier de -20 à 20, c'est à dire que la caméra sera (statistiquement parlant) autant en retard qu'en avance.
Nous allons donc utiliser la valeur "tendance" pour faire varier ça.
Ca va pas mal ressembler à la façon dont on a gérer le néon.
Quand tendance=1, la caméra sera toujours en avance.
Quand tendance=-1, la caméra sera toujours en retard.
si on le traduit pour le wiggle, ça donne ça :
tendance=-1 : le wiggle ira de -20 à 0 (avec un milieu à 10 donc)
tendance=0 : le wiggle ira de -20 à 20 (avec un milieu à 0 donc)
tendance=1 : le wiggle ira de 0 à 20 (avec un milieu à -10 donc)
Ecrivons donc cette amplitude qui peut aller de 20 à 40 selon les cas :
ampF=linear(Math.abs(tendance),0,1,amp,amp/2);
Voilà, on a bien ce qu'on voulait.
Maintenant, on doit créer la valeur final en décalant le centre du wiggle entre -10 et 10:
W=tendance*(amp/2)+wiggle(.2,ampF);
Ainsi, on transforme tendance pour qu'il varie de -10 à 10.
La dernière ligne, on transforme le nombre d'image en seconde :
d=thisComp.frameDuration*W;
Voilà, on a créé notre décalage en seconde.
Maintenant, écrivons l'expression pour la position de ce même calque (on est toujours dans "target cam" je vous rappelle):
p=thisComp.layer("target").transform.position;
d=effect("decalage")("Curseur");
p.valueAtTime(time+d);
J'explique même pas, vous connaissez par cœur tout ça. Juste une petite précision quand même.
Là j'ai écrit time+d car c'est la valeur de tendance (de -1 à 1) qui va définir le retard ou l'avance.
-1, et le calque sera toujours en retard. 1, et le calque sera toujours en avance. Vous pouvez aussi mettre -10 ou 456, ça ne change rien, la fonction linear écrête les résultats.
Bref, on a bien notre calque "target cam" qui suit la même trajectoire que la cible, parfois en avance, parfois en retard (ça dépend de la valeur de tendance).
Occupons de la caméra à présent.
Nous allons comprendre pourquoi nous n'avons pas écrit cette expression directement dans la caméra.
Certes notre caméraman va être en avance ou en retard, mais il paraît fortement improbable que sa caméra suive exactement le trajet de l'objet.
Nous allons donc utiliser une fonction pour altérer cette trajectoire, et plus exactement, l'adoucir.
Nous allons utiliser la fonction smooth(a,b).
a est la durée sur laquelle un adoucissement va être effectué. Plus la durée sera longue, plus les creux et les bosses seront mélangés.
b Correspond à la puissance du smooth. Gardez comme règle de toujours utiliser une valeur impaire (C'est comme ça, discutez pas).
Sauf qu'il y a un petit problème...
On pourrait se dire qu'écrire ceci fonctionnerait :
P=thisComp.layer("target cam").transform.position;
P.smooth(1,5)
Et bien non, ça ne marchera pas !
Je vous explique pourquoi.
Les expressions dans After Effect ont leurs limites, et notamment une très importante:
Elles n'ont aucune mémoire. Vous ne pouvez pas enregistrer dans la mémoire d'AE une valeur qu'on va venir chercher à chaque image, ou bien faire que cette valeur augmente de n à chaque image (il y a en fait une technique pour faire ça, mais c'est un systeme D où AE recalcule tout depuis le début à chaque image).
Le problème est que se le smooth va faire une moyenne des valeurs, par exemple sur 1 seconde, il va aller voir les valeurs sur 1/2 seconde avant, et 1/2 seconde après. Sauf que voilà, il ne peut pas connaître les valeurs du futur puisqu'elles n'ont pas encore été calculée.
Nous devons donc passer par une étape supplémentaire.
Ecrivons donc juste ceci :
P=thisComp.layer("target cam").transform.position;
La caméra a donc exactement le même mouvement que "target cam"
A présent, en ayant la variable "point ciblé" sélectionnée, allez dans Animation, assistant d'image clé, convertir l'expression en image clés.
After va créer une clef par image calculées par l'expression, et désactiver cette dernière.
A présent, effacez l'expression et remplacez là par
smooth(1,5)
Et voilà !
Donc à chaque fois que vous faite une modification dans l'objet "target cam", vous devez reconnecter la caméra en remettant :P=thisComp.layer("target cam").transform.position;
Refaire le coup de "Animation machin bidule), et remettre smooth(a,b).
Ne vous plaignez pas, ça prend 5 secondes.
Voilà c'est fini, vous avez votre belle caméra qui fait un beau mouvement.
Encore une article bien long, mais au final, il y a très peu de ligne à écrire.
Ce système est largement améliorable.
Par exemple, on peut imaginer que le caméraman dézoome quand la cible est trop loin de sa caméra.
Autre finesse, si l'objet se déplace essentiellement horizontalement, on voudra gérer de manière séparer X et Y.
Peut être pour un prochain article.
C'est parfois compliqué, fourbe, ingrat, ça fait pas ce qu'on veut, bref.
Nous allons en partie régler le problème pour un cas bien particulier, celui du suivi d'un objet dont le mouvement est important et plus ou moins chaotique, comme une mouche par exemple.
Nous allons essayer d'imiter le comportement d'un vrai caméraman.
Que fait le caméraman ? Il essaye tant bien que mal de suivre la trajectoire de l'objet pour le garder dans son cadre, en étant parfois en retard sur l'objet en question ou parfois un peu en avance s'il a anticipé.
Dans l'exemple, il s'agit d'un gros wiggle 3d bien large (le cercle fait 100 de large, le wiggle se déplace en tout sur 2000). Les particules sont là pour avoir un élément fixe pour que vous puissiez différencier le mouvement de la caméra et celui de l'objet.
Nous allons donc créer une expression sur le point ciblé de la caméra. La caméra en elle-même restera fixe.
Pour créer le caméraman parfait, il suffit logiquement de coller la position de l'objet au point ciblé par la caméra, et l'objet restera donc toujours au centre de l'image. Mais ça n'est pas ce que nous voulons faire.
Créez votre petite scène, et rajoutez un Null objet que nous appellerons "target cam". C'est à lui que nous allons appliquer l'expression et non à la caméra. Vous verrez un peu plus tard pourquoi.
Ajoutez 3 paramètres glissière à ce Null, et nommez les "amplitude", "tendance" et decalage".
amplitude définira le nombre d'images maximum de décalage dans le temps. (mettez 20 par exemple)
tendance nous permettra de définir si la camera sera plus souvent en retard ou en avance. (mettez -1 pour le moment)
decalage contiendra la valeur de décalage temporel à chaque image.
Écrivons l'expression dans "decalage" :
amp=effect("amplitude")("Curseur");
tendance=effect("tendance")("Curseur");
Expliquons un peut le processus avant de se lancer dans l'écriture de l'expression.
"decalage" va contenir un wiggle qui va faire varier le décalage temporel, selon l'amplitude.
Pour le moment, si on écrit juste "wiggle(0.2,amp), on va avoir une valeur qui va varier de -20 à 20, c'est à dire que la caméra sera (statistiquement parlant) autant en retard qu'en avance.
Nous allons donc utiliser la valeur "tendance" pour faire varier ça.
Ca va pas mal ressembler à la façon dont on a gérer le néon.
Quand tendance=1, la caméra sera toujours en avance.
Quand tendance=-1, la caméra sera toujours en retard.
si on le traduit pour le wiggle, ça donne ça :
tendance=-1 : le wiggle ira de -20 à 0 (avec un milieu à 10 donc)
tendance=0 : le wiggle ira de -20 à 20 (avec un milieu à 0 donc)
tendance=1 : le wiggle ira de 0 à 20 (avec un milieu à -10 donc)
Ecrivons donc cette amplitude qui peut aller de 20 à 40 selon les cas :
ampF=linear(Math.abs(tendance),0,1,amp,amp/2);
Voilà, on a bien ce qu'on voulait.
Maintenant, on doit créer la valeur final en décalant le centre du wiggle entre -10 et 10:
W=tendance*(amp/2)+wiggle(.2,ampF);
Ainsi, on transforme tendance pour qu'il varie de -10 à 10.
La dernière ligne, on transforme le nombre d'image en seconde :
d=thisComp.frameDuration*W;
Voilà, on a créé notre décalage en seconde.
Maintenant, écrivons l'expression pour la position de ce même calque (on est toujours dans "target cam" je vous rappelle):
p=thisComp.layer("target").transform.position;
d=effect("decalage")("Curseur");
p.valueAtTime(time+d);
J'explique même pas, vous connaissez par cœur tout ça. Juste une petite précision quand même.
Là j'ai écrit time+d car c'est la valeur de tendance (de -1 à 1) qui va définir le retard ou l'avance.
-1, et le calque sera toujours en retard. 1, et le calque sera toujours en avance. Vous pouvez aussi mettre -10 ou 456, ça ne change rien, la fonction linear écrête les résultats.
Bref, on a bien notre calque "target cam" qui suit la même trajectoire que la cible, parfois en avance, parfois en retard (ça dépend de la valeur de tendance).
Occupons de la caméra à présent.
Nous allons comprendre pourquoi nous n'avons pas écrit cette expression directement dans la caméra.
Certes notre caméraman va être en avance ou en retard, mais il paraît fortement improbable que sa caméra suive exactement le trajet de l'objet.
Nous allons donc utiliser une fonction pour altérer cette trajectoire, et plus exactement, l'adoucir.
Nous allons utiliser la fonction smooth(a,b).
a est la durée sur laquelle un adoucissement va être effectué. Plus la durée sera longue, plus les creux et les bosses seront mélangés.
b Correspond à la puissance du smooth. Gardez comme règle de toujours utiliser une valeur impaire (C'est comme ça, discutez pas).
Sauf qu'il y a un petit problème...
On pourrait se dire qu'écrire ceci fonctionnerait :
P=thisComp.layer("target cam").transform.position;
P.smooth(1,5)
Et bien non, ça ne marchera pas !
Je vous explique pourquoi.
Les expressions dans After Effect ont leurs limites, et notamment une très importante:
Elles n'ont aucune mémoire. Vous ne pouvez pas enregistrer dans la mémoire d'AE une valeur qu'on va venir chercher à chaque image, ou bien faire que cette valeur augmente de n à chaque image (il y a en fait une technique pour faire ça, mais c'est un systeme D où AE recalcule tout depuis le début à chaque image).
Le problème est que se le smooth va faire une moyenne des valeurs, par exemple sur 1 seconde, il va aller voir les valeurs sur 1/2 seconde avant, et 1/2 seconde après. Sauf que voilà, il ne peut pas connaître les valeurs du futur puisqu'elles n'ont pas encore été calculée.
Nous devons donc passer par une étape supplémentaire.
Ecrivons donc juste ceci :
P=thisComp.layer("target cam").transform.position;
La caméra a donc exactement le même mouvement que "target cam"
A présent, en ayant la variable "point ciblé" sélectionnée, allez dans Animation, assistant d'image clé, convertir l'expression en image clés.
After va créer une clef par image calculées par l'expression, et désactiver cette dernière.
A présent, effacez l'expression et remplacez là par
smooth(1,5)
Et voilà !
Donc à chaque fois que vous faite une modification dans l'objet "target cam", vous devez reconnecter la caméra en remettant :P=thisComp.layer("target cam").transform.position;
Refaire le coup de "Animation machin bidule), et remettre smooth(a,b).
Ne vous plaignez pas, ça prend 5 secondes.
Voilà c'est fini, vous avez votre belle caméra qui fait un beau mouvement.
Encore une article bien long, mais au final, il y a très peu de ligne à écrire.
Ce système est largement améliorable.
Par exemple, on peut imaginer que le caméraman dézoome quand la cible est trop loin de sa caméra.
Autre finesse, si l'objet se déplace essentiellement horizontalement, on voudra gérer de manière séparer X et Y.
Peut être pour un prochain article.
précision sur le néon
Certains se sont peut être demandé pourquoi j'ai créé un interrupteur qui va de 0 à 1 si c'est pour derrière l'utiliser uniquement en le transformant de 0,25 à 0,75.
C'est certes arbitraire, mais il y a plusieurs raisons:
Tout d'abord, une raison "logique". Étant donné qu'il s'agit d'un interrupteur, il est légitime qu'il aille de 0 à 1.
Ensuite, nous pourrions imaginer que cet interrupteur va agir sur d'autres éléments de l'animation, pour que ces derniers soient synchrones avec l'allumage du néon. Des valeurs allant de 0,25 à 0,75 seraient donc inappropriées d'un point de vue démocratique.
Enfin, et de manière plus générale, c'est un bon réflexe de créer ou de transformer les variables de 0 à 1 dans le cas où elles servent de potentiomètre ou d'échelle.
Nous avons déjà vu cela à plusieurs reprises:
Quand nous voulions avoir plusieurs calques qui se positionnent entre 2 calques et créent une chaine, nous avons utilisé leur index pour créer une variable allant de 0 à 1, et multiplier cette valeur par le vecteur allant d'un bout à l'autre pour les positionner. Plus génériquement, cela permet d'aller de 0 à la valeur finale d'une variable.
Les exemples sont nombreux, et souvent édifiants, car mathématiquement, c'est pratique :
-Pour la trigonométrie, on reste dans les valeurs du cosinus et du sinus.
-pour les vecteurs, on reste également à l'intérieur du vecteur sans le dépasser ni partir dans l'autre sens.
-Cela nous permet également de monter cette valeur à la puissance X, tout en restant entre 0 et 1, et ça, c'est extrêmement pratique.
Nous l'avons déjà vu par exemple pour l'amélioration des flares ou des lumières volumétriques. Au lieu d'avoir une droite qui va de 0 à 1, une courbe qui reste plus longtemps autour de 0 (avec une puissance supérieure à 1), ou au contraire on peut avoir une courbe qui va plus vite vers 1 (avec une puissance comprise entre 0 et 1 (non inclus). Pour rappel, la racine carrée correspond à une puissance de 0,5)
Nous verrons d'autres applications de l'utilisation de ce type de courbe pour casser la linéarité d'une valeur allant de 0 à 1.
C'est certes arbitraire, mais il y a plusieurs raisons:
Tout d'abord, une raison "logique". Étant donné qu'il s'agit d'un interrupteur, il est légitime qu'il aille de 0 à 1.
Ensuite, nous pourrions imaginer que cet interrupteur va agir sur d'autres éléments de l'animation, pour que ces derniers soient synchrones avec l'allumage du néon. Des valeurs allant de 0,25 à 0,75 seraient donc inappropriées d'un point de vue démocratique.
Enfin, et de manière plus générale, c'est un bon réflexe de créer ou de transformer les variables de 0 à 1 dans le cas où elles servent de potentiomètre ou d'échelle.
Nous avons déjà vu cela à plusieurs reprises:
Quand nous voulions avoir plusieurs calques qui se positionnent entre 2 calques et créent une chaine, nous avons utilisé leur index pour créer une variable allant de 0 à 1, et multiplier cette valeur par le vecteur allant d'un bout à l'autre pour les positionner. Plus génériquement, cela permet d'aller de 0 à la valeur finale d'une variable.
Les exemples sont nombreux, et souvent édifiants, car mathématiquement, c'est pratique :
-Pour la trigonométrie, on reste dans les valeurs du cosinus et du sinus.
-pour les vecteurs, on reste également à l'intérieur du vecteur sans le dépasser ni partir dans l'autre sens.
-Cela nous permet également de monter cette valeur à la puissance X, tout en restant entre 0 et 1, et ça, c'est extrêmement pratique.
Nous l'avons déjà vu par exemple pour l'amélioration des flares ou des lumières volumétriques. Au lieu d'avoir une droite qui va de 0 à 1, une courbe qui reste plus longtemps autour de 0 (avec une puissance supérieure à 1), ou au contraire on peut avoir une courbe qui va plus vite vers 1 (avec une puissance comprise entre 0 et 1 (non inclus). Pour rappel, la racine carrée correspond à une puissance de 0,5)
Nous verrons d'autres applications de l'utilisation de ce type de courbe pour casser la linéarité d'une valeur allant de 0 à 1.
jeudi 18 février 2010
animation modèle
Aujourd'hui, un petit truc tout simple, mais dont vous ne pourrez pas vous passer tant il peut vous faire gagner un temps précieux.
Imaginez que vous ayez créé une animation d'apparition pour un calque, qui mélange opacité, échelle, rotation, etc.
Vous êtes très content de votre mixture, ça fonctionne bien.
Sauf que cette apparition de luxe doit vous servir à faire apparaître 50 calques.
Alors oui, vous pourriez copier/coller toutes les clefs de chaque variable sur chaque calque, en faisant attention que les clefs soient bien synchro avec le début de chaque calque....
Et si vous changez votre animation, il faut tout refaire.
Bref, c'est tout pourri.
Nous allons donc dire à chaque calque de copier un calque modèle, chacun quand il le désire.
Imaginons comme dans l'exemple que vous ayez des clefs d'échelle et de rotation.
Ouvrez ces 2 propriétés dans votre 2ème calque, et écrivez ceci pour l'échelle par exemple :
target=thisComp.layer("modele");
e=target.scale;
e.valueAtTime(time-inPoint+target.inPoint)
C'est tout. Pas grand chose à expliquer.
Le valueAtTime nous permet donc de corriger le tir, et de faire en sorte que l'animation commence au bon moment, c'est à dire quand le calque apparait dans la composition.
Le +target.inPoint corrige également le tir si le calque modèle ne commence pas au début de la composition.
Il vous suffit de faire une expression équivalente pour chaque variable qui en a besoin, et tout sera automatisé.
Imaginez que vous ayez créé une animation d'apparition pour un calque, qui mélange opacité, échelle, rotation, etc.
Vous êtes très content de votre mixture, ça fonctionne bien.
Sauf que cette apparition de luxe doit vous servir à faire apparaître 50 calques.
Alors oui, vous pourriez copier/coller toutes les clefs de chaque variable sur chaque calque, en faisant attention que les clefs soient bien synchro avec le début de chaque calque....
Et si vous changez votre animation, il faut tout refaire.
Bref, c'est tout pourri.
Nous allons donc dire à chaque calque de copier un calque modèle, chacun quand il le désire.
Imaginons comme dans l'exemple que vous ayez des clefs d'échelle et de rotation.
Ouvrez ces 2 propriétés dans votre 2ème calque, et écrivez ceci pour l'échelle par exemple :
target=thisComp.layer("modele");
e=target.scale;
e.valueAtTime(time-inPoint+target.inPoint)
C'est tout. Pas grand chose à expliquer.
Le valueAtTime nous permet donc de corriger le tir, et de faire en sorte que l'animation commence au bon moment, c'est à dire quand le calque apparait dans la composition.
Le +target.inPoint corrige également le tir si le calque modèle ne commence pas au début de la composition.
Il vous suffit de faire une expression équivalente pour chaque variable qui en a besoin, et tout sera automatisé.
vendredi 12 février 2010
faux contact
Un petit truc tout simple aujourd'hui, nous allons créer un interrupteur qui galère un peu à se stabiliser, à la manière d'un néon.
Il y a 1000 façons de voir les choses, en voici une.
Voilà commet nous pourrions décrire l'allumage d'un néon :
A partir du moment où l'on appuie sur l'interrupteur, plus le temps passe, plus le néon a une forte probabilité d'être allumé, jusqu'à ce qu'il le reste allumé sans probabilité de revenir à une position éteinte.
Nous devons donc créer une courbe qui restitue cette définition.
Nous allons utiliser une variable qui ira de 0 à 1.
A 0, le néon n'aura aucune chance d'être allumé, et à 1, le néon sera forcément allumé. Nous allons donc utiliser 2 outils : le wiggle, et Math.round. Vous pouvez cliquer sur un des 2 mots pour avoir un rappel de leur fonction.
Pour le moment, occupons nous du wiggle. Voilà la 1ere courbe que nous voulons :
Rappelez-vous qu'ensuite, nous allons utiliser Math.round pour que la valeur de sortie ne puisse faire que 0 ou 1. Donc tout ce qui sera sous 0.5 vaudra 0, et tout ce qui vaudra 0.5 et plus faudra 1.
Donc quand la variable vaut 0, notre wiggle ne doit rien produire au delà de 0.4999. Le wiggle faisant varier la valeur aussi bien vers le haut que le bas, nous avons donc besoin d'un départ à 0.25, et que l'amplitude du wiggle soit égale à 0.25, pour qu'on aille bien de 0 à 0.5.
Dans la théorie, je suis bien d'accord, cela donne une possibilité d'atteindre 0.5, mais dans la pratique, ça n'est pas le cas, le wiggle atteint très rarement sa valeur max.
Quand la variable vaudra 1, c'est tout pareil, mais entre 0.5 et 1.
Le wiggle va donc garder son amplitude de 0.25 de chaque coté, mais avec une valeur moyenne de 0.75.
Voilà ce que ça donne :
I=thisComp.layer("controle").effect("switch")("Curseur");
.25+ I/2+ wiggle(20,.25)
N'oubliez pas que le wiggle contient la valeur initiale de la variable ! N'oubliez donc pas de bien mettre 0 dans la valeur qui contient l'expression pour que le wiggle tremble bien autour de 0.
.25+ I/2 varie bien de 0.25 à 0.75. La fréquence de 20 est arbitraire, mais fonctionne bien.
Il ne reste plus qu'à utiliser le Math.round:
I=thisComp.layer("controle").effect("switch")("Curseur");
Math.round(
.25+ I/2+ wiggle(20,.25)
)
Regardez votre graphique. Plus on s'approche de 1, moins le néon a une chance de s'éteindre.
Une fois que la variable vaut 1, plus aucune chance que ça s'éteigne.
La morale d'aujourd'hui ? (oui j'ose)
Même si c'est intuitivement très simple, on se doute bien qu'il s'agit d'une histoire de Wiggle & Cie, il faut bien réfléchir en amont pour avoir l'effet escompté.
Il y a 1000 façons de voir les choses, en voici une.
Voilà commet nous pourrions décrire l'allumage d'un néon :
A partir du moment où l'on appuie sur l'interrupteur, plus le temps passe, plus le néon a une forte probabilité d'être allumé, jusqu'à ce qu'il le reste allumé sans probabilité de revenir à une position éteinte.
Nous devons donc créer une courbe qui restitue cette définition.
Nous allons utiliser une variable qui ira de 0 à 1.
A 0, le néon n'aura aucune chance d'être allumé, et à 1, le néon sera forcément allumé. Nous allons donc utiliser 2 outils : le wiggle, et Math.round. Vous pouvez cliquer sur un des 2 mots pour avoir un rappel de leur fonction.
Pour le moment, occupons nous du wiggle. Voilà la 1ere courbe que nous voulons :
Rappelez-vous qu'ensuite, nous allons utiliser Math.round pour que la valeur de sortie ne puisse faire que 0 ou 1. Donc tout ce qui sera sous 0.5 vaudra 0, et tout ce qui vaudra 0.5 et plus faudra 1.
Donc quand la variable vaut 0, notre wiggle ne doit rien produire au delà de 0.4999. Le wiggle faisant varier la valeur aussi bien vers le haut que le bas, nous avons donc besoin d'un départ à 0.25, et que l'amplitude du wiggle soit égale à 0.25, pour qu'on aille bien de 0 à 0.5.
Dans la théorie, je suis bien d'accord, cela donne une possibilité d'atteindre 0.5, mais dans la pratique, ça n'est pas le cas, le wiggle atteint très rarement sa valeur max.
Quand la variable vaudra 1, c'est tout pareil, mais entre 0.5 et 1.
Le wiggle va donc garder son amplitude de 0.25 de chaque coté, mais avec une valeur moyenne de 0.75.
Voilà ce que ça donne :
I=thisComp.layer("controle").effect("switch")("Curseur");
.25+ I/2+ wiggle(20,.25)
N'oubliez pas que le wiggle contient la valeur initiale de la variable ! N'oubliez donc pas de bien mettre 0 dans la valeur qui contient l'expression pour que le wiggle tremble bien autour de 0.
.25+ I/2 varie bien de 0.25 à 0.75. La fréquence de 20 est arbitraire, mais fonctionne bien.
Il ne reste plus qu'à utiliser le Math.round:
I=thisComp.layer("controle").effect("switch")("Curseur");
Math.round(
.25+ I/2+ wiggle(20,.25)
)
Regardez votre graphique. Plus on s'approche de 1, moins le néon a une chance de s'éteindre.
Une fois que la variable vaut 1, plus aucune chance que ça s'éteigne.
La morale d'aujourd'hui ? (oui j'ose)
Même si c'est intuitivement très simple, on se doute bien qu'il s'agit d'une histoire de Wiggle & Cie, il faut bien réfléchir en amont pour avoir l'effet escompté.
dimanche 31 janvier 2010
lampe anisotropique et son flare
Derrière cette recette délicieuse se cache simplement le même principe que la luminosité de Lux, mais appliqué à un flare.
Quelle est la différence à observer ?
Si la lumière volumétrique est bel et bien un phénomène lumineux qui varie selon l'angle avec la caméra, il reste en principe visible dans toutes les directions, même si la lampe est dos à la caméra.
Pour les flares, ça n'est pas le cas. Ils ne sont visibles que lorsque la lampe est en face de la caméra. C'est même dans la nature profonde des flares d'avoir des changements importants au moindre changement d'angle de la lumière.
On peut donc considérer qu'un flare ne commence à apparaître que lorsque la lampe est AU MOINS de profile par rapport à la caméra.
Souvenez vous du petit diagramme avec l'angle de la lampe qui tourne.
La valeur de profil correspond donc à la situation ou les 2 segments sont perpendiculaires.
Les segments valant chacun 1, le vecteur bleu mesure donc racine carré de 2, donc environ 1.4
Il nous suffit donc de modifier la dernière ligne pour que la valeur ne commence non pas à 0, mais à ...hmm ?
Alors alors, souvenez vous, le vecteur bleu va de 2 à 0.
Et on avait transformer ça en valeur qui va de 0 à 1.
C'était donc 1-x/2 pour arriver à ça.
1-1.4/2=0.3
Donc la dernière ligne est :
ease(courbe,0.3,1,min,max)
Et voilà. Votre flare n'apparaîtra qu'à partir du moment où la lampe est dirigée vers la caméra.
Et vous pouvez toujours jouer avec la variable "falloff" pour contraster son apparition
Inscription à :
Articles (Atom)