Communitygithub.com

AbobakrDiara61/railway-system

Three.js-Animationen – Keyframe-Animation, Skelett-Animation, Morph-Targets, Animations-Mixing. Verwenden Sie diese, wenn Sie Objekte animieren, GLTF-Animationen abspielen, prozedurale Bewegungen erzeugen oder Animationen überblenden möchten.

Was ist railway-system?

Diese Fähigkeit (Skill) bietet einen umfassenden Leitfaden zur Animation in Three.js, der sowohl das integrierte Animationssystem als auch prozedurale Techniken abdeckt. Sie ist nützlich für Entwickler, die interaktive 3D-Szenen mit Bewegung erstellen – von einfachen Objekt-Rotationen bis hin zu komplexen skelettalen Animationen und Morph-Targets. Der Skill unterstützt die gängigsten Three.js-Animationen, darunter Keyframe-Animation, GLTF-Animationen, Morph-Target-Animation und Animations-Mixing mit Überblendungen und additiver Animation. Zudem werden neuere Features wie der `THREE.Timer` (ab r183) und der `THREE.BezierInterpolant` behandelt. Der Leitfaden enthält praktische Code-Beispiele für die Einrichtung von Animationen, das Abspielen von GLTF-Animationen, die programmatische Steuerung von Knochen (Bones), Morph-Targets und prozedurale Muster wie Smooth-Damping, Feder-Physik und Oszillation. Performance-Tipps runden den Skill ab.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/AbobakrDiara61/railway-system/tree/HEAD/frontend/skills/threejs-animation

In Ihrer bevorzugten KI fragen

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

Dokumentation

Three.js-Animationen

Wann verwenden

  • Sie müssen Objekte, Rigs, Morph-Targets oder importierte GLTF-Animationen in Three.js animieren.
  • Die Aufgabe umfasst Mixer, Clips, Keyframes, prozedurale Bewegungen oder Animations-Überblendungen.
  • Sie bauen Bewegungsverhalten in einer Three.js-Szene auf, nicht nur statisches Rendering.

Schnellstart

import * as THREE from "three";

// Einfache prozedurale Animation mit Timer (empfohlen ab 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);
});

Hinweis: THREE.Timer wird ab r183 gegenüber THREE.Clock empfohlen. Timer pausiert, wenn die Seite ausgeblendet ist, und hat eine sauberere API. THREE.Clock funktioniert weiterhin, gilt aber als Legacy.

Übersicht über das Animationssystem

Das Three.js-Animationssystem besteht aus drei Hauptkomponenten:

  1. AnimationClip – Container für Keyframe-Daten
  2. AnimationMixer – Spielt Animationen auf einem Root-Objekt 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
]);

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

// String-Track (für Morph-Targets)
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); // Sprungfunktion

BezierInterpolant (r183)

Three.js r183 fügt THREE.BezierInterpolant für Bezier-Kurveninterpolation in Keyframe-Tracks hinzu, was flüssigere Animationskurven mit Tangentensteuerung ermöglicht.

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

// In der Animationsschleife 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("Animation wiederholt:", 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 Überblendung)
action.weight = 1; // 0-1, Beitrag zur endgültigen Pose
action.setEffectiveWeight(1);

// Schleifenmodi
action.loop = THREE.LoopRepeat; // Standard: Endlosschleife
action.loop = THREE.LoopOnce; // Einmal abspielen und stoppen
action.loop = THREE.LoopPingPong; // Abwechselnd vorwärts/rückwärts
action.repetitions = 3; // Anzahl der Wiederholungen (Standard: Unendlich)

// Klemmverhalten
action.clampWhenFinished = true; // Letzten Frame beim Ende halten

// Ü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, Überblenden zu action2
action1.crossFadeTo(action2, 0.5, true);
action2.play();

Laden von GLTF-Animationen

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 Update-Schleife speichern
  window.mixer = mixer;
});

// Animationsschleife
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 skinned mesh 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);

Programmatische 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 abgespielt werden
  mixer.update(clock.getDelta());
}

Anhängen an Knochen

// 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-Targets

Zwischen verschiedenen Mesh-Formen überblenden.

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

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

// Morph-Target per Index setzen
mesh.morphTargetInfluences[0] = 0.5;

// Per Namen setzen
const smileIndex = mesh.morphTargetDictionary["smile"];
mesh.morphTargetInfluences[smileIndex] = 1;

Morph-Targets 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 mischen.

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

// Alle mit unterschiedlichen 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 Ebene (z.B. Atmen)
const additiveAction = mixer.clipAction(additiveClip);
additiveAction.blendMode = THREE.AdditiveAnimationBlendMode;
additiveAction.play();

// Clip in additive 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 additive 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

Sanftes Dämpfen

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

Performance-Tipps

  1. Clips teilen: Derselbe AnimationClip kann auf mehreren Mixern verwendet werden
  2. Clips optimieren: Rufen Sie clip.optimize() auf, um redundante Keyframes zu entfernen
  3. Deaktivieren, wenn nicht sichtbar: Stoppen Sie 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 cachen
const clipCache = new Map();
function getClip(name) {
  if (!clipCache.has(name)) {
    clipCache.set(name, loadClip(name));
  }
  return clipCache.get(name);
}

Siehe auch

  • threejs-loaders – Laden animierter GLTF-Modelle
  • threejs-fundamentals – Clock und Animationsschleife
  • threejs-shaders – Vertex-Animation in Shadern

Einschränkungen

  • Verwenden Sie diesen Skill nur, wenn die Aufgabe eindeutig dem oben beschriebenen Umfang entspricht.
  • Betrachten Sie die Ausgabe nicht als Ersatz für umgebungsspezifische Validierung, Tests oder Expertenüberprüfung.
  • Bitten Sie um Klärung, wenn erforderliche Eingaben, Berechtigungen, Sicherheitsgrenzen oder Erfolgskriterien fehlen.

Individual skills in this repo

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

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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.

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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.

AbobakrDiara61/railway-system

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.

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

Best practices for Remotion - Video creation in React

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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.

AbobakrDiara61/railway-system

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.

AbobakrDiara61/railway-system

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.

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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

AbobakrDiara61/railway-system

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.

AbobakrDiara61/railway-system

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

Verwandte Skills