Communitygithub.com

bardu-rgb/reels

Contenido, animación y mejores prácticas para efectos en Remotion.

¿Qué es reels?

Esta habilidad proporciona una guía completa para escribir marcado React en Remotion, centrándose en contenido, animación y efectos visuales. Es útil para desarrolladores que buscan crear videos animados programáticamente con control fino sobre la sincronización y la interactividad. La habilidad es compatible con plataformas como Claude Code, Cursor, Codex y el Studio de Remotion, y se basa en un archivo SKILL.md que detalla prácticas recomendadas. Incluye reglas para preservar cambios del usuario, usar `useCurrentFrame()` e `interpolate()` para animaciones, estructurar componentes interactivos con `Interactive.withSchema()`, y manejar activos, medios, transiciones y efectos como desenfoque de movimiento o contenido 3D. También cubre temas avanzados como voiceover, subtítulos, mapas, fuentes y medición de DOM.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/bardu-rgb/reels/tree/HEAD/.agents/skills/remotion-markup

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Vista previa

Del README del skill

Documentación

Esta es una guía para escribir React Markup en Remotion. Si esto no es relevante, carga Mejores Prácticas de Remotion en su lugar.

Preservar cambios del usuario

Los usuarios pueden hacer ediciones en el código fuera de la conversación.

Si detectas un cambio sorprendente realizado mientras tanto, no lo sobrescribas, asume que fue intencional o pide confirmación.

Reglas generales

Dentro de un componente de composición o escena, obtén fps de useVideoConfig() para todos los cálculos de segundos a fotogramas, incluyendo props de sincronización como from, trimBefore, durationInFrames y premountFor. Mantener la expresión en el nodo JSX, como trimBefore={4 * fps}, permite que Studio edite la sincronización y la mantiene correcta si la tasa de fotogramas de la composición cambia.

Impulsa las animaciones usando useCurrentFrame() e interpolate().
CSS transition o animation no se renderizarán correctamente, necesitan ser refactorizados.
Las clases de animación de Tailwind no se renderizarán correctamente, necesitan ser refactorizadas.

Usa Easing.bezier() y Easing.spring() para personalizar la sincronización.

Estructura tu marcado según las Mejores Prácticas de Interactividad de Remotion. Prefiere Interactive.withSchema({wrapInSequence: true}) para componentes visuales personalizados con props editables, y registra escenas reutilizables como composiciones conectadas. Coloca la sincronización directamente en los componentes que lo soporten; evita envoltorios redundantes de <Sequence>. Otorga a cada componente sincronizado que soporte premountFor un segundo de premontaje: premountFor={fps}, donde fps proviene de useVideoConfig(). Aplica esto a medios, componentes interactivos, <Sequence>, <Series.Sequence>, <TransitionSeries.Sequence>, y <TransitionSeries.Overlay>, incluyendo componentes sincronizados anidados dentro de escenas. También premonta el elemento de la línea de tiempo padre cuando un elemento anidado necesite montarse antes de que el padre comience. Un componente sin premountFor, como <TransitionSeries.Transition>, no necesita sustituto.

Studio edita el nodo fuente JSX que creó un elemento. Autoriza cada registro de composición, clip, escena, capa y secuencia que deba ser editable de forma independiente como su propio nodo JSX, con sus props editables en línea. Los bucles programáticos son adecuados cuando las instancias generadas se controlan intencionalmente como una plantilla fuente única, no cuando los usuarios necesitan editar las instancias por separado.

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

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

  return (
    <Interactive.Div
      name="Title"
      premountFor={fps}
      style={{
        opacity: interpolate(frame, [0, 2 * fps], [0, 1], {
          extrapolateRight: "clamp",
          extrapolateLeft: "clamp",
          easing: Easing.bezier(0.16, 1, 0.3, 1),
        }),
      }}
    >
      ¡Hola Mundo!
    </Interactive.Div>
  );
};

Mantén la llamada a interpolate() en línea en la prop style. Usa las propiedades CSS scale, translate, rotate en lugar de transform.

// 👍 Fotogramas clave en línea y abreviaturas de transformación editables
style={{
  scale: interpolate(frame, [0, 100], [0, 1], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
    output: 'perceptual-scale' // Para animaciones `scale`, usa "output: 'perceptual-scale'"
  }),
  translate: interpolate(frame, [0, 100], ["0px 0px", "100px 100px"], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
  }),
  rotate: interpolate(frame, [0, 100], ["20deg", "90deg"], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
  }),
}}

