Communitygithub.com

Hownameee/courtes-vidéos

Bonnes pratiques pour le contenu, l'animation et les effets

Qu'est-ce que courtes-vidéos ?

Ce fichier de compétence (skill) fournit des directives complètes pour créer du contenu vidéo avec Remotion en utilisant React et du balisage JSX. Il est conçu pour les développeurs qui construisent des vidéos animées et interactives, en particulier dans l'éditeur Studio de Remotion. Le fichier détaille l'utilisation de `useCurrentFrame()` et `interpolate()` pour les animations, en mettant en garde contre les transitions CSS ou les classes Tailwind qui ne sont pas prises en charge. Il insiste sur l'utilisation de composants interactifs (`Interactive.withSchema`) pour des scènes réutilisables et modifiables, et sur le prémontage (`premountFor`) pour garantir un rendu fluide des médias et des animations. Enfin, il fournit des exemples de code, des bonnes pratiques pour l'organisation des ressources, et des références vers des fichiers spécialisés pour les transitions, les effets, la 3D, les sous-titres, et bien plus encore.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Hownameee/short-videos/tree/HEAD/.agent/skills/remotion-markup

Demander à votre IA préférée

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

Aperçu

Depuis le README du skill

Documentation

Ceci est un guide pour écrire du balisage Remotion React. Si ce n'est pas pertinent, chargez plutôt les bonnes pratiques Remotion.

Préserver les modifications de l'utilisateur

Les utilisateurs peuvent apporter des modifications au code en dehors de la conversation.

Si vous détectez un changement surprenant effectué entre-temps, ne l'écrasez pas, supposez qu'il était intentionnel ou demandez une confirmation.

Règles générales

Conduisez les animations en utilisant useCurrentFrame() et interpolate(). Les transition ou animation CSS ne seront pas rendues correctement, elles doivent être refactorisées. Les classes d'animation Tailwind ne seront pas rendues correctement, elles doivent être refactorisées.

Utilisez Easing.bezier() et Easing.spring() pour personnaliser le timing.

Structurez votre balisage conformément aux meilleures pratiques d'interactivité Remotion. Préférez Interactive.withSchema({wrapInSequence: true}) pour les composants visuels personnalisés avec des propriétés modifiables, et enregistrez les scènes réutilisables en tant que compositions connectées. Placez le timing directement sur les composants qui le supportent ; évitez les wrappers <Sequence> redondants. Donnez à chaque composant temporisé qui supporte premountFor une seconde de prémontage : premountFor={fps}, où fps provient de useVideoConfig(). Appliquez ceci aux médias, composants interactifs, <Sequence>, <Series.Sequence>, <TransitionSeries.Sequence>, et <TransitionSeries.Overlay>, y compris les composants temporisés imbriqués dans les scènes. Prémontez également l'élément de la timeline parent lorsqu'un élément imbriqué doit être monté avant que le parent ne commence. Un composant sans premountFor, comme <TransitionSeries.Transition>, n'a pas besoin de substitut.

Le Studio édite le nœud source JSX qui a créé un élément. Rédigez chaque enregistrement de composition, clip, scène, couche et séquence qui doit être modifiable indépendamment en tant que son propre nœud JSX, avec ses propriétés modifiables en ligne. Les boucles programmatiques sont appropriées lorsque les instances générées sont intentionnellement contrôlées comme un seul modèle source, pas lorsque les utilisateurs ont besoin de modifier les instances séparément.

import { useCurrentFrame, useVideoConfig, Easing, interpolate, Interactive } from "remotion";

export const FadeIn = () => {
  const frame = useCurrentFrame();
  const {fps} = useVideoConfig();

  return (
    <Interactive.Div
      name="Title"
      premountFor={fps}
      style={{
        opacity: interpolate(frame, [0, 2 * fps], [0, 1], {
          extrapolateRight: "clamp",
          extrapolateLeft: "clamp",
          easing: Easing.bezier(0.16, 1, 0.3, 1),
        }),
      }}
    >
      Hello World!
    </Interactive.Div>
  );
};

Gardez l'appel interpolate() en ligne dans la propriété style. Utilisez les propriétés CSS scale, translate, rotate plutôt que transform.

// 👍 Images clés modifiables en ligne et raccourcis de transformation
style={{
  scale: interpolate(frame, [0, 100], [0, 1], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
    output: 'perceptual-scale' // Pour les animations `scale`, utilisez "output: 'perceptual-scale'"
  }),
  translate: interpolate(frame, [0, 100], ["0px 0px", "100px 100px"], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
  }),
  rotate: interpolate(frame, [0, 100], ["20deg", "90deg"], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
  }),
}}

