Expressions After Effects : les dix qui remplacent des heures de keyframes

This article is currently available in French only. The page chrome is translated, the article body is not yet.

loopOut : l'expression qui élimine 90 % des boucles manuelles

La première expression que tout motion designer devrait automatiser dans ses habitudes, c'est loopOut(). Elle prend les keyframes existants d'une propriété et les répète indéfiniment sans qu'on ait à en ajouter un seul de plus. On pose deux keyframes, on écrit loopOut("cycle"), et l'animation tourne jusqu'à la fin de la composition.

Les quatre modes méritent d'être connus : "cycle" répète la séquence identique, "pingpong" la joue en aller-retour, "offset" accumule la valeur à chaque cycle (utile pour une rotation continue qui ne revient jamais à zéro), et "continue" prolonge la trajectoire de la dernière interpolation. Ce dernier mode est particulièrement précieux pour simuler une décélération naturelle après un lancer.

Cas concret : un logo qui pulse en opacité sur une boucle de vingt-quatre frames. Sans expression, il faut dupliquer les keyframes sur toute la durée du film, parfois plusieurs minutes. Avec loopOut("cycle"), deux keyframes suffisent, et modifier la vitesse du pulse ne demande qu'à déplacer ces deux points. La maintenance du projet est radicalement simplifiée.

wiggle : du mouvement organique sans une seule courbe à dessiner

wiggle(fréquence, amplitude) génère un déplacement aléatoire et continu sur la propriété où on l'applique. On l'utilise massivement sur la position d'une caméra pour simuler un tremblement de main, sur l'opacité d'un scintillement, ou sur la rotation d'un élément suspendu dans un espace peu défini.

La plupart des utilisateurs s'arrêtent à la syntaxe de base. Mais wiggle accepte jusqu'à cinq arguments : wiggle(freq, amp, octaves, amp_mult, t). Les octaves ajoutent des couches de bruit superposées, ce qui rend le mouvement moins prévisible et plus naturel. Un wiggle(2, 15, 3, 0.5, time) sur la position d'un personnage stylisé donne une flottaison qui aurait nécessité plusieurs minutes de travail en courbes.

Variante utile pour un wiggle qui démarre à zéro et ne décale pas la position de repos : soustraire la valeur du wiggle au temps zéro. L'expression devient : val = wiggle(2,30); val - wiggle(2,30,1,0.5,0). Cela ancre le mouvement sur la position d'origine du layer sans changer le comportement général de l'oscillation.

time et timeRemap : synchroniser l'animation sur la durée réelle

La variable time contient la valeur du temps courant en secondes. Elle devient le moteur de quantité d'automatisations : rotation continue avec time * 90 sur la propriété Rotation, défilement vertical avec time * 200 sur la position Y, ou teinte qui évolue lentement avec time * 10 sur Hue dans un effet de colorisation.

Couplée à la propriété Time Remap, time ouvre des possibilités plus avancées. On peut par exemple écrire une expression de timeRemap qui lit une vidéo en boucle parfaite, en s'assurant que la valeur ne dépasse jamais la durée du clip : (time % duration) où duration est liée à la durée de la source via thisComp.layer("nom").source.duration.

Un cas d'usage fréquent en studio : une animation de fond en seamless loop doit s'adapter à des compositions de durées variables. Plutôt que de pré-calculer la durée et de caler les keyframes de timeRemap à la main, on laisse l'expression calculer automatiquement. Si la composition change de durée, rien ne casse.

valueAtTime : lire la valeur d'une propriété à un instant précis

valueAtTime(t) permet d'interroger la valeur d'une propriété à un moment donné dans la timeline, exprimé en secondes. C'est une expression peu connue des débutants, mais elle est fondamentale pour créer des effets de traîne, d'écho ou de décalage temporel sans précomposer.

Application directe : un layer suit la position d'un autre layer avec un retard d'une seconde. On lie la position du second layer à thisComp.layer("Layer 1").transform.position.valueAtTime(time - 1). Le résultat est un décalage temporel pur, sans interpolation artificielle. La courbe de la source, avec ses easings et ses accélérations, est reproduite telle quelle, juste en retard.

Cette approche remplace des rigs complexes de nulls enchainés pour des effets de train. Sur un générique où dix éléments texte suivent le premier avec des décalages progressifs, une seule expression paramétrable suffit, appliquée en cascade avec un index variable : thisComp.layer("Leader").transform.position.valueAtTime(time - (index * 0.08)).

linear et ease : contrôler les interpolations par le code

Les fonctions d'interpolation linear(t, tMin, tMax, value1, value2) et ease(t, tMin, tMax, value1, value2) permettent de piloter une valeur de sortie en fonction d'un paramètre d'entrée. Elles évitent de multiplier les keyframes pour des transitions progressives et donnent un contrôle chirurgical sur l'easing.

Scénario typique : un élément doit s'opacifier progressivement en fonction de sa position verticale dans le cadre. Avec linear(transform.position[1], 0, 540, 0, 100), l'opacité passe de 0 à 100 lorsque le layer descend du haut au centre de l'écran. Aucun keyframe, et le comportement s'adapte si on déplace le layer. ease() fait la même chose mais avec une courbe en S, ce qui donne des transitions moins mécaniques.

éaseIn() et easeOut() complètent la triade pour des montées douces ou des sorties amorties. Ces trois fonctions remplacent des dizaines de keyframes sur des animations génératives où les propriétés doivent réagir à d'autres propriétés plutôt qu'au temps brut.

thisComp, thisLayer, index : naviguer dans la hiérarchie du projet

Ces trois objets natifs d'After Effects sont les fondations de tout script d'expression réutilisable. thisComp donne accès aux propriétés de la composition active (durée, taille, framerate), thisLayer désigne le layer porteur de l'expression, et index retourne le numéro de position du layer dans la pile.

L'index est particulièrement puissant pour des animations en cascade. Sur une série de layers texte identiques, on peut décaler le temps de démarrage de chaque animation en multipliant l'index par une valeur fixe : startTime = (index - 1) * 0.15. Chaque layer lance son animation 150 ms après le précédent, sans qu'on touche à un seul keyframe manuellement. Ajouter ou supprimer un layer réorganise automatiquement les décalages.

thisComp.layer("Nom") permet de récupérer n'importe quelle propriété d'un autre layer de la composition. On s'en sert pour centraliser les paramètres de contrôle dans un layer nul dédié, que l'expression vient interroger. C'est la base de tout rig de contrôle sérieux : un seul endroit pour modifier, tous les layers qui s'actualisent.

ConclusionConclusion

Ces dix expressions ne demandent pas d'être un développeur. Elles demandent de comprendre ce qu'on cherche à automatiser, puis de choisir l'outil juste. Un projet bien expressé se maintient en quelques minutes là où un projet tout en keyframes demande une refonte complète au moindre changement de durée ou de timing. Intégrer ces réflexes dans le workflow quotidien, c'est livrer plus vite, avec moins d'erreurs, et garder de la marge pour ce qui compte vraiment : les décisions créatives.