Communitygithub.com

SwiftUI-Animation

Umfassende Referenz für SwiftUI-Animationen von iOS 13 bis iOS 26. Deckt das Animatable-Protokoll, das @Animatable-Makro, Federn vs. Timingkurven und die Transaktionssystem ab.

Was ist SwiftUI-Animation?

Dieses Skill ist ein umfassender Leitfaden für Entwickler, die SwiftUI-Animationen implementieren, debuggen oder optimieren möchten. Es erklärt die grundlegende Funktionsweise der Interpolation und des VectorArithmetic-Protokolls, auf dem alle Animationen basieren, und zeigt, warum bestimmte Datentypen (wie Int) nicht animiert werden können. Für fortgeschrittene Anwendungen wird detailliert das Animatable-Protokoll behandelt, einschließlich der Kombination mehrerer animierbarer Eigenschaften mit AnimatablePair und der leistungsbewussten Erstellung eigener animierbarer Views. Neuere Entwicklungen werden durch das @Animatable-Makro (verfügbar ab iOS 26) abgedeckt, das den Boilerplate-Code für die Animatable-Konformität drastisch reduziert und die Entwicklererfahrung verbessert. Der Leitfaden behandelt auch die Wahl zwischen Feder- und Timingkurven-Animationen, die Arbeit mit dem Transaction-System und die Implementierung komplexer, mehrstufiger Animationen. Es ist ein wertvolles Werkzeug für alle, die tief in die Materie einsteigen oder schnelle Lösungen für konkrete Animationsprobleme in SwiftUI suchen.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/IGTA-Tech/claude-skills-research/tree/HEAD/Axiom/.claude-plugin/plugins/axiom/skills/swiftui-animation-ref

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht SwiftUI-Animation?

Übersicht

Umfassender Leitfaden zum Animationssystem von SwiftUI, von grundlegenden Konzepten bis zu fortgeschrittenen Techniken. Dieses Skill behandelt das Animatable-Protokoll, das iOS 26 @Animatable-Makro, Animationstypen und das Transaktionssystem.

Kernprinzip Animation in SwiftUI ist mathematische Interpolation über die Zeit, angetrieben durch das VectorArithmetic-Protokoll. Dieses Verständnis erschließt die volle Leistungsfähigkeit des deklarativen Animationssystems von SwiftUI.

Wann dieses Skill verwendet werden sollte

  • Implementierung benutzerdefinierter animierter Views oder Shapes
  • Verstehen, warum eine Eigenschaft nicht animiert wird (Int vs. Float/Double)
  • Wahl zwischen Feder- und Timingkurven-Animationen
  • Verwendung des @Animatable-Makros (iOS 26+)
  • Konformität von Views mit dem Animatable-Protokoll
  • Debugging des Merging-Verhaltens von Animationen
  • Optimierung der Animationsleistung
  • Erstellung von mehrstufigen oder komplexen Animationen
  • Verständnis von Modell- vs. Präsentationswerten
  • Implementierung benutzerdefinierter Animationsalgorithmen

Systemanforderungen

iOS 13+ für Animatable-Protokoll

iOS 17+ für Standard-Feder-Animationen, begrenzte Animationen

iOS 26+ für @Animatable-Makro


Teil 1: Animation verstehen

Was ist Interpolation

Animation ist der Prozess der Generierung von Zwischenwerten zwischen einem Start- und einem Endzustand.

Beispiel: Opazitätsanimation

.opacity(0) → .opacity(1)

Während diese Animation läuft, berechnet SwiftUI Zwischenwerte:

0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0

Wie Werte verteilt werden

  • Bestimmt durch die Timingkurve oder Geschwindigkeitsfunktion der Animation
  • Feder-Animationen nutzen die Physiksimulation
  • Timingkurven nutzen Bézierkurven
  • Jeder Animationstyp berechnet Werte anders

VectorArithmetic-Protokoll

SwiftUI erfordert, dass animierte Daten dem Protokoll VectorArithmetic entsprechen, das Folgendes bereitstellt:

protocol VectorArithmetic {
    // Differenz zwischen zwei Werten berechnen
    static func - (lhs: Self, rhs: Self) -> Self

    // Werte skalieren
    static func * (lhs: Self, rhs: Double) -> Self

    // Werte addieren
    static func + (lhs: Self, rhs: Self) -> Self

    // Nullwert
    static var zero: Self { get }
}

Integrierte konforme Typen

  • 1-dimensional: CGFloat, Double, Float, Angle
  • 2-dimensional: CGPoint, CGSize
  • 4-dimensional: CGRect

Wichtige Erkenntnis Die Vektorarithmetik abstrahiert die Dimensionalität animierter Daten. SwiftUI kann alle diese Typen mit einer einzigen generischen Implementierung animieren.

