Communitygithub.com

tinh2/skills-hub-registry

Crie vídeos programaticamente com Remotion (React). Aborda composições, animações, sequenciamento, transições, incorporação de áudio/vídeo, física de molas, animações de texto, geração de voz com ElevenLabs TTS, integração FFmpeg, legendas, 3D com Three.js, gráficos e renderização. Baseado nas melhores práticas oficiais do Remotion.

O que é skills-hub-registry?

Esta habilidade permite que você crie vídeos programaticamente usando React com o framework Remotion. Ela cobre desde a configuração inicial do projeto até técnicas avançadas como animações baseadas em quadros, física de molas (spring), sequenciamento com `<Sequence>` e `<Series>`, transições com o pacote `@remotion/transitions`, e incorporação de áudio e vídeo com recursos como corte e volume dinâmico. A habilidade também inclui integração com ElevenLabs TTS para geração de voz, uso de FFmpeg para conversão de formatos, e boas práticas como o uso de `<OffthreadVideo>` para melhor desempenho de renderização. Baseada na documentação oficial e no repositório `remotion-dev/skills`, ela fornece exemplos práticos e regras essenciais para garantir vídeos renderizados corretamente, sem depender de animações CSS que não funcionam no ambiente do Remotion.

Funciona com✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/tinh2/skills-hub-registry/tree/HEAD/build/remotion

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Remotion -- Criação de Vídeos em React

Use esta habilidade ao trabalhar com código Remotion. O Remotion permite criar vídeos programaticamente usando componentes React.

Configuração do Projeto

npx create-video@latest meu-video
cd meu-video
npm start        # Visualizar no navegador
npm run render   # Renderizar para MP4

Composições

Um <Composition> define um vídeo renderizável com dimensões, fps e duração.

import { Composition } from "remotion";
import { MyVideo } from "./MyVideo";

export const RemotionRoot = () => (
  <Composition
    id="MyVideo"
    component={MyVideo}
    durationInFrames={300}
    fps={30}
    width={1920}
    height={1080}
    defaultProps={{ title: "Olá Mundo" } satisfies MeuVideoProps}
  />
);

Use declarações type para props (não interface) para segurança de tipo com defaultProps.

Use <Folder> para organizar composições na barra lateral. Use <Still> para saídas de quadro único (miniaturas, imagens OG).

Animações

Todas as animações DEVEM usar useCurrentFrame(). Transições CSS e classes de animação do Tailwind são PROIBIDAS -- elas não serão renderizadas corretamente.

import { useCurrentFrame, useVideoConfig, interpolate } from "remotion";

export const FadeIn = () => {
  const frame = useCurrentFrame();
  const { fps } = useVideoConfig();

  const opacity = interpolate(frame, [0, 2 * fps], [0, 1], {
    extrapolateRight: "clamp",
  });

  return <div style={{ opacity }}>Olá Mundo!</div>;
};

Animações com Spring

Springs fornecem movimento natural. Elas animam de 0 a 1.

import { spring, useCurrentFrame, useVideoConfig } from "remotion";

const frame = useCurrentFrame();
const { fps } = useVideoConfig();

const scale = spring({ frame, fps });
// Com configuração:
const smooth = spring({ frame, fps, config: { damping: 200 } }); // Sem salto
const snappy = spring({ frame, fps, config: { damping: 20, stiffness: 200 } });
const bouncy = spring({ frame, fps, config: { damping: 8 } });
const heavy  = spring({ frame, fps, config: { damping: 15, stiffness: 80, mass: 2 } });

Use o parâmetro delay para atrasar o início do spring:

const entrance = spring({ frame, fps, delay: 20 });

Interpolação

// Interpolação linear com clamp
const opacity = interpolate(frame, [0, 100], [0, 1], {
  extrapolateRight: "clamp",
  extrapolateLeft: "clamp",
});

// Interpolação de múltiplas etapas
const y = interpolate(frame, [0, 30, 60, 90], [100, 0, 0, -100]);

Sequenciamento

Sequence

Use <Sequence> para atrasar quando os elementos aparecem. Sempre use premountFor para pré-carregar componentes.

import { Sequence } from "remotion";

