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 ?