Промпт Скопировать
Добавь на мою страницу эффект «Карточки-линзы: фото выпучивается под курсором» (по мотивам Codrops «WebGL Bulge Effect», автор Robin Payot, демо 1, лицензия MIT). Ниже готовая страница: OGL 1.0.11 (через importmap), GSAP 3.13.0 и Lenis 1.1.13 с jsdelivr. Сначала перенеси её как есть и открой через локальный сервер, а не как файл: браузер не даст WebGL прочитать картинки с адреса `file://`. Убедись, что карточки пружинисто появляются при скролле, а под курсором фото вздувается, и только потом подгоняй.
Как устроен код. Разметку карточек строит скрипт из массива `IMAGES`: `.card` > `.card__content` > `<canvas>` и подпись `.text`. Класс `Card` создаёт на каждом холсте свой `Renderer` OGL и `Mesh` из `Triangle` (один треугольник на весь холст, без камеры). Вершинный шейдер обрезает картинку как `background-size: cover`. Фрагментный шейдер `bulge(uv, center)` умножает смещение от центра на `(1 - uBulge) + uBulge * uStrength / (1 + (dist / uRadius)^4)`: при `uBulge = 0` картинка ровная, при 1 — раздута. Центр линзы — `mix(uMouseIntro, uMouse, uIntro)`: сначала низ середины карточки, потом точка под курсором; `render()` догоняет курсор с коэффициентом 0.1. `show()` при входе в экран (IntersectionObserver) и `enter()`/`leave()` на `pointerenter`/`pointerleave` анимируют `uBulge` и `uIntro` через GSAP. Пружинистое появление карточки и подписи — это CSS: класс `is-visible`, `scale(.5)` → `none` и кривая `--ease-out-bounce`. Фон — второй холст с классическим шумом Перлина, смешивающим `#fdfaee` и `#d6abb4`; Lenis передаёт прогресс скролла в `uScroll`.
Что менять: картинки в `IMAGES` (вертикальные 2:3), подпись `LABEL`, размер и силу линзы в `BULGE` (`radius` 0.5–1, `strength` 0.8–2: чем дальше от единицы, тем сильнее искажение, меньше единицы — оно выворачивается наоборот), цвета фона `uColor1`/`uColor2`, размеры карточек (`width: 30vw`, `height: 60vh`, скругление `3vw`), сдвиг зигзага `translateX(±15vw)`, длительности в `show()` и `enter()`.
Если проект на React: вынеси карточку в компонент с `useRef` на холст, создавай `Renderer` и `Program` в `useEffect`, а при размонтировании снимай слушатели, вызывай `gsap.killTweensOf` для униформ и `renderer.gl.getExtension('WEBGL_lose_context')?.loseContext()`; общий `gsap.ticker`, Lenis и фон держи в родителе. Не делай больше 10–12 таких карточек на странице: у каждой свой контекст WebGL, а браузер держит их около 16. Не убирай ветку `prefers-reduced-motion`: в ней нет автоматических анимаций и плавного скролла, линза остаётся только по наведению.
Покажи, где на моём сайте такие карточки смотрятся лучше всего, и подставь мои фотографии. Код скопируется вместе с промптом
Колонка карточек с фотографиями идёт зигзагом по светлому кремово-розовому фону. Когда карточка въезжает в экран, она пружинисто вырастает из половинного размера, а картинка в ней «сдувается»: сначала она раздута пузырём, потом за полторы секунды выпрямляется. Наведите курсор — фото снова вздувается линзой, и центр линзы плавно ходит за мышью: края снимка заворачиваются внутрь, будто его натянули на стеклянный шар. Уводите курсор — линза опадает.
Устроено просто: у каждой карточки свой маленький холст WebGL на библиотеке OGL, на нём один треугольник на весь холст и фрагментный шейдер с функцией bulge. Она сдвигает координаты пикселей к точке под курсором, а сила сдвига падает с четвёртой степенью расстояния. Анимацию силы (uBulge) и «прилипания» линзы к курсору ведёт GSAP, появление карточек ловит IntersectionObserver, скролл сглаживает Lenis. Фон — отдельный холст с шумом Перлина, который медленно плывёт и сдвигается при прокрутке. Подходит для портфолио, каталога работ, карточек кейсов и товаров. На телефоне линза включается касанием пальца.
Код Скопировать
<!-- Pictures: images/1.webp ... images/6.webp (replace with your own, portrait 2:3). Serve over http, not file:// -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>WebGL Bulge Effect</title>
<link rel="icon" href="data:,">
<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter+Tight:wght@500&display=swap">
<script type="importmap">{ "imports": { "ogl": "https://cdn.jsdelivr.net/npm/ogl@1.0.11/src/index.js" } }</script>
<style>
*, *::before, *::after { box-sizing: border-box; }
:root { --ease-out-bounce: cubic-bezier(0.22, 1.45, 0.36, 1); }
html { overflow-x: hidden; }
html.lenis, html.lenis body { height: auto; }
body { margin: 0; color: #111; background: #fff; font-family: "Inter Tight", system-ui, sans-serif; -webkit-font-smoothing: antialiased; }
.frame { position: fixed; top: 1.5rem; left: 1.5rem; z-index: 10; margin: 0; font-size: .75rem; font-weight: 500; }
/* Background: a slow pink-cream noise gradient drawn by its own WebGL canvas */
.background { position: fixed; inset: 0; }
.background canvas { display: block; width: 100%; height: 100%; }
.scroll { position: fixed; bottom: 1.5rem; left: 1.5rem; z-index: 10; font-size: 2rem; opacity: 0; transition: opacity 1s; }
.scroll.is-visible { opacity: .75; }
/* Cards zigzag down the page; each one pops in (scale .5 -> 1 with a bounce) when it enters the screen */
.wrapper { position: relative; padding: 1px 0; }
.card { position: relative; width: 30vw; max-width: 400px; height: 60vh; max-height: 600px; margin: 15vh auto; opacity: 0; }
.card:nth-child(even) { transform: translateX(-15vw); }
.card:nth-child(odd) { transform: translateX(15vw); }
.card.is-visible { opacity: 1; transition: opacity .5s ease; }
.card__content { position: relative; width: 100%; height: 100%; border-radius: 3vw; overflow: hidden; cursor: pointer;
z-index: 1; transform: scale(.5); transition: transform 1s var(--ease-out-bounce); touch-action: pan-y; }
.card.is-visible .card__content { transform: none; }
.card canvas { position: absolute; inset: 0; width: 100%; height: 100%; display: block; }
.text { position: absolute; top: 50%; left: 50%; z-index: 2; width: 100%; height: 100%; display: flex; align-items: center; justify-content: center;
pointer-events: none; transform: translate(-50%, -50%) scale(.2); transition: transform 1.2s var(--ease-out-bounce) .1s; }
.card.is-visible .text { transform: translate(-50%, -50%); }
.text span { font-size: 3vw; }
@media (max-width: 768px) {
.card { width: 70vw; height: 52vh; }
.card:nth-child(even) { transform: translateX(-8vw); }
.card:nth-child(odd) { transform: translateX(8vw); }
.card__content { border-radius: 24px; }
.text span { font-size: 28px; }
}
</style>
</head>
<body>
<h1 class="frame">WebGL Bulge Effect</h1>
<div class="background"><canvas></canvas></div>
<div class="scroll is-visible">↓ Scroll</div>
<main class="wrapper" id="cards"></main>
<script src="https://cdn.jsdelivr.net/npm/gsap@3.13.0/dist/gsap.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/lenis@1.1.13/dist/lenis.min.js"></script>
<script type="module">
// Based on "WebGL Bulge Effect" by Robin Payot for Codrops (MIT, Copyright (c) 2009-2022 Codrops),
// https://github.com/Robpayot/webgl-distortion-bulge-effect
import { Renderer, Program, Mesh, Triangle, Texture, Vec2, Color } from 'ogl';
const reduceMotion = matchMedia('(prefers-reduced-motion: reduce)').matches;
const IMAGES = [1, 2, 3, 4, 5, 6].map(n => `images/${n}.webp`);
const LABEL = 'Discover';
const BULGE = { radius: 0.95, strength: 1.1 }; // size of the lens and how much it magnifies
document.getElementById('cards').innerHTML = IMAGES.map(() =>
`<div class="card"><div class="card__content"><canvas></canvas></div><div class="text"><span>${LABEL}</span></div></div>`).join('');
// One triangle that covers the whole canvas; uv is cropped like background-size: cover
const cardVertex = /* glsl */ `
attribute vec2 uv; attribute vec2 position;
uniform vec2 uResolution, uTextureResolution;
varying vec2 vUv;
void main() {
vec2 ratio = vec2(min((uResolution.x / uResolution.y) / (uTextureResolution.x / uTextureResolution.y), 1.0),
min((uResolution.y / uResolution.x) / (uTextureResolution.y / uTextureResolution.x), 1.0));
vUv = uv * ratio + (1.0 - ratio) * 0.5;
gl_Position = vec4(position, 0.0, 1.0);
}`;
// The bulge: pixels near the pointer are pulled towards it (magnified), the pull fades with distance^4
const cardFragment = /* glsl */ `
precision highp float;
uniform sampler2D uTexture; uniform vec2 uMouse, uMouseIntro;
uniform float uIntro, uRadius, uStrength, uBulge;
varying vec2 vUv;
vec2 bulge(vec2 uv, vec2 center) {
uv -= center;
float dist = length(uv) / uRadius;
float strengthAmount = uStrength / (1.0 + pow(dist, 4.0));
uv *= (1.0 - uBulge) + uBulge * strengthAmount; // uBulge 0..1 blends the effect in and out
return uv + center;
}
void main() {
vec2 center = mix(uMouseIntro, uMouse, uIntro); // starts at the bottom middle, then follows the pointer
gl_FragColor = vec4(texture2D(uTexture, bulge(vUv, center)).rgb, 1.0);
}`;
class Card {
constructor(el, src) {
this.el = el;
this.canvas = el.querySelector('canvas');
this.mouse = new Vec2(0.5, 0.5);
this.target = new Vec2(0.5, 0.5);
this.renderer = new Renderer({ canvas: this.canvas, dpr: Math.min(devicePixelRatio, 2) });
const { gl } = this.renderer;
gl.clearColor(1, 1, 1, 1);
this.ready = new Promise(resolve => {
const image = new Image();
image.onload = () => {
const texture = new Texture(gl, { image });
this.program = new Program(gl, {
vertex: cardVertex, fragment: cardFragment,
uniforms: {
uTexture: { value: texture },
uTextureResolution: { value: new Vec2(image.width, image.height) },
uResolution: { value: new Vec2(1, 1) },
uMouse: { value: this.mouse }, uMouseIntro: { value: new Vec2(0.5, 0) },
uIntro: { value: 0 }, uBulge: { value: 0 },
uRadius: { value: BULGE.radius }, uStrength: { value: BULGE.strength }
}
});
this.mesh = new Mesh(gl, { geometry: new Triangle(gl), program: this.program });
this.resize();
resolve();
};
image.src = src;
});
// pointerenter/leave work for the mouse and for a finger (touch down / up)
this.canvas.addEventListener('pointerenter', () => this.enter());
this.canvas.addEventListener('pointerleave', () => this.leave());
this.canvas.addEventListener('pointercancel', () => this.leave());
}
// The card came on screen: the bulge relaxes from full to none, the lens drifts to the pointer
show() {
this.visible = true;
this.el.classList.add('is-visible');
gsap.killTweensOf([this.program.uniforms.uBulge, this.program.uniforms.uIntro]);
if (reduceMotion) { this.program.uniforms.uBulge.value = 0; this.program.uniforms.uIntro.value = 1; return; }
gsap.fromTo(this.program.uniforms.uBulge, { value: 1 }, { value: 0, duration: 1.8, ease: 'power3.out' });
gsap.to(this.program.uniforms.uIntro, { value: 1, duration: 5 });
}
hide() {
this.visible = false;
this.el.classList.remove('is-visible');
gsap.killTweensOf([this.program.uniforms.uBulge, this.program.uniforms.uIntro]);
gsap.to(this.program.uniforms.uBulge, { value: 1, duration: 1.8, ease: 'power3.out' });
gsap.to(this.program.uniforms.uIntro, { value: 0, duration: 1 });
}
enter() {
if (!this.program) return;
gsap.killTweensOf([this.program.uniforms.uBulge, this.program.uniforms.uIntro]);
gsap.to(this.program.uniforms.uIntro, { value: 1, duration: 5, ease: 'expo.out' });
gsap.to(this.program.uniforms.uBulge, { value: 1, duration: 1, ease: 'expo.out' });
}
leave() {
if (!this.program) return;
gsap.to(this.program.uniforms.uBulge, { value: 0, duration: 1, ease: 'expo.out' });
}
pointer(x, y) {
if (!this.visible) return;
const r = this.canvas.getBoundingClientRect();
this.target.set(gsap.utils.clamp(0, 1, (x - r.left) / r.width), gsap.utils.clamp(0, 1, 1 - (y - r.top) / r.height));
}
resize() {
const w = this.canvas.parentNode.offsetWidth, h = this.canvas.parentNode.offsetHeight;
this.renderer.setSize(w, h);
this.program?.uniforms.uResolution.value.set(w, h);
}
render() {
if (!this.mesh || !this.visible) return;
// the lens follows the pointer with a little lag
this.mouse.x = gsap.utils.interpolate(this.mouse.x, this.target.x, 0.1);
this.mouse.y = gsap.utils.interpolate(this.mouse.y, this.target.y, 0.1);
this.renderer.render({ scene: this.mesh });
}
}
// Background: classic 2D Perlin noise (Stefan Gustavson, MIT) mixing two colours, shifted by scroll
const bgFragment = /* glsl */ `
precision highp float;
uniform vec3 uColor1, uColor2; uniform float uTime, uScroll;
varying vec2 vUv;
vec4 mod289(vec4 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec4 permute(vec4 x) { return mod289(((x * 34.0) + 1.0) * x); }
vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }
vec2 fade(vec2 t) { return t * t * t * (t * (t * 6.0 - 15.0) + 10.0); }
float cnoise(vec2 P) {
vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
Pi = mod289(Pi);
vec4 ix = Pi.xzxz, iy = Pi.yyww, fx = Pf.xzxz, fy = Pf.yyww;
vec4 i = permute(permute(ix) + iy);
vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0;
vec4 gy = abs(gx) - 0.5;
gx = gx - floor(gx + 0.5);
vec2 g00 = vec2(gx.x, gy.x), g10 = vec2(gx.y, gy.y), g01 = vec2(gx.z, gy.z), g11 = vec2(gx.w, gy.w);
vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x; g01 *= norm.y; g10 *= norm.z; g11 *= norm.w;
vec2 f = fade(Pf.xy);
vec2 n_x = mix(vec2(dot(g00, vec2(fx.x, fy.x)), dot(g01, vec2(fx.z, fy.z))),
vec2(dot(g10, vec2(fx.y, fy.y)), dot(g11, vec2(fx.w, fy.w))), f.x);
return 2.3 * mix(n_x.x, n_x.y, f.y);
}
void main() {
float noise = cnoise(vUv + uScroll + sin(uTime / 10.0));
gl_FragColor = vec4(mix(uColor1, uColor2, noise), 1.0);
}`;
const bgRenderer = new Renderer({ canvas: document.querySelector('.background canvas'), dpr: Math.min(devicePixelRatio, 2) });
const bgProgram = new Program(bgRenderer.gl, {
vertex: `attribute vec2 uv; attribute vec2 position; varying vec2 vUv; void main() { vUv = uv; gl_Position = vec4(position, 0.0, 1.0); }`,
fragment: bgFragment,
uniforms: { uTime: { value: 0 }, uScroll: { value: 0 }, uColor1: { value: new Color('#fdfaee') }, uColor2: { value: new Color('#d6abb4') } }
});
const bgMesh = new Mesh(bgRenderer.gl, { geometry: new Triangle(bgRenderer.gl), program: bgProgram });
const cards = [...document.querySelectorAll('.card')].map((el, i) => new Card(el, IMAGES[i % IMAGES.length]));
const scrollHint = document.querySelector('.scroll');
const onScroll = progress => { scrollHint.classList.remove('is-visible'); bgProgram.uniforms.uScroll.value = progress * 2; };
let lenis = null;
if (!reduceMotion) {
lenis = new Lenis({ lerp: 0.08 });
lenis.on('scroll', e => onScroll(e.progress));
} else {
addEventListener('scroll', () => onScroll(scrollY / Math.max(1, document.documentElement.scrollHeight - innerHeight)), { passive: true });
}
function resize() {
bgRenderer.setSize(innerWidth, innerHeight);
cards.forEach(c => c.resize());
}
resize();
addEventListener('resize', resize);
addEventListener('pointermove', e => cards.forEach(c => c.pointer(e.clientX, e.clientY)));
addEventListener('touchmove', e => cards.forEach(c => c.pointer(e.touches[0].clientX, e.touches[0].clientY)), { passive: true });
gsap.ticker.add(time => {
lenis?.raf(time * 1000);
if (!reduceMotion) bgProgram.uniforms.uTime.value = time;
bgRenderer.render({ scene: bgMesh });
cards.forEach(c => c.render());
});
// Cards animate in and out as they cross the viewport edge
Promise.all(cards.map(c => c.ready)).then(() => {
const io = new IntersectionObserver(entries => entries.forEach(entry => {
const card = cards.find(c => c.el === entry.target);
entry.isIntersecting ? card.show() : card.visible && card.hide();
}), { threshold: 0 });
cards.forEach(c => io.observe(c.el));
});
</script>
</body>
</html>