// 👎 Los valores no en línea y las cadenas de transformación se vuelven más difíciles de editar en Studio
const scale = interpolate(frame, [0, 100], [0, 1]);

style={{
  transform: `scale(${scale})`,
}}

Activos

Coloca los activos en la carpeta public/ en la raíz de tu proyecto. Usa staticFile() para referenciar archivos desde la carpeta public/.

Componentes multimedia

Agrega video y audio usando <Video> y <Audio> de @remotion/media.
Agrega imágenes usando el componente <CanvasImage>. Agrega imágenes animadas GIF, APNG, WebP o AVIF usando <AnimatedImage>, usa @remotion/gif si no usas Chrome. Usa staticFile() para archivos en public/ o pasa una URL remota directamente:

import { Audio, Video } from "@remotion/media";
import { staticFile, CanvasImage, AnimatedImage, useVideoConfig } from "remotion";

export const MyComposition = () => {
  const {fps} = useVideoConfig();

  return (
    <>
      <Video src={staticFile("video.mp4")} premountFor={fps} style={{ opacity: 0.5 }} />
      <Audio src={staticFile("audio.mp3")} premountFor={fps} />
      <CanvasImage
        src={staticFile("logo.png")}
        premountFor={fps}
        style={{ width: 100, height: 100 }}
      />
      <Video src="https://remotion.media/video.mp4" premountFor={fps} />
      <AnimatedImage src={staticFile('nyancat.gif')} premountFor={fps} />
    </>
  );
};

Si la composición es principalmente una línea de tiempo de clips de video o audio, lee video-editing.md antes de elegir su estructura fuente.

Escena de ejemplo

Un video de fondo con un tercio inferior. El tercio inferior es un componente interactivo con su propia línea de tiempo, registrado como una composición conectada. Su texto se pasa como children y accentColor es una prop editable. El fundido de entrada está animado por fotogramas clave en línea en el lugar de la llamada.

// MyScene.tsx
import { Video } from "@remotion/media";
import { Easing, interpolate, useCurrentFrame, useVideoConfig } from "remotion";
import { LowerThird } from "./LowerThird";

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

  return (
    <>
      <Video
        name="Background"
        src="https://remotion.media/video.mp4"
        premountFor={fps}
        objectFit="cover"
        style={{
          position: "absolute",
          width: "100%",
          height: "100%",
        }}
      />
      <LowerThird
        name="Lower third"
        from={1 * fps}
        premountFor={fps}
        accentColor="#0b84f3"
        style={{
          opacity: interpolate(frame, [1 * fps, 2 * fps], [0, 1], {
            extrapolateRight: "clamp",
            extrapolateLeft: "clamp",
            easing: Easing.bezier(0.16, 1, 0.3, 1),
          }),
        }}
      >
        Jane Doe, Diseñadora de Producto
      </LowerThird>
    </>
  );
};
// LowerThird.tsx
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: "Color de acento",
  },
} as const satisfies InteractivitySchema;

export const LowerThird = Interactive.withSchema({
  Component: LowerThirdInner,
  componentName: "<LowerThird>",
  schema: lowerThirdSchema,
  wrapInSequence: true,
});
// Root.tsx
import { Composition } from "remotion";
import { LowerThird } from "./LowerThird";
import { MyScene } from "./MyScene";

export const RemotionRoot: React.FC = () => {
  return (
    <>
      <Composition
        id="MyScene"
        component={MyScene}
        durationInFrames={60}
        fps={30}
        width={1280}
        height={720}
      />
      <Composition
        id="LowerThird"
        component={LowerThird}
        durationInFrames={30}
        fps={30}
        width={1280}
        height={720}
        defaultProps={{
          children: "Jane Doe, Diseñadora de Producto",
          accentColor: "#0b84f3",
        }}
      />
    </>
  );
};

Retraso, recorte

Coloca la sincronización directamente en los componentes que lo soporten. Consulta Props de sincronización para las props soportadas, ejemplos y orden de operaciones.

Mapas

Consulta Remotion Maps si deseas incluir mapas en el video.

Resaltados de texto y anotaciones

Consulta text-highlights.md para resaltados de texto (marcadores de resaltado), círculos, subrayados, tachados, texto tachado y cuadros.

Videos multi-escena

Consulta multi-scene-video.md si planeas hacer un video con múltiples escenas consecutivas.

Composiciones conectadas

Cuando una escena o grupo de capas merezca su propia línea de tiempo editable, sigue connected-compositions.md. Prefiere esta estructura para escenas sustanciales en un video multi-escena.

Acción de pre-componer

