Communitygithub.com

remotion-motion-design

Conçoit et implémente des compositions, timelines, systèmes de scènes, animations 2D/3D, typographies, transitions et composants réutilisables avec Remotion.

Qu'est-ce que remotion-motion-design ?

Ce skill permet à un agent IA de concevoir et d'implémenter des animations vidéo complexes avec Remotion, couvrant la création de compositions, la gestion des timelines, les systèmes de scènes, les animations 2D/3D, la typographie, les transitions et les composants réutilisables. Il fournit des directives précises pour garantir une animation déterministe basée sur les images (frames), en utilisant les API officielles de Remotion comme `useCurrentFrame()`, `interpolate()`, `spring()`, ainsi que les composants `Sequence`, `Series`, `Audio`, `Video`, etc. Le skill insiste sur des règles strictes pour éviter les bugs courants, comme le calcul incorrect des frames locales vs globales, l'utilisation de `damping <= 0` qui empêche l'animation de se stabiliser, ou l'absence de gestion des erreurs pour les ressources manquantes. Il supporte les workflows déterministes (pas de `setInterval`, `Date.now()`, ou de données réseau asynchrones) et propose des exemples concrets de routage de frames (routeur global ou `Series`) ainsi que des vérifications qualité avant remise, ce qui le rend idéal pour les projets de motion design professionnels avec Remotion.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/achmdfzn/motionforge-atelier/tree/main/.claude/skills/remotion-motion-design

Demander à votre IA préférée

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

Documentation

REMOTION MOTION DESIGN — Compétence d'implémentation

1. Revue avant de coder

  • Lisez CLAUDE.md, MASTER_PROMPT.md et les documents d'architecture.
  • Vérifiez les versions réelles de Remotion/React/TypeScript et le gestionnaire de paquets.
  • Trouvez le point d'entrée existant et le registre de compositions.
  • Suivez les conventions du dépôt ; ne changez pas les dépendances sans nécessité.
  • Utilisez la sortie de beyond-video, le script, le storyboard et la Style Bible comme spécification de production.
  • Vérifiez les API que vous utilisez par rapport à la source Remotion de la version installée (par ex. packages/core/src dans un clone de référence) avant de vous fier à la mémoire.

2. Profil de composition

Valeurs par défaut :

  • largeur : 1080
  • hauteur : 1920
  • fps : 60
  • aspect : 9:16
  • durée : entier positif en images

Chaque composition a besoin d'un ID unique et de métadonnées explicites. Ne stockez pas différentes valeurs FPS dans plusieurs couches sans raison.

<Composition> accepte id, fps, width, height, durationInFrames, defaultProps, et optionnellement calculateMetadata (durée/métadonnées dynamiques à partir des props) et schema. durationInFrames doit être positif.

3. Ingénierie de la timeline

  • Conservez les durées et les images de début dans des données/config centralisées.
  • Utilisez une seule convention d'intervalle d'images ; [début, fin) est recommandé.
  • La durationInFrames d'une scène doit être positive.
  • Assurez-vous que la durée totale de la composition contient chaque scène plus la fin/clôture.
  • Validez les chevauchements et les lacunes ; chevauchez uniquement lorsque c'est prévu pour une transition/composition.
  • Ne vous fiez pas aux nombres à virgule flottante pour la limite finale de l'image.

4. Animation déterministe — API temps/image (Remotion 4.x)

Sources temporelles :

  • useCurrentFrame() — l'image courante, indexée à partir de 0. Utilisable uniquement à l'intérieur d'un composant de composition ; en dehors d'une composition, elle lance une exception.
  • useVideoConfig() — retourne {width, height, fps, durationInFrames, id, defaultProps, defaultVideoImageFormat, ...} ; lance une exception en dehors d'une composition.

Interpolation et ressort :

  • interpolate(input, inputRange, outputRange, options?) — surcharges pour nombre, chaîne, booléen et tableau en sortie. Options : easing, extrapolateLeft / extrapolateRight ('extend' | 'identity' | 'clamp' | 'wrap'), output, outputType, posterize. Utilisez clamp comme extrapolation lorsque le mouvement ne doit pas dépasser la plage.
  • spring({frame, fps, config?, from=0, to=1, durationInFrames?, durationRestThreshold?, delay=0, reverse=false}). SpringConfig : damping (par défaut 10), mass (1), stiffness (100), overshootClamping (false). damping <= 0 rend l'animation instable (erreur de boucle infinie).
  • measureSpring({fps, config?, threshold=0.005}) — nombre d'images jusqu'à ce que le ressort se stabilise ; threshold=0 donne Infinity.

