Communitygithub.com

ASoudy/AGS

Animation Three.js - animation par images clés, animation squelettique, cibles de morphing, mixage d'animations. Utilisez-le pour animer des objets, jouer des animations GLTF, créer du mouvement procédural ou mixer des animations.

Qu'est-ce que AGS ?

Cette compétence (skill) permet de maîtriser le système d'animation de Three.js, de la création d'animations par images clés (keyframes) au mixage d'animations complexes. Elle couvre l'ensemble des composants principaux : AnimationClip pour stocker les données d'images clés, AnimationMixer pour orchestrer la lecture sur un objet racine, et AnimationAction pour contrôler finement la lecture (vitesse, boucle, fondu, poids de mélange). La compétence détaille la création de KeyframeTracks pour différents types de données (positions, rotations par quaternions, couleurs, booléens, cibles de morphing) et les modes d'interpolation (linéaire, lisse, discret). Elle guide également l'import et la lecture d'animations GLTF, le contrôle avancé des actions (fadeIn, fadeOut, crossfade) et l'utilisation du nouveau timer THHREE.Timer (recommandé dès r183) pour des animations plus fluides et respectueuses des performances. Parfaite pour les développeurs créant des scènes 3D dynamiques avec Three.js, que ce soit pour des personnages animés, des transitions d'interface, ou des effets visuels complexes.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ASoudy/AGS/tree/HEAD/AGAS/plugins/antigravity-awesome-skills-claude/skills/threejs-animation

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Animation Three.js

Quand utiliser

  • Vous devez animer des objets, des armatures, des cibles de morphing ou des animations GLTF importées dans Three.js.
  • La tâche implique des mixers, des clips, des images clés, un mouvement procédural ou un fondu d'animations.
  • Vous construisez un comportement de mouvement dans une scène Three.js plutôt qu'un rendu statique.

Démarrage rapide

import * as THREE from "three";

// Animation procédurale simple avec Timer (recommandé dans r183)
const timer = new THREE.Timer();

renderer.setAnimationLoop(() => {
  timer.update();
  const delta = timer.getDelta();
  const elapsed = timer.getElapsed();

  mesh.rotation.y += delta;
  mesh.position.y = Math.sin(elapsed) * 0.5;

  renderer.render(scene, camera);
});

Remarque : THREE.Timer est recommandé par rapport à THREE.Clock depuis r183. Timer se met en pause lorsque la page est cachée et possède une API plus propre. THREE.Clock fonctionne toujours mais est considéré comme hérité.

Présentation du système d'animation

Le système d'animation de Three.js comporte trois composants principaux :

  1. AnimationClip - Conteneur pour les données d'images clés
  2. AnimationMixer - Joue les animations sur un objet racine
  3. AnimationAction - Contrôle la lecture d'un clip

AnimationClip

Stocke les données d'animation par images clés.

// Créer un clip d'animation
const times = [0, 1, 2]; // Temps des images clés (secondes)
const values = [0, 1, 0]; // Valeurs à chaque image clé

const track = new THREE.NumberKeyframeTrack(
  ".position[y]", // Chemin de la propriété
  times,
  values,
);

const clip = new THREE.AnimationClip("bounce", 2, [track]);

Types de KeyframeTrack

// Piste numérique (valeur unique)
new THREE.NumberKeyframeTrack(".opacity", times, [1, 0]);
new THREE.NumberKeyframeTrack(".material.opacity", times, [1, 0]);

// Piste vectorielle (position, échelle)
new THREE.VectorKeyframeTrack(".position", times, [
  0,
  0,
  0, // t=0
  1,
  2,
  0, // t=1
  0,
  0,
  0, // t=2
]);

// Piste de quaternion (rotation)
const q1 = new THREE.Quaternion().setFromEuler(new THREE.Euler(0, 0, 0));
const q2 = new THREE.Quaternion().setFromEuler(new THREE.Euler(0, Math.PI, 0));
new THREE.QuaternionKeyframeTrack(
  ".quaternion",
  [0, 1],
  [q1.x, q1.y, q1.z, q1.w, q2.x, q2.y, q2.z, q2.w],
);

// Piste de couleur
new THREE.ColorKeyframeTrack(".material.color", times, [
  1,
  0,
  0, // rouge
  0,
  1,
  0, // vert
  0,
  0,
  1, // bleu
]);

// Piste booléenne
new THREE.BooleanKeyframeTrack(".visible", [0, 0.5, 1], [true, false, true]);

// Piste de chaîne (pour les cibles de morphing)
new THREE.StringKeyframeTrack(
  ".morphTargetInfluences[smile]",
  [0, 1],
  ["0", "1"],
);

Modes d'interpolation

