Communitygithub.com

Bailipa/EZTor_FULLBLOOD

Utilisez-le pour lire des animations, effectuer des transitions en fondu entre des états d'animation ou charger des animations squelettiques depuis GLTF dans Three.js. Évite les erreurs courantes comme oublier d'appeler mixer.update(delta) à chaque frame, une mauvaise configuration du fondu enchaîné ou l'absence de Clock. Couvre AnimationMixer, AnimationClip, AnimationAction, KeyframeTrack, fondu enchaîné, blending.

Qu'est-ce que EZTor_FULLBLOOD ?

Ce skill fournit un guide complet pour implémenter des animations dans Three.js, en couvrant tous les composants essentiels : AnimationMixer, AnimationClip, AnimationAction, KeyframeTrack et Clock. Il explique comment configurer correctement des animations squelettiques à partir de fichiers GLTF, en insistant sur les bonnes pratiques comme l'appel obligatoire de mixer.update(delta) à chaque frame dans la boucle de rendu et l'utilisation de Clock pour éviter les erreurs de timing. Il détaille également les techniques avancées telles que le fondu enchaîné entre animations (crossfade) pour créer des transitions fluides, le blending additif pour superposer des animations (respiration, réactions aux dégâts), et l'animation de morph targets. Le skill est utile pour tout développeur utilisant Three.js avec React Three Fiber ou directement, et inclut des exemples de code prêts à l'emploi ainsi que des avertissements sur les anti-patrons fréquents.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Bailipa/EZTor_FULLBLOOD/tree/HEAD/.opencode/skills/threejs/threejs-impl/threejs-impl-animation

Demander à votre IA préférée

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

Documentation

threejs-impl-animation

Référence rapide

Architecture

