Communitygithub.com

MengTo/Skills

Créez des pages d'atterrissage cinématographiques pilotées par le défilement avec un défilement fluide Lenis, GSAP ScrollTrigger, des progressions liées au défilement, des révélations de texte décalées, des piles de cartes persistantes, des arrière-plans en parallaxe, des transitions synchronisées au défilement, des révélations de pied de page et des préchargeurs immersifs. À utiliser lors de l'analyse ou de la création d'expériences éditoriales premium, de piles de projets persistantes, de typographie cinétique ou de narration section par section.

Qu'est-ce que Skills ?

Ce skill permet de construire des pages de narration visuelle premium, où le défilement devient le vecteur principal de l'expérience utilisateur. Il s'appuie sur GSAP, ScrollTrigger et Lenis pour orchestrer des animations complexes : révélations de texte mot par mot, piles de cartes persistantes avec échelle et profondeur, parallaxe subtile, transitions synchronisées et préchargeur cinématographique. Chaque section peut se dévoiler progressivement avec flou, opacité, et translation, tandis que les scènes épinglées avec scrubbing offrent une maîtrise totale du rythme. Le skill inclut une gestion intégrée de l'accessibilité (préférence de mouvement réduite) et un ordre de construction clair : statique d'abord, puis préchargeur, révélations textuelles, sections, piles persistantes, parallaxe, et enfin scènes épinglées. Les tokens de mouvement (durées, easings, staggers) sont prédéfinis pour garantir une cohérence esthétique haut de gamme. Il évite les effets brusques ou trop nombreux, privilégiant une élégance sobre et immersive. Parfait pour les portfolios de studios créatifs, les pages produit, ou tout site nécessitant une mise en scène éditoriale sophistiquée, ce skill fournit des patrons de code réutilisables (HTML, JS, CSS) et une checklist QA complète. Il est conçu pour les environnements utilisant GSAP et Lenis, et s'intègre nativement avec les frameworks modernes via npm.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Aperçu

Depuis le README du skill

Skills preview

Documentation

Narration cinématographique pilotée par le défilement

Quand l'utiliser

  • Lorsqu'une page doit ressembler à une histoire éditoriale premium qui se déroule au fur et à mesure que l'utilisateur fait défiler.
  • L'utilisateur mentionne la narration par défilement, l'animation liée au défilement, les piles de cartes persistantes, la parallaxe, le texte fractionné, le préchargeur ou la progression cinématographique.
  • Un portfolio, un studio, un produit ou une page d'atterrissage a besoin de révélations section par section avec une profondeur en couches.
  • L'implémentation peut utiliser GSAP, ScrollTrigger et Lenis.

Vocabulaire des effets

  • Narration pilotée par le défilement : les sections se révèlent comme une séquence pendant le défilement.
  • Animation liée au défilement : la progression est directement liée au défilement avec scrub.
  • Mouvement déclenché par le défilement : l'animation démarre lorsqu'une section entre dans la zone d'affichage.
  • Révélation décalée : les mots, lignes, cartes ou éléments apparaissent avec de petits délais.
  • Révélation progressive : l'opacité, l'échelle, le flou, le clip ou la position changent en fonction de la progression du défilement.
  • Pile de cartes persistante : les cartes persistantes se superposent, se mettent à l'échelle et reculent à l'arrivée de la carte suivante.
  • Défilement parallaxe : les couches d'arrière-plan et de premier plan se déplacent à des vitesses différentes.
  • Synchronisation du défilement : l'animation suit la barre de défilement avec scrub: true ou scrub: 1.
  • Typographie cinétique : mouvement de texte fractionné masqué, généralement mot par mot ou ligne par ligne.
  • Préchargeur : écran de chargement d'ouverture, barre de progression et transition d'introduction.

Ambiance recherchée

  • Site web éditorial de luxe.
  • Portfolio de studio créatif haut de gamme.
  • Polissage du mouvement de type Apple.
  • Langage d'interaction moderne de type Awwwards.
  • Page d'atterrissage cinématographique immersive.

À éviter :

  • Les mouvements rebondissants, élastiques ou ressortis.
  • Les sauts d'échelle agressifs.
  • Les effets flashy de style jeu vidéo.
  • Trop d'effets de défilement simultanés.
  • Le détournement du défilement qui rend la page difficile à lire.

