Communitygithub.com

MengTo/Skills

Crie landing pages cinematográficas com rolagem suave Lenis, GSAP ScrollTrigger, progressão vinculada à rolagem, revelações de texto escalonadas, pilhas de cartões fixos, fundos com paralaxe, transições com scrub, revelações de rodapé e preloaders imersivos. Use ao analisar ou construir experiências editoriais premium de rolagem, pilhas de projetos fixas, tipografia cinética ou storytelling seção por seção.

O que é Skills?

Esta skill oferece um conjunto completo de padrões e componentes para construir landing pages premium com storytelling cinematográfico acionado pela rolagem. Ela se baseia em três pilares: Lenis para rolagem suave e responsiva, GSAP com ScrollTrigger para animações de alto desempenho e uma arquitetura modular de seções que inclui preloader imersivo, hero com paralaxe, tipografia cinética com revelação de palavras, pilhas de cartões fixos com profundidade escalonada, seções com revelação progressiva e rodapé com paralaxe. A skill é ideal para portfólios de estúdios criativos, sites de produtos premium ou qualquer página que precise de uma sensação editorial luxuosa e interativa. Ela suporta React, Vue, Svelte ou HTML/CSS/JS puro, e inclui diretrizes claras de motion design, como evitar movimentos elásticos ou agressivos, e respeitar preferências de movimento reduzido. O código é fornecido em JavaScript puro com exemplos de marcação HTML, mas pode ser adaptado para qualquer framework moderno. A skill também recomenda uma ordem de construção passo a passo e uma checklist de QA para garantir acessibilidade, desempenho em mobile e funcionamento com JavaScript desabilitado.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/MengTo/Skills/tree/HEAD/agent-skills/web-design/cinematic-scroll-storytelling

Perguntar na sua IA favorita

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

Prévia

Do README da skill

Skills preview

Documentação

Storytelling Cinematográfico com Rolagem

Quando Usar

  • Quando uma página deve parecer uma história editorial premium que se desenrola conforme o usuário rola.
  • O usuário menciona storytelling acionado por rolagem, animação vinculada à rolagem, pilhas de cartões fixos, paralaxe, texto dividido, preloader ou progressão cinematográfica.
  • Um portfólio, estúdio, produto ou landing page precisa de revelações seção por seção com profundidade em camadas.
  • A implementação pode usar GSAP, ScrollTrigger e Lenis.

Vocabulário de Efeitos

  • Storytelling acionado por rolagem: as seções revelam-se em sequência enquanto o usuário rola.
  • Animação vinculada à rolagem: o progresso é diretamente atrelado à rolagem com scrub.
  • Movimento acionado por rolagem: a animação começa quando uma seção entra no viewport.
  • Revelação escalonada: palavras, linhas, cartões ou elementos entram com pequenos atrasos.
  • Revelação progressiva: opacidade, escala, desfoque, recorte ou posição mudam com o progresso da rolagem.
  • Pilha de cartões fixos: cartões sticky se sobrepõem, escalam e recuam conforme o próximo cartão chega.
  • Rolagem com paralaxe: camadas de fundo e primeiro plano movem-se em velocidades diferentes.
  • Scrub de rolagem: a animação segue a barra de rolagem através de scrub: true ou scrub: 1.
  • Tipografia cinética: movimento de texto dividido com máscara, geralmente palavra por palavra ou linha por linha.
  • Preloader: tela de carregamento inicial, barra de progresso e transição de introdução.

Sensação Almejada

  • Site editorial de luxo.
  • Portfólio de estúdio criativo de alto nível.
  • Polimento de movimento no nível Apple.
  • Linguagem de interação moderna Awwwards.
  • Landing page cinematográfica imersiva.

Evitar:

  • Movimento elástico, bounce ou spring.
  • Saltos de escala agressivos.
  • Efeitos chamativos de estilo gamer.
  • Muitos efeitos de rolagem simultâneos.
  • Sequestro de rolagem que dificulta a leitura.

Stack Principal

npm i gsap lenis
import Lenis from "lenis";
import "lenis/dist/lenis.css";
import { gsap } from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";

gsap.registerPlugin(ScrollTrigger);

const reduceMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;

if (!reduceMotion) {
  const lenis = new Lenis({
    lerp: 0.08,
    smoothWheel: true,
    wheelMultiplier: 0.9,
  });

  lenis.on("scroll", ScrollTrigger.update);

  gsap.ticker.add((time) => {
    lenis.raf(time * 1000);
  });

  gsap.ticker.lagSmoothing(0);
}

