Was macht Animationsdesigner?
Zweck
Entwerfen und implementieren Sie performante, zielgerichtete Web-Animationen, die die Benutzererfahrung verbessern, ohne die Leistung oder Zugänglichkeit zu beeinträchtigen. Dieser Skill behandelt Animationstools, Muster und den Entscheidungsrahmen für die Wahl des richtigen Ansatzes.
Auswahl des Animationstools
Entscheidungsmatrix
ANIMATIONSANFORDERUNG EMPFOHLENES TOOL
--------------------------------------------------------------
Einfache Hover-/Fokus-Effekte CSS-Übergänge
Keyframe-Sequenzen (Laden usw.) CSS @keyframes
Eingangs-/Ausgangsanimationen Framer Motion (React)
Vue <Transition> (Vue)
Scroll-gesteuerte Einblendungen CSS scrollgesteuerte Animationen
(oder Intersection Observer)
Komplexe Zeitachsenabläufe GSAP
SVG-Pfadanimationen GSAP oder CSS
Feder-/physikbasierte Bewegungen Framer Motion (spring)
Layout-Animationen (Position/Größe) Framer Motion (layoutId)
Gesten-gesteuert (Drag, Pinch) Framer Motion (drag)
Geteilte Elementübergänge View Transitions API
Datenvisualisierungsanimationen D3-Übergänge oder GSAP
Mikrointeraktionen (Symbole, Schalter) CSS oder Lottie
CSS-Übergänge
Grundlagen
/* Übergangskurzform: Eigenschaft Dauer Timingfunktion Verzögerung */
.button {
background: var(--color-brand);
transition: background 200ms ease-out, transform 150ms ease-out;
}
.button:hover {
background: var(--color-brand-hover);
transform: scale(1.02);
}
/* Einzelne Eigenschaften */
.card {
transition-property: transform, box-shadow, opacity;
transition-duration: 200ms, 300ms, 200ms;
transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
}
/* Benannte Timingfunktionen */
--ease-in: cubic-bezier(0.4, 0, 1, 1); /* Beschleunigend */
--ease-out: cubic-bezier(0, 0, 0.2, 1); /* Verlangsamend */
--ease-in-out: cubic-bezier(0.4, 0, 0.2, 1); /* Standard */
--ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1); /* Überschwingend */
Häufige Übergangsmuster
/* Ein-/Ausblenden */
.fade-enter { opacity: 0; }
.fade-enter-active { opacity: 1; transition: opacity 300ms ease-out; }
.fade-exit { opacity: 1; }
.fade-exit-active { opacity: 0; transition: opacity 200ms ease-in; }
/* Von unten hereinschieben */
.slide-up {
transform: translateY(20px);
opacity: 0;
transition: transform 300ms ease-out, opacity 200ms ease-out;
}
.slide-up.active {
transform: translateY(0);
opacity: 1;
}
/* Skeleton-Lade-Schimmer */
@keyframes shimmer {
0% { background-position: -200% 0; }
100% { background-position: 200% 0; }
}
.skeleton {
background: linear-gradient(90deg, #e0e0e0 25%, #f0f0f0 50%, #e0e0e0 75%);
background-size: 200% 100%;
animation: shimmer 1.5s ease-in-out infinite;
}
CSS @keyframes
/* Dreh-Anzeige */
@keyframes spin {
to { transform: rotate(360deg); }
}
.spinner {
animation: spin 1s linear infinite;
border: 3px solid var(--color-border);
border-top-color: var(--color-brand);
border-radius: 50%;
width: 24px; height: 24px;
}
/* Pulsieren (Aufmerksamkeitsindikator) */
@keyframes pulse {
0%, 100% { opacity: 1; }
50% { opacity: 0.5; }
}
.notification-dot {
# ... (verkürzt) ...
.list-item:nth-child(2) { animation-delay: calc(1 * 50ms); }
.list-item:nth-child(3) { animation-delay: calc(2 * 50ms); }
/* Oder mit style-Attribut: style="--i: 3" */
.list-item {
animation-delay: calc(var(--i) * 50ms);
}
CSS-Scrollgesteuerte Animationen
/* Animation basierend auf Scroll-Position */
@keyframes reveal {
from {
opacity: 0;
transform: translateY(40px) scale(0.95);
}
to {
opacity: 1;
transform: translateY(0) scale(1);
}
}
/* Auslösen, wenn Element in den Viewport eintritt */
.reveal-on-scroll {
animation: reveal linear both;
animation-timeline: view();
animation-range: entry 0% entry 50%;
}
# ... (verkürzt) ...
to { transform: translateY(-50px); }
}
.parallax-element {
animation: parallax linear;
animation-timeline: scroll();
}
Framer Motion (React)
Grundlegende Muster
import { motion, AnimatePresence } from 'framer-motion';
// Eingangsanimation
function Card() {
return (
<motion.div
initial={{ opacity: 0, y: 20 }}
animate={{ opacity: 1, y: 0 }}
transition={{ duration: 0.3, ease: 'easeOut' }}
>
<h2>Karteninhalt</h2>
</motion.div>
);
}
// Ausgangsanimation (erfordert AnimatePresence)
function Modal({ isOpen, onClose }: ModalProps) {
return (
# ... (verkürzt) ...
<motion.li key={item.id} variants={itemVariants}>
{item.name}
</motion.li>
))}
</motion.ul>
);
}
Federphysik
// Federanimation (natürliche, physikbasierte Bewegung)
<motion.div
animate={{ x: 100 }}
transition={{
type: 'spring',
stiffness: 300, // Höher = schnelleres Ansprechen
damping: 20, // Höher = weniger Hüpfen
mass: 1, // Höher = mehr Trägheit
}}
/> .// Voreinstellungen
const springPresets = {
snappy: { type: 'spring', stiffness: 400, damping: 25 },
bouncy: { type: 'spring', stiffness: 300, damping: 10 },
gentle: { type: 'spring', stiffness: 120, damping: 14 },
molasses: { type: 'spring', stiffness: 60, damping: 20 },
};
// Wann Feder vs. Easing verwenden:
// Feder: interaktive Elemente, Drag, Layout-Änderungen (fühlt sich natürlich an)
// Easing: einfache Übergänge, Eintritt/Austritt (fühlt sich vorhersagbar an)
Layout-Animationen
// Automatische Layout-Animation
function ExpandableCard({ expanded }: { expanded: boolean }) {
return (
<motion.div layout className={expanded ? 'card-expanded' : 'card-collapsed'}>
<motion.h2 layout="position">Titel</motion.h2>
{expanded && (
<motion.p
initial={{ opacity: 0 }}
animate={{ opacity: 1 }}
exit={{ opacity: 0 }}
>
Erweiterter Inhalt hier.
</motion.p>
)}
</motion.div>
);
}
# ... (verkürzt) ...
{item.title}
</motion.div>
))}
</div>
</LayoutGroup>
);
}
Gesten-Animationen
// Drag
<motion.div
drag
dragConstraints={{ top: -100, bottom: 100, left: -100, right: 100 }}
dragElastic={0.2}
whileDrag={{ scale: 1.1, cursor: 'grabbing' }}
/> .// Hover und Tippen
<motion.button
whileHover={{ scale: 1.05 }}
whileTap={{ scale: 0.95 }}
transition={springPresets.snappy}
>
Klick mich
</motion.button> .// Scroll-gesteuert (mit useInView)
# ... (verkürzt) ...
animate={isInView ? { opacity: 1, y: 0 } : {}}
transition={{ duration: 0.6, ease: 'easeOut' }}
>
{children}
</motion.div>
);
}
GSAP (Komplexe Zeitachsen)
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
// Zeitachsenablauf
const tl = gsap.timeline({ defaults: { ease: 'power2.out', duration: 0.5 } });
tl.from('.hero-title', { y: 60, opacity: 0 })
.from('.hero-subtitle', { y: 40, opacity: 0 }, '-=0.3') // Überlappung um 0,3s
.from('.hero-cta', { scale: 0.8, opacity: 0 }, '-=0.2')
.from('.hero-image', { x: 100, opacity: 0 }, '-=0.4');
// Scroll-gesteuerte Animation
gsap.from('.feature-card', {
scrollTrigger: {
trigger: '.features-section',
start: 'top 80%',
# ... (verkürzt) ...
const ctx = gsap.context(() => {
// Alle GSAP-Animationen hier
gsap.from('.item', { opacity: 0, y: 20, stagger: 0.1 });
}, containerRef);
return () => ctx.revert(); // Alle Animationen bereinigen
}, []);
Einstellungen für reduzierte Bewegung
Implementierung
/* CSS: Nutzerwunsch global respektieren */
@media (prefers-reduced-motion: reduce) {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
// React: useReducedMotion-Hook
function useReducedMotion(): boolean {
const [reduced, setReduced] = useState(false);
useEffect(() => {
const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
setReduced(mq.matches);
const handler = (e: MediaQueryListEvent) => setReduced(e.matches);
mq.addEventListener('change', handler);
return () => mq.removeEventListener('change', handler);
}, []);
return reduced;
}
// Verwendung
function AnimatedCard() {
const reduced = useReducedMotion();
# ... (verkürzt) ...
Inhalt
</motion.div>
);
}
// Framer Motion integriert (v6+)
import { useReducedMotion } from 'framer-motion';
Leistungsbudget für Animationen
ZIEL: Animationen müssen 60fps beibehalten (16,67ms pro Frame)
REGELN:
1. Nur transform und opacity animieren (nur Compositor-Eigenschaften)
2. Animieren von width, height, top, left, margin, padding vermeiden
3. will-change sparsam verwenden (erhöht Speicherverbrauch)
4. Gleichzeitige Animationen auf ~10-15 Elemente begrenzen
5. requestAnimationFrame für JS-gesteuerte Animationen verwenden
6. Scroll-Handler entprellen (oder CSS-scrollgesteuerte Animationen verwenden)
7. Animieren von Elementen vermeiden, die Layout in anderen Elementen auslösen
MESSUNG:
- Chrome DevTools > Performance > Frame-Diagramm
- Ziel: Keine Frames über 16ms
- Auf Layout-Thrashing prüfen (erzwungene Reflow-Indikatoren)
OPTIMIERUNGSTECHNIKEN:
- transform: translateZ(0) oder will-change zur Layer-Förderung verwenden
- contain: layout paint für animierte Container verwenden
- content-visibility: auto für außerhalb des Bildschirms animierte Inhalte verwenden
- Animationen anhalten, wenn nicht sichtbar (Intersection Observer)
Prinzipien des Animationsdesigns
1. ZWECK: Jede Animation muss einer Funktion dienen
- Aufmerksamkeit lenken
- Beziehungen zeigen (übergeordnet-untergeordnet, vorher-nachher)
- Feedback geben (Klick, Hover, Erfolg, Fehler)
- Räumliche Orientierung bewahren (woher der Inhalt kam)
- Gefühlte Wartezeit reduzieren
2. DAUERRICHTLINIEN:
Mikrointeraktionen (Hover, Schalter): 100-200ms
Eingangsanimationen: 200-400ms
Ausgangsanimationen: 150-300ms (schneller als Eingang)
Seitenübergänge: 300-500ms
Komplexe Abläufe: 500-1000ms insgesamt
3. EASING:
Eintreten: ease-out (verlangsamend – erscheint schnell, setzt sich)
Austreten: ease-in (beschleunigend – startet langsam, verlässt schnell)
Bewegen: ease-in-out (natürliche Bewegung)
Kontinuierlich: linear (Drehungen, Fortschritt)
4. STAFFELUNG:
30-80ms zwischen Listenelementen (schneller bei mehr Elementen)
Maximale Gesamtdauer der Staffelung: ~500ms (selbst bei 20+ Elementen)
Checkliste für die Animationsarchitektur
- Animationstool basierend auf Komplexitätsanforderungen ausgewählt
- CSS-Übergänge für einfache Hover-/Fokus-Effekte verwendet
- CSS @keyframes für sich wiederholende und Ladeanimationen verwendet
- Framer Motion oder Äquivalent für Ein-/Ausgangs-/Layout-Animationen verwendet
- GSAP für komplexe Zeitachsenabläufe reserviert
- Alle Animationen halten 60fps (in DevTools verifiziert)
- Nur transform und opacity werden animiert (keine Layout-Eigenschaften)
- prefers-reduced-motion global respektiert
- Animationsdauern folgen UX-Richtlinien (100-500ms)
- Staffelungszeit auf angemessene Gesamtdauer begrenzt
- Jede Animation hat einen klaren Zweck (nicht dekorativ)
- Federphysik für interaktive/Gesten-Animationen verwendet
- Scroll-gesteuerte Animationen verwenden CSS-API, wo unterstützt
- GSAP-Animationen beim Unmounten der Komponente bereinigt
- will-change nur während aktiver Animation verwendet
Verwendungshinweise
Diesen Skill verwenden, wenn:
- Lösungen für das Design oder die Implementierung von Animationen entworfen werden
- Vorhandene Ansätze für Animationen überprüft oder verbessert werden
- Architektur- oder Implementierungsentscheidungen zu Animationen getroffen werden
- Muster und Best Practices für Animationen erlernt werden
- Probleme im Zusammenhang mit Animationen behoben werden
Diesen Skill NICHT verwenden, wenn:
- Die Frage eine grundlegend andere Technologiedomäne betrifft
- Ein spezifischerer verwandter Skill das genaue Thema abdeckt
- Der Benutzer ein vollständiges praktisches Tutorial anstatt fachkundiger Beratung benötigt
Ausgabeformat
# Analyse des Animationsdesigns
## Kontextbewertung
[Situationszusammenfassung und Einschränkungen]
## Empfohlener Ansatz
[Primäre Empfehlung mit Begründung]
## Implementierungsschritte
1. [Schritt mit spezifischen Details]
2. [Schritt mit spezifischen Details]
3. [Schritt mit spezifischen Details]
## Kompromisse und Überlegungen
- [Wichtiger Kompromiss 1]
- [Wichtiger Kompromiss 2]
## Nächste Schritte
- [Sofortiger Aktionspunkt]
- [Folge-Aktionspunkt]
Beispiel
Eingabe: "Hilf mir, den Animationsdesigner für eine mittelgroße Produktionsanwendung zu implementieren"
Ausgabe: Eine strukturierte Analyse, die die aktuelle Zustandsbewertung, den empfohlenen Ansatz für den Animationsdesigner mit spezifischen Mustern, einen Implementierungsfahrplan mit Meilensteinen und Strategien zur Risikominderung umfasst, die auf den Anwendungsumfang und die Einschränkungen zugeschnitten sind.
Grenzfälle
- Integration in Altsysteme: Wenn der Animationsdesigner mit Altan-sätzen koexistieren muss, einen schrittweisen Migrationspfad anstelle einer vollständigen Neuimplementierung empfehlen
- Maßstabs-Diskrepanz: Wenn die Komplexität der Lösung den Projektumfang übersteigt, einen einfacheren Ansatz empfehlen und darauf hinweisen, wann dieser erneut überprüft werden sollte
- Qualifikationslücken im Team: Wenn dem Team die Erfahrung mit dem empfohlenen Ansatz fehlt, Lernressourcen und einfachere Alternativen einbeziehen
- Widersprüchliche Anforderungen: Wenn Einschränkungen in Konflikt stehen (z. B. Leistung vs. Wartbarkeit), den Kompromiss explizit benennen und basierend auf den genannten Prioritäten empfehlen