Kinematografisches GSAP-Lenis-Bewegungssystem
Verwendung
- Die Website benötigt eine erstklassige Motion-Sprache, nicht nur eine isolierte Animation.
- Sanftes Scrollen, Scroll-Enthüllungen, Pinned-Szenen, Parallax, Hover-Bewegungen und Cursor-Verhalten sollen sich verbunden anfühlen.
- Das angestrebte Gefühl ist: luxuriöses Editorial, Apple-ähnliche Raffinesse, kreatives Studio-Portfolio oder immersives, kinematografisches Storytelling.
- Der Technologie-Stack kann GSAP, ScrollTrigger und Lenis verwenden.
Bewegungsästhetik
- Sanft, elegant, leicht verzögert und bewusst.
- Gestaffelte Bewegungen sollten die Lesereihenfolge leiten.
- Geschichtete Bewegungen sollen Tiefe erzeugen, ohne die Benutzeroberfläche überladen wirken zu lassen.
- ScrollTrigger sollte Szenen starten, wenn sie in den Viewport gelangen, nicht auf jede winzige Scrollbewegung reagieren.
- Bevorzuge Subtilität gegenüber Intensität.
Vermeide:
- Hüpfende, elastische, federnde oder verspielte Bewegungen.
- Schnelle, abrupte Übergänge.
- Große Skalensprünge.
- Überanimierte UI-Elemente.
- Auffällige Spiel-Effekte.
Basis-Tokens
- Eases:
power3.out,power4.out,expo.out. - Scroll Scrub:
scrub: 0.8bis1.4für kinematografische Verzögerung. - Enthüllungen:
0.75sbis1.1s. - Hover:
0.35sbis0.6s. - Cursor-Verzögerung:
0.25sbis0.45s. - Text-Staffelung: Wörter
0.035sbis0.07s, Zeilen0.08sbis0.14s. - Karten-Staffelung:
0.06sbis0.1s. - Enthüllungs-Trigger:
start: "top 82%". - Pin-Übergabe:
anticipatePin: 1.
Einrichtung
Installation:
npm i gsap lenis
Einmal initialisieren, nachdem das DOM existiert. Lenis treibt seine RAF über den GSAP-Ticker an, sodass ScrollTrigger und sanftes Scrollen synchron bleiben.
import Lenis from "lenis";
import "lenis/dist/lenis.css";
import { gsap } from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";
gsap.registerPlugin(ScrollTrigger);
gsap.defaults({ ease: "power3.out", duration: 0.85 });
const reduceMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
let lenis;
if (!reduceMotion) {
lenis = new Lenis({
lerp: 0.08,
smoothWheel: true,
wheelMultiplier: 0.9,
anchors: true,
});
lenis.on("scroll", ScrollTrigger.update);
gsap.ticker.add((time) => {
lenis.raf(time * 1000);
});
gsap.ticker.lagSmoothing(0);
}
window.addEventListener("load", () => {
ScrollTrigger.refresh();
});
Markup-API
Verwende kleine Datenattribute, damit das Bewegungssystem seitenübergreifend wiederverwendet werden kann.
<h1 data-motion-text="lines">Digitale Produkte mit kinematografischer Zurückhaltung.</h1>
<p data-motion-text="words">Jede Interaktion sollte sich bewusst anfühlen.</p>
<section data-reveal-group>
<article data-reveal="fade-up" data-reveal-item>...</article>
<article data-reveal="fade-up" data-reveal-item>...</article>
</section>
<figure data-image-reveal data-parallax-section>
<img data-parallax-image src="/studio.jpg" alt="">
</figure>
<a data-magnetic data-cursor-label="Entdecken" href="/work">Entdecken</a>
<div data-cursor><span data-cursor-label></span></div>
CSS-Grundlage
html.has-motion [data-motion-text],
html.has-motion [data-reveal],
html.has-motion [data-reveal-item],
html.has-motion [data-image-reveal] {
visibility: hidden;
}
.motion-line-mask,
.motion-word-mask {
display: inline-block;
overflow: hidden;
vertical-align: top;
}
.motion-line,
.motion-word {
display: inline-block;
will-change: transform, opacity, filter;
}
[data-image-reveal] {
overflow: hidden;
}
[data-parallax-image] {
display: block;
width: 100%;
height: 115%;
object-fit: cover;
will-change: transform;
}
[data-cursor] {
position: fixed;
left: 0;
top: 0;
z-index: 9999;
pointer-events: none;
mix-blend-mode: difference;
transform: translate3d(-50%, -50%, 0);
will-change: transform;
}
@media (prefers-reduced-motion: reduce), (pointer: coarse) {
[data-cursor] {
display: none;
}
}
Gestaffelte Texteinblendungen
Verwende maskierte Container für erstklassigen Text. Bevorzuge manuelle Zeilenumbrüche, wenn exakte Zeilenumbrüche wichtig sind. Verwende Wort-Trennung für flexiblen, responsiven Text.
document.documentElement.classList.add("has-motion");
function splitWords(element) {
if (element.dataset.motionSplit === "true") return;
const text = element.textContent || "";
const parts = text.split(/(\s+)/);
element.textContent = "";
element.setAttribute("aria-label", text.trim());
let index = 0;
parts.forEach((part) => {
if (!part.trim()) {
element.appendChild(document.createTextNode(part));
return;
}
const mask = document.createElement("span");
const word = document.createElement("span");
mask.className = "motion-word-mask";
mask.setAttribute("aria-hidden", "true");
word.className = "motion-word";
word.textContent = part;
word.style.setProperty("--word-index", index);
mask.appendChild(word);
element.appendChild(mask);
index += 1;
});
element.dataset.motionSplit = "true";
}
function splitLines(element) {
if (element.dataset.motionLineSplit === "true") return;
if (element.querySelector(".motion-line")) return;
const text = (element.textContent || "").trim();
const lines = text.split(/\n+/).map((line) => line.trim()).filter(Boolean);
if (lines.length < 2) return;
element.textContent = "";
element.setAttribute("aria-label", text);
lines.forEach((line) => {
const mask = document.createElement("span");
const inner = document.createElement("span");
mask.className = "motion-line-mask";
mask.setAttribute("aria-hidden", "true");
inner.className = "motion-line";
inner.textContent = line;
mask.appendChild(inner);
element.appendChild(mask);
element.appendChild(document.createTextNode(" "));
});
element.dataset.motionLineSplit = "true";
}
function initTextReveals() {
if (reduceMotion) {
gsap.set("[data-motion-text]", { autoAlpha: 1, clearProps: "all" });
return;
}
gsap.utils.toArray("[data-motion-text='words']").forEach((element) => {
splitWords(element);
const words = element.querySelectorAll(".motion-word");
gsap.set(element, { autoAlpha: 1 });
gsap.fromTo(
words,
{ yPercent: 110, autoAlpha: 0, filter: "blur(8px)" },
{
yPercent: 0,
autoAlpha: 1,
filter: "blur(0px)",
duration: 0.9,
ease: "power4.out",
stagger: 0.055,
scrollTrigger: {
trigger: element,
start: "top 82%",
once: true,
},
}
);
});
gsap.utils.toArray("[data-motion-text='lines']").forEach((element) => {
splitLines(element);
const lines = element.querySelectorAll(".motion-line");
const targets = lines.length ? lines : element.children;
gsap.set(element, { autoAlpha: 1 });
gsap.fromTo(
targets,
{ yPercent: 100, autoAlpha: 0, filter: "blur(8px)" },
{
yPercent: 0,
autoAlpha: 1,
filter: "blur(0px)",
duration: 1,
ease: "power4.out",
stagger: 0.11,
scrollTrigger: {
trigger: element,
start: "top 84%",
once: true,
},
}
);
});
}
Zeilen-Markup, wenn exakte Zeilenumbrüche wichtig sind:
<h2 data-motion-text="lines">
<span class="motion-line-mask"><span class="motion-line">Kinematografische Bewegung</span></span>
<span class="motion-line-mask"><span class="motion-line">mit redaktioneller Zurückhaltung.</span></span>
</h2>
Scroll-Enthüllungen
Erstelle eine kleine Voreinstellungs-Map für Enthüllungen. Verwende autoAlpha, Transformationen und leichte Unschärfe. Verwende Unschärfe sparsam bei großen Elementen.
const revealPresets = {
"fade-up": { from: { y: 32, autoAlpha: 0 }, to: { y: 0, autoAlpha: 1 } },
"blur-in": { from: { y: 18, autoAlpha: 0, filter: "blur(10px)" }, to: { y: 0, autoAlpha: 1, filter: "blur(0px)" } },
"scale": { from: { scale: 0.96, autoAlpha: 0 }, to: { scale: 1, autoAlpha: 1 } },
"slide-left": { from: { x: 48, autoAlpha: 0 }, to: { x: 0, autoAlpha: 1 } },
"slide-right": { from: { x: -48, autoAlpha: 0 }, to: { x: 0, autoAlpha: 1 } },
};
function initScrollReveals() {
if (reduceMotion) {
gsap.set("[data-reveal], [data-reveal-item]", { autoAlpha: 1, clearProps: "all" });
return;
}
gsap.utils.toArray("[data-reveal-group]").forEach((group) => {
const items = group.querySelectorAll("[data-reveal-item]");
gsap.set(group, { autoAlpha: 1 });
gsap.fromTo(
items,
{ y: 36, autoAlpha: 0, filter: "blur(8px)" },
{
y: 0,
autoAlpha: 1,
filter: "blur(0px)",
duration: 0.95,
ease: "power4.out",
stagger: 0.075,
scrollTrigger: {
trigger: group,
start: "top 82%",
once: true,
},
}
);
});
gsap.utils.toArray("[data-reveal]:not([data-reveal-item])").forEach((element) => {
const preset = revealPresets[element.dataset.reveal] || revealPresets["fade-up"];
gsap.set(element, { autoAlpha: 1 });
gsap.fromTo(element, preset.from, {
...preset.to,
duration: 0.9,
ease: "power4.out",
delay: Number(element.dataset.revealDelay || 0),
scrollTrigger: {
trigger: element,
start: "top 84%",
once: true,
},
});
});
}
Clip-Bild-Enthüllungen
function initImageReveals() {
if (reduceMotion) {
gsap.set("[data-image-reveal]", { autoAlpha: 1, clipPath: "none" });
return;
}
gsap.utils.toArray("[data-image-reveal]").forEach((figure) => {
const image = figure.querySelector("img");
gsap.set(figure, { autoAlpha: 1 });
const tl = gsap.timeline({
scrollTrigger: {
trigger: figure,
start: "top 82%",
once: true,
},
});
tl.fromTo(
figure,
{ clipPath: "inset(0 0 100% 0)" },
{ clipPath: "inset(0 0 0% 0)", duration: 1.1, ease: "power4.out" }
).fromTo(
image,
{ scale: 1.08, autoAlpha: 0.75 },
{ scale: 1, autoAlpha: 1, duration: 1.2, ease: "power4.out" },
0
);
});
}
Parallax-Bewegung
Verwende Geschwindigkeitsunterschiede anstelle von dramatischen Bewegungen. Hintergründe bewegen sich langsamer als der Inhalt. Akzente im Vordergrund bewegen sich etwas schneller.
function initParallax() {
if (reduceMotion) return;
gsap.utils.toArray("[data-parallax-image], [data-parallax-layer]").forEach((layer) => {
const speed = Number(layer.dataset.parallaxSpeed || 0.18);
const section = layer.closest("[data-parallax-section]") || layer;
gsap.to(layer, {
y: () => window.innerHeight * speed * -1,
ease: "none",
scrollTrigger: {
trigger: section,
start: "top bottom",
end: "bottom top",
scrub: 1.2,
invalidateOnRefresh: true,
},
});
});
}
Pinned-Scroll-Abschnitte
Verwende Pinned-Abschnitte nur für Story-Momente. Halte scroll-synchronisierte Bewegungen linear und füge dann sanfte Enthüllungs-Tweens innerhalb der Szene hinzu.
function initHorizontalGalleries() {
if (reduceMotion) return;
gsap.utils.toArray("[data-horizontal-gallery]").forEach((section) => {
const track = section.querySelector("[data-horizontal-track]");
if (!track) return;
gsap.to(track, {
x: () => -(track.scrollWidth - window.innerWidth),
ease: "none",
scrollTrigger: {
trigger: section,
start: "top top",
end: () => `+=${track.scrollWidth}`,
scrub: 1,
pin: true,
anticipatePin: 1,
invalidateOnRefresh: true,
},
});
});
}
Storytelling-Muster mit Sticky-Elementen:
function initStoryScenes() {
if (reduceMotion) return;
gsap.utils.toArray("[data-story-scene]").forEach((scene) => {
const panels = scene.querySelectorAll("[data-story-panel]");
gsap.timeline({
scrollTrigger: {
trigger: scene,
start: "top top",
end: () => `+=${panels.length * window.innerHeight}`,
scrub: 1.1,
pin: true,
anticipatePin: 1,
},
})
.to(panels, { yPercent: -100 * (panels.length - 1), ease: "none" })
.to(scene.querySelectorAll("[data-story-depth]"), { yPercent: -16, ease: "none" }, 0);
});
}
Hochwertige Hover-Interaktionen
Verwende GSAPs quickTo für magnetische Bewegung, damit der Hover dem Zeiger folgt, ohne bei jedem Ereignis neue Tweens zu erstellen.
function initMagnetic() {
if (reduceMotion || window.matchMedia("(pointer: coarse)").matches) return;
gsap.utils.toArray("[data-magnetic]").forEach((element) => {
const strength = Number(element.dataset.magnetic || 0.18);
const xTo = gsap.quickTo(element, "x", { duration: 0.45, ease: "power3.out" });
const yTo = gsap.quickTo(element, "y", { duration: 0.45, ease: "power3.out" });
element.addEventListener("pointermove", (event) => {
const rect = element.getBoundingClientRect();
const x = (event.clientX - rect.left - rect.width / 2) * strength;
const y = (event.clientY - rect.top - rect.height / 2) * strength;
xTo(x);
yTo(y);
});
element.addEventListener("pointerleave", () => {
xTo(0);
yTo(0);
});
});
}
Hover-Rezepte:
- Magnetische Buttons: Nur
x/yverschieben, Skalierung unter1.03halten. - Magnetische Karten:
rotateX/rotateYunter4deghinzufügen. - Bild-Zoom:
scale: 1auf1.06, Dauer0.7s, Easepower3.out. - Graustufen-zu-Farbe: Filter-Übergang nur bei kleinen/mittleren Medien.
- Animierte Pfeile: Symbol
x: 0aufx: 6bewegen, das doppelte Symbol einblenden. - Richtungsabhängiger Hover: Berechne die Eintrittsseite des Zeigers, aber halte die Bewegung unter
16px.
Benutzerdefinierter Cursor
Verwende einen Cursor-Follower als Atmosphäre, nicht als Dekoration. Verstecke ihn auf Touch-Geräten.
function initCursor() {
if (reduceMotion || window.matchMedia("(pointer: coarse)").matches) return;
const cursor = document.querySelector("[data-cursor]");
if (!cursor) return;
const label = cursor.querySelector("[data-cursor-label]");
const xTo = gsap.quickTo(cursor, "x", { duration: 0.35, ease: "power3.out" });
const yTo = gsap.quickTo(cursor, "y", { duration: 0.35, ease: "power3.out" });
document.addEventListener("pointermove", (event) => {
xTo(event.clientX);
yTo(event.clientY);
});
gsap.utils.toArray("[data-cursor-label]")
…
[truncated for translation]
