Ao escrever a marcação 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 girar
- Editando os estilos CSS
- Tornando keyframes e valores de easing editáveis
Se a marcação for muito complexa para o Studio tornar interativa, os valores ficarão acinzentados.
Prefira componentes interativos com suas próprias linhas do tempo
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 de implementação decorativos dentro do componente.
O componente deve aceitar style e repassá-lo a 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 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.
As chaves podem usar notação de ponto, como style.color.
| Tipo | Use 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 (segurado) |
color | Strings de cor CSS | Sim |
enum | Uma escolha entre variants, cada uma com seu próprio schema aninhado | Opt-in (segurado) |
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 normalizado [x, y] no elemento | Sim |
svg-path | Dados de caminho SVG | Sim |
remotion-captions | Dados Caption[] | Não |
hidden | Um valor mantido fora dos controles | — |
Todo 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 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 linha do tempo enquanto compartilham a mesma implementação de componente com o vídeo 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, Product Designer',
accentColor: '#0b84f3',
}}
/>
);
Escolha um ID único, valores padrão inline representativos e dimensões, fps e duração adequados para 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 tempo diretamente no componente
Evite um <Sequence> separado em torno de um componente que já aceita props de
tempo. Componentes interativos integrados e componentes personalizados feitos com
wrapInSequence: true podem receber name, from, durationInFrames,
trimBefore, playbackRate e premountFor diretamente.
<LowerThird
name="Lower third"
from={30}
durationInFrames={90}
accentColor="#0b84f3"
>
Jane Doe, Product Designer
</LowerThird>
Ao remover uma sequência redundante, mova seu tempo e nome para o filho.
Preserve qualquer tempo filho existente; não sobrescreva ou aplique deslocamentos duplicados.
Uma chamada useCurrentFrame() dentro do componente lê seu quadro local, enquanto uma
expressão de estilo no local de chamada ainda usa o quadro do chamador. Preserve essa
distinção ao mover estilos de animação.
Mantenha um <Sequence> quando ele fornece tempo compartilhado para vários irmãos,
substitui dimensões para useVideoConfig() ou envolve um componente que não lida
com tempo. 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 independente seu próprio nó JSX
O Studio edita o nó fonte JSX que criou um item. Se vários itens em tempo de execução vêm do mesmo nó JSX, eles compartilham um alvo de edição de fonte.
Para cada registro de composição, clipe, cena, camada ou sequência que deve ser
editável por conta própria, 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 linha do tempo 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
de um nó fonte JSX. 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
independentes, props, metadados, tempo, ordenação, exclusão ou duplicação no
Studio.
Torne um elemento HTML interativo usando Interactive
Todo elemento HTML e SVG (exceto <Img>, já é interativo) como <div> pode ser tornado 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 linha do tempo 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 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.
<>
<Interactive.Div name="Título principal" style={{fontSize: 80}}>
Dia de 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 de lançamento
</Interactive.Div>
</>
Mantenha todos os estilos CSS inline
A melhor maneira é simplesmente passar um objeto puro para style - sem referir-se 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, // ❌ Referir-se a constantes não é suportado
scale: frame * 10 // ❌ Matemática não é suportada
}}
>
Olá Mundo!
</Interactive.Div>
Anime 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.
O intervalo de entrada pode adicionalmente usar durationInFrames, fps, width e height desestruturados diretamente de useVideoConfig(). Identificadores simples como durationInFrames, multiplicação por 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 na marcação
<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: interpolate(anyVariable, [0, 30], [0, 1]) // ❌ Só pode interpretar a variável `frame`.
}}
/>
Mantenha os caminhos SVG
…
