Communitygithub.com

ComeOnOliver/skillshub

Three.js-Animation: Keyframe-Animation, Skelett-Animation, Morph-Targets, Animations-Mixing. Verwende es beim Animieren von Objekten, Abspielen von GLTF-Animationen, Erstellen von prozeduralen Bewegungen oder Mischen von Animationen.

Was ist skillshub?

Diese Fähigkeit bietet eine umfassende Einführung in das Three.js-Animationssystem, das aus drei Hauptkomponenten besteht: AnimationClip (zur Speicherung von Keyframe-Daten), AnimationMixer (zum Abspielen von Animationen auf einem Root-Objekt) und AnimationAction (zur Steuerung der Wiedergabe). Es behandelt alle wichtigen Techniken: Erstellen und Bearbeiten von Keyframes (Number-, Vector-, Quaternion-, Color-, Boolean- und String-Tracks), Abspielen und Mischen von Animationen (Gewichtung, Fade-Effekte, additive oder normale Überblendung), Skellett-Animation mit Bones und ihrer programmgesteuerten Manipulation, Arbeiten mit Morph-Targets und deren Animation (sowohl prozedural als auch via Keyframes), Laden und Abspielen von GLTF-Animationen sowie fortgeschrittene prozedurale Muster (Smooth Damping, Federphysik, Oszillation). Die Dokumentation enthält außerdem ausführliche Codebeispiele für alle Funktionen und Performance-Tipps wie Clip-Teilung, Optimierung und Deaktivierung von Animationen bei nicht sichtbaren Objekten. Diese Fähigkeit ist ideal für Entwickler, die mit Three.js realistische oder stilvolle Animationen erstellen möchten, egal ob für Spiele, Visualisierungen oder interaktive 3D-Webanwendungen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/Harmeet10000/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();

Übersicht über das Animationssystem

Das Three.js-Animationssystem besteht aus drei Hauptkomponenten:

  1. AnimationClip – Behälter 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

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

// Vector-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],
);

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

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;

// Gewichtung (zum Mischen)
action.weight = 1; // 0-1, Beitrag zur endgültigen Pose
action.setEffectiveWeight(1);

// Wiederholungsmodi
action.loop = THREE.LoopRepeat; // Standard: endlos wiederholen
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)

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

// Mischen
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 die Aktualisierungsschleife 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 Bones

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

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

// Bestimmten Bone 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 Bone-Animation

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

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

Bone-Anhänge

// Objekt an einem Bone befestigen
const weapon = new THREE.Mesh(weaponGeometry, weaponMaterial);
const handBone = skeleton.bones.find((b) => b.name === "RightHand");
if (handBone) handBone.add(weapon);

// Anhang versetzen
weapon.position.set(0, 0, 0.5);
weapon.rotation.set(0, Math.PI / 2, 0);

Morph-Targets

Wechsel zwischen verschiedenen Mesh-Formen.

// Morph-Targets sind 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 Gewichtungen
mesh.morphTargetDictionary; // Name -> Index-Zuordnung

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

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

Animationsmischung

Mehrere Animationen miteinander mischen.

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

// Alle mit unterschiedlichen Gewichtungen abspielen
idleAction.play();
walkAction.play();
runAction.play();

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

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

Additives Mischen

// Basispose
const baseAction = mixer.clipAction(baseClip);
baseAction.play();

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

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

Animations-Dienstprogramme

import * as THREE from "three";

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

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

Smooth Damping

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

Federphysik

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;

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

  // Achterbahn
  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: Rufe clip.optimize() auf, um redundante Keyframes zu entfernen
  3. Deaktivieren, wenn nicht sichtbar: 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() hat 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

Individual skills in this repo

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

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Verwandte Skills