const track = new THREE.VectorKeyframeTrack(".position", times, values);

// Interpolation
track.setInterpolation(THREE.InterpolateLinear); // Par défaut
track.setInterpolation(THREE.InterpolateSmooth); // Spline cubique
track.setInterpolation(THREE.InterpolateDiscrete); // Fonction échelon

BezierInterpolant (r183)

Three.js r183 ajoute THREE.BezierInterpolant pour l'interpolation de courbes de Bézier dans les pistes d'images clés, permettant des courbes d'animation plus lisses avec un contrôle de tangente.

AnimationMixer

Joue des animations sur un objet et ses descendants.

const mixer = new THREE.AnimationMixer(model);

// Créer une action à partir du clip
const action = mixer.clipAction(clip);
action.play();

// Mise à jour dans la boucle d'animation
function animate() {
  const delta = clock.getDelta();
  mixer.update(delta); // Obligatoire !

  requestAnimationFrame(animate);
  renderer.render(scene, camera);
}

Événements du mixer

mixer.addEventListener("finished", (e) => {
  console.log("Animation terminée :", e.action.getClip().name);
});

mixer.addEventListener("loop", (e) => {
  console.log("Animation en boucle :", e.action.getClip().name);
});

AnimationAction

Contrôle la lecture d'un clip d'animation.

const action = mixer.clipAction(clip);

// Contrôle de lecture
action.play();
action.stop();
action.reset();
action.halt(fadeOutDuration);

// État de lecture
action.isRunning();
action.isScheduled();

// Contrôle temporel
action.time = 0.5; // Temps actuel
action.timeScale = 1; // Vitesse de lecture (négatif = inversé)
action.paused = false;

// Poids (pour le fondu)
action.weight = 1; // 0-1, contribution à la pose finale
action.setEffectiveWeight(1);

// Modes de boucle
action.loop = THREE.LoopRepeat; // Par défaut : boucle infinie
action.loop = THREE.LoopOnce; // Joue une fois et s'arrête
action.loop = THREE.LoopPingPong; // Alterne avant/arrière
action.repetitions = 3; // Nombre de boucles (Infini par défaut)

// Verrouillage
action.clampWhenFinished = true; // Conserve la dernière image lorsque terminé

// Fondu
action.blendMode = THREE.NormalAnimationBlendMode;
action.blendMode = THREE.AdditiveAnimationBlendMode;

Fondu d'entrée/sortie

// Fondu d'entrée
action.reset().fadeIn(0.5).play();

// Fondu de sortie
action.fadeOut(0.5);

// Fondu croisé entre animations
const action1 = mixer.clipAction(clip1);
const action2 = mixer.clipAction(clip2);

action1.play();

// Plus tard, fondu croisé vers action2
action1.crossFadeTo(action2, 0.5, true);
action2.play();

Chargement d'animations GLTF

Source la plus courante d'animations squelettiques.

import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";

const loader = new GLTFLoader();
loader.load("model.glb", (gltf) => {
  const model = gltf.scene;
  scene.add(model);

  // Créer un mixer
  const mixer = new THREE.AnimationMixer(model);

  // Récupérer tous les clips
  const clips = gltf.animations;
  console.log(
    "Animations disponibles :",
    clips.map((c) => c.name),
  );

  // Jouer la première animation
  if (clips.length > 0) {
    const action = mixer.clipAction(clips[0]);
    action.play();
  }

  // Jouer une animation spécifique par nom
  const walkClip = THREE.AnimationClip.findByName(clips, "Walk");
  if (walkClip) {
    mixer.clipAction(walkClip).play();
  }

  // Stocker le mixer pour la boucle de mise à jour
  window.mixer = mixer;
});

// Boucle d'animation
function animate() {
  const delta = clock.getDelta();
  if (window.mixer) window.mixer.update(delta);

  requestAnimationFrame(animate);
  renderer.render(scene, camera);
}

Animation squelettique

Squelette et os

// Accéder au squelette depuis un maillage peaufiné
const skinnedMesh = model.getObjectByProperty("type", "SkinnedMesh");
const skeleton = skinnedMesh.skeleton;

// Accéder aux os
skeleton.bones.forEach((bone) => {
  console.log(bone.name, bone.position, bone.rotation);
});

// Trouver un os spécifique par nom
const headBone = skeleton.bones.find((b) => b.name === "Head");
if (headBone) headBone.rotation.y = Math.PI / 4; // Tourner la tête

// Aide visuelle pour le squelette
const helper = new THREE.SkeletonHelper(model);
scene.add(helper);

Animation programmatique des os

