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: trueouscrub: 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.outoupower4.out. - Scènes synchronisées :
ease: "none"avecscrub: 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, puis0px. - Profondeur d'échelle de la carte persistante :
1jusqu'à0.92.
Anatomie de la page
- Préchargeur : écran noir, barre de progression, marque/titre, fondu d'introduction.
- Hero : parallaxe d'image, révélation de titre masqué, indication subtile de défilement.
- Introduction : typographie cinétique mot par mot.
- Sections d'histoire : révélations par fondu, flou et clip déclenchées par le défilement.
- Projets récents : pile de cartes persistante avec échelle et profondeur en couches.
- Galerie ou preuve : révélations horizontales ou progressives synchronisées au défilement.
- 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
- Construisez d'abord la page statique.
- Ajoutez le préchargeur et l'entrée du hero.
- Ajoutez les révélations de texte fractionné.
- Ajoutez les révélations section par section.
- Ajoutez la progression de la pile de cartes persistante.
- Ajoutez les couches de parallaxe.
- Ajoutez des scènes épinglées synchronisées uniquement là où l'histoire en a besoin.
- Ajoutez des solutions de repli pour mouvement réduit et tactile.
- 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
scrubintentionnellement. - 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.