window.addEventListener("load", () => ScrollTrigger.refresh());

Tokens de Movimento

  • Ease de entrada: power3.out ou power4.out.
  • Cenas com scrub: ease: "none" com scrub: 0.8 a 1.4.
  • Duração de revelação de texto: 0.8s a 1.1s.
  • Duração de revelação de cartão: 0.9s a 1.2s.
  • Escalonamento de palavras: 0.035s a 0.07s.
  • Escalonamento de linhas: 0.08s a 0.14s.
  • Escalonamento de cartões: 0.06s a 0.1s.
  • Offset de revelação: y: 24 a 48.
  • Desfoque: 4px a 10px, depois 0px.
  • Profundidade de escala de cartão fixo: 1 até 0.92.

Anatomia da Página

  1. Preloader: tela preta, barra de progresso, marca/título, fade de introdução.
  2. Hero: paralaxe de imagem, revelação de headline com máscara, dica sutil de rolagem.
  3. Introdução: tipografia cinética palavra por palavra.
  4. Seções de história: revelações fade-up, blur-in e clip acionadas por rolagem.
  5. Projetos Recentes: pilha de cartões fixos com escala e profundidade em camadas.
  6. Galeria ou prova: revelações horizontais ou progressivas com scrub.
  7. Rodapé: revelação com paralaxe ou transição lenta para cima.

Padrão de Marcação

<div class="preloader" data-preloader>
  <div class="preloader__bar" data-preloader-bar></div>
</div>

<main>
  <section class="hero" data-parallax-section>
    <img data-parallax-layer data-speed="-0.18" src="/hero.jpg" alt="">
    <h1 data-split-reveal>Design que se desenrola com contenção cinematográfica.</h1>
  </section>

  <section data-story-section>
    <p data-split-reveal="words">Cada bloco chega com intenção silenciosa.</p>
  </section>

  <section class="project-stack" data-sticky-stack>
    <article data-stack-card>Projeto Um</article>
    <article data-stack-card>Projeto Dois</article>
    <article data-stack-card>Projeto Três</article>
  </section>

  <footer data-footer-parallax>...</footer>
</main>

Sequência do Preloader

Use um preloader para definir o tom cinematográfico e depois faça a transição para a revelação do hero.

function initPreloader() {
  const loader = document.querySelector("[data-preloader]");
  const bar = document.querySelector("[data-preloader-bar]");
  if (!loader) return Promise.resolve();

  if (reduceMotion) {
    loader.remove();
    return Promise.resolve();
  }

  return new Promise((resolve) => {
    const tl = gsap.timeline({
      defaults: { ease: "power3.out" },
      onComplete: () => {
        loader.remove();
        resolve();
      },
    });

    tl.fromTo(bar, { scaleX: 0, transformOrigin: "left" }, { scaleX: 1, duration: 1.1 })
      .to(loader, { yPercent: -100, duration: 0.9, ease: "power4.inOut" }, "+=0.15");
  });
}

Revelação de Texto Dividido

Use contêineres com overflow oculto. Evite dividir texto que contenha links ou marcação inline significativa.

function splitWords(element) {
  if (element.dataset.splitReady === "true") return;

  const text = element.textContent || "";
  const parts = text.split(/(\s+)/);
  element.textContent = "";
  element.setAttribute("aria-label", text.trim());

  parts.forEach((part) => {
    if (!part.trim()) {
      element.appendChild(document.createTextNode(part));
      return;
    }

    const mask = document.createElement("span");
    const word = document.createElement("span");
    mask.className = "split-word-mask";
    word.className = "split-word";
    word.textContent = part;
    mask.setAttribute("aria-hidden", "true");
    mask.appendChild(word);
    element.appendChild(mask);
  });

  element.dataset.splitReady = "true";
}

function initSplitReveals() {
  if (reduceMotion) {
    gsap.set("[data-split-reveal]", { autoAlpha: 1 });
    return;
  }

  gsap.utils.toArray("[data-split-reveal]").forEach((element) => {
    splitWords(element);
    const words = element.querySelectorAll(".split-word");

    gsap.fromTo(
      words,
      { yPercent: 110, autoAlpha: 0, filter: "blur(8px)" },
      {
        yPercent: 0,
        autoAlpha: 1,
        filter: "blur(0px)",
        duration: 0.95,
        ease: "power4.out",
        stagger: 0.05,
        scrollTrigger: {
          trigger: element,
          start: "top 82%",
          once: true,
        },
      }
    );
  });
}
.split-word-mask {
  display: inline-block;
  overflow: hidden;
  vertical-align: top;
}