Warum Int nicht animiert werden kann

Int entspricht nicht VectorArithmetic, weil:

  1. Keine gebrochenen Zwischenwerte — Es gibt keine „3,5“ zwischen 3 und 4
  2. Nicht stetig — Ganzzahlen sind diskrete Werte
  3. Skalierung ist sinnlos — Was bedeutet 5 × 0,5 für eine ganze Zahl?

Was passiert, wenn man es versucht

struct CounterView: View {
    @State private var count: Int = 0

    var body: some View {
        Text("\(count)")
            .animation(.spring, value: count)
    }
}

Ergebnis: SwiftUI ersetzt einfach den alten Text durch den neuen. Es findet keine Interpolation statt.

Lösung: Verwende Float oder Double

struct AnimatedCounterView: View {
    @State private var count: Float = 0

    var body: some View {
        Text("\(Int(count))")
            .animation(.spring, value: count)
    }
}

Ergebnis: SwiftUI interpoliert 0.0 → ... → 100.0, und du zeigst die gerundete Ganzzahl bei jedem Frame an.

Modell- vs. Präsentationswerte

Animierbare Attribute haben konzeptionell zwei Werte:

Modellwert

  • Der Zielwert, der von Ihrem Code gesetzt wird
  • Wird sofort aktualisiert, wenn sich der Zustand ändert
  • Was Sie in den Body Ihrer View schreiben

Präsentationswert

  • Der aktuell interpolierte Wert, der gerendert wird
  • Aktualisiert sich Frame für Frame während der Animation
  • Was der Benutzer tatsächlich sieht

Beispiel

.scaleEffect(selected ? 1.5 : 1.0)

Wenn selected true wird:

  • Modellwert: Wird sofort zu 1.5
  • Präsentationswert: Interpoliert 1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5 über die Zeit

Teil 2: Animatable-Protokoll

Übersicht

Das Animatable-Protokoll erlaubt es Views, ihre Eigenschaften zu animieren, indem es definiert, welche Daten interpoliert werden sollen.

protocol Animatable {
    associatedtype AnimatableData: VectorArithmetic

    var animatableData: AnimatableData { get set }
}

SwiftUI erstellt ein animierbares Attribut für jede View, die diesem Protokoll entspricht.

Integrierte animierbare Views

Viele SwiftUI-Modifier entsprechen Animatable:

Visuelle Effekte

  • .scaleEffect() — Animiert die Skalierungstransformation
  • .rotationEffect() — Animiert die Rotation
  • .offset() — Animiert den Positionsversatz
  • .opacity() — Animiert die Transparenz
  • .blur() — Animiert den Weichzeichnungsradius
  • .shadow() — Animiert Schatteneigenschaften

Alle Shape-Typen

  • Circle, Rectangle, RoundedRectangle
  • Capsule, Ellipse, Path
  • Benutzerdefinierte Shape-Implementierungen

AnimatablePair für mehrdimensionale Daten

Verwende AnimatablePair, um mehrere Eigenschaften zu animieren und Vektoren zu kombinieren.

Beispiel: scaleEffect-Implementierung

struct ScaleEffectModifier: ViewModifier, Animatable {
    var scale: CGSize
    var anchor: UnitPoint

    // Kombiniere zwei 2D-Vektoren zu einem 4D-Vektor
    var animatableData: AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData> {
        get {
            AnimatablePair(scale.animatableData, anchor.animatableData)
        }
        set {
            scale.animatableData = newValue.first
            anchor.animatableData = newValue.second
        }
    }

    func body(content: Content) -> some View {
        content.scaleEffect(scale, anchor: anchor)
    }
}

Wie es funktioniert

  • CGSize ist 2-dimensional (Breite, Höhe)
  • UnitPoint ist 2-dimensional (x, y)
  • AnimatablePair vereint sie zu einem 4-dimensionalen Vektor
  • SwiftUI interpoliert alle 4 Werte zusammen

Benutzerdefinierte Animatable-Konformität

Wann verwenden

  • Animation benutzerdefinierter Layouts (wie RadialLayout)
  • Animation benutzerdefinierten Zeichencodes
  • Animation von Eigenschaften, die Shape-Pfade beeinflussen

Beispiel: Animierte Zahlenansicht

struct AnimatableNumberView: View, Animatable {
    var number: Double

    var animatableData: Double {
        get { number }
        set { number = newValue }
    }

    var body: some View {
        Text("\(Int(number))")
            .font(.largeTitle)
    }
}

// Verwendung
AnimatableNumberView(number: value)
    .animation(.spring, value: value)

