|
|
Tutoriaux After Effects Le langage des expressions par
nab
Méthode aléatoire : random
La méthode "random" va nous permettre de générer des valeurs aléatoires (comprendre "au hasard"). A la différence de la méthode "wiggle" qui effectue un tremblement
linéaire (il n' y pas de "saut" entre les valeurs), la méthode "random" va nous donner à chaque image de l'animation une valeur aléatoire comprise dans un intervalle défini,
sans tenir compte de la valeur générée à l'image précédente.
Voyons quelques exemples pour mieux comprendre.
random ( ) ; // valeur aléatoire entre 0 et 1
random( 100 ) ; // valeur aléatoire entre 0 et 100
random( - 50 , 50 ) ; // valeur aléatoire entre -50 et 50
Cette méthode fonctionne également avec des vecteurs de n'importe quelle dimension, de dimension 2 ou 3 par exemple.
random( [20,20,-40], [50,50,100] ) ; // valeur aléatoire entre [20,20,-40] et [50,50,100]
Pour visualiser ce que cela peut donner en terme d'animation, écrivons l'expression suivante sur la propriété de position de notre calque:
random( [width/2,height/2], [thisComp.width-width/2,thisComp.height-height/2] ) ;
Nous nous rappelons que "thisComp.width" et "thisComp.height" désignent la taille de la composition et que "width" et "height" désigne la taille de notre calque.
Nous attribuons donc au calque une position aléatoire mais toujours comprise dans les limites de la composition (notre calque ne dépasse jamais). Nous obtenons quelque chose comme cela:
Nous constatons qu'à chaque image la fonction "random" va positionner le calque de façon aléatoire, ceci peut être désiré
mais parfois on aimerait avoir plus de contrôle sur ce côté aléatoire. After Effects met à notre disposition une méthode permettant d'avoir un certain contrôle sur le "random".
Cette méthode est appelée "seedRandom".
Son fonctionnement n'est pas forcément facile à appréhender, tentons de voir de quoi il est question.
La méthode "random" génère une séquence de nombres aléatoires, un nombre à la première image, un autre nombre à la deuxième image, etc.
Cette séquence est toujours différente, une même expression "random" sur deux calques distincts par exemple nous donnera des valeurs différentes pour chacun.
La méthode "seedRandom" prend en considération deux arguments, le premier est appelé la "seed" (graine, en français) et sera un nombre; le deuxième argument sera "true" ou "false".
Nous utiliserons la méthode "seedRandom" avant d'appeler la méthode "random". Si nous reprenons l'exemple précédent en écrivant cette fois:
seedRandom( 5 , true ) ;
random( [width/2,height/2], [thisComp.width-width/2,thisComp.height-height/2] ) ;
Nous avons maintenant un calque qui est positionné aléatoirement mais uniquement lors de la première image, ensuite il conserve la même position.
Nous avons fixé la "seed" et par conséquent la méthode "random" nous génèrera toujours la même valeur : une valeur générée pour la première image (qui déplace aléatoirement notre calque) et la même valeur pour toutes les images suivantes (qui laisse donc le calque à la même position).
Nous avons choisis la "seed" égale à 5, nous aurions pu prendre n'importe quelle autre valeur.
En revanche si l'on change la valeur de la "seed", la méthode "random" qui suit va nous donner de nouvelles valeurs.
Changer la valeur de la "seed" aura pour influence de changer la séquence de nombres générée par la méthode "random".
A chaque valeur de la "seed" correspond une séquence de nombres. Supposons que nous ayons écrit une expression dans laquelle on aurait une "seed" égale à 1 et que nous ferions ensuite appel
quatre fois de suite à la méthode "random". Elle nous génèrerait par exemple 2 , 3 , 4 , 5.
Si l'on modifie notre "seed", en lui attribuant une valeur de 2, la méthode "random" va nous générer une séquence différente, disons 6 , 7, 8, 9.
Maintenant si l'on modifie à nouveau la valeur de la "seed" en lui redonnant la valeur de 1, la méthode "random" va à ce moment là
nous regénérer la séquence 2, 3, 4, 5. Nous avons un certain contrôle, notamment pour récupérer des informations du passé ("malheureusement" en les recalculant à chaque fois).
Avec la méthode "seedRandom" , nous allons aussi pouvoir attribuer une position aléatoire à notre calque, non pas à chaque image mais à chaque intervalle de temps qu'on
aura spécifié. Voyons comment.
Ecrivons cette expression sur la propriété de position du calque:
duree = 0.5 ; // durée de l'intervalle en seconde
i = Math.floor( time / duree ) ;
seedRandom( i , true ) ;
random( [width/2,height/2], [thisComp.width-width/2,thisComp.height-height/2] ) ;
La première instruction définit la durée entre deux repositionnements du calque. Ici toutes les 0.5 secondes, le calque va changer aléatoirement de position. La fonction "Math.floor" calcule la partie entière d'un nombre, en arrondissant vers le bas.
Par exemple "Math.floor(2.7)=2". La variable "i" va donc augmenter de 1 toutes les 0.5 secondes. Par conséquent toutes les 0.5 secondes,
on modifie la valeur de la "seed" (notre "seed" est représentée par "i" dans l'exemple). Ainsi la méthode "random" produira
une nouvelle valeur aléatoire pour la position du calque toutes les 0.5 secondes.
La nouvelle animation est elle-ci:
Amusons nous maintenant à réaliser un tableau de lettres qui défileraient
aléatoirement pendant un certain laps de temps, puis se fixeraient pendant un autre laps de temps.
Nos deux paramètres d'entrée sont donc la durée du défilement et la durée de l'immobilité.
Commençons par créer notre calque texte dans une composition 320*240. Puisque nous souhaitons réaliser un tableau nous le dupliquerons par la suite.
Mais avant de le dupliquer appliquons l'expression suivante sur sa propriété de position
(nous avons déja vu ce type d'expression pour placer automatiquement les calques dupliqués avec un décalage, ici vertical):
dec = 25 ; // décalage entre deux lignes, en pixel
[ 160 , index * dec ] ;
Maintenant nous écrivons une nouvelle expression sur la propriété "Décalage de caractères" (petit triangle "Animer" puis "Décalage de caractères"). C'est elle qui va produire l'effet recherché.
rd = 1.0 ; // durée affichage aléatoire, en seconde
fix = 0.5 ; // durée affichage fixe, en seconde
cycle = rd + fix ;
reste = time % cycle ;
if( reste < rd ) {
random(26);
}
else {
0 ;
}
Pour l'expliquer prenons un cas en particulier, par exemple le moment où "time=2.8s".
L'expression va calculer (la variable "reste"): "2.8%1.5 = 1.3", puis elle compare cette valeur avec "rd", qui est de 1.0.
La valeur est donc supérieure à "rd" et par conséquent le premier bloc d'instruction ne sera pas évalué, le second oui.
Le décalage sera ainsi de 0 (texte fixe) pour "time=2.8s".
Nous obtenons notre tableau, les lettres défilent pendant une seconde et se fixent pendant 0.5 secondes.
Et en guise de dernier exemple, qui ne sera pas expliqué ici (nous pouvons retrouver pas mal de commentaires et d'explications
sur cette expression en consultant le forum du Repaire, "Jeu sur les expressions"), voilà
une expression qui permet de déplacer un calque aléatoirement sur un damier, en se déplaçant de façon linéaire d'une case à une autre.
Au passage j'en profite pour remercier "Sequelles", l'auteur de cette expression.
deplace = 1 ; // durée de déplacement intercase, en nombre d'images
fixe = 1 ; // durée affichage fixe, en nombre d'images
G = width ;
D = thisComp.width - G ;
H = height ;
B = thisComp.height - H ;
P1 = P2 = position ;
dep = [ 0 , 0 , 0 , 0 ] ;
i = 0 ;
while( i < timeToFrames( ) ) {
seedRandom( i , 1 ) ;
P1 = P2 ;
bor = [ ( G <= P1[ 0 ] ) , ( P1[ 0 ] <= D ) , ( H <= P1[ 1 ] ) , ( P1[ 1 ] <=B ) ] ;
ale = Math.ceil( random( bor[ 0 ] + bor[ 1 ] + bor[ 2 ] + bor[ 3 ] ) ) ;
for( n = 0 ; n <= 3 ; n++ ) {
dep[ n ] = bor[ n ] * ( ale == 1 ) ;
ale -= bor[ n ] ;
}
P2 += [ ( (dep[ 0 ] == 0) - (dep[ 1 ] == 0) )* G , ( (dep [2 ] == 0) - (dep [3 ] == 0) )* H ] ;
i += deplace + fixe;
}
linear( timeToFrames( ) , i - deplace , i , P1 , P2 ) ;
Et voilà un exemple d'animation obtenue à l'aide de cette expression.
|
|
