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 :
- AnimationClip - Conteneur pour les données d'images clés
- AnimationMixer - Joue les animations sur un objet racine
- 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
- Partager les clips : Un même AnimationClip peut être utilisé sur plusieurs mixers
- Optimiser les clips : Appeler
clip.optimize()pour supprimer les images clés redondantes - Désactiver lorsque hors écran : Arrêter les mises à jour du mixer pour les objets invisibles
- Utiliser LOD pour les animations : Armatures plus simples pour les personnages lointains
- 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ésthreejs-fundamentals- Horloge et boucle d'animationthreejs-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.