Wie es funktioniert

  1. number ändert sich von 0 auf 100
  2. SwiftUI ruft body für jeden Frame der Animation auf
  3. Jeder Frame erhält einen neuen number-Wert: 0 → 5 → 15 → 30 → 55 → 80 → 100
  4. Text wird aktualisiert, um den interpolierten Integer anzuzeigen

Leistungswarnung

Benutzerdefinierte Animatable-Konformität kann teuer sein.

Wenn Sie eine View konform zu Animatable machen:

  • SwiftUI ruft den body Ihrer View für jeden Frame der Animation auf
  • Layout wird bei jedem Frame neu berechnet
  • Dies geschieht auf dem Hauptthread

Integrierte animierbare Effekte (wie .scaleEffect(), .opacity()) sind viel effizienter:

  • Sie laufen außerhalb des Hauptthreads
  • Sie rufen den body Ihrer View nicht auf
  • Sie aktualisieren nur die Rendering-Ebene

Richtlinie

  • Verwende nach Möglichkeit integrierte Effekte
  • Verwende benutzerdefinierte Animatable-Konformität nur, wenn du den Effekt nicht mit integrierten Modifiern erzielen kannst
  • Bei Leistungsproblemen mit Instruments profilieren

Beispiel: Kreis-Layout-Animation

// Dies ist teuer, aber notwendig, um entlang eines kreisförmigen Pfades zu animieren
@Animatable
struct RadialLayout: Layout {
    var offsetAngle: Angle

    var animatableData: Angle.AnimatableData {
        get { offsetAngle.animatableData }
        set { offsetAngle.animatableData = newValue }
    }

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        proposal.replacingUnspecifiedDimensions()
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let radius = min(bounds.width, bounds.height) / 2
        let center = CGPoint(x: bounds.midX, y: bounds.midY)
        let angleStep = Angle.degrees(360.0 / Double(subviews.count))

        for (index, subview) in subviews.enumerated() {
            let angle = offsetAngle + angleStep * Double(index)
            let x = center.x + radius * cos(angle.radians)
            let y = center.y + radius * sin(angle.radians)

            subview.place(at: CGPoint(x: x, y: y), anchor: .center, proposal: .unspecified)
        }
    }
}

Warum notwendig: Das Animieren von offsetAngle erfordert eine Neuberechnung der Positionen bei jedem Frame. Kein integrierter Modifier kann dies leisten.


Teil 3: @Animatable-Makro (iOS 26+)

Übersicht

Das @Animatable-Makro eliminiert den Boilerplate-Code für die manuelle Konformität mit dem Animatable-Protokoll.

Vor iOS 26 musstest du:

  1. Manuell Animatable konform machen
  2. animatableData-Getter und -Setter schreiben
  3. AnimatablePair für mehrere Eigenschaften verwenden
  4. Nicht animierbare Eigenschaften manuell ausschließen

iOS 26+ fügst du einfach @Animatable hinzu:

@MainActor
@Animatable
struct MyView: View {
    var scale: CGFloat
    var opacity: Double

    var body: some View {
        // ...
    }
}

Das Makro automatisiert:

  • Generiert die Animatable-Konformität
  • Untersucht alle gespeicherten Eigenschaften
  • Erstellt animatableData aus VectorArithmetic-konformen Eigenschaften
  • Behandelt mehrdimensionale Daten mit AnimatablePair

Vorher/Nachher-Vergleich

Vor @Animatable-Makro

struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double
    var drawingDirection: Bool // Soll nicht animiert werden

    // Mühsame manuelle animatableData-Deklaration
    var animatableData: AnimatablePair<AnimatablePair<CGFloat, CGFloat>,
                        AnimatablePair<Double, AnimatablePair<CGFloat, CGFloat>>> {
        get {
            AnimatablePair(
                AnimatablePair(startPoint.x, startPoint.y),
                AnimatablePair(elevation, AnimatablePair(endPoint.x, endPoint.y))
            )
        }
        set {
            startPoint = CGPoint(x: newValue.first.first, y: newValue.first.second)
            elevation = newValue.second.first
            endPoint = CGPoint(x: newValue.second.second.first, y: newValue.second.second.second)
        }
    }

    func path(in rect: CGRect) -> Path {
        // Zeichencode
    }
}

Nach @Animatable-Makro

@Animatable
struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double

    @AnimatableIgnored
    var drawingDirection: Bool // Von der Animation ausgeschlossen

    func path(in rect: CGRect) -> Path {
        // Zeichencode
    }
}

Codezeilen: 20 → 12 (40 % Reduzierung)

@AnimatableIgnored

Verwende @AnimatableIgnored, um Eigenschaften von der Animation auszuschließen.