const { fps } = useVideoConfig();

<Sequence from={1 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
  <Title />
</Sequence>
<Sequence from={2 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
  <Subtitle />
</Sequence>

Use layout="none" para evitar o wrapper de posicionamento absoluto.

Series

Use <Series> para reprodução sequencial sem sobreposição:

import { Series } from "remotion";

<Series>
  <Series.Sequence durationInFrames={45}><Intro /></Series.Sequence>
  <Series.Sequence durationInFrames={60}><ConteudoPrincipal /></Series.Sequence>
  <Series.Sequence durationInFrames={30}><Outro /></Series.Sequence>
</Series>

offset negativo cria transições sobrepostas:

<Series.Sequence offset={-15} durationInFrames={60}>
  <CenaB />
</Series.Sequence>

Transições

npx remotion add @remotion/transitions
import { TransitionSeries, linearTiming } from "@remotion/transitions";
import { fade } from "@remotion/transitions/fade";
import { slide } from "@remotion/transitions/slide";
import { wipe } from "@remotion/transitions/wipe";

<TransitionSeries>
  <TransitionSeries.Sequence durationInFrames={60}>
    <CenaA />
  </TransitionSeries.Sequence>
  <TransitionSeries.Transition
    presentation={fade()}
    timing={linearTiming({ durationInFrames: 15 })}
  />
  <TransitionSeries.Sequence durationInFrames={60}>
    <CenaB />
  </TransitionSeries.Sequence>
</TransitionSeries>

Sobreposições de Vazamento de Luz

import { LightLeak } from "@remotion/light-leaks";

<TransitionSeries>
  <TransitionSeries.Sequence durationInFrames={60}>
    <CenaA />
  </TransitionSeries.Sequence>
  <TransitionSeries.Overlay durationInFrames={20}>
    <LightLeak />
  </TransitionSeries.Overlay>
  <TransitionSeries.Sequence durationInFrames={60}>
    <CenaB />
  </TransitionSeries.Sequence>
</TransitionSeries>

Uma sobreposição não pode ser adjacente a uma transição ou a outra sobreposição.

Áudio

npx remotion add @remotion/media
import { Audio } from "@remotion/media";
import { staticFile } from "remotion";

// Áudio básico
<Audio src={staticFile("audio.mp3")} />

// Com corte (valores em frames)
<Audio src={staticFile("audio.mp3")} trimBefore={2 * fps} trimAfter={10 * fps} />

// Controle de volume
<Audio src={staticFile("audio.mp3")} volume={0.5} />

// Volume dinâmico (callback recebe o frame)
<Audio src={staticFile("audio.mp3")} volume={(f) =>
  interpolate(f, [0, 30], [0, 1], { extrapolateRight: "clamp" })
} />

// Mudança de velocidade
<Audio src={staticFile("audio.mp3")} playbackRate={1.5} />

// Atraso no início do áudio
<Sequence from={1 * fps}>
  <Audio src={staticFile("audio.mp3")} />
</Sequence>

Múltiplos componentes <Audio> são sobrepostos automaticamente.

Incorporação de Vídeo

import { Video } from "@remotion/media";

// Vídeo básico
<Video src={staticFile("video.mp4")} />

// Com corte
<Video src={staticFile("video.mp4")} trimBefore={2 * fps} trimAfter={10 * fps} />

// Velocidade, volume, loop
<Video src={staticFile("video.mp4")} playbackRate={2} volume={0.5} loop />

// Para desempenho de renderização, use OffthreadVideo
import { OffthreadVideo } from "remotion";
<OffthreadVideo src={staticFile("video.mp4")} />

SEMPRE use <OffthreadVideo> para melhor desempenho de renderização. Use <Video> apenas durante a pré-visualização.

Locução com ElevenLabs TTS

Gere áudio por cena e use calculateMetadata para dimensionar a composição dinamicamente.

Gerar Áudio

const response = await fetch(
  `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
  {
    method: "POST",
    headers: {
      "xi-api-key": process.env.ELEVENLABS_API_KEY!,
      "Content-Type": "application/json",
      Accept: "audio/mpeg",
    },
    body: JSON.stringify({
      text: "Bem-vindo ao show.",
      model_id: "eleven_multilingual_v2",
      voice_settings: { stability: 0.5, similarity_boost: 0.75, style: 0.3 },
    }),
  },
);
const audioBuffer = Buffer.from(await response.arrayBuffer());
writeFileSync(`public/locucao/cena-01.mp3`, audioBuffer);

Duração Dinâmica

import { CalculateMetadataFunction, staticFile } from "remotion";

const FPS = 30;
const CENAS = ["locucao/cena-01.mp3", "locucao/cena-02.mp3"];

export const calculateMetadata: CalculateMetadataFunction<Props> = async () => {
  const durations = await Promise.all(
    CENAS.map((file) => getAudioDuration(staticFile(file)))
  );
  const totalFrames = durations.reduce((sum, d) => sum + Math.ceil(d * FPS), 0);
  return { durationInFrames: totalFrames };
};

Ativos

Coloque os arquivos em public/ e faça referência com staticFile():

import { staticFile, Img } from "remotion";

<Img src={staticFile("logo.png")} />

NUNCA use require() ou import para arquivos de mídia. Sempre use staticFile().

Fontes

import { loadFont } from "@remotion/google-fonts/Inter";
const { fontFamily } = loadFont();

// Ou fontes locais
const { fontFamily } = loadFont({
  url: staticFile("fonts/MinhaFonte.woff2"),
  display: "swap",
});

FFmpeg no Remotion

FFmpeg já está incluído -- não é necessário instalar:

bunx remotion ffmpeg -i input.mp4 output.mp3
bunx remotion ffprobe input.mp4

Para cortar, prefira as props trimBefore/trimAfter em vez do FFmpeg. Use FFmpeg para conversão de formatos ou operações que o Remotion não pode fazer nativamente.

Ao usar FFmpeg para cortar, é NECESSÁRIO recodificar para evitar quadros congelados:

bunx remotion ffmpeg -ss 00:00:05 -i public/input.mp4 -to 00:00:10 -c:v libx264 -c:a aac public/output.mp4

Renderização

# Renderizar composição específica
npx remotion render MyVideo output.mp4

# Renderizar um quadro estático
npx remotion still MyVideo --frame=100 thumbnail.png

# Com props personalizadas
npx remotion render MyVideo output.mp4 --props='{"title": "Personalizado"}'

# Codec específico
npx remotion render MyVideo output.webm --codec=vp8

Padrões Comuns

Vídeo Baseado em Cenas

const CENAS = [
  { component: CenaTitulo, duration: 90 },
  { component: CenaProblema, duration: 150 },
  { component: CenaSolucao, duration: 120 },
  { component: CenaCTA, duration: 90 },
];

export const MyVideo = () => {
  let offset = 0;
  return (
    <>
      {CENAS.map(({ component: Component, duration }, i) => {
        const from = offset;
        offset += duration;
        return (
          <Sequence key={i} from={from} durationInFrames={duration}>
            <Component />
          </Sequence>
        );
      })}
    </>
  );
};

Música de Fundo + Locução

<>
  {/* Música de fundo em volume baixo */}
  <Audio src={staticFile("musica/bg.mp3")} volume={0.12} loop />

  {/* Locuções das cenas em volume total */}
  <Sequence from={0} durationInFrames={framesCena1}>
    <Audio src={staticFile("locucao/cena-01.mp3")} volume={1} />
  </Sequence>
  <Sequence from={framesCena1} durationInFrames={framesCena2}>
    <Audio src={staticFile("locucao/cena-02.mp3")} volume={1} />
  </Sequence>
</>

Regras Principais

  1. Sem animações CSS -- todo movimento via useCurrentFrame() + interpolate()/spring()
  2. Sem classes de animação do Tailwind -- elas não renderizam corretamente
  3. Sempre staticFile() para ativos, nunca require()
  4. Sempre pré-monte Sequences com premountFor
  5. Use <OffthreadVideo> em vez de <video> para renderização
  6. Escreva durações em segundos e multiplique por fps
  7. Use a palavra-chave satisfies para segurança de tipo com defaultProps

Fonte: remotion-dev/skills, remotion.dev

Habilidades Relacionadas