motion-animate
O design decide se um quadro é bom. O movimento decide se ele parece caro. A mesma composição animada com easing linear e entradas simultâneas parece gerada; animada com o vocabulário abaixo, parece autoral.
Receitas dos motores: Apêndice A, Apêndice B.
As quatro leis
- Nada é linear. Cada propriedade se move com uma suavização. Movimento linear não existe no mundo físico e o olho percebe isso instantaneamente.
- Nada entra ao mesmo tempo. Os elementos chegam em uma ordem deliberada com 60–120ms entre eles. Entrada simultânea é o maior sinal de movimento genérico.
- A câmera nunca fica parada. Um push contínuo lento ou deriva sutil em cada composição. Quadros estáticos parecem slides.
- Nada é metronômico. Varie durações e espaçamentos entre cortes. Batidas uniformes de 1s parecem automatizadas, não importa o quão boa seja cada batida.
Tabela de temporização
Valores para 30fps; escale para 60fps. Tempos em ms.
| Elemento | Duração | Escalonamento | Easing |
|---|---|---|---|
| Palavra em uma linha de texto | 400–550 | 60–90 | out-expo / power3.out |
| Linha de texto (como unidade) | 500–650 | 120–180 | out-cubic / power2.out |
| Ícone / elemento de UI pequeno | 350–450 | 80–120 | out-back (overshoot ≤1.06) |
| Painel / cartão | 550–700 | 140–200 | out-quint / power4.out |
| Objeto hero (scale-in) | 700–900 | — | out-expo |
| Objeto hero (slide-in) | 650–850 | — | out-quint |
| Linha / traço de desenho | 600–1000 | — | in-out-cubic |
| Push de câmera (por cena) | duração total da cena | — | out-sine, ou linear-ish se muito lento |
| Saída (qualquer elemento) | 250–350 | 40–60 | in-cubic |
Saídas são sempre mais rápidas que entradas, aproximadamente metade. Uma animação de saída simétrica parece lenta.
Os movimentos principais
Texto — pop-blur-fade, palavra por palavra
O movimento característico. Todas as propriedades animam juntas, por palavra, escalonadas.
y: +18px → 0
blur: 12px → 0
opacity: 0 → 1
ease: out-expo, duration 480ms, stagger 70ms
Opcionalmente adicione scale: 0.96 → 1. Não adicione rotação. Não faça bounce.
Para uma linha longa, escalone por palavra, não por caractere — escalonamento por caractere parece um truque de máquina de escrever e demora muito. Reserve o escalonamento por caractere para uma única palavra curta de destaque.
Palavra de destaque
Executa o mesmo movimento, mas atrasado 120–200ms em relação aos vizinhos e com uma propriedade extra — uma mudança de cor, um aumento de escala para 1.04 ou uma barra de destaque que aparece por trás. Ela deve chegar por último e chegar de forma diferente.
Ícones e UI
Pop-fade: scale 0.7 → 1, opacity 0 → 1, out-back com overshoot limitado a 1.06. Qualquer coisa acima de 1.1 parece um bounce barato.
Regra sequencial: o elemento âncora entra primeiro, depois seus dependentes. Um cartão entra, depois seu ícone, depois seu rótulo. Nunca o inverso, nunca juntos.
Painéis / cartões / vidro
y: +40 → 0, opacity 0 → 1, out-quint, 600ms, escalonados 160ms em uma pilha. Adicione um destaque de luz que percorre o painel 150ms depois que ele pousa — o painel chega, então pega a luz.
Objeto hero
Duas opções, escolha pelo arquétipo:
- Scale-in:
scale 1.25 → 1.00comrotate 3° → 0°,out-expo, 800ms. Parece que se acomoda no lugar. - Slide-in: de fora do quadro com uma inclinação de 2° que se resolve para 0°,
out-quint, 750ms. Parece entregue.
A sombra projetada e a textura recortada devem ser parentadas ao hero para que se movam com ele. Sombras não parentadas deslizando independentemente é uma falha grave.
Traço / desenho de linha
Animar comprimento do caminho 0 → 100%, in-out-cubic, 600–1000ms. Suavize na entrada e na saída — um desenho que começa em velocidade máxima parece mecânico. Use para conectar um rótulo a um assunto, sublinhar uma palavra de destaque ou traçar um gráfico.
Câmera
Em cada composição, uma das opções:
- Push in:
scale 1.00 → 1.08durante toda a batida,out-sine. - Push out:
scale 1.12 → 1.00, mais rápido no início, estabilizando. - Drift: translação em
xouyde 2–4% durante a batida.
Contrato anti-tremor:
- Anime um elemento wrapper, nunca o elemento que gerencia layout ou clipping.
- Use apenas
transform— nuncatop/left/width/height. - Escale a camada em movimento cerca de 6% além do quadro para que as bordas nunca apareçam.
- Defina
will-change: transforme force a composição por GPU. - Mantenha o deslocamento total pequeno. Grandes movimentos de câmera amplificam cada erro de arredondamento.
Transições entre batidas
- Corte seco mascarado por um efeito sonoro — o padrão. Crossfades entre quadros desenhados embaralham ambos.
- Scale-through — um elemento escala para preencher o quadro e a próxima cena é revelada dentro dele.
- Wipe por uma forma — um círculo ou painel escala além da borda do quadro, carregando a próxima cena.
Não faça crossfade de duas composições desenhadas. Não use um preset de transição genérico.
Proibido
- Easing linear em algo visível.
- Overshoot de bounce >1.1 (exceção: um estilo intencionalmente lúdico de SaaS/produto, e então consistentemente).
- Todos os elementos entrando no mesmo quadro.
- Durações de batidas uniformes em toda a edição.
repeat: -1ou qualquer loop infinito — as renderizações são amostradas por quadro e devem ser determinísticas.Math.random(),Date.now()ou requisições de rede dentro de uma composição. A mesma entrada deve produzir o mesmo quadro todas as vezes.- Movimento aplicado a um wrapper que o framework já controla (veja a regra de clipping no Apêndice B).
Autoavaliação
Percorra a renderização a 0.25× da velocidade. Pergunte:
- Alguma coisa começa e para abruptamente? → falta easing.
- Tudo chega junto? → falta escalonamento.
- O quadro algum fica totalmente parado? → falta câmera.
- Batidas consecutivas parecem uma batida de tambor? → durações muito uniformes.
- As bordas de uma camada em movimento aparecem? → não foi superescalada.
Apêndice A — Receitas para Remotion
Baseado em quadros, determinístico por construção. Toda temporização deriva de useCurrentFrame().
Utilitário: tempo em ms, não quadros
Trabalhar em quadros fixa seu fps. Converta.
import {useVideoConfig, useCurrentFrame, interpolate, Easing} from 'remotion';
const useMs = () => {
const {fps} = useVideoConfig();
return (ms: number) => (ms / 1000) * fps;
};
Mapa de easing
Os nomes na tabela de temporização, em termos do Remotion:
Easing.out(Easing.exp) // out-expo
Easing.out(Easing.cubic) // out-cubic
Easing.out(Easing.quad) // out-quad
Easing.out(Easing.poly(4)) // out-quint-ish
Easing.inOut(Easing.cubic) // in-out-cubic
Easing.out(Easing.sin) // out-sine
Easing.in(Easing.cubic) // in-cubic (saídas)
Easing.bezier(0.16, 1, 0.3, 1) // o workhorse — expo-ish out
Para overshoot, prefira um spring em vez de Easing.back — é mais fácil manter sutil.
import {spring} from 'remotion';
const s = spring({frame, fps, config: {damping: 200, stiffness: 120, mass: 0.6}});
// damping 200 = sem overshoot visível. Reduza para ~14 para um pequeno ajuste.
Texto — pop-blur-fade, palavra por palavra
const Words: React.FC<{text: string; delay?: number}> = ({text, delay = 0}) => {
const frame = useCurrentFrame();
const ms = useMs();
const STAGGER = ms(70);
const DUR = ms(480);
return (
<span style={{display: 'inline-flex', flexWrap: 'wrap', gap: '0.28em'}}>
{text.split(' ').map((word, i) => {
const local = frame - ms(delay) - i * STAGGER;
const p = interpolate(local, [0, DUR], [0, 1], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
easing: Easing.bezier(0.16, 1, 0.3, 1),
});
return (
<span
key={i}
style={{
display: 'inline-block',
opacity: p,
filter: `blur(${(1 - p) * 12}px)`,
transform: `translateY(${(1 - p) * 18}px)`,
willChange: 'transform, filter, opacity',
}}
>
{word}
</span>
);
})}
</span>
);
};
A palavra de destaque é o mesmo componente com delay definido 120–200ms depois, mais sua própria cor e um scale(1.04).
Câmera — push sempre ativo
Envolva a cena inteira. Superescala para que as bordas nunca apareçam.
const Camera: React.FC<{children: React.ReactNode; durationInFrames: number}> = ({
children, durationInFrames,
}) => {
const frame = useCurrentFrame();
const scale = interpolate(frame, [0, durationInFrames], [1.0, 1.08], {
extrapolateRight: 'clamp',
easing: Easing.out(Easing.sin),
});
return (
<AbsoluteFill style={{transform: `scale(${scale})`, willChange: 'transform'}}>
{children}
</AbsoluteFill>
);
};
Coloque a câmera acima da camada de fundo e abaixo de qualquer elemento que deva ficar fixo na borda do quadro.
Pilha de cartões escalonada
const cards = ['Um', 'Dois', 'Três'];
const ms = useMs();
{cards.map((label, i) => {
const local = frame - i * ms(160);
const p = interpolate(local, [0, ms(600)], [0, 1], {
extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
easing: Easing.out(Easing.poly(4)),
});
return (
<div key={i} style={{
opacity: p,
transform: `translateY(${(1 - p) * 40}px)`,
}}>{label}</div>
);
})}
Saída — metade da entrada
const exitStart = durationInFrames - ms(300);
const out = interpolate(frame, [exitStart, durationInFrames], [1, 0], {
extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
easing: Easing.in(Easing.cubic),
});
Estrutura
Use <Sequence from={...} durationInFrames={...}> por batida, guiada diretamente pela tabela de motion-plan. Um Sequence por linha. As durações das batidas vêm do plano, não de números redondos.
<Series>
<Series.Sequence durationInFrames={ms(5200)}><BeatTwo /></Series.Sequence>
<Series.Sequence durationInFrames={ms(2100)}><BeatThree /></Series.Sequence>
</Series>
Determinismo
- Nunca
Math.random()— se precisar de dispersão, derive-a do índice do elemento. - Nunca
Date.now()ounew Date(). - Nunca faça fetch dentro de um componente. Pré-carregue com
staticFile()/delayRender(). <Video>/<Audio>deve ser<OffthreadVideo>quando possível para correção da renderização.
Pegadinhas
filter: blur()em muitos elementos simultâneos é caro — limite o número de nós desfocados simultâneos ou pré-desfoque no asset.- Carregamento de fontes: use
@remotion/google-fontsoudelayRenderem torno de umFontFace.load()local, ou os primeiros quadros renderizarão em uma fonte alternativa. interpolatelança um erro se o intervalo de entrada não for monotonicamente crescente — proteja intervalos computados.- Sempre passe
extrapolateLeft/extrapolateRight: 'clamp'a menos que você especificamente queira que o valor ultrapasse o intervalo.
Apêndice B — Receitas para HyperFrames / GSAP
HyperFrames compõe HTML + GSAP e renderiza por amostragem de quadros de um navegador headless. Determinismo é obrigatório.
Execute npx hyperframes docs para a API atual. Este arquivo é o padrão de movimento sobre ela — veja a skill hyperframes para o pipeline (init → preview → lint → render).
A regra de clipping (quebra renderizações se violada)
Cada elemento temporizado precisa de data-start, data-duration, data-track-index e class="clip". O framework controla a visibilidade e a transformação em .clip.
Nunca anime o próprio elemento .clip com GSAP. Anime um wrapper filho.
<div class="clip" data-start="4.2" data-duration="5.2" data-track-index="2">
<div class="cam"> <!-- movimentos da câmera aqui -->
<div class="inner"> <!-- movimento do elemento aqui -->
<h1 class="headline">…</h1>
</div>
</div>
</div>
Registro da timeline
const tl = gsap.timeline({paused: true});
window.__timelines['main'] = tl; // id deve corresponder a data-composition-id
Pausada, sempre. O renderizador a posiciona (seek).
Mapa de easing
| Nome da tabela | GSAP |
|---|---|
| out-expo | expo.out |
| out-cubic | power2.out |
| out-quint | power4.out |
| out-back (limitado) | back.out(1.2) |
| in-out-cubic | power2.inOut |
| out-sine | sine.out |
| in-cubic (saídas) | power2.in |
Texto — pop-blur-fade, palavra por palavra
Divida em spans de palavra no momento da autoria (não dependa de um divisor em tempo de execução — ele pode competir com o primeiro quadro amostrado).
<h1 class="headline">
<span class="w">O</span> <span class="w">que</span>
<span class="w accent">parece</span> <span class="w">disciplina</span>
</h1>
tl.from('.headline .w', {
y: 18,
opacity: 0,
filter: 'blur(12px)',
duration: 0.48,
ease: 'expo.out',
stagger: 0.07,
}, 0);
// palavra de destaque chega por último e de forma diferente
tl.from('.headline .accent', {
scale: 0.96,
color: 'var(--surface)',
duration: 0.5,
ease: 'expo.out',
}, 0.18);
Câmera
Anime .cam, nunca .clip.
tl.fromTo('.cam',
{scale: 1.0},
{scale: 1.08, duration: 5.2, ease: 'sine.out', force3D: true},
0);
.cam { will-change: transform; transform: translateZ(0); }
Superescala a camada em movimento cerca de 6% além do quadro para que as bordas nunca apareçam durante um push-out ou drift.
Pilha de cartões escalonada
tl.from('.card', {
y: 40, opacity: 0,
duration: 0.6, ease: 'power4.out', stagger: 0.16,
}, 1.2);
// destaque de luz chega 150ms após o painel
tl.fromTo('.card .sweep', {xPercent: -140}, {
xPercent: 140, duration: 0.7, ease: 'power2.inOut', stagger: 0.16,
}, 1.35);
Desenho de traço
tl.fromTo('.connector', {drawSVG: '0%'}, {drawSVG: '100%', duration: 0.8, ease: 'power2.inOut'});
// sem DrawSVGPlugin? use stroke-dasharray/offset:
tl.fromTo('.connector', {strokeDashoffset: 1000}, {strokeDashoffset: 0, duration: 0.8, ease: 'power2.inOut'});
Regras rígidas
- Apenas determinístico — sem
Math.random(), semDate.now(), sem fetch, semrepeat: -1. - 9:16 = 1080×1920. Defina
#root { container-type: size; }e dimensione tudo emcqw/cqh(1cqw = 10.8px), nuncavw/vh. - Clips adjacentes no mesmo track não devem se tocar. A matemática de ponto flutuante faz
3.2 + 0.35 = 3.5500000000000003, o que sobrepõe um clip começando em3.55e causaoverlapping_clips_same_track. Deixe uma lacuna ou use durações como0.34. - Áudio: vídeos são
muted; use uma faixa<audio>mestre pré-misturada (VO + SFX misturados com ffmpegadelay+amix) em umdata-track-indexalto dedicado. Múltiplas faixas de áudio podem dessincronizar entre as passadas de renderização.