Principes de design de mouvement
C'est la couche de la sensation. Elle décide comment un élément doit bouger pour paraître soigné et intentionnel, au lieu d'être saccadé, flottant ou bon marché. Elle n'écrit pas le code qui joue le mouvement : une fois que vous avez choisi la courbe, le timing et l'arc, cette décision est l'entrée d'une compétence de mise en scène/rendu (pour une vidéo produit, transmettez-la à product-demo-director ou à vos transitions CSS/JS pour l'UI). Gardez les deux tâches séparées : cette compétence possède le jugement ; la compétence de réalisation possède l'orchestration et la mécanique.
Déclenchez-la pour tout ce qui concerne la sensation du mouvement : « rends ça moins saccadé », « plus fluide », « plus soigné », « plus vivant », « l'easing est mauvais », « ça a l'air cheap », « dois-je utiliser ease-in ou ease-out », « spring ou interpolation ».
Quand utiliser une compétence voisine à la place
Cette compétence est le jugement exclusif sur la courbe/timing/arc. Déléguez quand la vraie question est :
- Quels plans, ordre des scènes ou liste de plans → video-storyboard.
- Réaliser une démo produit complète – mouvements de curseur, captures d'écran, annotations de fonctionnalités, assemblage de séquence → product-demo-director. (Cette compétence produit la spécification de mouvement qu'elle consomme.)
- Animer du texte ou des lettres – texte qui vole/construit/révèle → kinetic-typography.
- Caler le mouvement sur un rythme, une partition ou un effet sonore → sound-and-music-sync.
- Recadrer ou recadrer pour une plateforme (9:16, 1:1, zones de sécurité) → social-video-formatter.
- Lumière, exposition, lueur ou mouvement de couleur → motion-color-and-light.
Procédure opératoire
Diagnostiquez avant de prescrire. La plupart des mouvements « saccadés » correspondent à l'un des quatre problèmes nommés ci-dessous, et chacun a une solution spécifique. Travaillez les étapes dans l'ordre : la correction d'easing est inutile si le timing est mauvais, et la correction de timing est inutile si l'élément n'a pas d'arc.
Étape 1 : Nommez ce qui ne va pas
Observez le mouvement (ou la description) et classez-le. Presque chaque plainte correspond à l'un de ces cas :
- Linéaire / robotique – vitesse constante, arrêt brusque. Pas d'easing. Correction à l'étape 2.
- Flottant / mou – trop lent, ou easing entrant et sortant quand il faudrait un snap. Mauvaise durée ou mauvaise courbe. Correction aux étapes 2 et 3.
- Saccadé / à-coups – entrée et sortie à la même vitesse, ou chaque propriété s'anime sur la même timeline plate sans décalage. Espacement et arc manquants. Correction aux étapes 3 et 4.
- Mort / sans vie – techniquement correct mais ennuyeux : pas d'anticipation, pas de dépassement, pas de suivi. Arc et mouvement secondaire manquants. Correction aux étapes 4 et 5.
Notez le diagnostic en une ligne avant de toucher à quoi que ce soit. « La modale est flottante parce qu'elle apparaît avec un fondu en 600ms en ease-in-out » est une correction ; « rends-la plus jolie » ne l'est pas.
Étape 2 : Choisissez la courbe d'easing
L'easing est la forme vitesse/temps du mouvement. La courbe porte presque toute la qualité perçue. Faites correspondre la courbe à ce que fait l'élément :
- ease-out (départ rapide, ralentissement progressif) – valeur par défaut pour les entrées et pour tout ce que l'utilisateur a déclenché. Il donne une sensation de réactivité car le mouvement commence immédiatement, puis décélère jusqu'à la position. Utilisez-le pour : les éléments qui apparaissent, les menus déroulants qui s'ouvrent, un bouton qui répond après un tap, un contenu qui glisse. En cas de doute, optez pour ease-out.
- ease-in (départ lent, sortie rapide) – pour les sorties. L'élément accélère pour disparaître de l'écran. Utilisé seul sur une entrée, il donne une sensation de lenteur et de décalage, ce qui est la cause n°1 des « flottants ». Utilisez-le pour : les rejets, les fermetures, les sorties.
- ease-in-out (lent, rapide, lent) – pour déplacer un élément déjà à l'écran d'un point A à un point B : réorganisation de cartes, avancement d'un carrousel, glissement d'un interrupteur. Les deux extrémités sont ancrées, donc un easing aux deux bouts donne une sensation de contrôle. Ne l'utilisez pas pour les entrées : le démarrage lent tue la réactivité.
- spring (physique : masse, raideur, amortissement – dépasse puis se stabilise) – pour les mouvements qui doivent paraître vivants et physiques : une modale qui surgit, un bouton à bascule, un bouton « j'aime », une notification qui tombe. Le léger dépassement est ce qui rend le mouvement « vivant ». Réglez l'amortissement pour la personnalité : un amortissement plus faible donne plus de rebond et de jeu, un amortissement plus élevé donne plus de rigidité et de professionnalisme.
Le choix spring() vs interpolate() (quand utiliser l'un ou l'autre dans le code) est dans la barre de qualité et l'artefact exécutable ci-dessous. En résumé : spring pour les transformations physiques/vivantes, interpolate pour les valeurs précises calibrées image par image comme les fondus d'opacité, les couleurs et les barres de progression.
Étape 3 : Définissez le timing et l'espacement
Timing = durée totale. Espacement = comment la distance est répartie sur cette durée – l'espacement est l'easing rendu littéral (un ease-out a des images regroupées à la fin). Deux règles :
- La durée dépend de la distance et de la taille, pas du goût. Un petit élément qui se déplace sur une courte distance doit être rapide (UI : ~150 – 250 ms). Un grand élément ou un long trajet nécessite plus de temps (~300 – 500 ms) sinon il téléporte. Les grands mouvements plein écran / héros dans une vidéo peuvent durer plus longtemps. Même mouvement, distance plus longue → durée plus longue.
- L'entrée et la sortie ne sont pas symétriques. Les sorties doivent être plus rapides que les entrées (~0,7 – 0,8×) – l'utilisateur en a fini avec l'élément, donc dégagez-le. Des durées entrée/sortie égales sont une source classique de « saccadé ».
Pour une vidéo produit, convertissez en images dès que vous quittez cette compétence : images = round(secondes * fps). Ces nombres d'images sont l'entrée littérale que vous transmettez à product-demo-director (qui les transforme en plan de scène temporel).
Étape 4 : Construisez l'arc anticipation → action → suivi
Un mouvement réaliste est rarement un simple déplacement. Le mouvement le plus riche, le plus « vivant » a trois temps :
- Anticipation – un tout petit mouvement préparatoire dans la direction opposée avant le mouvement principal (un bouton s'enfonce légèrement avant de surgir, une carte recule avant de glisser dehors). Cela prépare l'œil et rend l'action intentionnelle. Restez léger et rapide ; trop d'anticipation ressemble à un bug.
- Action – le mouvement principal, avec l'easing de l'étape 2 et la durée de l'étape 3. C'est là que vit l'espacement.
- Suivi – l'élément dépasse sa cible puis revient (le dépassement du spring), et tout élément attaché/secondaire prend un léger retard sur le leader (un libellé qui rattrape la carte sur laquelle il se trouve). C'est ce qui vend le poids et la vie.
Toutes les micro-interactions n'ont pas besoin des trois : une infobulle de 150 ms n'est que l'action. Mais quand quelque chose semble « mort », c'est presque toujours qu'il manque l'anticipation ou le suivi. Ajoutez l'arc avant d'ajouter des fioritures.
Étape 5 : Appliquez les principes Disney pertinents
Les 12 principes de l'animation de Disney s'appliquent directement à l'UI et au mouvement produit. Vous ne les appliquez pas tous ; vous utilisez ceux qui corrigent le problème diagnostiqué. La cartographie complète est dans references/twelve-principles. Les plus importants :
- Slow in & slow out → easing (étape 2). Le levier de qualité le plus puissant.
- Anticipation → le préparatif (étape 4).
- Follow-through & overlapping action → dépassement + éléments secondaires en retard (étape 4). La différence entre « correct » et « vivant ».
- Timing → durée et espacement (étape 3).
- Squash & stretch → échelle subtile à la pression/impact pour suggérer la masse ; dans l'UI, limitez-vous à quelques pourcents sinon ça fait jouet.
- Staging → déplacez une chose à la fois pour que l'œil sache où regarder ; n'animez jamais six propriétés en même temps sur la même courbe.
- Secondary action → un petit mouvement d'accompagnement (une ombre qui s'assombrit quand une carte se soulève) qui renforce le mouvement principal sans lui faire compétition.
- Exaggeration → poussez la pose clé légèrement au-delà du réaliste ; mesuré dans l'UI, plus libre dans une vidéo produit punchy.
Étape 6 : Transmettez le cahier des charges
Remplissez le template de spécification de mouvement ci-dessous – courbe, durée (et images), les temps de l'arc, et le choix spring vs interpolate par propriété. Ce template rempli est l'artefact de transmission : pour une scène vidéo produit, il va directement dans product-demo-director ; pour l'UI, il devient vos valeurs de transition/keyframe. Associez-le avec motion-color-and-light si la scène a besoin de mouvement de lumière/exposition, kinetic-typography si du texte est animé, et sound-and-music-sync si le timing doit tomber sur un temps.
Barre de qualité
Le mouvement est A+ seulement quand tous ces points sont vrais :
- Le diagnostic est nommé (linéaire / flottant / saccadé / mort), et chaque changement en découle. Pas de « rendu plus joli » sans raison.
- Les entrées sont en ease-out, les sorties en ease-in, les A→B à l'écran en ease-in-out, le vivant/physique utilise spring. Aucun mouvement linéaire brut n'est livré sauf les boucles à vitesse constante intentionnelles (un spinner, un marquee).
- La durée dépend de la distance/taille, et la sortie est plus rapide que l'entrée.
- L'appel à
spring()vsinterpolate()est explicite par propriété : spring pour les transformations physiques (scale, translate, le pop/slide/posé – vous voulez le dépassement) ; interpolate pour les valeurs temporelles précises (fondus d'opacité, couleur, progression, tout ce pour quoi un dépassement serait mauvais). Un fondu piloté par un spring, ou un pop de logo piloté par un interpolate linéaire, est un défaut. - Au moins une anticipation ou un suivi est présent sur le mouvement héros / signature ; un mouvement sans vie manque exactement ces éléments.
- Une chose mène à la fois (staging) ; les propriétés sont décalées plutôt que de toutes déclencher sur une seule timeline plate.
- La courbe, la durée et le nombre d'images sont écrits et prêts à être transmis à product-demo-director ou à une transition – cette compétence ne laisse jamais la décision implicite.
À NE PAS FAIRE
- NE LIVREZ PAS d'easing linéaire pour les entrées ou sorties – c'est le défaut robotique et cela donne l'impression d'un travail non terminé. La vitesse constante est seulement pour les boucles intentionnelles.
- NE FAITES PAS d'ease-in sur une entrée ni d'ease-out sur une sortie – c'est la sensation flottante/lente inversée. Les entrées sont en ease-out, les sorties en ease-in.
- N'UTILISEZ PAS des durées d'entrée et de sortie égales ; les sorties doivent être ~0,7 – 0,8× plus rapides.
- NE PILOTEZ PAS un fondu, une couleur ou une barre de progression avec un spring – le dépassement fait dépasser les valeurs de leur plage et provoque des flashs. Utilisez interpolate pour les valeurs temporelles.
- NE PILOTEZ PAS un pop/glissement/échelle vivant avec un interpolate linéaire quand vous voulez qu'il paraisse vivant – utilisez un spring pour le dépassement.
- N'ANIMEZ PAS plusieurs propriétés sur une seule timeline plate ; espacez et décalez-les.
- NE SURESTIMEZ PAS l'anticipation ou le dépassement dans l'UI – quelques pixels / quelques pourcents. Les grands préparatifs et rebonds ressemblent à un bug ou un jouet.
- NE PLANIFIEZ PAS l'ordre des plans ni n'assemblez la démo ici – transmettez le cahier des charges à product-demo-director ; l'ordre du storyboard est dans video-storyboard.
Sélecteur d'easing et de spring
Script Node.js autonome. Sauvegardez-le sous motion_pick.js et exécutez-le avec node motion_pick.js. Modifiez le tableau requests pour les éléments que vous animez ; il retourne la courbe, une durée adaptée à la distance (ms et images), la durée de sortie, et le choix spring vs interpolate. Aucune dépendance.
// Motion picker. Edit `requests`, then: node motion_pick.js
const fps = 30 // for product video; UI ignores the frame column
// role: 'enter' | 'exit' | 'move' | 'lively'
// distancePx: how far it travels (drives duration). sizePx: rough element size.
const requests = [
{ name: 'Modal pop-in', role: 'lively', property: 'scale', distancePx: 0, sizePx: 600 },
{ name: 'Modal backdrop', role: 'enter', property: 'opacity', distancePx: 0, sizePx: 1920 },
{ name: 'Toast slide-in', role: 'enter', property: 'translate', distancePx: 320, sizePx: 360 },
{ name: 'Toast dismiss', role: 'exit', property: 'translate', distancePx: 320, sizePx: 360 },
{ name: 'Card reorder', role: 'move', property: 'translate', distancePx: 140, sizePx: 280 },
{ name: 'Progress fill', role: 'move', property: 'width', distancePx: 800, sizePx: 800 },
]
function curveFor(role) {
if (role === 'enter') return 'ease-out'
if (role === 'exit') return 'ease-in'
if (role === 'move') return 'ease-in-out'
return 'spring' // lively
}
// Duration scales with travel distance and element size. Floor + slope, clamped.
function durationMs(role, distancePx, sizePx) {
const reach = Math.max(distancePx, sizePx * 0.4)
let ms = 140 + reach * 0.45
ms = Math.min(Math.max(ms, 140), 600)
if (role === 'exit') ms *= 0.75 // exits are faster
return Math.round(ms)
}
// spring for physical transforms; interpolate for timed values.
function driver(role, property) {
const physical = property === 'scale' || property === 'translate'
if (role === 'lively') return 'spring() // want the overshoot'
if (physical && role !== 'move') return 'spring() // physical, lively settle'
return 'interpolate() // precise, timed-to-frame'
}
const pad = (s, n) => String(s).padEnd(n)
console.log(pad('ELEMENT', 18), pad('CURVE', 12), pad('MS', 6), pad('FRAMES', 8), 'DRIVER')
for (const r of requests) {
const curve = curveFor(r.role)
const ms = durationMs(r.role, r.distancePx, r.sizePx)
const frames = Math.round((ms / 1000) * fps)
console.log(pad(r.name, 18), pad(curve, 12), pad(ms, 6), pad(frames, 8), driver(r.role, r.property))
}
Exemple de sortie
Avec les requêtes ci-dessus, le script imprime :
ELEMENT CURVE MS FRAMES DRIVER
Modal pop-in spring 252 8 spring() // want the overshoot
Modal backdrop ease-out 600 18 interpolate() // precise, timed-to-frame
Toast slide-in ease-out 284 9 spring() // physical, lively settle
Toast dismiss ease-in 213 6 interpolate() // precise, timed-to-frame
Card reorder ease-in-out 203 6 interpolate() // precise, timed-to-frame
Progress fill ease-in-out 500 15 interpolate() // precise, timed-to-frame
Lisez-le : la modale pop avec un spring (dépassement = vivant) tandis que son fond fond avec un interpolate temporel – deux pilotes différents sur le même composant, exactement comme l'exige la barre de qualité. Le toast entre en 284 ms et disparaît plus vite en 213 ms (règle de sortie 0,75×), et son glissement est physique donc il arrive avec un spring mais ressort en interpolate. La barre de progression est une valeur de largeur précise – jamais un spring, sinon le remplissage tremblerait.
Template de spécification de mouvement
Copiez ce bloc pour chaque élément en mouvement et remplissez-le. Le résultat rempli est ce que vous transmettez.
ÉLÉMENT : [nom]
Propriété : [scale | translate | opacity | color | width | ...]
Rôle : [entrer | sortir | déplacer | vivant]
Courbe : [ease-out | ease-in | ease-in-out | spring]
Pilote : [spring() | interpolate()]
Durée : [ms] → [images à fps]
Anticipation : [oui/non] → [petite description, ms]
Suivi : [oui/non] → [petite description, ms]