.split-word {
  display: inline-block;
  will-change: transform, opacity, filter;
}

Revelações Acionadas por Rolagem

Use estas para seções normais. Elas devem ser executadas uma vez e parecer compostas, não nervosas.

function initSectionReveals() {
  if (reduceMotion) {
    gsap.set("[data-story-section], [data-reveal-item]", { autoAlpha: 1, clearProps: "all" });
    return;
  }

  gsap.utils.toArray("[data-story-section]").forEach((section) => {
    const items = section.querySelectorAll("[data-reveal-item]");
    const targets = items.length ? items : section.children;

    gsap.fromTo(
      targets,
      { y: 36, autoAlpha: 0, filter: "blur(8px)" },
      {
        y: 0,
        autoAlpha: 1,
        filter: "blur(0px)",
        duration: 1,
        ease: "power4.out",
        stagger: 0.08,
        scrollTrigger: {
          trigger: section,
          start: "top 82%",
          once: true,
        },
      }
    );
  });
}

Progressão Vinculada à Rolagem

Use timelines com scrub para progressão cinematográfica. Mantenha a animação com scrub linear e deixe a posição de rolagem determinar o tempo.

function initProgressionScenes() {
  if (reduceMotion) return;

  gsap.utils.toArray("[data-progress-scene]").forEach((scene) => {
    const media = scene.querySelector("[data-progress-media]");
    const copy = scene.querySelectorAll("[data-progress-copy]");

    gsap.timeline({
      scrollTrigger: {
        trigger: scene,
        start: "top top",
        end: "+=140%",
        scrub: 1.1,
        pin: true,
        anticipatePin: 1,
      },
    })
      .fromTo(media, { scale: 1.08 }, { scale: 1, ease: "none" })
      .fromTo(copy, { autoAlpha: 0, y: 40 }, { autoAlpha: 1, y: 0, stagger: 0.15, ease: "none" }, 0.15);
  });
}

Pilha de Cartões Fixos

Use position: sticky para layout e ScrollTrigger para escala/profundidade em camadas. Cartões anteriores devem recuar conforme os posteriores chegam.

[data-sticky-stack] {
  position: relative;
}

[data-stack-card] {
  position: sticky;
  top: 12vh;
  transform-origin: center top;
  will-change: transform, opacity;
}
function initStickyCardStack() {
  if (reduceMotion) return;

  gsap.utils.toArray("[data-sticky-stack]").forEach((stack) => {
    const cards = gsap.utils.toArray(stack.querySelectorAll("[data-stack-card]"));

    cards.forEach((card, index) => {
      const nextCard = cards[index + 1];
      if (!nextCard) return;

      gsap.to(card, {
        scale: 0.92 + index * 0.015,
        autoAlpha: 0.72,
        y: -24,
        ease: "none",
        scrollTrigger: {
          trigger: nextCard,
          start: "top 78%",
          end: "top 24%",
          scrub: true,
          invalidateOnRefresh: true,
        },
      });
    });
  });
}

Paralaxe

Use paralaxe para imagens hero, camadas de fundo e revelações de rodapé. Mantenha a distância pequena.

function initParallax() {
  if (reduceMotion) return;

  gsap.utils.toArray("[data-parallax-layer]").forEach((layer) => {
    const speed = Number(layer.dataset.speed || -0.16);
    const section = layer.closest("[data-parallax-section]") || layer;

    gsap.to(layer, {
      y: () => window.innerHeight * speed,
      ease: "none",
      scrollTrigger: {
        trigger: section,
        start: "top bottom",
        end: "bottom top",
        scrub: 1,
        invalidateOnRefresh: true,
      },
    });
  });
}

Revelação de rodapé com paralaxe:

function initFooterReveal() {
  if (reduceMotion) return;

  const footer = document.querySelector("[data-footer-parallax]");
  if (!footer) return;

  gsap.fromTo(
    footer,
    { yPercent: -12, autoAlpha: 0.85 },
    {
      yPercent: 0,
      autoAlpha: 1,
      ease: "none",
      scrollTrigger: {
        trigger: footer,
        start: "top bottom",
        end: "top 45%",
        scrub: 1,
      },
    }
  );
}

