:clapper:
Vidéo Remotion
Remotion est un framework pour créer des vidéos par programmation en utilisant React. Au lieu d'éditeurs basés sur une timeline, vous écrivez des compositions comme des composants React où chaque frame est une fonction du numéro de frame actuel. Cela vous offre toute la puissance de TypeScript, des paquets npm et de l'architecture basée sur les composants pour créer des vidéos - des explications animées et des clips pour réseaux sociaux aux visualisations de données et vidéos personnalisées à grande échelle.
Cette compétence couvre la configuration de projet, la structure des compositions, les animations basées sur les frames avec interpolate et spring, le séquencement de scènes, la gestion des assets, l'intégration audio, les vidéos paramétrées avec des schémas Zod, et le rendu en MP4/WebM via CLI ou APIs programmatiques.
Quand utiliser cette compétence
Déclenchez cette compétence lorsque l'utilisateur :
- Souhaite créer une vidéo par programmation en utilisant React/TypeScript
- Pose des questions sur les compositions Remotion, useCurrentFrame ou useVideoConfig
- A besoin d'animer du texte, des éléments ou des transitions entre scènes
- Veut rendre une vidéo en MP4, WebM ou GIF à partir de code
- Pose des questions sur les animations spring, interpolate ou le timing basé sur les frames
- A besoin de configurer un nouveau projet Remotion à partir de zéro
- Veut ajouter de l'audio, des images ou des polices à une vidéo Remotion
- Pose des questions sur la génération de vidéos paramétrées ou basées sur des données
- A besoin de configurer Remotion Studio pour prévisualiser des compositions
Ne PAS déclencher cette compétence pour :
- Des questions générales sur React sans rapport avec la création vidéo - utilisez les compétences React
- L'édition vidéo avec des outils traditionnels basés sur une timeline (Premiere, DaVinci, FFmpeg CLI)
- Les animations CSS pour pages web - utilisez les compétences d'animation/conception de mouvement
- La lecture ou le streaming vidéo dans des applications web - utilisez les compétences de lecteur multimédia
Principes clés
-
Chaque frame est une fonction pure - Un composant Remotion reçoit le frame actuel via
useCurrentFrame()et doit rendre de manière déterministe pour ce frame. Pas d'effets de bord, pas d'aléatoire sans graine, pas de dépendance à l'horloge système. Le même numéro de frame doit toujours produire le même résultat visuel. -
Les compositions sont l'unité vidéo - Chaque
<Composition>définit une vidéo avec des dimensions explicites (largeur, hauteur), une fréquence d'images (fps) et une durée (durationInFrames). Considérez les compositions comme des "pages" dans votre projet - une par variante de vidéo ou scène pouvant être rendue indépendamment. -
Interpolate pour tout - La fonction
interpolate()mappe les numéros de frame à n'importe quelle valeur numérique (opacité, position, échelle, canaux de couleur). Combinée avecextrapolateRight: 'clamp', c'est le cheval de bataille de toutes les animations. Utilisezspring()lorsque vous avez besoin d'un easing basé sur la physique. -
Sequence pour les décalages temporels - Utilisez
<Sequence from={frame}>pour retarder le démarrage des enfants, et<Series>pour les jouer l'un après l'autre. N'utilisez jamais setTimeout ou du calcul manuel de frames pour le séquencement - les primitives déclaratives gèrent cela correctement en prévisualisation comme en rendu. -
Les assets sont statiques, les données sont dynamiques - Placez les images, polices et fichiers audio dans le dossier
public/et référencez-les avecstaticFile(). Pour les données dynamiques (réponses API, enregistrements de base de données), utilisezdelayRender()/continueRender()pour suspendre le rendu jusqu'à ce que les données soient chargées.
Concepts centraux
Structure d'une composition
Chaque projet Remotion a un fichier racine qui enregistre les compositions :
import { Composition } from 'remotion';
import { MyVideo } from './MyVideo';
export const RemotionRoot: React.FC = () => {
return (
<Composition
id="MyVideo"
component={MyVideo}
durationInFrames={150}
fps={30}
width={1920}
height={1080}
/>
);
};
Timing basé sur les frames
Tout le timing dans Remotion est exprimé en frames, pas en secondes. Pour convertir :
- Secondes en frames :
secondes * fps - Frames en secondes :
frame / fps
À 30 fps, une vidéo de 5 secondes fait 150 frames. Le frame 0 est le premier frame.
Modèle d'animation
Remotion fournit deux primitives d'animation fondamentales :
| Primitive | Cas d'utilisation | Exemple |
|---|---|---|
interpolate() | Mappage linéaire/contraint de frame à valeur | Fondu, glissement, échelle |
spring() | Animation basée sur la physique avec amortissement/masse | Entrées rebondissantes, mouvement naturel |
Les deux renvoient un nombre que vous appliquez aux styles (opacité, transform, etc.).
Tâches courantes
1. Configurer un nouveau projet Remotion
npx create-video@latest
Ceci génère un projet avec TypeScript, une composition exemple et Remotion Studio configuré. La structure du projet sera :
my-video/
src/
Root.tsx # Enregistre toutes les compositions
MyComp.tsx # Votre premier composant de composition
public/ # Assets statiques (images, polices, audio)
remotion.config.ts # Configuration Remotion
package.json
Démarrez le studio de prévisualisation avec :
npx remotion studio
2. Créer une composition basique avec useCurrentFrame
import { AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';
export const FadeInText: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const opacity = interpolate(frame, [0, 30], [0, 1], {
extrapolateRight: 'clamp',
});
const translateY = interpolate(frame, [0, 30], [20, 0], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#0f0f0f',
}}
>
<h1
style={{
fontSize: 80,
color: 'white',
opacity,
transform: `translateY(${translateY}px)`,
}}
>
Hello Remotion
</h1>
</AbsoluteFill>
);
};
3. Animer du texte mot par mot
Divisez le texte en mots et espacez l'apparition de chaque mot en utilisant <Sequence> :
import { AbsoluteFill, Sequence, useCurrentFrame, interpolate } from 'remotion';
const AnimatedWord: React.FC<{ children: string }> = ({ children }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 15], [0, 1], {
extrapolateRight: 'clamp',
});
const translateY = interpolate(frame, [0, 15], [10, 0], {
extrapolateRight: 'clamp',
});
return (
<span
style={{
display: 'inline-block',
opacity,
transform: `translateY(${translateY}px)`,
marginRight: 12,
}}
>
{children}
</span>
);
};
export const WordByWord: React.FC<{ text: string }> = ({ text }) => {
const words = text.split(' ');
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#1a1a2e',
flexWrap: 'wrap',
padding: 100,
}}
>
{words.map((word, i) => (
<Sequence key={i} from={i * 8}>
<AnimatedWord>{word}</AnimatedWord>
</Sequence>
))}
</AbsoluteFill>
);
};
4. Animations d'éléments avec spring
Utilisez spring() pour des animations basées sur la physique qui semblent naturelles :
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring } from 'remotion';
export const SpringCard: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const scale = spring({
frame,
fps,
config: { damping: 200, stiffness: 100, mass: 0.5 },
});
const slideUp = spring({
frame: frame - 10,
fps,
config: { damping: 12, stiffness: 100 },
});
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center', backgroundColor: '#0d1117' }}>
<div
style={{
width: 400,
height: 250,
backgroundColor: '#161b22',
borderRadius: 16,
transform: `scale(${scale}) translateY(${(1 - slideUp) * 50}px)`,
}}
>
<p style={{ color: 'white', fontSize: 32 }}>Spring Animation</p>
</div>
</AbsoluteFill>
);
};
5. Transitions de scènes avec Sequence et Series
Utilisez <Sequence> pour les scènes qui se chevauchent et <Series> pour une lecture séquentielle :
import { AbsoluteFill, Sequence, Series, useCurrentFrame, interpolate } from 'remotion';
const Scene: React.FC<{ color: string; title: string }> = ({ color, title }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 20], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill style={{ backgroundColor: color, justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ color: 'white', fontSize: 72, opacity }}>{title}</h1>
</AbsoluteFill>
);
};
export const MultiScene: React.FC = () => {
return (
<AbsoluteFill>
<Series>
<Series.Sequence durationInFrames={60}>
<Scene color="#e63946" title="Scène Une" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Scene color="#457b9d" title="Scène Deux" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Scene color="#2a9d8f" title="Scène Trois" />
</Series.Sequence>
</Series>
</AbsoluteFill>
);
};
6. Gestion des assets (images, polices, staticFile)
Référencez les assets statiques depuis le dossier public/ en utilisant staticFile() :
import { AbsoluteFill, Img, staticFile } from 'remotion';
export const AssetDemo: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<Img
src={staticFile('logo.png')}
style={{ width: 300, height: 300 }}
/>
</AbsoluteFill>
);
};
Chargez des polices personnalisées avec @remotion/google-fonts ou CSS @font-face :
import { loadFont } from '@remotion/google-fonts/Inter';
const { fontFamily } = loadFont();
export const FontDemo: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ fontFamily, fontSize: 64, color: 'white' }}>
Police Personnalisée
</h1>
</AbsoluteFill>
);
};
7. Intégration audio
Ajoutez de l'audio avec contrôle du volume et timing :
import { AbsoluteFill, Audio, Sequence, staticFile, interpolate } from 'remotion';
export const WithAudio: React.FC = () => {
return (
<AbsoluteFill style={{ backgroundColor: '#000' }}>
<Audio
src={staticFile('background-music.mp3')}
volume={(f) =>
interpolate(f, [0, 30, 120, 150], [0, 0.8, 0.8, 0], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
})
}
/>
<Sequence from={15}>
<Audio src={staticFile('whoosh.mp3')} volume={0.5} />
</Sequence>
</AbsoluteFill>
);
};
8. Rendu de vidéos
Rendu en MP4 depuis la ligne de commande :
# Rendu de la composition par défaut
npx remotion render src/index.ts MyVideo out/video.mp4
# Rendu en résolution 4K
npx remotion render src/index.ts MyVideo out/video.mp4 --width 3840 --height 2160
# Rendu en WebM
npx remotion render src/index.ts MyVideo out/video.webm --codec vp8
# Rendu d'une plage de frames spécifique
npx remotion render src/index.ts MyVideo out/video.mp4 --frames 0-90
# Rendu avec des props personnalisées
npx remotion render src/index.ts MyVideo out/video.mp4 --props '{"title": "Hello"}'
Pour le rendu programmatique, voir references/rendering-guide.md.
Anti-patrons / erreurs courantes
| Erreur | Pourquoi c'est faux | Que faire à la place |
|---|---|---|
Utiliser Math.random() sans graine | Produit une sortie différente par frame pendant le rendu | Utiliser une graine déterministe ou random() de Remotion |
Utiliser setTimeout / setInterval | Brise le rendu basé sur les frames - les minuteries n'avancent pas par frame | Utiliser useCurrentFrame() et le calcul de frames pour tout le timing |
Oublier extrapolateRight: 'clamp' | Les valeurs dépassent la plage cible sur les frames suivants | Toujours ajouter { extrapolateRight: 'clamp' } à interpolate() |
| Coder en dur le fps dans les calculs de frames | Casse lorsque le fps de la composition change | Utiliser useVideoConfig().fps pour dériver le timing |
Utiliser <Video> pour la sortie rendue | Performances de rendu plus lentes en raison de la surcharge de recherche | Utiliser <OffthreadVideo> pour de meilleures performances de rendu |
Oublier delayRender() pour les données asynchrones | Rendu avant le chargement des données, affichant des frames vides/cassés | Appeler delayRender() immédiatement, continueRender() quand prêt |
| Styles en ligne avec des valeurs non déterministes | Scintillements ou incohérence entre prévisualisation et rendu | Dériver toutes les valeurs de style uniquement du numéro de frame |
| Composition unique géante | Difficile à maintenir et impossible à rendre les scènes indépendamment | Diviser en plusieurs compositions ou utiliser Series pour les scènes |
Pièges
-
extrapolateRight par défaut est 'extend' - Si vous écrivez
interpolate(frame, [0, 30], [0, 1])sans contrainte, la valeur continuera d'augmenter au-delà de 1 après le frame 30 (par exemple, frame 60 donne une opacité de 2). Passez toujours{ extrapolateRight: 'clamp' }sauf si vous voulez intentionnellement une extrapolation. -
spring() commence au frame 0 de son contexte - Lorsque vous utilisez
spring()à l'intérieur d'un<Sequence from={60}>, le frame passé à spring se réinitialise à 0 au frame 60 du parent. Si vous passez le frame brut du parent, l'animation sera déjà terminée. UtilisezuseCurrentFrame()à l'intérieur de l'enfant Sequence, pas un frame du parent. -
Les chemins staticFile() sont relatifs à public/ - Appeler
staticFile('images/logo.png')cherchepublic/images/logo.png. Utiliser des chemins absolus ou des chemins en dehors depublic/échouera silencieusement en prévisualisation et générera une erreur lors du rendu. Assurez-vous que tous les assets se trouvent dans le répertoirepublic/. -
delayRender a un délai d'attente de 30 secondes - Si votre opération asynchrone (appel API, chargement de police) prend plus de 30 secondes, le rendu sera abandonné. Augmentez le délai avec
delayRender('Chargement des données', { timeoutInMilliseconds: 60000 })pour les opérations lentes. -
Les dimensions de la composition doivent être des nombres pairs - Les codecs vidéo (H.264, VP8) nécessitent une largeur et une hauteur paires. Remotion générera une erreur si vous fournissez des dimensions impaires. Utilisez toujours des valeurs paires ou normalisez avec
Math.round(width / 2) * 2.
Références utiles
- Documentation Remotion
- Exemples de compositions
- Dépôts GitHub Remotion
- Plugin Remotion pour Cursor
- Rendu programmatique (Node.js)
- Animations basées sur le défilement
Considérations de performances
| Technique | Avantage | Quand l'utiliser |
|---|---|---|
<OffthreadVideo> | Décodage dans un thread séparé | Plusieurs sources vidéo dans une composition |
Pré-rendu avec useMemo | Évite les recalculs | Animations coûteuses par frame |
cancelRender() | Arrêt propre des rendus longs | Délais d'attente ou erreurs utilisateur |
Composants lazy | Réduction de l'empreinte mémoire | Grandes bibliothèques de compositions |