Para una solicitud de Studio como Pre-componer Resplandor ambiental (src/BarChart.tsx:134), encuentra el marcado de la secuencia seleccionada en la ubicación dada. Crea una composición conectada, siguiendo connected-compositions.md: extrae el marcado en un componente con nombre, preferiblemente hazlo interactivo con Interactive.withSchema({wrapInSequence: true}), y registra la misma referencia de componente exportada con un <Composition> único en la raíz. Renderiza el componente interactivo directamente con sus props de sincronización, o como el único hijo de una secuencia cuando ese envoltorio tenga un propósito. Si el nodo seleccionado ya es una secuencia, conserva sus props y extrae sus hijos. El registro necesita dimensiones, fps, duración y defaultProps equivalentes a su uso parental. Una extracción de componente sin una composición registrada no completa una solicitud de pre-composición.

Transfiere los estilos heredados como fontFamily y la carga de fuentes al componente extraído; consulta independencia parental.

Voiceover

Consulta voiceover.md para agregar un voiceover generado por IA a las composiciones de Remotion usando ElevenLabs TTS.

Incrustar videos

Consulta embedding-videos.md para conocimiento avanzado sobre incrustación de videos: recorte, volumen, velocidad, bucle y tono.

Incrustar audio

Consulta audio.md para funciones avanzadas de audio como recorte, volumen, velocidad y tono.

Recorte

Consulta cropping.md si necesitas recortar el rectángulo visible de un componente.

Transiciones

Consulta transitions.md para patrones de transición de escenas.

Desenfoque de movimiento

Al agregar desenfoque de movimiento o una estela de movimiento, lee motion-blur.md para el enfoque preferido de HTML en canvas, requisitos de vista previa y alternativas.

Efectos visuales y de píxeles

Al crear un efecto visual, considera si es factible usando CSS y HTML, o si se necesita un sombreador.
Orden de preferencia:

  1. HTML + CSS regular u otras técnicas web
  2. Un efecto aplicado directamente al elemento (<Video>, <Img>), o envolviendo el contenido en <HtmlInCanvas>, que también acepta effects:
  • Un efecto listado a través de effects.md
  • Un createEffect() personalizado a través de effects.md cuando no haya un ajuste preestablecido disponible.

Contenido 3D

Consulta ./3d.md para contenido 3D en Remotion usando Three.js y React Three Fiber.

Efectos de sonido

Cuando necesites usar efectos de sonido, carga el archivo ./sfx.md para más información.

Visualización de audio

Cuando necesites visualizar audio (barras de espectro, formas de onda, efectos reactivos a graves), carga el archivo ./audio-visualization.md para más información.

Mapas

Para mapas estáticos, rutas animadas y marcadores, explicadores geográficos, Mapbox, MapLibre, MapTiler, GeoJSON, o sobrevuelos geográficos 3D, carga Remotion Maps.

Subtítulos

Al tratar con subtítulos o leyendas, carga la habilidad de Subtítulos de Remotion para más información.

Google Fonts

Es la forma recomendada de cargar fuentes en Remotion. Consulta google-fonts.md para saber cómo cargar Google Fonts.

Fuentes locales

Consulta local-fonts.md para saber cómo cargar fuentes locales.

GIFs

Consulta gifs.md para saber cómo mostrar GIFs sincronizados con la línea de tiempo de Remotion.

Imágenes avanzadas

Consulta images.md para dimensionar y posicionar imágenes, rutas dinámicas de imágenes y obtener dimensiones de imágenes.

Animaciones Lottie

Consulta lottie.md para incrustar animaciones Lottie en Remotion.

Sincronización

Consulta timing.md para más técnicas de sincronización para interpolate().

Videos parametrizados

Consulta parameters.md para hacer una composición parametrizable añadiendo un esquema Zod.

Medición de nodos DOM

Consulta measuring-dom-nodes.md para medir dimensiones de elementos DOM en Remotion.

Medición de texto

Consulta measuring-text.md para medir dimensiones de texto, ajustar texto a contenedores y verificar desbordamiento.

Usando FFmpeg

Para algunas operaciones de video, como recortar videos o detectar silencio, se debe usar FFmpeg. Carga el archivo ./ffmpeg.md para más información.

Detección de silencio

Cuando necesites detectar y recortar segmentos silenciosos de archivos de video o audio, carga el archivo ./silence-detection.md.

Duración dinámica, dimensiones y datos

Consulta calculate-metadata.md para establecer dinámicamente la duración de la composición, dimensiones, y más.

Individual skills in this repo

This repo contains 5 individual skills — each has its own dedicated page.

Skills relacionados