Règles :

  • Le mouvement doit être une fonction de l'image et des props.
  • Fixez les valeurs de particules/bruit/aléatoire.
  • Évitez setInterval, setTimeout, requestAnimationFrame, Date.now(), et les keyframes CSS auto-exécutés comme source principale du mouvement vidéo.
  • Ne récupérez pas de données réseau pendant le rendu de la composition.
  • N'incluez pas de contenu audio/vidéo provenant d'URL instables ou nécessitant une connexion.
  • delayRender(label?, options?) retient le rendu jusqu'à ce que continueRender(handle) soit appelé (par ex. ressources asynchrones) ; son délai d'attente est défini avec l'option CLI --timeout.

5. Sequence, Series, et images locales vs globales

C'est la règle la plus souvent mal comprise — un vrai bug est survenu une fois parce qu'un composant calculait l'image globale à l'intérieur d'un Series.Sequence :

  • À l'intérieur d'un <Sequence>, useCurrentFrame() retourne l'image RELATIVE au début de la Sequence : (frame - (cumulatedFrom + relativeFrom)) * playbackRate. Les composants à l'intérieur d'une Sequence ne voient PAS l'image globale.
  • Props de <Sequence> : from?, name?, durationInFrames? (doit être positif ; requis avec loop), layout ('absolute-fill' | 'none'), premountFor, loop, et les props de recadrage (uniquement avec layout="absolute-fill").
  • <Series.Sequence> peut UNIQUEMENT être utilisé à l'intérieur de <Series> ; un Series.Sequence en dehors de <Series> lance une exception "This component must be inside a <Series /> component."
  • Deux modèles de routage valides — choisissez-en un et restez cohérent :
    • Routeur d'image global (utilisé dans le projet vidéo) : un composant routeur utilise useCurrentFrame() global et sélectionne le beat par sa plage [début, fin) ; les composants de beat calculent à partir de l'image globale.
    • Series : chaque Series.Sequence contient un beat ; les composants de beat calculent à partir de l'image locale (0 au début de la Sequence).
  • Ne mélangez pas les deux modèles dans une même composition sans raison explicite.

6. Structure des scènes/composants

  • Une scène a une seule responsabilité narrative/visuelle.
  • Les props de scène sont définies en TypeScript.
  • Les composants réutilisables résolvent une tâche visuelle claire.
  • Évitez qu'un seul fichier ne contienne toute la vidéo.
  • Séparez la configuration du contenu, le moteur de rendu, les tokens de style et les références aux ressources.
  • Ajoutez des solutions de repli conçues pour les ressources optionnelles ; ne cachez jamais une ressource critique manquante.

7. Composants médias et ressources

  • <Img src> — une image qui ne se charge pas sans onError annule le rendu (cancelRender). Fournissez toujours onError pour les ressources critiques, ou assurez-vous que la ressource existe avant le rendu.
  • staticFile(path) — mappe un fichier dans public/ ; utilisez-le pour chaque ressource locale (images, audio, vidéo).
  • <Audio> — voir sound-design pour mapper une feuille de repères aux props (trimBefore/After — alias plus ancien startFrom/endAt — volume, playbackRate). La position d'un repère sur la timeline est définie par <Sequence from> ; les props de recadrage ne coupent que la partie du fichier qui est jouée. <Audio> n'a pas de prop muted ; le silence est un indicateur CLI (--muted).
  • <Video> / <OffthreadVideo> et <Still> suivent les mêmes règles d'images ; la durée des médias doit être planifiée à partir des images, pas des métadonnées du fichier.

8. Animation 2D

Utilisez SVG/formes/CSS/rasters selon les besoins. Tenez compte des ancres, des origines de transformation, de l'anticrénelage, des couches, du clipping et de la zone de sécurité. Chaque transformation doit être pilotée par l'image.

9. Support pixel art et bonhomme allumette

Pixel art :

  • verrouillez le canevas logique et l'échelle des pixels ;
  • utilisez le voisin le plus proche lors du redimensionnement des sprites ;
  • accrochez les positions à la grille si nécessaire ;
  • verrouillez la palette et les dimensions des sprites ;
  • évitez le flou et le scintillement sous-pixel.