// 👎 Les valeurs non en ligne et les chaînes de transformation deviennent plus difficiles à éditer dans Studio
const scale = interpolate(frame, [0, 100], [0, 1]);

style={{
  transform: `scale(${scale})`,
}}

Ressources

Placez les ressources dans le dossier public/ à la racine de votre projet. Utilisez staticFile() pour référencer les fichiers du dossier public/.

Composants médias

Ajoutez de la vidéo et de l'audio en utilisant <Video> et <Audio> depuis @remotion/media. Ajoutez des images en utilisant le composant <CanvasImage>. Ajoutez des GIFs animés, APNG, WebP ou AVIF en utilisant <AnimatedImage>, utilisez @remotion/gif si vous n'utilisez pas Chrome. Utilisez staticFile() pour les fichiers dans public/ ou passez une URL distante directement :

import { Audio, Video } from "@remotion/media";
import { staticFile, CanvasImage, AnimatedImage, useVideoConfig } from "remotion";

export const MyComposition = () => {
  const {fps} = useVideoConfig();

  return (
    <>
      <Video src={staticFile("video.mp4")} premountFor={fps} style={{ opacity: 0.5 }} />
      <Audio src={staticFile("audio.mp3")} premountFor={fps} />
      <CanvasImage
        src={staticFile("logo.png")}
        premountFor={fps}
        style={{ width: 100, height: 100 }}
      />
      <Video src="https://remotion.media/video.mp4" premountFor={fps} />
      <AnimatedImage src={staticFile('nyancat.gif')} premountFor={fps} />
    </>
  );
};

Si la composition est principalement une timeline de clips vidéo ou audio, lisez video-editing.md avant de choisir sa structure source.

Exemple de scène

Une vidéo d'arrière-plan avec un tiers inférieur. Le tiers inférieur est un composant interactif avec sa propre timeline, enregistré comme une composition connectée. Son texte est passé comme children et accentColor est une propriété modifiable. L'apparition en fondu est animée par images clés en ligne sur le site d'appel.

// MyScene.tsx
import { Video } from "@remotion/media";
import { Easing, interpolate, useCurrentFrame, useVideoConfig } from "remotion";
import { LowerThird } from "./LowerThird";

export const MyScene = () => {
  const { fps } = useVideoConfig();
  const frame = useCurrentFrame();

  return (
    <>
      <Video
        name="Background"
        src="https://remotion.media/video.mp4"
        premountFor={fps}
        objectFit="cover"
        style={{
          position: "absolute",
          width: "100%",
          height: "100%",
        }}
      />
      <LowerThird
        name="Lower third"
        from={1 * fps}
        premountFor={fps}
        accentColor="#0b84f3"
        style={{
          opacity: interpolate(frame, [1 * fps, 2 * fps], [0, 1], {
            extrapolateRight: "clamp",
            extrapolateLeft: "clamp",
            easing: Easing.bezier(0.16, 1, 0.3, 1),
          }),
        }}
      >
        Jane Doe, Product Designer
      </LowerThird>
    </>
  );
};
// LowerThird.tsx
import type React from "react";
import { Interactive, type InteractivitySchema } from "remotion";

type LowerThirdProps = {
  readonly children: string;
  readonly accentColor: string;
  readonly style?: React.CSSProperties;
};

const LowerThirdInner: React.FC<LowerThirdProps> = ({
  children,
  accentColor,
  style,
}) => {
  return (
    <Interactive.Div
      style={{
        position: "absolute",
        left: 80,
        bottom: 80,
        display: "flex",
        alignItems: "center",
        gap: 20,
        backgroundColor: "white",
        borderRadius: 16,
        padding: "20px 32px",
        color: "black",
        fontFamily: "Helvetica, Arial, sans-serif",
        fontSize: 48,
        fontWeight: 600,
        ...style,
      }}
    >
      <div
        style={{
          width: 8,
          alignSelf: "stretch",
          borderRadius: 4,
          backgroundColor: accentColor,
        }}
      />
      {children}
    </Interactive.Div>
  );
};

const lowerThirdSchema = {
  children: { type: "text-content", default: "", description: "Texte" },
  accentColor: {
    type: "color",
    default: "#0b84f3",
    description: "Couleur d'accentuation",
  },
} as const satisfies InteractivitySchema;

