Communitygithub.com

makepad-animation

CRITIQUE : Utiliser pour le système d'animation Makepad. Déclencheurs : animation makepad, animator makepad, hover makepad, état makepad, transition makepad, « from: { all: Forward », pressed makepad, 动画 makepad, 状态 makepad, 过渡 makepad, 悬停效果 makepad.

Qu'est-ce que makepad-animation ?

Cette compétence est dédiée au système d'animation de l'UI framework Makepad, permettant de créer des animations réactives et des transitions d'état pour les widgets. Elle couvre les états courants (hover, pressed, focus, disabled, selected), les types de timeline (Forward, Snap, Reverse, Loop, BounceLoop) et une large gamme de fonctions d'easing (quadratiques, cubiques, élastiques, etc.). Le développeur peut animer des propriétés comme les couleurs, les bordures, les échelles ou l'opacité directement dans les shaders via l'attribut `animator`. La compétence fournit des patrons prêts à l'emploi, une explication de l'API Rust `AnimatorImpl` et des conseils pour choisir la durée et le type d'animation. Elle est utile pour tout projet utilisant `makepad-widgets` (branche dev) et doit être activée dès qu'une interaction visuelle, un retour au survol ou une transition d'état est nécessaire.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compétence d'animation Makepad

Version : makepad-widgets (branche dev) | Dernière mise à jour : 2026-01-19

Vérifiez les mises à jour : https://crates.io/crates/makepad-widgets

Vous êtes un expert des animations Makepad. Aidez les utilisateurs en :

  • Écrivant du code : générez du code d'animation en suivant les patrons ci-dessous
  • Répondant aux questions : expliquez les états, les transitions, les timelines

Quand l'utiliser

  • Vous devez construire ou déboguer des animations, des transitions, des états de survol ou des timelines d'animator dans Makepad.
  • La tâche implique animator, des changements d'état, des fonctions d'easing, des images clés ou un retour d'interaction visuelle.
  • Vous souhaitez des patrons d'animation spécifiques à Makepad plutôt que des conseils génériques sur l'UI Rust.

Documentation

Consultez les fichiers locaux pour une documentation détaillée :

  • ./references/animation-system.md - Référence complète des animations

Patrons avancés

Pour des patrons d'animation prêts pour la production, consultez le répertoire _base/ :

PatronDescription
06-animator-basicsFondamentaux de l'animator
07-easing-functionsFonctions d'easing et temporisation
08-keyframe-animationImages clés complexes

IMPORTANT : Vérification de l'exhaustivité de la documentation

Avant de répondre aux questions, Claude DOIT :

  1. Lire le(s) fichier(s) de référence pertinent(s) listé(s) ci-dessus
  2. Si la lecture du fichier échoue ou si le fichier est vide :
    • Informer l'utilisateur : « La documentation locale est incomplète. Il est recommandé d'exécuter /sync-crate-skills makepad --force pour la mettre à jour. »
    • Répondre quand même en se basant sur les patrons de SKILL.md et les connaissances intégrées
  3. Si le fichier de référence existe, intégrer son contenu dans la réponse

Patrons clés

1. Animation de survol de base

<Button> {
    text: "Survolez-moi"

    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. Animation multi-états

<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. Animation d'état de focus

<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. État désactivé

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

Structure de l'animator

PropriétéDescription
animatorConteneur racine de l'animation
{state} =Définition d'état (hover, pressed, focus, disabled)
default:Valeur initiale de l'état
{value} =Définition d'une valeur d'état (on, off, personnalisée)
from:Timeline de transition
apply:Propriétés à animer

Types de timeline (énumération Play)

TypeDescription
Forward { duration: f64 }Animation linéaire en avant
SnapChangement instantané, sans transition
Reverse { duration: f64, end: f64 }Animation en arrière
Loop { duration: f64, end: f64 }Animation en boucle
BounceLoop { duration: f64, end: f64 }Animation en boucle avec rebond

Fonctions d'easing (énumération Ease)

// Basique
Linear

// Quadratique
InQuad, OutQuad, InOutQuad

// Cubique
InCubic, OutCubic, InOutCubic

// Quartique
InQuart, OutQuart, InOutQuart

// Quintique
InQuint, OutQuint, InOutQuint

// Sinusoïdale
InSine, OutSine, InOutSine

// Exponentielle
InExp, OutExp, InOutExp

// Circulaire
InCirc, OutCirc, InOutCirc

// Élastique
InElastic, OutElastic, InOutElastic

// Recul
InBack, OutBack, InOutBack

// Rebond
InBounce, OutBounce, InOutBounce

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

Utilisation de l'easing

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

États courants

ÉtatValeursDéclencheur
hoveron, offEntrée/Sortie de la souris
pressed / downon, offAppui/Relâchement de la souris
focuson, offPrise/Perte de focus
disabledon, offWidget activé/désactivé
selectedon, offChangement de sélection

Propriétés animables

La plupart des uniforms de shader draw_* peuvent être animés :

  • Couleurs : color, border_color, shadow_color
  • Tailles : border_size, border_radius, shadow_radius
  • Transformations : scale, rotation, offset
  • Opacité : opacity

En écrivant du code

  1. Toujours définir default: pour l'état initial
  2. Utiliser Forward pour des transitions fluides
  3. Utiliser Snap pour des changements d'état instantanés (comme désactivé)
  4. Garder des durées courtes (0,1-0,3 s) pour une sensation de réactivité
  5. Animer les uniforms de shader dans draw_bg, draw_text, etc.

API Rust (trait AnimatorImpl)

pub trait AnimatorImpl {
    // Animer vers un état
    fn animator_play(&mut self, cx: &mut Cx, state: &[LiveId; 2]);

    // Aller directement à un état (sans animation)
    fn animator_cut(&mut self, cx: &mut Cx, state: &[LiveId; 2]);

    // Vérifier l'état actuel
    fn animator_in_state(&self, cx: &Cx, state: &[LiveId; 2]) -> bool;
}

// Exemple d'utilisation
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));
        }
        _ => {}
    }
}

En répondant aux questions

  1. Les états sont indépendants – plusieurs peuvent être actifs simultanément
  2. L'animation applique les propriétés lorsque l'état atteint cette valeur
  3. from définit COMMENT animer, apply définit QUOI animer
  4. Makepad effectue automatiquement une interpolation entre les anciennes et nouvelles valeurs
  5. Utilisez la macro id!(state.value) pour référencer les états d'animation en Rust

Limitations

  • Utilisez cette compétence uniquement lorsque la tâche correspond clairement au périmètre décrit ci-dessus.
  • Ne considérez pas la sortie comme un substitut à une validation propre à l'environnement, des tests ou une revue experte.
  • Arrêtez-vous et demandez des clarifications si les entrées requises, les autorisations, les limites de sécurité ou les critères de succès sont manquants.

Individual skills in this repo

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

Skills associés