Bonhomme allumette :

  • maintenez des proportions et des pivots cohérents ;
  • utilisez une bibliothèque de poses/rigging lorsque l'échelle du projet le justifie ;
  • animez la silhouette et le geste pour qu'ils soient lisibles ;
  • synchronisez les expressions/poses avec les beats de l'histoire.

Pour les cycles de marche, le suivi et le mouvement au repos, voir character-animation.

10. Animation 3D

  • Ajoutez la 3D uniquement lorsqu'elle apporte une valeur créative.
  • Vérifiez les versions de three, @react-three/fiber, @remotion/three et leur documentation.
  • Pour l'intégration ThreeCanvas de Remotion, suivez l'approche pilotée par les images de la version de l'API installée ; ne supposez pas que les motifs R3F en temps réel sont automatiquement déterministes.
  • Pilotez la caméra, les transformations, les matériaux, l'éclairage et les particules à partir de l'image.
  • Tenez compte de la compatibilité du moteur de rendu/sans tête, de la taille des textures, de la géométrie et du coût de calcul.
  • Séparez la couche 3D de la typographie/des superpositions 2D lorsque cela améliore la lisibilité et la maintenabilité.
  • Pour diriger les scènes 3D en détail, voir 3d-scene-director.

11. Typographie et transitions

  • Priorisez la hiérarchie et la lisibilité.
  • Ne couvrez jamais un texte important avec une transition.
  • Chaque transition relie deux beats ; n'ajoutez pas d'effets sans fonction.
  • Maintenez des courbes de mouvement et une intensité cohérentes dans toute la Style Bible.
  • Adaptez la durée du texte aux besoins de lecture.

12. Implémentation de la clôture

Implémentez le logo de clôture + CTA selon le tableau de bord beyond-video. Le logo doit provenir d'une ressource officielle ou d'un placeholder approuvé. Le texte, le timing, le motif et la composition doivent donner l'impression d'être faits pour la vidéo en question.

13. Assurance qualité avant remise

Vérifiez l'ID de la composition, les métadonnées, les plages d'images, les importations, les types, les ressources statiques, les polices, la cohérence du style, la zone de sécurité, la clôture et les licences des ressources. Exécutez les vérifications lint/typecheck/tests disponibles. Ne rendez pas en MP4. Ne commitez pas/poussez pas.

Format de sortie

  • Registre de composition : ID, 1080×1920, 60 FPS, durationInFrames, liste des scènes + plages d'images.
  • API utilisées : nom de l'API + signature pertinente + où elle a été vérifiée (version Remotion installée).
  • Modèle de routage des images : global ou Series — un choix, cohérent dans toute la composition.
  • Registre des ressources : fichier, staticFile, solution de repli/onError par ressource critique.
  • Liste de vérification QA + résultats du typecheck/lint.

Exemple minimal

Routeur d'image global (modèle de projet vidéo) :

const frame = useCurrentFrame();
const beat = BEATS.find((b) => frame >= b.start && frame < b.end);
return (
  <AbsoluteFill>
    {beat?.id === 'S01-B01' && <Hook />}
    {beat?.id === 'S01-B02' && <Problem />}
  </AbsoluteFill>
);

Ressort avec une durée mesurée :

const settle = measureSpring({fps, config: {damping: 12}});
const progress = spring({frame, fps, config: {damping: 12}});

Modes d'échec

  • Un composant à l'intérieur de Series.Sequence calcule l'image globale → mauvais beat, les scènes apparaissent au mauvais moment. Correctif : calculez à partir de l'image locale, ou passez à un routeur d'image global.
  • Series.Sequence utilisé sans <Series> → lance une exception au rendu. Enveloppez-le dans <Series>, ou utilisez <Sequence> directement (pas Series.Sequence).
  • spring avec damping <= 0 → l'animation ne se stabilise jamais. Gardez damping > 0.
  • Image manquante sans onError → le rendu est annulé. Ajoutez onError ou assurez-vous que la ressource existe avant le rendu.
  • useCurrentFrame()/useVideoConfig() en dehors d'une composition → lance une exception. Appelez-les uniquement à l'intérieur des composants de composition.

Individual skills in this repo

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

Skills associés