Communitygithub.com

threejs-animation

Three.js-Animation – Keyframe-Animationen, Skelett-Animation, Morph-Ziele und Animations-Mixing. Verwenden Sie es zum Animieren von Objekten, Abspielen von GLTF-Animationen, Erstellen prozeduraler Bewegungen oder Überblenden von Animationen.

Was ist threejs-animation?

Das Skill `threejs-animation` deckt das gesamte Three.js-Animationssystem ab, einschließlich Keyframe-Animationen, Skelett-Animationen (Skeletal Animation), Morph-Zielen (Morph Targets) und Animations-Mixing. Es richtet sich an Entwickler, die mit Three.js im Browser arbeiten (z. B. mit React Three Fiber oder purem Three.js) und bietet sowohl die programmatische Erstellung von Animationen als auch das Laden und Abspielen von GLTF-Animationen. Das Skill erklärt die drei Kernkomponenten (AnimationClip, AnimationMixer, AnimationAction) und zeigt, wie man Interpolationsmodi, Überblendungen (Crossfades), additive Animationen und prozedurale Muster wie Federung (Spring Physics) oder geschwindigkeitsabhängiges Blending umsetzt. Es enthält außerdem Best Practices zur Performance-Optimierung. Der Skill ist als umfassende Referenz für alle gängigen Animationsaufgaben in Three.js konzipiert und unterstützt sowohl Anfänger als auch fortgeschrittene Nutzer bei der Implementierung flüssiger, komplexer Animationen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/RamonsDka/the-architect-overlay/tree/HEAD/skills/threejs-animation

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Three.js-Animation

Schnellstart

import * as THREE from "three";

// Einfache prozedurale Animation
const clock = new THREE.Clock();

function animate() {
  const delta = clock.getDelta();
  const elapsed = clock.getElapsedTime();

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

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

Überblick über das Animationssystem

Das Animationssystem von Three.js besteht aus drei Hauptkomponenten:

  1. AnimationClip – Container für Keyframe-Daten
  2. AnimationMixer – Spielt Animationen auf einem Wurzelobjekt ab
  3. AnimationAction – Steuert die Wiedergabe eines Clips

AnimationClip

Speichert Keyframe-Animationsdaten.

// Animationsclip erstellen
const times = [0, 1, 2]; // Keyframe-Zeiten (Sekunden)
const values = [0, 1, 0]; // Werte an jedem Keyframe

const track = new THREE.NumberKeyframeTrack(
  ".position[y]", // Eigenschaftspfad
  times,
  values,
);

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

KeyframeTrack-Typen

// Zahlen-Track (einzelner Wert)
new THREE.NumberKeyframeTrack(".opacity", times, [1, 0]);
new THREE.NumberKeyframeTrack(".material.opacity", times, [1, 0]);

// Vektor-Track (Position, Skalierung)
new THREE.VectorKeyframeTrack(".position", times, [
  0, 0, 0, // t=0
  1, 2, 0, // t=1
  0, 0, 0, // t=2
]);

// Quaternion-Track (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],
);

// Farb-Track
new THREE.ColorKeyframeTrack(".material.color", times, [
  1, 0, 0, // rot
  0, 1, 0, // grün
  0, 0, 1, // blau
]);

// Boolean-Track
new THREE.BooleanKeyframeTrack(".visible", [0, 0.5, 1], [true, false, true]);

// String-Track (für Morph-Ziele)
new THREE.StringKeyframeTrack(
  ".morphTargetInfluences[smile]",
  [0, 1],
  ["0", "1"],
);

Interpolationsmodi

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

// Interpolation
track.setInterpolation(THREE.InterpolateLinear); // Standard
track.setInterpolation(THREE.InterpolateSmooth); // Kubischer Spline
track.setInterpolation(THREE.InterpolateDiscrete); // Treppenfunktion

AnimationMixer

Spielt Animationen auf einem Objekt und seinen Nachkommen ab.

const mixer = new THREE.AnimationMixer(model);

// Aktion aus Clip erstellen
const action = mixer.clipAction(clip);
action.play();

