Introduction
Les animations basées sur la physique créent des mouvements naturels et satisfaisants qui rendent vos interfaces plus intuitives et engageantes. Contrairement aux transitions CSS linéaires, les simulations physiques produisent des comportements organiques et prévisibles que les utilisateurs reconnaissent instinctivement.
Dans ce tutoriel, nous allons explorer 5 techniques essentielles d'animation physique : le rebond (bounce), les ressorts (springs), la gravite, le pendule et l'easing élastique. Chaque technique est accompagnée d'une demo interactive et du code complet.
Les animations physiques reposent principalement sur requestAnimationFrame et les courbes cubic-bezier personnalisées. Ces APIs sont supportées par tous les navigateurs modernes.
1. Bounce Effect
L'effet de rebond est l'animation physique la plus reconnaissable. Il utilise une courbe de Bezier spécifique pour simuler un objet qui rebondit, avec une décélération naturelle à chaque contact avec le sol.
.bounce-ball {
width: 50px;
height: 50px;
background: linear-gradient(135deg, #6366f1, #d946ef);
border-radius: 50%;
/* Courbe de rebond personnalisee */
animation: bounce 1s
cubic-bezier(0.36, 0, 0.66, -0.56)
infinite alternate;
}
@keyframes bounce {
to {
transform: translateY(-150px);
}
}
Comment ça fonctionne
La clé de l'effet bounce réside dans la courbe cubic-bezier :
- cubic-bezier(0.36, 0, 0.66, -0.56) : la valeur négative du 4e paramètre crée un dépassement (overshoot) qui simule le rebond
- infinite alternate : l'animation boucle en alternant la direction, créant un mouvement de va-et-vient naturel
- translateY : le déplacement vertical simule l'effet de la gravite
2. Spring Animation
L'animation de ressort combine déplacement et déformation pour un effet organique. Le scale applique un écrasement qui imite un objet souple attache à un ressort.
/* Cubic-bezier elastique pour effet ressort */
.spring-ball {
width: 50px;
height: 50px;
background: linear-gradient(135deg, #6366f1, #d946ef);
border-radius: 50%;
animation: spring 0.6s
cubic-bezier(0.68, -0.55, 0.265, 1.55)
infinite alternate;
}
@keyframes spring {
to {
/* Deplacement + deformation */
transform:
translateY(-100px)
scale(1.1, 0.9);
}
}
La valeur cubic-bezier(0.68, -0.55, 0.265, 1.55) est souvent appelée "easeInOutBack". Les valeurs négatives et supérieures à 1 créent le dépassement élastique caractéristique des ressorts.
3. Gravity Simulation
Pour une simulation de gravite vraiment réaliste, il faut utiliser JavaScript. On calcule la vélocité et la position à chaque frame en appliquant une constante de gravite, avec un coefficient de rebond pour l'amortissement.
const ball = document.querySelector('.gravity-ball');
let y = 0;
let velocity = 0;
const gravity = 0.5; // Force de gravite
const bounceCoef = 0.7; // Coefficient de rebond
const floor = 150; // Position du sol
function animate() {
// Appliquer la gravite a la velocite
velocity += gravity;
y += velocity;
// Collision avec le sol
if (y >= floor) {
y = floor;
velocity *= -bounceCoef; // Inverser + amortir
}
// Arreter quand l'energie est epuisee
if (Math.abs(velocity) < 0.5 && y >= floor - 1) {
y = floor;
return;
}
ball.style.top = y + 'px';
requestAnimationFrame(animate);
}
animate();
Les paramètres clés
- gravity (0.5) : l'accélération vers le bas à chaque frame. Plus la valeur est haute, plus la chute est rapide
- bounceCoef (0.7) : détermine combien d'énergie est conservée après chaque rebond. 1.0 = rebond parfait, 0.0 = aucun rebond
- floor (150) : la position Y du sol en pixels. La balle rebondit quand elle atteint cette limite
Sans condition d'arrêt, la boucle requestAnimationFrame tourne indéfiniment. Ajoutez toujours un seuil minimum de vélocité pour stopper l'animation quand l'objet est "au repos".
4. Pendulum Effect
Le pendule est un classique de la simulation physique. On peut le réaliser en CSS pur en combinant transform-origin et une rotation animée avec un easing sinusoïdal.
.pendulum-container {
position: relative;
width: 100px;
height: 200px;
}
.pendulum-string {
position: absolute;
top: 0;
left: 50%;
width: 2px;
height: 150px;
background: #a1a1aa;
/* Pivot en haut */
transform-origin: top center;
animation: swing 2s ease-in-out infinite;
}
.pendulum-ball {
position: absolute;
bottom: -25px;
left: 50%;
transform: translateX(-50%);
width: 50px;
height: 50px;
border-radius: 50%;
}
@keyframes swing {
0%, 100% {
transform: rotate(30deg);
}
50% {
transform: rotate(-30deg);
}
}
L'easing ease-in-out est essentiel pour simuler le ralentissement naturel du pendule aux extrémités de son mouvement, et l'accélération au centre.
5. Elastic Easing
L'easing élastique est parfait pour les interactions utilisateur : boutons, menus, modals. Le dépassement élastique donne un retour visuel satisfaisant qui rend l'interface plus vivante et réactive.
.elastic-btn {
padding: 16px 32px;
background: #6366f1;
color: white;
border: none;
border-radius: 12px;
cursor: pointer;
font-weight: 600;
/* Easing elastique */
transition: transform 0.3s
cubic-bezier(0.68, -0.55, 0.265, 1.55);
}
.elastic-btn:hover {
transform: scale(1.1);
}
.elastic-btn:active {
transform: scale(0.95);
}
On peut aussi créer un easing élastique plus avancé en JavaScript pour des animations personnalisées :
// Fonction d'easing elastique personnalisee
function elasticOut(t) {
const p = 0.3;
return Math.pow(2, -10 * t)
* Math.sin((t - p / 4)
* (2 * Math.PI) / p) + 1;
}
// Utilisation avec une animation manuelle
function animateElastic(element, from, to, duration) {
const start = performance.now();
function tick(now) {
const t = Math.min((now - start) / duration, 1);
const progress = elasticOut(t);
const value = from + (to - from) * progress;
element.style.transform =
`scale(${value})`;
if (t < 1) requestAnimationFrame(tick);
}
requestAnimationFrame(tick);
}
Bonnes pratiques
Avant de conclure, voici quelques recommandations pour utiliser les animations physiques de manière efficace :
Performance
- Utilisez
transformetopacityuniquement pour les animations. Ces propriétés sont composées par le GPU et ne déclenchent pas de reflow - Limitez les simulations JavaScript actives simultanément. Chaque
requestAnimationFrameconsomme des ressources - Ajoutez
will-change: transformsur les éléments animés pour prevenire le navigateur - Préférez CSS quand c'est possible : les animations CSS sont souvent plus performantes que leur équivalent JavaScript
Design et UX
- Gardez les durées courtes : 200-500ms pour les micro-interactions, 500ms-1s pour les animations décoratives
- Restez cohérent : utilisez le même type d'easing dans toute votre interface
- Ne surchargez pas : une ou deux animations physiques par page suffisent
Accessibilité
/* Desactiver les animations pour les utilisateurs sensibles */
@media (prefers-reduced-motion: reduce) {
.bounce-ball,
.spring-ball,
.pendulum-string {
animation: none;
}
.elastic-btn {
transition: none;
}
}
Vérifiez toujours que prefers-reduced-motion est respecté. Pour les simulations JavaScript, testez ce media query avec window.matchMedia et désactivez les animations en conséquence.
Conclusion
Les animations physiques transforment une interface statique en une expérience vivante et intuitive. En maîtrisant les courbes cubic-bezier personnalisées et les simulations JavaScript avec requestAnimationFrame, vous pouvez créer des interactions qui semblent naturelles et satisfaisantes.
Les cinq techniques présentées ici couvrent les cas d'usage les plus courants : le bounce pour les notifications, le spring pour les transitions d'éléments, la gravite pour les simulations réalistes, le pendule pour les animations décoratives, et l'easing élastique pour les micro-interactions.
N'hésitez pas à expérimenter avec les valeurs et les paramètres pour trouver l'équilibre parfait entre réalisme et performance pour votre projet.
Retrouvez des dizaines d'effets d'animation prêts à l'emploi dans notre bibliothèque d'effets, avec code copiable en un clic.




