Ao escrever o markup do Remotion de uma forma específica, o Remotion Studio consegue reconhecer a estrutura do código e torná-lo interativo:
- Permitindo que itens sejam selecionados clicando neles
- Permitindo arrastar e soltar, redimensionar e rotacionar
- Editando os estilos CSS
- Tornando keyframes e valores de easing editáveis
Se o markup for muito complexo para o Studio torná-lo interativo, os valores ficarão acinzentados.
Prefira componentes interativos com suas próprias timelines
Use Interactive.withSchema({wrapInSequence: true}) para cenas personalizadas, cartões, títulos e outros componentes visuais cujas props devem ser editáveis por instância. Exponha controles de conteúdo e aparência significativos em um InteractivitySchema. Mantenha os detalhes decorativos de implementação dentro do componente.
O componente deve aceitar style e repassá-lo para uma raiz visual. Mantenha uma raiz compartilhada quando transformações, corte ou opacidade devem afetar todas as suas camadas. Achate wrappers internos redundantes quando seus estilos podem ser movidos para um elemento existente sem alterar o layout ou a animação.
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: 'Texto'},
accentColor: {
type: 'color',
default: '#0b84f3',
description: 'Cor de destaque',
},
} as const satisfies InteractivitySchema;
export const LowerThird = Interactive.withSchema({
Component: LowerThirdInner,
componentName: '<LowerThird>',
schema: lowerThirdSchema,
wrapInSequence: true,
});
Repassar o style injetado dentro do componente é obrigatório; mantenha os estilos editáveis inline no local de chamada do componente.
Escolha os campos do schema
Cada chave no schema é uma prop que o Studio pode ler e editar no local de chamada. Props que não estão no schema ainda funcionam, mas não são editáveis no Studio. Chaves podem usar notação de ponto, como style.color.
| Tipo | Uso para | Com keyframe |
|---|---|---|
text-content | Texto, como um título | Não |
number | Números, com min, max, step, integer opcionais | Sim |
boolean | Interruptores liga/desliga | Sim (hold) |
color | Strings de cor CSS | Sim |
enum | Uma escolha entre variants, cada uma com seu próprio schema | Opt-in (hold) |
array | Listas de números, cores, enums e mais | Não |
asset | Fontes de mídia, com assetType opcional | Não |
font-family | Família de fonte CSS | Não |
font-weight | Peso da fonte | Sim |
translate, scale, rotation-css, rotation-degrees, transform-origin | Transformações | Sim |
uv-coordinate | Um ponto [x, y] normalizado no elemento | Sim |
svg-path | Dados de caminho SVG | Sim |
remotion-captions | Dados Caption[] | Não |
hidden | Um valor mantido fora dos controles | — |
Cada campo precisa de um default e deve ter um description, que o Studio mostra como rótulo.
Defina keyframable: false para mostrar um controle estático.
Exponha conteúdo e aparência por instância, como o texto e uma cor de destaque.
Não adicione campos para style.translate, style.scale, style.rotate, style.transformOrigin e style.opacity: wrapInSequence: true já os adiciona.
Para tornar as propriedades CSS da raiz editáveis por instância, espalhe os fragmentos de schema integrados:
const cardSchema = {
...Interactive.textSchema, // style.color, style.fontSize, style.fontWeight, ...
...Interactive.backgroundSchema, // style.backgroundColor
...Interactive.borderRadiusSchema, // style.borderRadius, ...
} as const satisfies InteractivitySchema;
Também disponível: Interactive.borderSchema e Interactive.captionsSchema para componentes que aceitam legendas.
Veja InteractivitySchema para todas as opções.
Registre componentes reutilizáveis como composições conectadas
Registre cenas substanciais e componentes reutilizáveis com suas próprias camadas ou animação como composições independentes. O Studio chama essas composições conectadas: elas podem ser abertas em sua própria timeline enquanto compartilham a mesma implementação de componente com o vídeo pai.
Defina estilos obrigatórios e carregue fontes dentro do componente para que funcione sem seu pai. Veja independência do pai.
Registre a mesma referência de componente exportada que o pai renderiza. Para o exemplo acima, use component={LowerThird}, não LowerThirdInner ou um wrapper inline.
Com wrapInSequence: true, nenhum <Sequence> extra é necessário para a conexão.
import {Composition} from 'remotion';
import {LowerThird} from './LowerThird';
export const RemotionRoot = () => (
<Composition
id="LowerThird"
component={LowerThird}
width={1280}
height={720}
fps={30}
durationInFrames={30}
defaultProps={{
children: 'Jane Doe, Designer de Produto',
accentColor: '#0b84f3',
}}
/>
);
Escolha um ID único, padrões inline representativos, e dimensões, fps e duração adequados para pré-visualizar o componente. Os padrões de registro não copiam automaticamente props de uma instância pai. Veja composições conectadas para detalhes de registro e extração.
Coloque o timing diretamente no componente
Evite um <Sequence> separado em torno de um componente que já aceita props de timing. Componentes interativos integrados e componentes personalizados feitos com wrapInSequence: true podem receber name, from, durationInFrames, trimBefore, playbackRate e premountFor diretamente.
<LowerThird
name="Terço inferior"
from={30}
durationInFrames={90}
accentColor="#0b84f3"
>
Jane Doe, Designer de Produto
</LowerThird>
Ao remover uma sequência redundante, mova seu timing e nome para o filho.
Preserve qualquer timing filho existente; não sobrescreva ou aplique deslocamentos duplicados.
Uma chamada useCurrentFrame() dentro do componente lê seu frame local, enquanto uma expressão de estilo no local de chamada ainda usa o frame do chamador. Preserve essa distinção ao mover estilos de animação.
Mantenha um <Sequence> quando ele fornecer timing compartilhado para vários irmãos, substituir dimensões para useVideoConfig(), ou envolver um componente que não lida com timing. Mantenha <Series.Sequence> para layout consecutivo e <TransitionSeries.Sequence> para transições; props from diretas não substituem esses comportamentos.
Dê a cada item editável individual seu próprio nó JSX
O Studio edita o nó JSX fonte que criou um item. Se vários itens em tempo de execução vêm do mesmo nó JSX, eles compartilham um único alvo de edição de fonte.
Para cada registro de composição, clipe, cena, camada ou sequência que deve ser editável por si só, escreva um nó JSX separado e mantenha suas props editáveis nesse nó. Isso se aplica a <Composition>, <Still>, componentes de mídia integrados, <Sequence>, <Series.Sequence>, <TransitionSeries.Sequence> e componentes personalizados.
Por exemplo, crie uma timeline editável assim:
<Series>
<Series.Sequence name="Introdução" durationInFrames={90}>
<Introduction />
</Series.Sequence>
<Series.Sequence name="Demonstração" durationInFrames={150}>
<Demo />
</Series.Sequence>
</Series>
Um .map() ou outro loop programático criaria vários itens em tempo de execução a partir de um único nó JSX fonte. Isso é apropriado para saída repetida que é intencionalmente controlada como um modelo, como barras de visualização ou partículas. Não é apropriado quando as instâncias precisam de IDs ou nomes, props, metadados, timing, ordenação, exclusão ou duplicação independentes no Studio.
Torne um elemento HTML interativo usando Interactive
Todo elemento HTML e SVG (exceto <Img>, que já é interativo) como <div> pode se tornar interativo usando Interactive:
<Interactive.Div
name="Cartão de saudação"
style={{fontSize: 80, padding: 24}}
>
Olá
</Interactive.Div>
Isso permite que estilos e keyframes sejam definidos no Studio. Seja sensato; se um componente tiver muitos elementos, a timeline pode ficar bagunçada.
Prefira texto inline
Se o texto é fixo e usado apenas uma vez, escreva-o diretamente dentro do elemento interativo em vez de extraí-lo para uma constante.
// 👍 Cópia fixa permanece editável
<Interactive.Div name="Título">
Melhores Práticas do Remotion
</Interactive.Div>
Use uma prop ou variável apenas quando o texto for dinâmico ou reutilizado.
Dê aos elementos interativos um nome descritivo
Adicione uma prop name aos elementos para torná-los facilmente identificáveis.
Evite nomes computados; codifique-os manualmente.
<>
<Interactive.Div name="Título herói" style={{fontSize: 80}}>
Dia do lançamento
</Interactive.Div>
<Img name="Avatar" src="https://remotion.media/image.jpeg" />
<Video name="Fundo" src="https://remotion.media/video.mp4" />
<Interactive.Div name="Título">
Dia do lançamento
</Interactive.Div>
</>
Mantenha todos os estilos CSS inline
A melhor maneira é simplesmente passar um objeto simples para style - sem referências a constantes, sem espalhamento de objetos, sem matemática.
<Interactive.Div
style={{
fontSize: 80,
color: 'red',
}}
>
Olá Mundo!
</Interactive.Div>
const baseStyle = useMemo(() => {
return {
fontSize: 12 // ❌ Estilos não inline não são suportados
}
}, []);
<Interactive.Div
style={{
...baseStyle, // ❌ Espalhamento não é suportado
color: RED, // ❌ Referenciar constantes não é suportado
scale: frame * 10 // ❌ Matemática não é suportada
}}
>
Olá Mundo!
</Interactive.Div>
Animar usando interpolate()
Escreva animações como chamadas interpolate() inline na propriedade que muda.
O intervalo de saída, easing, extrapolação e a propriedade output devem usar valores codificados manualmente.
O intervalo de entrada pode adicionalmente usar durationInFrames, fps, width e height desestruturados diretamente de useVideoConfig(). Identificadores simples como durationInFrames, multiplicação com um número como 2 * fps ou fps * 2, e subtração de um número como durationInFrames - 1 são suportados.
const {fps, durationInFrames} = useVideoConfig();
// 👍 Valores inline podem ser padronizados e com keyframe
<Interactive.Div
name="Cartão de produto"
style={{
color: 'white',
fontSize: 80,
scale: interpolate(frame, [0, fps], [0, 1], {
easing: Easing.spring({damping: 200}),
output: 'perceptual-scale',
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp'
}),
rotate: interpolate(frame, [0, 1 * fps], ['0deg', '20deg'], {
easing: Easing.spring({damping: 200}),
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp'
}),
translate: interpolate(
frame,
[durationInFrames - 30, durationInFrames],
['0px 0px', '0px 120px'],
{
easing: Easing.spring({damping: 200}),
output: 'perceptual-scale',
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp'
}
),
}}
/>
const translateY = interpolate(frame, [0, 30], [0, 120]); // ❌ A matemática deve estar diretamente no markup
<Interactive.Div
name="Cartão de produto"
style={{
translate: translateY, // ❌ Apenas chamadas interpolate() inline são suportadas
rotate: interpolate(frame, [start, start + 10], [0, Math.PI]), // ❌ Não é possível usar matemática com variáveis arbitrárias, não é possível usar constantes
scale
…
[truncado para tradução]