Wann verwenden

  • Debug-Werte — Flags nur für die Entwicklung
  • IDs — Bezeichner, die nicht animiert werden sollen
  • Zeitstempel — Wann die View erstellt/aktualisiert wurde
  • Interner Zustand — Nicht-visuelle Buchhaltung
  • Nicht-VectorArithmetic-Typen — Farben, Zeichenketten, Boolesche Werte

Beispiel

@MainActor
@Animatable
struct ProgressView: View {
    var progress: Double // Animiert
    var totalItems: Int // Animiert (wenn Float, nicht wenn Int)

    @AnimatableIgnored
    var title: String // Nicht animiert

    @AnimatableIgnored
    var startTime: Date // Nicht animiert

    @AnimatableIgnored
    var debugEnabled: Bool // Nicht animiert

    var body: some View {
        VStack {
            Text(title)
            ProgressBar(value: progress)
            if debugEnabled {
                Text("Gestartet: \(startTime.formatted())")
            }
        }
    }
}

Anwendungsfälle aus der Praxis

Numerische Animationen sind in allen App-Kategorien sehr verbreitet:

Fintech-Apps

@MainActor
@Animatable
struct StockPriceView: View {
    var price: Double
    var changePercent: Double

    var body: some View {
        VStack(alignment: .trailing) {
            Text("$\(price, format: .number.precision(.fractionLength(2)))")
                .font(.title)
            Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
                .foregroundColor(changePercent > 0 ? .green : .red)
        }
    }
}

Anwendungsfall: Aktienkursänderungen, Portfoliowert, Kontostand-Übergänge animieren

Gesundheit & Fitness

@MainActor
@Animatable
struct HeartRateView: View {
    var bpm: Double

    @AnimatableIgnored
    var timestamp: Date

    var body: some View {
        VStack {
            Text("\(Int(bpm))")
                .font(.system(size: 60, weight: .bold))
            Text("BPM")
                .font(.caption)
                .foregroundColor(.secondary)
        }
    }
}

Anwendungsfall: Herzfrequenzanzeigen, Schrittzähler, Kalorienberechnungen, zurückgelegte Strecke

Spiele

@MainActor
@Animatable
struct ScoreView: View {
    var score: Float
    var multiplier: Float

    var body: some View {
        HStack {
            Text("\(Int(score))")
                .font(.largeTitle)
            Text("×\(multiplier, format: .number.precision(.fractionLength(1)))")
                .font(.title2)
                .foregroundColor(.orange)
        }
    }
}

Anwendungsfall: Punktzahlenanimationen, XP-Übergänge, Level-Fortschritt, Combo-Multiplikatoren

Produktivitäts-Apps

@MainActor
@Animatable
struct TimerView: View {
    var remainingSeconds: Double

Individual skills in this repo

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

IGTA-Tech/claude-skills-research

Use when localizing apps, using String Catalogs, generating type-safe symbols (Xcode 26+), handling plurals, RTL layouts, locale-aware formatting, or migrating from .strings files - comprehensive i18n patterns for Xcode 15-26

IGTA-Tech/claude-skills-research

Use when CAAnimation completion handler doesn't fire, spring physics look wrong on device, animation duration mismatches actual time, gesture + animation interaction causes jank, or timing differs between simulator and real hardware - systematic CAAnimation diagnosis with CATransaction patterns, frame rate awareness, and device-specific behavior

IGTA-Tech/claude-skills-research

This skill should be used when comparing two videos to analyze compression results or quality differences. Generates interactive HTML reports with quality metrics (PSNR, SSIM) and frame-by-frame visual comparisons. Triggers when users mention "compare videos", "video quality", "compression analysis", "before/after compression", or request quality assessment of compressed videos.

IGTA-Tech/claude-skills-research

Download YouTube videos and HLS streams (m3u8) from platforms like Mux, Vimeo, etc. using yt-dlp and ffmpeg. Use this skill when users request downloading videos, extracting audio, handling protected streams with authentication headers, or troubleshooting download issues like nsig extraction failures, 403 errors, or cookie extraction problems.

IGTA-Tech/claude-skills-research

Write high-converting landing page copy using proven frameworks like PAS (Problem-Agitate-Solution), AIDA, and StoryBrand. Creates headlines, value propositions, CTAs, and full page sections optimized for conversion. Use when users need landing page copy, sales page content, or marketing website text.

IGTA-Tech/claude-skills-research

Downloads videos from YouTube and other platforms for offline viewing, editing, or archival. Handles various formats and quality options.

IGTA-Tech/claude-skills-research

Download YouTube video transcripts when user provides a YouTube URL or asks to download/get/fetch a transcript from YouTube. Also use when user wants to transcribe or get captions/subtitles from a YouTube video.

Verwandte Skills