O que Remotion Compose faz?
Você transforma um briefing em linguagem natural em uma composição Remotion completa e pronta para pré-visualização – React/TypeScript real com animação baseada em quadros. A saída é um arquivo .tsx em src/compositions/, registrado em src/Root.tsx, que o usuário pode imediatamente manipular no Studio ou passar para remotion-render.
Ative ao receber qualquer solicitação para criar, gerar, animar ou "escrever o código do vídeo para" uma demo de produto, walkthrough, destaque de funcionalidade ou animação de marketing – incluindo "construa um vídeo de 20 segundos mostrando X".
Passo 1 – Extrair o briefing
Não comece a codificar até ter estas informações. Pergunte em um bloco compacto; preencha lacunas óbvias com padrões sensatos em vez de travar:
- Duração em segundos e fps (padrão 30 – o padrão para vídeos de produto e marketing, e metade do custo de renderização de 60. Use 60fps apenas ao animar movimentos finos de cursor ou UI de rolagem onde 30 trava visivelmente).
- Cenas – o que acontece, em ordem. Peça uma lista de momentos: "logotipo, três funcionalidades e um CTA" é melhor que "uma demonstração do meu app".
- Marca – cores hexadecimais primária/de destaque/fundo, e a fonte (um nome de família do
@remotion/google-fonts). - Proporção / plataforma – 16:9 paisagem (1920×1080), 9:16 retrato (1080×1920) para redes sociais, ou 1:1 quadrado (1080×1080).
- Texto – os títulos reais, nomes de funcionalidades, texto do CTA. Nunca invente alegações sobre o produto; pergunte pelas palavras reais.
Converta segundos para quadros em todo lugar: durationInFrames = seconds * fps. Durações típicas: 15-60s para uma demo social/produto, 6-15s para um anúncio.
Passo 2 – Criar um plano de cenas
Uma <Composition> por vídeo, um componente por cena, costurados na linha do tempo com <Sequence>. Defina o orçamento de quadros antes de codificar:
Total: 20s @ 30fps = 600 quadros
Introdução (logotipo) quadros 0-90 (Sequence from=0 durationInFrames=90)
Funcionalidade 1 quadros 90-240 (Sequence from=90 durationInFrames=150)
Funcionalidade 2 quadros 240-390 (Sequence from=240 durationInFrames=150)
Funcionalidade 3 quadros 390-540 (Sequence from=390 durationInFrames=150)
CTA final quadros 540-600 (Sequence from=540 durationInFrames=60)
Limiares de ritmo ao planejar:
- Dê a qualquer momento que contenha texto pelo menos 2 segundos (60 quadros a 30fps) – animação de entrada mais pausa. Um título precisa de aproximadamente 150-200ms de pausa por palavra para ser legível; um título de 6 palavras quer ~1s de pausa após aparecer.
- Animações de entrada: 10-20 quadros. Cross-fades e saídas: 12-15 quadros. Mais longo parece lento; mais curto parece falha.
- Nenhuma cena com menos de ~45 quadros, a menos que seja um corte flash intencional.
<Sequence from={F}> desloca o relógio local do filho para que dentro desse componente useCurrentFrame() comece em 0. Anime cada cena como se começasse no quadro 0.
Passo 3 – Referência da API principal
useCurrentFrame()– o quadro atual (o relógio). Tudo anima como função disto.useVideoConfig()–{ fps, width, height, durationInFrames }.interpolate(frame, [inFrames], [outValues], opts)– mapeamento linear. Sempre passe{ extrapolateLeft: "clamp", extrapolateRight: "clamp" }para entrada/saída, para que os valores não ultrapassem seu intervalo.spring({ frame, fps, config })– 0→1 baseado em física (levemente ultrapassa). Use para qualquer coisa que deva parecer viva (pops, slides, escalas).AbsoluteFill– uma div de quadro completo posicionada absolutamente; a camada base de cada cena.Sequence– desloca no tempo e limita temporalmente os filhos (o agendador de cenas).Series/Series.Sequence– cenas consecutivas sem calcular deslocamentosfrommanualmente.Img,staticFile– veja o Passo 6.
Passo 4 – spring() vs interpolate()
Use spring() quando… | Use interpolate() quando… |
|---|---|
| O movimento deve parecer físico – pops, saltos, escalas, deslizamentos | Você precisa de controle linear preciso entre quadros exatos |
| Você quer um assentamento/ultrapassagem natural | Fades (opacidade 0→1), mudanças de cor, barras de progresso, qualquer coisa sincronizada ao quadro |
| Entradas de cartões, logotipos, badges | Cross-fades e saídas onde ultrapassagem pareceria errada |
Padrão – use uma mola para transformação, interpolate para opacidade:
const { fps } = useVideoConfig();
const frame = useCurrentFrame();
const pop = spring({ frame, fps, config: { damping: 200 } }); // 0 → 1, vivo
const opacity = interpolate(frame, [0, 15], [0, 1], { extrapolateRight: "clamp" });
const scale = interpolate(pop, [0, 1], [0.8, 1]);
damping: 200 é a configuração padrão de trabalho – um assentamento rápido com ultrapassagem quase invisível. Damping menor (~10-20) salta visivelmente; use apenas quando o salto for o objetivo.
Passo 5 – Estrutura padrão de demo de produto
Codifique esta forma a menos que o briefing diga o contrário: introdução do logotipo/marca → N destaques de funcionalidades → CTA final. Torne-o orientado a dados (Passo 6) para que variações sejam gratuitas.
// src/compositions/ProductDemo.tsx
import {
AbsoluteFill, Sequence, useCurrentFrame, useVideoConfig,
interpolate, spring,
} from "remotion";
import { loadFont } from "@remotion/google-fonts/Inter";
const { fontFamily } = loadFont();
export type Feature = { title: string; body: string };
export type ProductDemoProps = {
brand: string;
colors: { bg: string; fg: string; accent: string };
logoText: string;
features: Feature[];
cta: string;
};
const Intro: React.FC<{ text: string; colors: ProductDemoProps["colors"] }> = ({ text, colors }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const s = spring({ frame, fps, config: { damping: 200 } });
const scale = interpolate(s, [0, 1], [0.7, 1]);
const opacity = interpolate(frame, [0, 12], [0, 1], { extrapolateRight: "clamp" });
return (
<AbsoluteFill style={{ backgroundColor: colors.bg, justifyContent: "center", alignItems: "center" }}>
<h1 style={{ fontFamily, fontSize: 120, color: colors.fg, transform: `scale(${scale})`, opacity }}>
{text}
</h1>
</AbsoluteFill>
);
};
const FeatureCallout: React.FC<{ feature: Feature; colors: ProductDemoProps["colors"] }> = ({ feature, colors }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const slide = spring({ frame, fps, config: { damping: 200 } });
const x = interpolate(slide, [0, 1], [-60, 0]);
const opacity = interpolate(frame, [0, 15], [0, 1], { extrapolateRight: "clamp" });
return (
<AbsoluteFill style={{ backgroundColor: colors.bg, justifyContent: "center", paddingLeft: 160 }}>
<div style={{ transform: `translateX(${x}px)`, opacity }}>
<div style={{ fontFamily, fontSize: 32, color: colors.accent, fontWeight: 700, letterSpacing: 2 }}>
{feature.title.toUpperCase()}
</div>
<div style={{ fontFamily, fontSize: 64, color: colors.fg, maxWidth: 1100, marginTop: 16 }}>
{feature.body}
</div>
</div>
</AbsoluteFill>
);
};
const Outro: React.FC<{ cta: string; colors: ProductDemoProps["colors"] }> = ({ cta, colors }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 18], [0, 1], { extrapolateRight: "clamp" });
return (
<AbsoluteFill style={{ backgroundColor: colors.accent, justifyContent: "center", alignItems: "center" }}>
<h2 style={{ fontFamily, fontSize: 84, color: colors.bg, opacity }}>{cta}</h2>
</AbsoluteFill>
);
};
export const ProductDemo: React.FC<ProductDemoProps> = ({ colors, logoText, features, cta }) => {
const intro = 90;
const per = 150;
const outro = 60;
return (
<AbsoluteFill>
<Sequence durationInFrames={intro}>
<Intro text={logoText} colors={colors} />
</Sequence>
{features.map((f, i) => (
<Sequence key={i} from={intro + i * per} durationInFrames={per}>
<FeatureCallout feature={f} colors={colors} />
</Sequence>
))}
<Sequence from={intro + features.length * per} durationInFrames={outro}>
<Outro cta={cta} colors={colors} />
</Sequence>
</AbsoluteFill>
);
};
Registre em src/Root.tsx, calculando durationInFrames a partir dos mesmos números e fornecendo defaultProps:
<Composition
id="ProductDemo"
component={ProductDemo}
durationInFrames={90 + 3 * 150 + 60}
fps={30}
width={1920}
height={1080}
defaultProps={{
brand: "Acme",
colors: { bg: "#0B0B0F", fg: "#FFFFFF", accent: "#6C5CE7" },
logoText: "Acme",
features: [
{ title: "Rápido", body: "Envie em segundos, não em sprints." },
{ title: "Simples", body: "Um prompt, um vídeo." },
{ title: "Seu", body: "Sua marca, seu texto." },
],
cta: "Comece grátis →",
}}
/>
Para vertical/redes sociais, defina width={1080} height={1920}; para quadrado, 1080×1080. Mantenha os componentes idênticos – apenas a tela muda.
Passo 6 – Props orientadas a dados e ativos estáticos
A composição acima é totalmente orientada a dados: cada palavra e cor é uma prop. Esse é o objetivo – variações (novo texto, nova paleta, texto localizado) não precisam de nova solicitação; basta passar props diferentes (remotion-render faz isso a partir de um arquivo JSON para lotes).
Ativos estáticos (logotipos, capturas de tela, áudio) ficam em public/assets/ e são referenciados com staticFile() – nunca como import ou caminho bruto:
import { Img, staticFile } from "remotion";
<Img src={staticFile("assets/logo.png")} />
Passo 7 – Saída
Salve o arquivo final em src/compositions/<VideoName>.tsx, registre em src/Root.tsx e diga ao usuário para pré-visualizar com npx remotion studio (http://localhost:3000). Em seguida, passe adiante: "Manipule no Studio. Diga-me o que mudar – muito rápido, cor errada, texto diferente – e eu edito e re-renderizo (remotion-render)."
NÃO FAÇA
- NÃO anime com transições/animações CSS ou
setTimeout/setInterval. O Remotion renderiza quadros independentemente e em paralelo; qualquer coisa não derivada deuseCurrentFrame()fica invisível ou inconsistente na renderização final, mesmo que pareça correta na prévia do navegador. - NÃO use
Math.random()para efeitos dispersos/de partículas – cada worker de renderização obtém valores diferentes e os quadros param de corresponder. Userandom(seed)do Remotion para pseudo-aleatoriedade determinística. - NÃO busque dados ou espere trabalho assíncrono sem
delayRender()/continueRender()– o renderizador captura o quadro antes dos dados chegarem. - NÃO codifique fps, largura ou altura dentro dos componentes de cena – leia-os de
useVideoConfig()para que alternar entre 30↔60fps ou paisagem↔retrato não quebre cada temporização e layout. - NÃO omita
extrapolateLeft/Right: "clamp"em interpolações de entrada/saída – a opacidade ultrapassa 1 e elementos flutuam para fora da tela após o fim do intervalo. - NÃO invente títulos, alegações de funcionalidades ou CTAs – use o texto real do usuário e peça por ele se estiver faltando.
Padrão de qualidade
- Todo valor animado é uma função pura de
useCurrentFrame()(mais props) – manipular para trás no Studio parece idêntico a avançar. - O orçamento de quadros no plano soma exatamente
durationInFramesemRoot.tsx, e nenhum momento de texto segura por menos que seu mínimo legível. - Todo texto e cores chegam via props tipadas com
defaultPropsfornecidas – sem literais enterrados em componentes de cena. - Ativos carregam via
staticFile(); o arquivo registra limpo e pré-visualiza no Studio sem erros no console.