export const LowerThird = Interactive.withSchema({
  Component: LowerThirdInner,
  componentName: "<LowerThird>",
  schema: lowerThirdSchema,
  wrapInSequence: true,
});
// Root.tsx
import { Composition } from "remotion";
import { LowerThird } from "./LowerThird";
import { MyScene } from "./MyScene";

export const RemotionRoot: React.FC = () => {
  return (
    <>
      <Composition
        id="MyScene"
        component={MyScene}
        durationInFrames={60}
        fps={30}
        width={1280}
        height={720}
      />
      <Composition
        id="LowerThird"
        component={LowerThird}
        durationInFrames={30}
        fps={30}
        width={1280}
        height={720}
        defaultProps={{
          children: "Jane Doe, Product Designer",
          accentColor: "#0b84f3",
        }}
      />
    </>
  );
};

Retard, recadrage

Placez le timing directement sur les composants qui le supportent. Voir Propriétés de timing pour les propriétés prises en charge, des exemples et l'ordre des opérations.

Cartes

Voir Remotion Maps si vous souhaitez inclure des cartes dans la vidéo.

Surlignages et annotations de texte

Voir text-highlights.md pour les surlignages de texte (marqueurs de surbrillance), les cercles, les soulignements, les barrés, le texte biffé, les boîtes.

Vidéos multi-scènes

Voir multi-scene-video.md si vous prévoyez de réaliser une vidéo avec plusieurs scènes consécutives.

Compositions connectées

Lorsqu'une scène ou un groupe de couches mérite sa propre timeline modifiable, suivez connected-compositions.md. Préférez cette structure pour les scènes importantes dans une vidéo multi-scènes.

Action de pré-composition

Pour une demande du Studio telle que Pre-compose Ambient glow (src/BarChart.tsx:134), trouvez le balisage de séquence sélectionné à l'emplacement donné. Créez une composition connectée, en suivant connected-compositions.md : extrayez le balisage dans un composant nommé, de préférence rendez-le interactif avec Interactive.withSchema({wrapInSequence: true}), et enregistrez la même référence de composant exportée avec un <Composition> unique dans la racine. Rendez le composant interactif directement avec ses propriétés de timing, ou comme seul enfant d'une séquence lorsque ce wrapper a un but. Si le nœud sélectionné est déjà une séquence, conservez ses propriétés et extrayez ses enfants. L'enregistrement nécessite des dimensions, fps, durée et defaultProps équivalents à son utilisation parente. Une extraction de composant sans composition enregistrée ne termine pas une demande de pré-composition.

Voix off

Voir voiceover.md pour ajouter une voix off générée par IA aux compositions Remotion à l'aide de ElevenLabs TTS.

Intégration de vidéos

Voir embedding-videos.md pour des connaissances avancées sur l'intégration de vidéos - recadrage, volume, vitesse, bouclage, hauteur.

Intégration d'audio

Voir audio.md pour les fonctionnalités audio avancées comme le recadrage, le volume, la vitesse, la hauteur.

Recadrage

Voir cropping.md si vous avez besoin de recadrer le rectangle visible d'un composant.

Transitions

Voir transitions.md pour les modèles de transition de scène.

Flou de mouvement

Lorsque vous ajoutez un flou de mouvement ou une traînée de mouvement, lisez motion-blur.md pour l'approche préférée HTML dans canvas, les exigences de prévisualisation et les alternatives.

Effets visuels et de pixels

Lorsque vous créez un effet visuel, demandez-vous s'il est réalisable en utilisant CSS et HTML, ou si un shader est nécessaire. Ordre de préférence :

  1. HTML + CSS classique ou autres techniques web
  2. Un effet appliqué directement à l'élément (<Video>, <Img>), ou en enveloppant le contenu dans <HtmlInCanvas>, qui accepte également les effects :
  • Un effet listé via effects.md
  • Un createEffect() personnalisé via effects.md lorsqu'aucun préréglage n'est disponible.

Contenu 3D

Voir ./3d.md pour le contenu 3D dans Remotion utilisant Three.js et React Three Fiber.

Effets sonores

Lorsque vous avez besoin d'utiliser des effets sonores, chargez le fichier ./sfx.md pour plus d'informations.

Visualisation audio

Lorsque vous avez besoin de visualiser de l'audio (barres de spectre, formes d'onde, effets réactifs aux basses), chargez le fichier ./audio-visualization.md pour plus d'informations.

Cartes

Pour les cartes statiques, les itinéraires animés et les marqueurs, les explications géographiques, Mapbox, MapLibre, MapTiler, GeoJSON ou les survols géographiques 3D, chargez Remotion Maps.

