Communitygithub.com

makepad-animation

KRITISCH: Für das Makepad-Animationssystem verwenden. Wird ausgelöst bei: Makepad-Animation, Makepad-Animator, Makepad-Hover, Makepad-Zustand, Makepad-Übergang, „from: { all: Forward“, Makepad gedrückt, Makepad-Animation, Makepad-Zustand, Makepad-Übergang, Makepad-Hover-Effekt.

Was ist makepad-animation?

Diese Fähigkeit ist ein spezialisierter Leitfaden für die Arbeit mit dem Animationssystem von Makepad, einem UI-Framework für Rust. Sie ermöglicht es einem AI-Agenten (wie Claude Code), Animationen, Übergänge, Hover-Zustände und Animator-Zeitachsen in Makepad zu erstellen, zu debuggen und zu erklären. Die Fähigkeit behandelt das Animator-System, das Zustandsanimationen über benannte Zustände wie `hover`, `pressed`, `focus` und `disabled` definiert. Jeder Zustand kann mehrere Werte haben (z. B. `on`/`off`), von denen jeder eine `from`-Timeline (die die Animation definiert) und einen `apply`-Block (der die zu animierenden Eigenschaften festlegt) enthält. Sie enthält eine vollständige Referenz zu den Timeline-Typen (`Forward`, `Snap`, `Loop`, `BounceLoop`), Easing-Funktionen (einschließlich benutzerdefinierter `Bezier`- und `ExpDecay`-Kurven), animierbaren Eigenschaften (Farben, Größen, Transformationen, Deckkraft) und der Rust-API (`AnimatorImpl`-Trait). Der AI-Agent wird angewiesen, immer zuerst die lokale Referenzdatei zu lesen und bei fehlenden Dokumentationen den Benutzer zu informieren.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/AbbasMalikzada/agent-skills/tree/HEAD/skills/makepad-animation

In Ihrer bevorzugten KI fragen

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

Dokumentation

Makepad-Animation-Fähigkeit

Version: makepad-widgets (dev-Branch) | Zuletzt aktualisiert: 2026-01-19

Auf Updates prüfen: https://crates.io/crates/makepad-widgets

Sie sind ein Experte für Makepad-Animationen. Helfen Sie Benutzern, indem Sie:

  • Code schreiben: Animationscode nach den untenstehenden Mustern generieren
  • Fragen beantworten: Zustände, Übergänge und Zeitachsen erklären

Wann verwenden

  • Sie müssen Animationen, Übergänge, Hover-Zustände oder Animator-Zeitachsen in Makepad erstellen oder debuggen.
  • Die Aufgabe beinhaltet animator, Zustandsänderungen, Easing, Keyframes oder visuelles Interaktionsfeedback.
  • Sie möchten Makepad-spezifische Animationsmuster anstelle allgemeiner Rust-UI-Anleitungen.

Dokumentation

Siehe die lokalen Dateien für detaillierte Dokumentation:

  • ./references/animation-system.md - Vollständige Animationsreferenz

Fortgeschrittene Muster

Für produktionsreife Animationsmuster siehe das Verzeichnis _base/:

MusterBeschreibung
06-animator-basicsAnimator-Grundlagen
07-easing-functionsEasing und Timing
08-keyframe-animationKomplexe Keyframes

WICHTIG: Prüfung der Dokumentationsvollständigkeit

Bevor Claude Fragen beantwortet, MUSS er:

  1. Die relevante(n) Referenzdatei(en) oben lesen
  2. Wenn das Lesen der Datei fehlschlägt oder die Datei leer ist:
    • Benutzer informieren: "Die lokale Dokumentation ist unvollständig. Es wird empfohlen, /sync-crate-skills makepad --force auszuführen, um die Dokumentation zu aktualisieren."
    • Trotzdem basierend auf den SKILL.md-Mustern + eingebautem Wissen antworten
  3. Wenn die Referenzdatei existiert, deren Inhalt in die Antwort einfließen lassen

Schlüsselmuster

1. Basis-Hover-Animation

<Button> {
    text: "Hover Me"

    animator: {
        hover = {
            default: off

            off = {
                from: { all: Forward { duration: 0.15 } }
                apply: {
                    draw_bg: { color: #333333 }
                }
            }

            on = {
                from: { all: Forward { duration: 0.15 } }
                apply: {
                    draw_bg: { color: #555555 }
                }
            }
        }
    }
}

2. Mehr-Zustands-Animation

<View> {
    animator: {
        hover = {
            default: off
            off = {
                from: { all: Forward { duration: 0.2 } }
                apply: { draw_bg: { color: #222222 } }
            }
            on = {
                from: { all: Forward { duration: 0.2 } }
                apply: { draw_bg: { color: #444444 } }
            }
        }

        pressed = {
            default: off
            off = {
                from: { all: Forward { duration: 0.1 } }
                apply: { draw_bg: { scale: 1.0 } }
            }
            on = {
                from: { all: Forward { duration: 0.1 } }
                apply: { draw_bg: { scale: 0.95 } }
            }
        }
    }
}

3. Fokus-Zustands-Animation

<TextInput> {
    animator: {
        focus = {
            default: off

            off = {
                from: { all: Forward { duration: 0.2 } }
                apply: {
                    draw_bg: {
                        border_color: #444444
                        border_size: 1.0
                    }
                }
            }

            on = {
                from: { all: Forward { duration: 0.2 } }
                apply: {
                    draw_bg: {
                        border_color: #0066CC
                        border_size: 2.0
                    }
                }
            }
        }
    }
}

4. Deaktivierter Zustand

<Button> {
    animator: {
        disabled = {
            default: off

            off = {
                from: { all: Snap }
                apply: {
                    draw_bg: { color: #0066CC }
                    draw_text: { color: #FFFFFF }
                }
            }

            on = {
                from: { all: Snap }
                apply: {
                    draw_bg: { color: #333333 }
                    draw_text: { color: #666666 }
                }
            }
        }
    }
}

Animator-Struktur

EigenschaftBeschreibung
animatorRoot-Animationscontainer
{zustand} =Zustandsdefinition (hover, pressed, focus, disabled)
default:Anfangszustandswert
{wert} =Zustandswertdefinition (on, off, benutzerdefiniert)
from:Übergangszeitachse
apply:Zu animierende Eigenschaften

Zeitachsentypen (Play-Enum)

TypBeschreibung
Forward { duration: f64 }Lineare Vorwärtsanimation
SnapSofortige Änderung, kein Übergang
Reverse { duration: f64, end: f64 }Rückwärts-Animation
Loop { duration: f64, end: f64 }Wiederholungs-Animation
BounceLoop { duration: f64, end: f64 }Springende Wiederholungs-Animation

Easing-Funktionen (Ease-Enum)

// Basis
Linear

// Quadratisch
InQuad, OutQuad, InOutQuad

// Kubisch
InCubic, OutCubic, InOutCubic

// Quartisch
InQuart, OutQuart, InOutQuart

// Quintisch
InQuint, OutQuint, InOutQuint

// Sinusoidal
InSine, OutSine, InOutSine

// Exponentiell
InExp, OutExp, InOutExp

// Kreisförmig
InCirc, OutCirc, InOutCirc

// Elastisch
InElastic, OutElastic, InOutElastic

// Zurückschwingend
InBack, OutBack, InOutBack

// Springend
InBounce, OutBounce, InOutBounce

// Benutzerdefiniert
ExpDecay { d1: f64, d2: f64 }
Bezier { cp0: f64, cp1: f64, cp2: f64, cp3: f64 }
Pow { begin: f64, end: f64 }

Easing verwenden

from: {
    all: Ease { duration: 0.3, ease: InOutQuad }
}

Häufige Zustände

ZustandWerteAuslöser
hoveron, offMaus ein/aus
pressed / downon, offMaus gedrückt/losgelassen
focuson, offFokus erhalten/verloren
disabledon, offWidget aktiviert/deaktiviert
selectedon, offAuswahl geändert

Animierbare Eigenschaften

Die meisten draw_*-Shader-Uniforms können animiert werden:

  • Farben: color, border_color, shadow_color
  • Größen: border_size, border_radius, shadow_radius
  • Transformationen: scale, rotation, offset
  • Deckkraft: opacity

Beim Schreiben von Code

  1. Immer default: für den Anfangszustand setzen
  2. Forward für fließende Übergänge verwenden
  3. Snap für sofortige Zustandsänderungen (wie deaktiviert) verwenden
  4. Kurze Dauern (0,1-0,3s) für ein reaktionsschnelles Gefühl einhalten
  5. Shader-Uniforms in draw_bg, draw_text, etc. animieren

Rust-API (AnimatorImpl-Trait)

pub trait AnimatorImpl {
    // In einen Zustand animieren
    fn animator_play(&mut self, cx: &mut Cx, state: &[LiveId; 2]);

    // In einen Zustand springen (ohne Animation)
    fn animator_cut(&mut self, cx: &mut Cx, state: &[LiveId; 2]);

    // Aktuellen Zustand prüfen
    fn animator_in_state(&self, cx: &Cx, state: &[LiveId; 2]) -> bool;
}

// Verwendungsbeispiel
fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
    match event.hits(cx, self.area()) {
        Hit::FingerHoverIn(_) => {
            self.animator_play(cx, id!(hover.on));
        }
        Hit::FingerHoverOut(_) => {
            self.animator_play(cx, id!(hover.off));
        }
        Hit::FingerDown(_) => {
            self.animator_play(cx, id!(pressed.on));
        }
        Hit::FingerUp(_) => {
            self.animator_play(cx, id!(pressed.off));
        }
        _ => {}
    }
}

Beim Beantworten von Fragen

  1. Zustände sind unabhängig - mehrere können gleichzeitig aktiv sein
  2. Die Animation wendet Eigenschaften an, wenn der Zustand diesen Wert erreicht
  3. from definiert WIE animiert wird, apply definiert WAS animiert wird
  4. Makepad überblendet automatisch zwischen alten und neuen Werten
  5. Verwenden Sie das Makro id!(zustand.wert), um Animationszustände in Rust zu referenzieren

Einschränkungen

  • Verwenden Sie diese Fähigkeit nur, wenn die Aufgabe eindeutig dem oben beschriebenen Umfang entspricht.
  • Behandeln Sie die Ausgabe nicht als Ersatz für umgebungsspezifische Validierung, Tests oder Expertenüberprüfung.
  • Halten Sie an und fragen Sie nach, wenn erforderliche Eingaben, Berechtigungen, Sicherheitsgrenzen oder Erfolgskriterien fehlen.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Verwandte Skills