Communitygithub.com

AlperTuncOrtak/crypto-data-pipeline

Animation Three.js - animation par images clés, animation squelettique, morph targets, mélange d'animations. À utiliser pour animer des objets, jouer des animations GLTF, créer des mouvements procéduraux ou mélanger des animations.

Qu'est-ce que crypto-data-pipeline ?

Cette compétence fournit un guide complet et détaillé sur le système d'animation de Three.js. Elle couvre l'ensemble des composants essentiels : AnimationClip pour le stockage des données d'images clés, AnimationMixer pour la lecture des animations sur un objet racine, et AnimationAction pour le contrôle fin de la lecture (lecture, arrêt, vitesse, boucle, fondu). Elle explique en détail les différents types de KeyframeTrack (nombre, vecteur, quaternion, couleur, booléen, chaîne) ainsi que les modes d'interpolation (linéaire, lisse, discret, et le nouvel interpolateur Bezier dans r183). La compétence guide également l'utilisateur à travers des cas pratiques comme le chargement et la lecture d'animations GLTF, l'animation squelettique avec manipulation directe des os, l'utilisation des morph targets pour déformer des maillages, et des techniques avancées de mélange d'animations (poids, fondu enchaîné, blending additif). Des patrons d'animation procédurale sont fournis (damping, ressort, oscillation) ainsi que des conseils de performance. Elle est destinée aux développeurs utilisant Three.js dans des environnements comme les navigateurs web, Node.js avec un contexte de rendu, ou tout projet nécessitant une animation 3D interactive.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/AlperTuncOrtak/crypto-data-pipeline/tree/HEAD/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 l'utiliser

  • Vous devez animer des objets, des armatures, des morph targets ou des animations GLTF importées dans Three.js.
  • La tâche implique des mixers, des clips, des images clés, des mouvements procéduraux ou du mélange 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é plutôt que 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 a 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 morph targets)
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 en escalier

BezierInterpolant (r183)

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

AnimationMixer

Joue les animations sur un objet et ses descendants.

const mixer = new THREE.AnimationMixer(model);

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

// Mettre à 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("Boucle d'animation :", e.action.getClip().name);
});

AnimationAction

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

const action = mixer.clipAction(clip);

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

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

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

// Poids (pour le mélange)
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; // Jouer une fois puis s'arrêter
action.loop = THREE.LoopPingPong; // Alterner avant/arrière
action.repetitions = 3; // Nombre de boucles (Infini par défaut)

// Blocage
action.clampWhenFinished = true; // Maintenir la dernière image une fois terminée

// Mélange
action.blendMode = THREE.NormalAnimationBlendMode;
action.blendMode = THREE.AdditiveAnimationBlendMode;

Fondu entrant/sortant

// Fondu entrant
action.reset().fadeIn(0.5).play();

// Fondu sortant
action.fadeOut(0.5);

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

action1.play();

// Plus tard, fondu enchaîné 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);

  // Obtenir 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 skin
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);

Morph Targets

Mélanger entre différentes formes de maillage.

// Les morph targets sont stockés dans la géométrie
const geometry = mesh.geometry;
console.log("Attributs morph :", Object.keys(geometry.morphAttributes));

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

// Définir un morph target par index
mesh.morphTargetInfluences[0] = 0.5;

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

Animer les morph targets

// 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();

Mélange d'animations

Mélanger plusieurs animations ensemble.

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

// Jouer toutes avec différents poids
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);
  }
}

Mélange additif

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

// Couche additive (par exemple, 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 d'un clip
clip.duration;

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

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

Patrons d'animation procédurale

Damping lissé

// Suivi lissé / 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 de 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;

  // Figure en 8
  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 quand hors écran : Arrêter les mises à jour du mixer pour les objets invisibles
  4. Utiliser le LOD pour les animations : Armatures plus simples pour les personnages éloignés
  5. Limiter les mixers actifs : Chaque mixer.update() a un coût
// Mettre en pause l'animation quand elle n'est pas visible
mesh.onBeforeRender = () => {
  action.paused = false;
};

mesh.onAfterRender = () => {
  // Vérifier si l'objet sera visible à la prochaine image
  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 vertex dans les shaders

Limitations

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

Individual skills in this repo

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

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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.

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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.

AlperTuncOrtak/crypto-data-pipeline

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.

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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 悬停效果

AlperTuncOrtak/crypto-data-pipeline

Best practices for Remotion - Video creation in React

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

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.

AlperTuncOrtak/crypto-data-pipeline

Automate TikTok tasks via Rube MCP (Composio): upload/publish videos, post photos, manage content, and view user profiles/stats. Always search tools first for current schemas.

AlperTuncOrtak/crypto-data-pipeline

Video and audio perception, indexing, and editing. Ingest files/URLs/live streams, build visual/spoken indexes, search with timestamps, edit timelines, add overlays/subtitles, generate media, and create real-time alerts.

AlperTuncOrtak/crypto-data-pipeline

Upload, stream, search, edit, transcribe, and generate AI video and audio using the VideoDB SDK.

AlperTuncOrtak/crypto-data-pipeline

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

AlperTuncOrtak/crypto-data-pipeline

Automate YouTube tasks via Rube MCP (Composio): upload videos, manage playlists, search content, get analytics, and handle comments. Always search tools first for current schemas.

AlperTuncOrtak/crypto-data-pipeline

Extract transcripts from YouTube videos and generate comprehensive, detailed summaries using intelligent analysis frameworks

Skills associés