// Im Animations-Loop aktualisieren
function animate() {
  const delta = clock.getDelta();
  mixer.update(delta); // Erforderlich!

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

Mixer-Ereignisse

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

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

AnimationAction

Steuert die Wiedergabe eines Animationsclips.

const action = mixer.clipAction(clip);

// Wiedergabesteuerung
action.play();
action.stop();
action.reset();
action.halt(fadeOutDuration);

// Wiedergabestatus
action.isRunning();
action.isScheduled();

// Zeitsteuerung
action.time = 0.5; // Aktuelle Zeit
action.timeScale = 1; // Wiedergabegeschwindigkeit (negativ = rückwärts)
action.paused = false;

// Gewicht (für Überblendungen)
action.weight = 1; // 0-1, Beitrag zur finalen Pose
action.setEffectiveWeight(1);

// Schleifenmodi
action.loop = THREE.LoopRepeat; // Standard: endlos wiederholen
action.loop = THREE.LoopOnce; // Einmal abspielen und stoppen
action.loop = THREE.LoopPingPong; // Vorwärts/rückwärts abwechseln
action.repetitions = 3; // Anzahl der Wiederholungen (Standard: Infinity)

// Clamping
action.clampWhenFinished = true; // Letzten Frame halten, wenn fertig

// Überblendung
action.blendMode = THREE.NormalAnimationBlendMode;
action.blendMode = THREE.AdditiveAnimationBlendMode;

Ein-/Ausblenden

// Einblenden
action.reset().fadeIn(0.5).play();

// Ausblenden
action.fadeOut(0.5);

// Überblenden zwischen Animationen
const action1 = mixer.clipAction(clip1);
const action2 = mixer.clipAction(clip2);

action1.play();

// Später zu action2 überblenden
action1.crossFadeTo(action2, 0.5, true);
action2.play();

GLTF-Animationen laden

Häufigste Quelle für Skelett-Animationen.

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

  // Mixer erstellen
  const mixer = new THREE.AnimationMixer(model);

  // Alle Clips abrufen
  const clips = gltf.animations;
  console.log(
    "Verfügbare Animationen:",
    clips.map((c) => c.name),
  );

  // Erste Animation abspielen
  if (clips.length > 0) {
    const action = mixer.clipAction(clips[0]);
    action.play();
  }

  // Bestimmte Animation nach Namen abspielen
  const walkClip = THREE.AnimationClip.findByName(clips, "Walk");
  if (walkClip) {
    mixer.clipAction(walkClip).play();
  }

  // Mixer für den Update-Loop speichern
  window.mixer = mixer;
});

// Animations-Loop
function animate() {
  const delta = clock.getDelta();
  if (window.mixer) window.mixer.update(delta);

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

Skelett-Animation

Skelett und Knochen

// Auf Skelett aus SkinnedMesh zugreifen
const skinnedMesh = model.getObjectByProperty("type", "SkinnedMesh");
const skeleton = skinnedMesh.skeleton;

// Auf Knochen zugreifen
skeleton.bones.forEach((bone) => {
  console.log(bone.name, bone.position, bone.rotation);
});

// Bestimmten Knochen nach Namen finden
const headBone = skeleton.bones.find((b) => b.name === "Head");
if (headBone) headBone.rotation.y = Math.PI / 4; // Kopf drehen

// Skelett-Helfer
const helper = new THREE.SkeletonHelper(model);
scene.add(helper);

Programmgesteuerte Knochen-Animation

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

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

  // Mixer aktualisieren, falls auch Clips laufen
  mixer.update(clock.getDelta());
}

Knochen-Anhänge

// Objekt an Knochen anhängen
const weapon = new THREE.Mesh(weaponGeometry, weaponMaterial);
const handBone = skeleton.bones.find((b) => b.name === "RightHand");
if (handBone) handBone.add(weapon);

// Versatz des Anhängsels
weapon.position.set(0, 0, 0.5);
weapon.rotation.set(0, Math.PI / 2, 0);

Morph-Ziele

