Ceci est un guide pour l'écriture de balisage React Remotion. Si cela 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 entre-temps, ne l'écrasez pas, supposez qu'il était intentionnel ou demandez une confirmation.
Règles générales
À l'intérieur d'un composant de composition ou de scène, obtenez fps à partir de useVideoConfig() pour tous les calculs de secondes-à-images, y compris les propriétés de timing telles que from, trimBefore, durationInFrames et premountFor. Garder l'expression sur le nœud JSX, comme trimBefore={4 * fps}, permet au Studio de modifier le timing et de le maintenir correct si la fréquence d'images de la composition change.
Entraînez 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 Bonnes 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 prennent en charge ; évitez les wrappers <Sequence> redondants.
Donnez à chaque composant temporisé qui prend en charge premountFor une seconde de prémontage : premountFor={fps}, où fps provient de useVideoConfig(). Appliquez cela 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 se monter avant que le parent ne démarre. Un composant sans premountFor, comme <TransitionSeries.Transition>, ne nécessite pas de substitut.
Le Studio modifie le nœud source JSX qui a créé un élément. Créez chaque enregistrement de composition, clip, scène, calque 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 modèle source unique, et non 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 à modifier 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 des vidéos et de l'audio en utilisant <Video> et <Audio> de @remotion/media.
Ajoutez des images en utilisant le composant <CanvasImage>.
Ajoutez des GIFs animés, APNG, WebP ou des images AVIF en utilisant <AnimatedImage> ; utilisez @remotion/gif si vous n'utilisez pas Chrome.
Utilisez staticFile() pour les fichiers dans public/ ou transmettez 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 de fond avec un tiers inférieur.
Le tiers inférieur est un composant interactif avec sa propre timeline, enregistré en tant que composition connectée.
Son texte est passé comme children et accentColor est une propriété modifiable.
Le fondu entrant est animé 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",
}}
/>
</>
);
};
Retards, rognage
Placez le timing directement sur les composants qui le prennent en charge. Voir Propriétés de timing pour les propriétés prises en charge, les exemples et l'ordre des opérations.
Cartes
Voir Remotion Maps si vous souhaitez inclure des cartes dans la vidéo.
Surlignements et annotations de texte
Voir text-highlights.md pour les surlignements de texte (marqueurs de surlignement), cercles, soulignements, barrés, texte barré, 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 calques 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 Pré-composer Lueur ambiante (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 unique 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.
Transportez les styles hérités tels que fontFamily et le chargement de polices dans le composant extrait ; voir indépendance parentale.
Voix off
Voir voiceover.md pour ajouter une voix off générée par IA aux compositions Remotion en utilisant ElevenLabs TTS.
Intégration de vidéos
Voir embedding-videos.md pour des connaissances avancées sur l'intégration de vidéos : rognage, volume, vitesse, bouclage, hauteur.
Intégration d'audio
Voir audio.md pour des fonctionnalités audio avancées comme le rognage, le volume, la vitesse, la hauteur.
Recadrage
Voir cropping.md si vous devez recadrer le rectangle visible d'un composant.
Transitions
Voir transitions.md pour les modèles de transition de scène.
Flou de mouvement
Lors de l'ajout d'un flou de mouvement ou d'une traînée de mouvement, lisez motion-blur.md pour l'approche préférée HTML-dans-canvas, les exigences d'aperçu et les alternatives.
Effets visuels et pixel
Lors de la création d'un effet visuel, considérez s'il est réalisable en utilisant CSS et HTML, ou si un shader est nécessaire. Ordre de préférence :
- HTML + CSS régulier ou autres techniques web
- Un effet appliqué directement à l'élément (
<Video>,<Img>), ou en enveloppant le contenu dans<HtmlInCanvas>, qui accepte également leseffects:
- 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 en utilisant Three.js et React Three Fiber.
Effets sonores
Lorsque vous devez utiliser des effets sonores, chargez le fichier ./sfx.md pour plus d'informations.
Visualisation audio
Lorsque vous devez 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 explicateurs géographiques, Mapbox, MapLibre, MapTiler, GeoJSON, ou les survols géographiques 3D, chargez Remotion Maps.
Sous-titres
Lorsqu'il s'agit de sous-titres ou de 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 Google Fonts.
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 d'image.
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 rognage 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 rogner les segments silencieux de fichiers vidéo ou audio, chargez le fichier ./silence-detection.md.
Durée dynamique, dimensions et données
Voir calculate-metadata.md pour définir dynamiquement la durée de la composition, les dimensions et les données.