Animations physiques : gravity, springs et bounce

Donnez vie à vos interfaces avec des animations basées sur la physique réelle. Gravite, ressorts, rebonds, pendule et easing élastique : le guide complet pour des mouvements naturels et satisfaisants.

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.

💡
Bon à savoir

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.css
.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.

spring.css
/* 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);
  }
}
🎨
Astuce design

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.

gravity.js
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
⚠️
Attention à la boucle infinie

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.css
.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-button.css
.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 :

elastic-easing.js
// 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 transform et opacity uniquement 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 requestAnimationFrame consomme des ressources
  • Ajoutez will-change: transform sur 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é

accessibility.css
/* Desactiver les animations pour les utilisateurs sensibles */
@media (prefers-reduced-motion: reduce) {
  .bounce-ball,
  .spring-ball,
  .pendulum-string {
    animation: none;
  }

  .elastic-btn {
    transition: none;
  }
}
⚠️
Pensez à l'accessibilité

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.

🎨
Allez plus loin

Retrouvez des dizaines d'effets d'animation prêts à l'emploi dans notre bibliothèque d'effets, avec code copiable en un clic.

Les effets de cet article dans le catalogue

Les mêmes techniques, prêtes à copier : aperçu en direct, réglages et code complet sur la page de leur catégorie.

À lire aussi

Trois articles proches pour aller plus loin.