Stack de base

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 mouvement

  • Easing d'entrée : power3.out ou power4.out.
  • Scènes synchronisées : ease: "none" avec scrub: 0.8 à 1.4.
  • Durée de révélation du texte : 0.8s à 1.1s.
  • Durée de révélation des cartes : 0.9s à 1.2s.
  • Décalage des mots : 0.035s à 0.07s.
  • Décalage des lignes : 0.08s à 0.14s.
  • Décalage des cartes : 0.06s à 0.1s.
  • Décalage de révélation : y: 24 à 48.
  • Flou : 4px à 10px, puis 0px.
  • Profondeur d'échelle de la carte persistante : 1 jusqu'à 0.92.

Anatomie de la page

  1. Préchargeur : écran noir, barre de progression, marque/titre, fondu d'introduction.
  2. Hero : parallaxe d'image, révélation de titre masqué, indication subtile de défilement.
  3. Introduction : typographie cinétique mot par mot.
  4. Sections d'histoire : révélations par fondu, flou et clip déclenchées par le défilement.
  5. Projets récents : pile de cartes persistante avec échelle et profondeur en couches.
  6. Galerie ou preuve : révélations horizontales ou progressives synchronisées au défilement.
  7. Pied de page : révélation en parallaxe ou transition lente vers le haut.

Modèle de balisage

<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>Un design qui se dévoile avec retenue cinématographique.</h1>
  </section>

  <section data-story-section>
    <p data-split-reveal="words">Chaque bloc arrive avec une intention silencieuse.</p>
  </section>

  <section class="project-stack" data-sticky-stack>
    <article data-stack-card>Projet Un</article>
    <article data-stack-card>Projet Deux</article>
    <article data-stack-card>Projet Trois</article>
  </section>

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

Séquence du préchargeur

Utilisez un préchargeur pour établir le ton cinématographique, puis passez à la révélation du 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");
  });
}

Révélation de texte fractionné

Utilisez des conteneurs de débordement masqués. Évitez de fractionner le texte contenant des liens ou un balisage en ligne significatif.

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;
}

Révélations déclenchées par le défilement

Utilisez-les pour les sections normales. Elles doivent jouer une fois et donner une sensation de composition, pas de nervosité.

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,
        },
      }
    );
  });
}

Progression liée au défilement

Utilisez des timelines synchronisées pour une progression cinématographique. Gardez l'animation synchronisée linéaire et laissez la position de défilement gérer le minutage.

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);
  });
}

Pile de cartes persistante

Utilisez position: sticky pour la mise en page et ScrollTrigger pour l'échelle/la profondeur en couches. Les cartes précédentes doivent reculer à l'arrivée des cartes suivantes.

[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,
        },
      });
    });
  });
}

Parallaxe

Utilisez la parallaxe pour les images hero, les couches d'arrière-plan et les révélations de pied de page. Gardez la distance faible.

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,
      },
    });
  });
}

Révélation du pied de page en parallaxe :

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,
      },
    }
  );
}

Ordre de construction

  1. Construisez d'abord la page statique.
  2. Ajoutez le préchargeur et l'entrée du hero.
  3. Ajoutez les révélations de texte fractionné.
  4. Ajoutez les révélations section par section.
  5. Ajoutez la progression de la pile de cartes persistante.
  6. Ajoutez les couches de parallaxe.
  7. Ajoutez des scènes épinglées synchronisées uniquement là où l'histoire en a besoin.
  8. Ajoutez des solutions de repli pour mouvement réduit et tactile.
  9. Effectuez un contrôle qualité navigateur sur desktop et mobile.

Modèle de prompt

Créez une page d'atterrissage cinématographique pilotée par le défilement avec un défilement fluide Lenis, des animations GSAP ScrollTrigger, des révélations de texte décalées, une progression de pile de cartes persistante, des arrière-plans en parallaxe, des transitions synchronisées au défilement, une narration section par section et une animation de préchargeur immersive. Utilisez une profondeur en couches, des transitions d'échelle, des changements progressifs d'opacité et un mouvement fluide déclenché par la zone d'affichage pour une expérience éditoriale premium.

Liste de contrôle QA

  • Le contenu est lisible avec JavaScript désactivé.
  • Les utilisateurs avec mouvement réduit voient un contenu statique et aucune couche de défilement fluide.
  • Les révélations déclenchées par le défilement jouent une fois.
  • Les scènes liées au défilement utilisent scrub intentionnellement.
  • Les cartes persistantes ne chevauchent pas le pied de page et ne bloquent pas la page.
  • Le mouvement de parallaxe reste subtil et ne nuit pas à la lisibilité.
  • Le préchargeur se ferme de manière fiable même si les images se chargent lentement.
  • ScrollTrigger.refresh() s'exécute après les images/polices/changements de mise en page.
  • Le mobile a un épinglage simplifié ou pas d'épinglage si les performances chutent.

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.

Skills associés