AnimationClip        (données : tableau d'objets KeyframeTrack)
  └── AnimationAction  (contrôleur de lecture : play, pause, fade, crossfade)
        └── AnimationMixer (planificateur maître : un par objet racine animé)
              └── Clock    (fournit le temps delta pour mixer.update)

Créez TOUJOURS exactement UN AnimationMixer par objet racine animé. Appelez TOUJOURS mixer.update(delta) à chaque frame dans la boucle de rendu. N'instanciez JAMAIS AnimationAction directement — utilisez TOUJOURS mixer.clipAction(clip).

Imports essentiels

import * as THREE from 'three';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';

Configuration minimale d'animation

import * as THREE from 'three';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';

const clock = new THREE.Clock();
let mixer;

const loader = new GLTFLoader();
loader.load('character.glb', (gltf) => {
  scene.add(gltf.scene);
  mixer = new THREE.AnimationMixer(gltf.scene);

  // Jouer toutes les animations du fichier GLTF
  gltf.animations.forEach((clip) => {
    mixer.clipAction(clip).play();
  });
});

function animate() {
  const delta = clock.getDelta();
  if (mixer) mixer.update(delta);
  renderer.render(scene, camera);
}
renderer.setAnimationLoop(animate);

Avertissements critiques

NE JAMAIS oublier d'appeler mixer.update(delta) dans la boucle de rendu — les animations ne seront PAS lues sans cela.

NE JAMAIS utiliser new Date() ou performance.now() pour calculer delta manuellement — utilisez TOUJOURS THREE.Clock ou renderer.setAnimationLoop qui fournit un timing d'image stable.

NE JAMAIS appeler mixer.clipAction(clip) de manière répétée dans la boucle de rendu — il met en cache en interne, mais la recherche est une surcharge inutile. Stockez TOUJOURS l'action retournée dans une variable.

NE JAMAIS appeler .play() à chaque frame — appelez-le UNE FOIS pour démarrer la lecture. Appeler .play() à nouveau sur une action déjà en cours n'a aucun effet, mais indique une méprise.

Appelez TOUJOURS .reset() avant .play() lors du redémarrage d'une action arrêtée ou terminée, sinon l'action peut reprendre depuis sa dernière position.

Définissez TOUJOURS action.clampWhenFinished = true avec LoopOnce — sinon l'action revient à la première image une fois terminée.


AnimationMixer

Le planificateur maître qui gère toutes les actions d'animation pour une hiérarchie d'objets unique.

Constructeur

const mixer = new THREE.AnimationMixer(rootObject);

rootObject est l'Object3D racine du modèle animé (généralement gltf.scene).

Propriétés

PropriétéTypeDéfautDescription
.timenumber0Temps global du mixer en secondes
.timeScalenumber1Multiplicateur de vitesse global ; 0 met PAUSE toutes les actions

Méthodes

MéthodeRetourneDescription
.clipAction(clip, root?, blendMode?)AnimationActionRetourne ou crée une action pour le clip
.existingAction(clip, root?)AnimationAction | nullRetourne l'action précédemment créée ou null
.update(delta)thisAvance le mixer du delta en secondes — DOIT être appelée à chaque frame
.setTime(seconds)thisDéfinit le temps global, met à jour toutes les actions
.stopAllAction()thisDésactive toutes les actions planifiées
.getRoot()Object3DRetourne l'objet racine du mixer
.uncacheAction(clip, root?)voidDésalloue l'action mise en cache
.uncacheClip(clip)voidDésalloue les données du clip
.uncacheRoot(root)voidDésalloue les données de l'objet racine

Événements

Écoutez via mixer.addEventListener(type, callback) :

ÉvénementDéclenché quand
'finished'L'action se termine (UNIQUEMENT avec LoopOnce + clampWhenFinished = true)
'loop'L'action termine une itération de boucle

Propriétés de l'objet événement : { action, loopDelta, type }.

Modes de mélange

Passez comme troisième argument à mixer.clipAction(clip, root, blendMode) :

ConstanteComportement
THREE.NormalAnimationBlendModeMélange standard (par défaut)
THREE.AdditiveAnimationBlendModeSuperposé à l'animation de base

AnimationAction

Contrôle la lecture d'un seul clip d'animation. Ne jamais instancier directement.

Propriétés

PropriétéTypeDéfautDescription
.blendModenumberNormalAnimationBlendModeStratégie de mélange
.clampWhenFinishedbooleanfalsePause sur la dernière image une fois terminée
.enabledbooleantrueDésactiver sans réinitialiser
.loopnumberLoopRepeatMode de boucle
.pausedbooleanfalseGeler la lecture
.repetitionsnumberInfinityNombre de répétitions
.timenumber0Temps local en secondes
.timeScalenumber1Vitesse : 0 met en pause, négatif inverse
.weightnumber1Influence du mélange [0, 1]
.zeroSlopeAtEndbooleantrueInterpolation lisse à la fin de la boucle
.zeroSlopeAtStartbooleantrueInterpolation lisse au début de la boucle

Modes de boucle

ConstanteComportement
THREE.LoopOnceJoue une fois, s'arrête
THREE.LoopRepeatRedémarre depuis le début à chaque boucle
THREE.LoopPingPongAlterne avant/arrière

Méthodes de lecture

MéthodeDescription
.play()Démarrer la lecture
.stop()Arrêter et réinitialiser au début
.reset()Réinitialiser le temps, le poids, la vitesse à l'état initial
.startAt(mixerTime)Retarder le démarrage jusqu'au temps spécifié du mixer

Méthodes de fondu et de fondu enchaîné

MéthodeDescription
.fadeIn(duration)Fondre le poids de 0 à 1
.fadeOut(duration)Fondre le poids de 1 à 0
.crossFadeFrom(fadeOutAction, duration, warp)Fondu enchaîné depuis une autre action vers celle-ci
.crossFadeTo(fadeInAction, duration, warp)Fondu enchaîné de cette action vers une autre
.stopFading()Annuler tout fondu actif

Méthodes de vitesse et de timing

MéthodeDescription
.halt(duration)Décélérer timeScale jusqu'à 0 sur la durée
.warp(startScale, endScale, duration)Transiter en douceur la vitesse de lecture
.stopWarping()Annuler toute transition de vitesse active
.setDuration(seconds)Ajuster timeScale pour qu'une boucle prenne exactement seconds
.setEffectiveTimeScale(scale)Définir l'échelle de temps effective
.setEffectiveWeight(weight)Définir le poids effectif
.setLoop(mode, repetitions)Définir le mode de boucle et le nombre de répétitions
.syncWith(otherAction)Synchroniser le temps avec une autre action

Méthodes de requête

MéthodeRetourneDescription
.isRunning()booleantrue uniquement si en lecture active
.isScheduled()booleantrue si .play() a été appelé
.getClip()AnimationClipLe clip associé
.getMixer()AnimationMixerLe mixer propriétaire
.getRoot()Object3DL'objet racine
.getEffectiveTimeScale()numberÉchelle de temps calculée
.getEffectiveWeight()numberPoids calculé

AnimationClip

Un ensemble réutilisable de pistes d'images clés. Généralement chargé depuis des fichiers GLTF.

Constructeur

const clip = new THREE.AnimationClip(name, duration, tracks, blendMode);
  • name -- identifiant chaîne (les clips GLTF utilisent les noms du fichier)
  • duration -- secondes ; -1 pour calcul automatique à partir des pistes
  • tracks -- tableau d'objets KeyframeTrack
  • blendMode -- constante de mode de mélange optionnelle

Méthodes statiques clés

MéthodeDescription
AnimationClip.findByName(arrayOrObject, name)Rechercher un clip par nom
AnimationClip.CreateFromMorphTargetSequence(name, targets, fps, noLoop)Créer un clip à partir de cibles de morphing
AnimationClip.parse(json)Désérialiser depuis JSON

Types de KeyframeTrack

Type de pisteType de valeurCas d'usage
VectorKeyframeTrackVector3Position, échelle
QuaternionKeyframeTrackQuaternionRotation (utilise slerp)
NumberKeyframeTracknumberOpacité, intensité
BooleanKeyframeTrackbooleanCommutateurs de visibilité
ColorKeyframeTrackColorAnimation de couleur
StringKeyframeTrackstringValeurs discrètes de chaîne

Modes d'interpolation

ConstanteComportement
THREE.InterpolateDiscreteFonction échelon, pas de lissage
THREE.InterpolateLinearInterpolation linéaire (par défaut)
THREE.InterpolateSmoothInterpolation par spline cubique

Format du chemin PropertyBinding

"meshName.position"                    // animer la position
"meshName.material.opacity"            // animer une propriété de matériau
"meshName.morphTargetInfluences[0]"    // animer une cible de morphing
"boneName.quaternion"                  // animer la rotation d'un os

Clock

Constructeur

const clock = new THREE.Clock(autoStart); // autoStart vaut true par défaut

Méthodes

MéthodeRetourneDescription
.getDelta()numberSecondes depuis le dernier appel à getDelta()
.getElapsedTime()numberTemps total écoulé en secondes
.start()voidDémarrer le chronomètre
.stop()voidArrêter sans réinitialiser

Modèle de fondu enchaîné (machine à états de personnage)

const actions = {};
gltf.animations.forEach((clip) => {
  actions[clip.name] = mixer.clipAction(clip);
});

let currentAction = actions['Idle'];
currentAction.play();

function switchAction(toName, duration = 0.5) {
  const toAction = actions[toName];
  toAction.reset();
  toAction.setEffectiveTimeScale(1);
  toAction.setEffectiveWeight(1);
  toAction.crossFadeFrom(currentAction, duration, true);
  toAction.play();
  currentAction = toAction;
}

Appelez TOUJOURS .reset() sur l'action entrante avant le fondu enchaîné. Stockez TOUJOURS la référence de l'action courante pour la prochaine transition.


Mélange d'animations additif

const baseAction = mixer.clipAction(baseClip);
const additiveAction = mixer.clipAction(
  additiveClip, undefined, THREE.AdditiveAnimationBlendMode
);

baseAction.play();
additiveAction.play();
additiveAction.setEffectiveWeight(0.5);

Utilisez le mélange additif pour des effets superposés : respiration, réactions aux dégâts, décalages de visée.


Animation de morph targets

// Contrôle manuel
mesh.morphTargetInfluences[0] = Math.sin(elapsed) * 0.5 + 0.5;

// Via un clip d'animation GLTF (recommandé)
const morphAction = mixer.clipAction(morphClip);
morphAction.play();

Liens de référence

Sources officielles

Individual skills in this repo

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

Bailipa/EZTor_FULLBLOOD

Create video compositions, animations, title cards, overlays, captions, voiceovers, audio-reactive visuals, and scene transitions in HyperFrames HTML. Use when asked to build any HTML-based video content, add captions or subtitles synced to audio, generate text-to-speech narration, create audio-reactive animation (beat sync, glow, pulse driven by music), add animated text highlighting (marker sweeps, hand-drawn circles, burst lines, scribble, sketchout), or add transitions between scenes (crossfades, wipes, reveals, shader transitions). Covers composition authoring, timing, media, and the full video production workflow. For CLI commands (init, lint, preview, render, transcribe, tts) see the hyperframes-cli skill.

Bailipa/EZTor_FULLBLOOD

A single-frame motion-design composition with looping CSS animations — rotating type ring, animated globe, ticking timer, parallax labels. Renders as a hero video poster you can hand straight to HyperFrames or any keyframe-based exporter. Use when the brief asks for "motion design", "animated hero", "loop", "video poster", "title card", or pairs Open Claude Design with HyperFrames for a kinetic export.

Bailipa/EZTor_FULLBLOOD

Single-page SaaS landing with hero, features, social proof, pricing, and CTA. Respects the active DESIGN.md color/typography/layout tokens. Trigger keywords: "saas landing", "marketing page", "product landing".

Bailipa/EZTor_FULLBLOOD

A pixel / sprite-style animated explainer slide — full-bleed cream stage, bold display year, animated pixel-art mascot (e.g. Hanafuda card, mushroom, or 8-bit console), kinetic Japanese display type, ticking timeline ribbon. Reads like a single frame of an educational motion video — looping CSS keyframes, no JS, ready to be screen-recorded into a vertical video. Use when the brief asks for a "sprite animation", "pixel-art video", "8-bit explainer", "history of X explainer", "kinetic typography history", "Nintendo-style", "精灵图动画", "像素动画", or "复古动画".

Bailipa/EZTor_FULLBLOOD

Short-form video generation skill — 3-10 second clips for product reveals, motion teasers, ambient loops. Defaults to Seedance 2 but works the same with Kling 3 / 4, Veo 3 or Sora 2. Output is one MP4 saved to the project folder. When the workspace also ships an interactive-video / hyperframes skill, prefer composing several short shots into a single timeline rather than one long monolithic clip.

Skills associés