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.
Dans un studio de motion design sous pression, chaque minute compte. Poser des centaines de keyframes pour simuler un tremblement de caméra, synchroniser une rotation sur une position ou faire rebondir un calque mécaniquement sont des tâches qui rongent le temps de production sans rien apporter à la créativité. Les expressions After Effects existent précisément pour prendre en charge cette mécanique répétitive.
Cet article recense les dix expressions les plus rentables en contexte professionnel — celles que l'on retrouve dans les templates de studios, les rigs d'animation avancés et les pipelines automatisés. Chacune est présentée avec sa syntaxe, son cas d'usage concret et les pièges à éviter. Aucune connaissance en JavaScript avancé n'est requise, mais une familiarité avec l'interface d'expression d'After Effects est assumée.
wiggle() : le générateur de mouvement organique par excellence
La fonction `wiggle(fréquence, amplitude)` est probablement l'expression la plus utilisée en motion design. Appliquée à la position d'une caméra, elle simule un handheld shot sans une seule keyframe. Appliquée à la rotation d'un personnage, elle crée une respiration subtile qui donne vie à un calque statique.
Syntaxe de base : `wiggle(2, 15)` — deux oscillations par seconde, amplitude de 15 pixels. Pour un tremblement de caméra lors d'un impact, on montera à `wiggle(20, 40)` sur une durée bornée avec un `if` conditionnel sur `time`.
Le piège classique est d'appliquer wiggle directement sur une valeur qui possède déjà des keyframes. Dans ce cas, on utilise `valueAtTime(time) + wiggle(2, 10)` pour sommer la valeur animée et l'oscillation procédurale. Autre subtilité : wiggle est lié au numéro de calque et à la composition, ce qui génère des mouvements identiques si deux calques partagent exactement les mêmes paramètres — on corrige ça en ajoutant un décalage temporel : `wiggle(2, 15)` sur le second calque devient `seedRandom(index, true); wiggle(2, 15)`.
loopOut() et loopIn() : l'animation infinie sans duplication
Créer un cycle d'animation — rotation de roue, clignotement de LED, oscillation de pendule — exige normalement de dupliquer des keyframes indéfiniment ou d'utiliser Time Remapping. `loopOut('cycle')` résout ce problème en bouclant automatiquement les keyframes existantes jusqu'à la fin de la composition.
Les quatre modes disponibles couvrent la majorité des cas : `cycle` répète la séquence, `pingpong` l'inverse en alternance, `continue` prolonge la trajectoire extrapolée, et `offset` répète en décalant la valeur de départ. En production, `loopOut('pingpong')` est particulièrement efficace pour des animations d'UI comme un indicateur de chargement ou un effet de souffle.
`loopIn()` fonctionne de manière symétrique pour préparer l'entrée d'un calque. Combinés, `loopIn('cycle') + loopOut('cycle')` permettent de créer des calques entièrement procéduraux qui s'adaptent à n'importe quelle durée de composition — un atout majeur pour les templates destinés à être modifiés par des clients ou des monteurs non-techniciens.
linear() et ease() : le contrôle de courbe par expression
Quand on anime un paramètre en fonction d'un autre — l'opacité qui suit la position, la taille qui dépend du temps — les fonctions `linear()` et `ease()` remplacent les courbes de Bezier dans le graphe d'animation.
`linear(t, tMin, tMax, valMin, valMax)` effectue un remapping linéaire : `linear(time, 1, 3, 0, 100)` passe de 0 à 100 entre la seconde 1 et la seconde 3, indépendamment de toute keyframe. `ease()` applique le même remapping avec une interpolation fluide de type ease-in/ease-out, et `easeIn()` / `easeOut()` permettent de n'assouplir qu'un seul côté.
En pratique, cette famille d'expressions est le fondement des rigs de contrôle. Un slider de composition contrôle la valeur `t`, et chaque propriété de chaque calque est pilotée par une expression `linear()` qui mappe la plage du slider à sa propre plage de valeurs. Résultat : une animation complexe multi-calques pilotée par un seul slider, modifiable en une seconde par n'importe quel intervenant du projet.
thisComp.layer() et pickWhip : les liaisons dynamiques entre calques
Relier la position d'un calque à celle d'un autre via le pickWhip génère une expression statique qui casse si le calque est renommé ou déplacé dans la hiérarchie. `thisComp.layer('Nom du calque').transform.position` est plus robuste, mais toujours sensible au renommage.
La solution professionnelle consiste à référencer par index ou par marqueur : `thisComp.layer(thisComp.layer('CTRL_Master').index - 1).transform.position` permet de cibler le calque immédiatement au-dessus du calque de contrôle, quelle que soit sa position dans le panneau. Pour les rigs complexes, on stocke les noms dans des expressions commentées et on centralise les références dans un calque null dédié.
Cette approche est utilisée intensivement dans les systèmes de caractère rig : les membres suivent les contrôleurs IK, les yeux pointent vers un null cible, les expressions faciales sont pilotées par des sliders sur un calque CTRL unique. La maintenance d'un tel rig est incomparablement plus rapide qu'un système de parenté pur couplé à des keyframes manuelles.
time et framesToTime() : synchronisation sur la timeline
La variable `time` renvoie la position temporelle courante en secondes. C'est la base de toutes les animations procédurales liées à la progression de la composition : `time * 360` fait tourner un calque d'un tour complet par seconde, `Math.sin(time * Math.PI) * 50` oscille entre -50 et 50 de façon sinusoïdale.
`framesToTime(10)` convertit 10 frames en secondes selon le framerate de la composition — indispensable pour écrire des expressions indépendantes du framerate. De même, `timeToFrames(time)` renvoie le numéro de frame courant, utile pour des animations step-by-step ou des sélections conditionnelles par paire/impaire.
En production, la combinaison `Math.floor(timeToFrames(time) / 4)` génère un compteur qui s'incrémente toutes les 4 frames, ce qui permet de créer des animations en stop-motion procédurale — un panneau d'affichage qui change de valeur, une animation pixel art qui avance par pas — sans une seule keyframe et avec une précision au frame près.
valueAtTime() : lire le passé pour animer le présent
`valueAtTime(t)` renvoie la valeur d'une propriété à un instant t passé en argument. C'est l'expression centrale de tous les effets de traînée (lag, echo, delay) appliqués au mouvement. `position.valueAtTime(time - 0.1)` place un calque exactement là où était le calque parent 100ms plus tôt — la base d'une queue de serpent, d'un effet de follow-through ou d'un système de particules simplifié.
Dans un rig de personnage, appliquer `rotation.valueAtTime(time - index * 0.05)` à chaque segment d'une queue ou d'une chevelure crée une propagation naturelle du mouvement sans simulation physique. La valeur `index` (numéro du calque) sert de décalage automatique, évitant de régler manuellement chaque délai.
L'expression devient encore plus puissante combinée à une propriété animée sur un calque maître : le calque de tête suit des keyframes normales, les calques suivants le suivent via `valueAtTime` avec des délais croissants. Modifier la trajectoire du calque maître répercute automatiquement le changement sur toute la chaîne — un gain de temps considérable lors des allers-retours de révision.
ConclusionConclusion
Ces dix expressions — et les combinaisons que l'on peut en tirer — représentent l'essentiel de ce qu'un motion designer professionnel exploite quotidiennement pour travailler vite sans sacrifier la qualité. Le vrai gain ne se mesure pas seulement en temps de pose de keyframes, mais en flexibilité lors des révisions : une animation pilotée par expressions supporte les changements de durée, de framerate ou de valeur cible sans reconstruction manuelle. Investir deux heures pour maîtriser ces outils, c'est récupérer des dizaines d'heures sur les prochains projets.
Questions fréquentesFrequently asked questions
Faut-il connaître JavaScript pour utiliser des expressions After Effects ?
Non. Les expressions AE utilisent un sous-ensemble simplifié de JavaScript. Les dix expressions présentées ici s'écrivent en une à trois lignes et ne nécessitent aucune notion de programmation orientée objet. La compréhension des types (nombre, tableau, chaîne) et de la logique conditionnelle de base suffit pour couvrir 90 % des usages professionnels.
Les expressions ralentissent-elles le rendu After Effects ?
L'impact est généralement négligeable pour des expressions simples comme wiggle ou loopOut. En revanche, valueAtTime sur des centaines de calques dans une même composition peut alourdir le recalcul à chaque frame. L'optimisation classique consiste à prébaker (Menu Animation > Keyframe Assistant > Convert Expression to Keyframes) les expressions lourdes avant le rendu final.
Comment déboguer une expression qui génère une erreur ?
After Effects affiche l'erreur en rouge directement sur le calque concerné. Cliquer sur le triangle d'alerte ouvre le détail. La méthode la plus efficace est d'isoler le problème en commentant (// ) chaque ligne jusqu'à identifier la source. L'extension gratuite Expression Evaluator permet aussi de tester des fragments en temps réel sans toucher au projet.
Peut-on réutiliser des expressions entre projets facilement ?
Oui. La méthode la plus propre est de constituer une bibliothèque de fichiers .txt ou un snippet manager (comme celui intégré à certaines extensions) contenant les expressions commentées. Certains studios maintiennent un fichier After Effects 'Expression Library' avec des calques null commentés jouant le rôle de référence copier-coller.
Quelle est la différence entre wiggle() et le bruit de Perlin utilisé manuellement ?
wiggle() utilise internalement un bruit de Perlin, mais l'expose via une API simplifiée. Si vous avez besoin de contrôler précisément la graine aléatoire, la dimension ou de créer un bruit multidimensionnel personnalisé, il est plus approprié d'utiliser directement noise(seedRandom + time) pour construire votre propre wiggle à la main.
Comment appliquer une expression à plusieurs calques simultanément ?
Sélectionnez tous les calques cibles, puis Alt+cliquez sur l'icône de chronomètre de la propriété souhaitée sur n'importe lequel d'eux. L'expression saisie s'applique à tous les calques sélectionnés en une seule opération. Pour des applications plus complexes, les scripts JSX et les outils comme aescripts permettent d'automatiser cette distribution à l'échelle d'un projet entier.
loopOut() fonctionne-t-il avec les effets, pas seulement les transformations ?
Oui. loopOut() s'applique à n'importe quelle propriété animable dans After Effects : opacité, couleur d'un effet, point de contrôle d'un masque, valeur d'un paramètre de plugin tiers. La seule condition est que la propriété possède au minimum deux keyframes pour définir le cycle à répéter.
Comment lier une expression à un slider de composition pour créer un contrôle centralisé ?
Ajoutez un calque null, appliquez-lui l'effet 'Curseur de commande' (Effect > Expression Controls > Slider Control), puis référencez-le dans vos expressions : thisComp.layer('CTRL').effect('Slider Control')('Slider'). Toutes les propriétés liées à ce slider bougent en bloc quand on le manipule, ce qui est la base de tout rig de motion design professionnel.
Les expressions sont-elles compatibles avec le rendu via Adobe Media Encoder ou un render farm ?
Oui, les expressions sont évaluées au moment du rendu, qu'il soit local, via Media Encoder ou via un render farm qui utilise aerender en ligne de commande. La seule exception concerne les expressions qui font appel à des ressources externes (fichiers JSON, API) — ces cas avancés nécessitent que chaque nœud du farm ait accès aux mêmes ressources réseaux.
Peut-on désactiver temporairement une expression sans la supprimer ?
Oui. Cliquez sur l'icône '=' (égal) dans la colonne des expressions, à gauche du champ de texte. L'expression se met en pause et la propriété revient à sa valeur précédente ou à une valeur éditée manuellement. Cette fonctionnalité est précieuse pour comparer le résultat avec et sans expression, ou pour déboguer une animation complexe sans perdre le code écrit.