Ordem de Construção

  1. Construa a página estática primeiro.
  2. Adicione preloader e entrada do hero.
  3. Adicione revelações de texto dividido.
  4. Adicione revelações seção por seção.
  5. Adicione progressão da pilha de cartões fixos.
  6. Adicione camadas de paralaxe.
  7. Adicione cenas fixas com scrub apenas onde a história precisar.
  8. Adicione fallbacks para movimento reduzido e toque.
  9. Execute QA no navegador em desktop e mobile.

Template de Prompt

Crie uma landing page cinematográfica com rolagem suave Lenis, animações GSAP ScrollTrigger, revelações de texto escalonadas, progressão de pilha de cartões fixos, fundos com paralaxe, transições com scrub, storytelling seção por seção e uma animação de preloader imersiva. Use profundidade em camadas, transições de escala, mudanças progressivas de opacidade e movimento suave acionado pelo viewport para uma experiência editorial premium.

Checklist de QA

  • O conteúdo é legível com JavaScript desabilitado.
  • Usuários com movimento reduzido veem conteúdo estático e nenhuma camada de rolagem suave.
  • Revelações acionadas por rolagem são executadas uma vez.
  • Cenas vinculadas à rolagem usam scrub intencionalmente.
  • Cartões fixos não sobrepõem o rodapé nem travam a página.
  • O movimento de paralaxe permanece sutil e não prejudica a legibilidade.
  • O preloader sai de forma confiável mesmo se as imagens carregarem lentamente.
  • ScrollTrigger.refresh() é executado após imagens/fontes/mudanças de layout.
  • O mobile tem pinning simplificado ou nenhum pinning se o desempenho cair.

Individual skills in this repo

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

MengTo/Skills

Create polished 60 fps 4:3 4K browser screen-recording style videos from Codex in-app browser captures, with browser-only crop, natural macOS cursor styling, deliberate click choreography, zoom-follow framing, ffprobe/thumbnail verification, and optional native recording compatibility checks. Use when the user asks to record or re-record browser actions, show cursor clicks and zooms, make Dribbble/UI inspiration or product demo recordings, or asks whether Codex, Playwright, or an MCP can produce a natural browser demo video.

MengTo/Skills

Generate ElevenLabs text-to-speech audio from scripts or inline text using local voice profiles. Use when the user asks for ElevenLabs, text-to-speech, TTS, narration, voiceover, speech audio, or voice generation; load voice names, voice ids, emails, owners, and account-specific defaults only from local config outside the skill.

MengTo/Skills

Profile, audit, and optimize frontend page performance with emphasis on animation work, memory-leak risks, long-session slowdowns, CSS animations, canvas/WebGL requestAnimationFrame loops, marquees, skeletons, GSAP/Three/Matter effects, timers, listeners, and observers. Use when the user asks to make animations performant, pause offscreen animations, look for memory leaks, profile pages that slow the computer over time, fix janky scrolling, reduce CPU/GPU use, or repeat the "only play in view" optimization on React/Vite/Next/frontend pages using Codex Browser.

MengTo/Skills

Turn a reference video into a super detailed recreation or inspiration prompt. Use when the user provides, mentions, uploads, links, or points to a video and asks to analyze the design, UI, animations, transitions, scroll interactions, typography, colors, assets, WebGL/Three.js, storytelling, section-by-section behavior, or to create a prompt/article that recreates the page, app, interaction, or motion system.

MengTo/Skills

Create an on-scroll animation trigger using IntersectionObserver with Tailwind-friendly animation classes and keyframes. Use when asked for scroll-reveal, animate-on-scroll, or sequencing element animations when they enter the viewport.

MengTo/Skills

Use when designing or implementing product-grade web motion like Stripe, Linear, Apple, and Vercel. Covers motion principles, easing/duration defaults, choreography patterns, scroll/hover interactions, performance, accessibility (reduced motion), and implementation guidance.

MengTo/Skills

Create premium cinematic web motion systems with GSAP, ScrollTrigger, and Lenis. Use for luxury editorial websites, creative studio portfolios, Awwwards-style interactions, smooth scroll reveals, staggered text, parallax, pinned sections, magnetic hover states, custom cursors, and mouse-reactive layered movement.

MengTo/Skills

Use when designing or rewriting a high-converting SaaS pricing page (structure, plan design, copywriting, SEO/AEO, FAQs, layout patterns, experiments). Includes checklists, templates, and common pitfalls.

MengTo/Skills

Use when creating or refining WebGL-heavy landing pages and you need to steer toward a specific visual outcome (premium, technical, playful, cinematic) while balancing conversion clarity, performance, and implementation complexity.

Habilidades Relacionadas