Sous-titres

Lorsque vous traitez des sous-titres ou des légendes, chargez la compétence Remotion Captions pour plus d'informations.

Google Fonts

Est la méthode recommandée pour charger des polices dans Remotion. Voir google-fonts.md pour savoir comment charger des polices Google.

Polices locales

Voir local-fonts.md pour savoir comment charger des polices locales.

GIFs

Voir gifs.md pour savoir comment afficher des GIFs synchronisés avec la timeline de Remotion.

Images avancées

Voir images.md pour le dimensionnement et le positionnement des images, les chemins d'image dynamiques et l'obtention des dimensions des images.

Animations Lottie

Voir lottie.md pour intégrer des animations Lottie dans Remotion.

Timing

Voir timing.md pour plus de techniques de timing pour interpolate().

Vidéos paramétrées

Voir parameters.md pour rendre une composition paramétrable en ajoutant un schéma Zod.

Mesure des nœuds DOM

Voir measuring-dom-nodes.md pour mesurer les dimensions des éléments DOM dans Remotion.

Mesure du texte

Voir measuring-text.md pour mesurer les dimensions du texte, adapter le texte aux conteneurs et vérifier le débordement.

Utilisation de FFmpeg

Pour certaines opérations vidéo, telles que le recadrage de vidéos ou la détection de silence, FFmpeg doit être utilisé. Chargez le fichier ./ffmpeg.md pour plus d'informations.

Détection de silence

Lorsque vous devez détecter et supprimer les segments silencieux de fichiers vidéo ou audio, chargez le fichier ./silence-detection.md.

Durée, dimensions et données dynamiques

Voir calculate-metadata.md pour définir dynamiquement la durée, les dimensions et les propriétés de la composition.

Compositions et images fixes

Avant d'enregistrer des éléments <Composition> ou <Still>, lisez compositions.md pour les enregistrements modifiables à la source, les dossiers, les propriétés par défaut et l'imbrication. Pour la navigation Studio dans la timeline d'une scène, utilisez les compositions connectées.

Séquençage avancé

Voir sequencing.md pour plus de modèles de séquençage - retard, recadrage, limitation de la durée des éléments.

Installer des modules

Utilisez npx remotion add pour ajouter de nouveaux packages avec la bonne version :

npx remotion add @rem

… [tronqué pour la traduction]

Individual skills in this repo

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

Hownameee/short-videos

Generate, revise or troubleshoot local Kokoro narration, pronunciation and scene word timing. Reuse verified unchanged clips; inspect the Python environment before setup changes. Exclude research, visuals, music composition and publishing.

Hownameee/short-videos

Router for all Remotion skills

Hownameee/short-videos

Transcribing, displaying and animating captions

Hownameee/short-videos

Structure Remotion markup for interactivity

Hownameee/short-videos

Remotion Map animation knowledge

Hownameee/short-videos

Upgrade Remotion, and related packages

Hownameee/short-videos

>- Run Phase 1 of the shared short-video workflow: turn a raw topic or prompt into a sourced research pack and 2–4 distinct video directions, each with a defensible tension hook, promise, payoff, beats, visual approach, duration range, and risks. Use whenever the user asks for video ideas, angles, research, facts, hooks, topic analysis, or choices before scriptwriting. Stop for the user's direction choice and do not silently continue into script or production.

Hownameee/short-videos

Produce an approved short video or correct an existing video's background sound, emotion, captions, mix or export. Generate only changed narration, render and review a current preview, run technical and editorial QC, then export. Exclude script-only and general audio-advice requests.

Hownameee/short-videos

>- Run Phase 2 of the shared short-video workflow: convert an explicitly selected direction and its research into a reviewable beat sheet, narration, flexible scene timing, on-screen text, visual plan, captions, music and SFX cues, pronunciation notes, payoff, takeaway, and contextual CTA. Use whenever a user asks to write, revise, preview, or approve a short-video script. Stop for script approval and do not generate TTS or render video yet.

Hownameee/short-videos

>- Design and review a coherent visual system for short-form video before and during Remotion implementation. Use for video art direction, scene UI, typography, layout, color, diagrams, captions, motion, transitions, platform safe areas, or visual-quality review. Use Remotion skills separately for API, timeline, media, Studio, and rendering behavior; do not use this skill for narration-only or research-only work.

Hownameee/short-videos

Coordinate prompt-to-short-video discovery, scripting and production. Resume existing projects and route soundtrack or mix corrections directly to production. Preserve direction choice and script approval; exclude general audio advice.

Skills associés