function animate() {
  const time = clock.getElapsedTime();

  // Animer un os
  const headBone = skeleton.bones.find((b) => b.name === "Head");
  if (headBone) {
    headBone.rotation.y = Math.sin(time) * 0.3;
  }

  // Mettre à jour le mixer si des clips sont également joués
  mixer.update(clock.getDelta());
}

Attachements aux os

// Attacher un objet à un os
const weapon = new THREE.Mesh(weaponGeometry, weaponMaterial);
const handBone = skeleton.bones.find((b) => b.name === "RightHand");
if (handBone) handBone.add(weapon);

// Décaler l'attachement
weapon.position.set(0, 0, 0.5);
weapon.rotation.set(0, Math.PI / 2, 0);

Cibles de morphing

Mélanger différentes formes de maillage.

// Les cibles de morphing sont stockées dans la géométrie
const geometry = mesh.geometry;
console.log("Attributs de morphing :", Object.keys(geometry.morphAttributes));

// Accéder aux influences des cibles de morphing
mesh.morphTargetInfluences; // Tableau de poids
mesh.morphTargetDictionary; // Nom -> index de correspondance

// Définir une cible de morphing par index
mesh.morphTargetInfluences[0] = 0.5;

// Définir par nom
const smileIndex = mesh.morphTargetDictionary["smile"];
mesh.morphTargetInfluences[smileIndex] = 1;

Animation des cibles de morphing

// Procédural
function animate() {
  const t = clock.getElapsedTime();
  mesh.morphTargetInfluences[0] = (Math.sin(t) + 1) / 2;
}

// Avec animation par images clés
const track = new THREE.NumberKeyframeTrack(
  ".morphTargetInfluences[smile]",
  [0, 0.5, 1],
  [0, 1, 0],
);
const clip = new THREE.AnimationClip("smile", 1, [track]);
mixer.clipAction(clip).play();

Fondu d'animations

Mélanger plusieurs animations ensemble.

// Configuration des actions
const idleAction = mixer.clipAction(idleClip);
const walkAction = mixer.clipAction(walkClip);
const runAction = mixer.clipAction(runClip);

// Jouer toutes avec des poids différents
idleAction.play();
walkAction.play();
runAction.play();

// Définir les poids initiaux
idleAction.setEffectiveWeight(1);
walkAction.setEffectiveWeight(0);
runAction.setEffectiveWeight(0);

// Mélanger en fonction de la vitesse
function updateAnimations(speed) {
  if (speed < 0.1) {
    idleAction.setEffectiveWeight(1);
    walkAction.setEffectiveWeight(0);
    runAction.setEffectiveWeight(0);
  } else if (speed < 5) {
    const t = speed / 5;
    idleAction.setEffectiveWeight(1 - t);
    walkAction.setEffectiveWeight(t);
    runAction.setEffectiveWeight(0);
  } else {
    const t = Math.min((speed - 5) / 5, 1);
    idleAction.setEffectiveWeight(0);
    walkAction.setEffectiveWeight(1 - t);
    runAction.setEffectiveWeight(t);
  }
}

Fondu additif

// Posture de base
const baseAction = mixer.clipAction(baseClip);
baseAction.play();

// Couche additive (ex : respiration)
const additiveAction = mixer.clipAction(additiveClip);
additiveAction.blendMode = THREE.AdditiveAnimationBlendMode;
additiveAction.play();

// Convertir un clip en additif
THREE.AnimationUtils.makeClipAdditive(additiveClip);

Utilitaires d'animation

import * as THREE from "three";

// Trouver un clip par nom
const clip = THREE.AnimationClip.findByName(clips, "Walk");

// Créer un sous-clip
const subclip = THREE.AnimationUtils.subclip(clip, "subclip", 0, 30, 30);

// Convertir en additif
THREE.AnimationUtils.makeClipAdditive(clip);
THREE.AnimationUtils.makeClipAdditive(clip, 0, referenceClip);

// Cloner un clip
const clone = clip.clone();

// Obtenir la durée du clip
clip.duration;

// Optimiser le clip (supprimer les images clés redondantes)
clip.optimize();

// Réinitialiser le clip à la première image
clip.resetDuration();

Modèles d'animation procédurale

Amortissement lisse

// Suivi lisse / lerp
const target = new THREE.Vector3();
const current = new THREE.Vector3();
const velocity = new THREE.Vector3();

function smoothDamp(current, target, velocity, smoothTime, deltaTime) {
  const omega = 2 / smoothTime;
  const x = omega * deltaTime;
  const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
  const change = current.clone().sub(target);
  const temp = velocity
    .clone()
    .add(change.clone().multiplyScalar(omega))
    .multiplyScalar(deltaTime);
  velocity.sub(temp.clone().multiplyScalar(omega)).multiplyScalar(exp);
  return target.clone().add(change.add(temp).multiplyScalar(exp));
}