Überblenden zwischen verschiedenen Mesh-Formen.

// Morph-Ziele werden in der Geometrie gespeichert
const geometry = mesh.geometry;
console.log("Morph-Attribute:", Object.keys(geometry.morphAttributes));

// Auf Morph-Ziel-Einflüsse zugreifen
mesh.morphTargetInfluences; // Array von Gewichten
mesh.morphTargetDictionary; // Name -> Index-Zuordnung

// Morph-Ziel nach Index setzen
mesh.morphTargetInfluences[0] = 0.5;

// Nach Name setzen
const smileIndex = mesh.morphTargetDictionary["smile"];
mesh.morphTargetInfluences[smileIndex] = 1;

Morph-Ziele animieren

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

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

Animationsüberblendung

Mehrere Animationen miteinander mischen.

// Aktionen einrichten
const idleAction = mixer.clipAction(idleClip);
const walkAction = mixer.clipAction(walkClip);
const runAction = mixer.clipAction(runClip);

// Alle mit verschiedenen Gewichten abspielen
idleAction.play();
walkAction.play();
runAction.play();

// Anfangsgewichte setzen
idleAction.setEffectiveWeight(1);
walkAction.setEffectiveWeight(0);
runAction.setEffectiveWeight(0);

// Basierend auf Geschwindigkeit überblenden
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);
  }
}

Additive Überblendung

// Basis-Pose
const baseAction = mixer.clipAction(baseClip);
baseAction.play();

// Additive Schicht (z. B. Atmung)
const additiveAction = mixer.clipAction(additiveClip);
additiveAction.blendMode = THREE.AdditiveAnimationBlendMode;
additiveAction.play();

// Clip in additiv umwandeln
THREE.AnimationUtils.makeClipAdditive(additiveClip);

Animationshilfsfunktionen

import * as THREE from "three";

// Clip nach Namen finden
const clip = THREE.AnimationClip.findByName(clips, "Walk");

// Subclip erstellen
const subclip = THREE.AnimationUtils.subclip(clip, "subclip", 0, 30, 30);

// In additiv umwandeln
THREE.AnimationUtils.makeClipAdditive(clip);
THREE.AnimationUtils.makeClipAdditive(clip, 0, referenceClip);

// Clip klonen
const clone = clip.clone();

// Clip-Dauer abrufen
clip.duration;

// Clip optimieren (redundante Keyframes entfernen)
clip.optimize();

// Clip auf ersten Frame zurücksetzen
clip.resetDuration();

Prozedurale Animationsmuster

Sanfte Dämpfung

// Sanftes Folgen/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);
}

Feder-Physik

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);
}

Oszillation

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

  // Sinuswelle
  mesh.position.y = Math.sin(t * 2) * 0.5;

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

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

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

Leistungstipps

  1. Clips teilen: Derselbe AnimationClip kann auf mehreren Mixern verwendet werden
  2. Clips optimieren: Rufe clip.optimize() auf, um redundante Keyframes zu entfernen
  3. Bei Unsichtbarkeit deaktivieren: Stoppe Mixer-Updates für unsichtbare Objekte
  4. LOD für Animationen verwenden: Einfachere Rigs für entfernte Charaktere
  5. Aktive Mixer begrenzen: Jeder mixer.update() verursacht Kosten
// Animation pausieren, wenn nicht sichtbar
mesh.onBeforeRender = () => {
  action.paused = false;
};

mesh.onAfterRender = () => {
  // Prüfen, ob im nächsten Frame sichtbar
  if (!isInFrustum(mesh)) {
    action.paused = true;
  }
};

// Clips zwischenspeichern
const clipCache = new Map();
function getClip(name) {
  if (!clipCache.has(name)) {
    clipCache.set(name, loadClip(name));
  }
  return clipCache.get(name);
}

Siehe auch

  • threejs-loaders – Animierte GLTF-Modelle laden
  • threejs-fundamentals – Clock und Animations-Loop
  • threejs-shaders – Vertex-Animation in Shadern

Individual skills in this repo

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

Verwandte Skills