function animate() {
  current.copy(smoothDamp(current, target, velocity, 0.3, delta));
  mesh.position.copy(current);
}

Physique d'un ressort

class Spring {
  constructor(stiffness = 100, damping = 10) {
    this.stiffness = stiffness;
    this.damping = damping;
    this.position = 0;
    this.velocity = 0;
    this.target = 0;
  }

  update(dt) {
    const force = -this.stiffness * (this.position - this.target);
    const dampingForce = -this.damping * this.velocity;
    this.velocity += (force + dampingForce) * dt;
    this.position += this.velocity * dt;
    return this.position;
  }
}

const spring = new Spring(100, 10);
spring.target = 1;

function animate() {
  mesh.position.y = spring.update(delta);
}

Oscillation

function animate() {
  const t = clock.getElapsedTime();

  // Onde sinusoïdale
  mesh.position.y = Math.sin(t * 2) * 0.5;

  // Rebond
  mesh.position.y = Math.abs(Math.sin(t * 3)) * 2;

  // Mouvement circulaire
  mesh.position.x = Math.cos(t) * 2;
  mesh.position.z = Math.sin(t) * 2;

  // Mouvement en huit
  mesh.position.x = Math.sin(t) * 2;
  mesh.position.z = Math.sin(t * 2) * 1;
}

Conseils de performance

  1. Partager les clips : Un même AnimationClip peut être utilisé sur plusieurs mixers
  2. Optimiser les clips : Appeler clip.optimize() pour supprimer les images clés redondantes
  3. Désactiver lorsque hors écran : Arrêter les mises à jour du mixer pour les objets invisibles
  4. Utiliser LOD pour les animations : Armatures plus simples pour les personnages lointains
  5. Limiter les mixers actifs : Chaque mixer.update() a un coût
// Mettre en pause l'animation lorsqu'elle n'est pas visible
mesh.onBeforeRender = () => {
  action.paused = false;
};

mesh.onAfterRender = () => {
  // Vérifier si elle sera visible dans l'image suivante
  if (!isInFrustum(mesh)) {
    action.paused = true;
  }
};

// Mettre en cache les clips
const clipCache = new Map();
function getClip(name) {
  if (!clipCache.has(name)) {
    clipCache.set(name, loadClip(name));
  }
  return clipCache.get(name);
}

Voir aussi

  • threejs-loaders - Chargement de modèles GLTF animés
  • threejs-fundamentals - Horloge et boucle d'animation
  • threejs-shaders - Animation de sommets dans les shaders

Limitations

  • Utilisez cette compétence uniquement lorsque la tâche correspond clairement au cadre décrit ci-dessus.
  • Ne considérez pas la sortie comme un substitut à une validation, un test ou une revue par un expert spécifique à l'environnement.
  • Arrêtez-vous et demandez des clarifications si les entrées requises, les autorisations, les limites de sécurité ou les critères de succès sont absents.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ASoudy/AGS

Advanced JavaScript animation library skill for creating complex, high-performance web animations.

ASoudy/AGS

Astropy is the core Python package for astronomy, providing essential functionality for astronomical research and data analysis.

ASoudy/AGS

Build content-focused websites with Astro — zero JS by default, islands architecture, multi-framework components, and Markdown/MDX support.

ASoudy/AGS

One sentence - what this skill does and when to invoke it

ASoudy/AGS

Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.

ASoudy/AGS

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

ASoudy/AGS

Pull a YouTube video transcript into a queryable markdown vault with yt-dlp subtitle discovery, VTT cleanup, metadata frontmatter, and capture-seed stubs.

ASoudy/AGS

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

ASoudy/AGS

Generates high-converting Next.js/React landing pages with Tailwind CSS. Uses PAS, AIDA, and BAB frameworks for optimized copy/components (Heroes, Features, Pricing). Focuses on Core Web Vitals/SEO.

ASoudy/AGS

AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

ASoudy/AGS

CRITICAL: Use for Makepad animation system. Triggers on: makepad animation, makepad animator, makepad hover, makepad state, makepad transition, "from: { all: Forward", makepad pressed, makepad 动画, makepad 状态, makepad 过渡, makepad 悬停效果

ASoudy/AGS

Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

ASoudy/AGS

Next.js App Router principles. Server Components, data fetching, routing patterns.

ASoudy/AGS

Expert integration of Supabase Auth with Next.js App Router

ASoudy/AGS

React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

ASoudy/AGS

Best practices for Remotion - Video creation in React

ASoudy/AGS

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

ASoudy/AGS

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

ASoudy/AGS

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

ASoudy/AGS

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Skills associés