Чёрный экран, и в нём кружит облако из четверти миллиона частиц. Три невидимых центра притягивают их и закручивают каждый вокруг своей оси: частицы собираются в вихри, перетекают от одного центра к другому, медленные светятся фиолетовым, быстрые разгораются персиковым. Один центр следует за курсором или пальцем, и весь рой тянется за ним шлейфом; когда мышь замирает, центр возвращается на свой путь. Это официальный пример three.js webgpu_tsl_compute_attractors_particles: физика (гравитация, закрутка, ограничение скорости, затухание) считается compute-шейдером на TSL прямо на видеокарте, а частицы рисуются одним InstancedMesh. В стенде убраны панель настроек, гизмо TransformControls и OrbitControls; вместо них центры сами плывут по плавным траекториям, один ловит курсор, камера медленно облетает рой. Квадратные частицы заменены мягкими круглыми, а пыль вдали от центра гаснет, чтобы рой читался объёмом; на телефоне частиц вдвое меньше. Подойдёт для AI- и data-продуктов, научных проектов, конференций и интерактивных промо-страниц.
Библиотека дизайна / Эффекты и шейдеры
Рой из 260 000 частиц, который кружит за курсором
Четверть миллиона частиц на видеокарте кружат вокруг трёх притягивающих центров, один из них следует за курсором или пальцем.

Промпт
Добавь на мою страницу эффект «Рой частиц за курсором» (по мотивам официального примера three.js webgpu_tsl_compute_attractors_particles, лицензия MIT). Ниже готовая страница одним файлом: three.js 0.184.0 через importmap с jsdelivr (`three/webgpu` и `three/tsl`), холст `<canvas class="bg">` закреплён на весь экран, заголовок `.hero` лежит поверх. Сначала перенеси как есть и проверь, что частицы кружат сами и тянутся за мышью, потом подгоняй. Как устроен код. Рендерер — `WebGPURenderer`: в браузерах с WebGPU он работает через WebGPU, а где его нет, сам откатывается на WebGL2 (compute-шейдеры там выполняются через transform feedback), картинка та же. Перед первым `compute` нужен `await renderer.init()`. Для каждой частицы на видеокарте хранятся два буфера `instancedArray`: позиция и скорость. Compute-шейдер `initCompute` один раз раскладывает частицы плоским диском со случайной скоростью. Compute-шейдер `updateCompute` на каждом кадре для каждой частицы складывает силы от всех центров из `attractorsPositions`: притяжение `масса / расстояние²` и закрутку вокруг оси из `attractorsRotationAxes` (векторное произведение); затем ограничивает скорость `maxSpeed`, гасит её на `velocityDamping` и переносит частицы, улетевшие за куб `BOUND`, на противоположную сторону. Шаг времени фиксированный (1/60), поэтому картинка одинакова при любой частоте кадров. Рисует частицы `SpriteNodeMaterial` с аддитивным смешиванием: позиция берётся прямо из буфера, цвет — смесь `COLOR_SLOW` и `COLOR_FAST` по скорости, прозрачность делает каждую частицу мягким кружком яркостью `GLOW` и гасит её между `FADE_NEAR` и `FADE_FAR` от центра. Центр №0 следует за курсором: луч из камеры через курсор пересекается с плоскостью y = 0; через 3 секунды без движения центр возвращается на свою траекторию. Центры №1 и №2 и камера двигаются сами. Что менять: число частиц `COUNT` (2¹⁸ на компьютере, 2¹⁷ на телефоне), цвета `COLOR_SLOW` и `COLOR_FAST`, размер `PARTICLE_SIZE` и яркость `GLOW` (частицы складываются, поэтому при большем числе частиц яркость уменьшай), дальность затухания `FADE_NEAR` и `FADE_FAR`, силу притяжения `ATTRACTOR_MASS`, закрутку `SPINNING`, предельную скорость `MAX_SPEED`, затухание `DAMPING`, размер куба `BOUND`, скорость облёта `ORBIT_SPEED`, исходные места и траектории центров (`attractorsPositions` и синусы в цикле анимации). Центров может быть больше трёх: добавь точки в оба массива, длина подхватится сама. Если проект на React: холст в компоненте, инициализацию в `useEffect` с пустым списком зависимостей и `ref` на холст (асинхронную часть с `await renderer.init()` оберни в функцию и проверяй флаг отмены). При размонтировании вызови `renderer.setAnimationLoop(null)`, `particles.geometry.dispose()`, `material.dispose()`, `renderer.dispose()` и сними слушатели `pointermove` и `resize`. Не убирай `await renderer.init()` перед первым `compute`, `particles.frustumCulled = false`, фиксированный шаг времени, ограничение `devicePixelRatio` двойкой и ветку `prefers-reduced-motion`, которая замедляет симуляцию. Покажи, как поставить этот рой под первый экран моего сайта, и подбери цвета частиц под мой бренд.
Код скопируется вместе с промптом
Код
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Particle attractors</title>
<link rel="icon" href="data:,">
<script type="importmap">{ "imports": {
"three": "https://cdn.jsdelivr.net/npm/three@0.184.0/build/three.webgpu.js",
"three/webgpu": "https://cdn.jsdelivr.net/npm/three@0.184.0/build/three.webgpu.js",
"three/tsl": "https://cdn.jsdelivr.net/npm/three@0.184.0/build/three.tsl.js",
"three/addons/": "https://cdn.jsdelivr.net/npm/three@0.184.0/examples/jsm/"
} }</script>
<style>
*, *::before, *::after { box-sizing: border-box; }
html, body { height: 100%; margin: 0; overflow: hidden; background: #000; color: #fff;
font-family: system-ui, -apple-system, "Segoe UI", sans-serif; }
.bg { position: fixed; inset: 0; width: 100%; height: 100%; display: block; touch-action: none; }
.hero { position: relative; z-index: 1; min-height: 100%; display: grid; place-content: start center; gap: 1rem;
padding: 12vh 1.5rem 1.5rem; text-align: center; pointer-events: none; }
.hero h1 { margin: 0; font-size: clamp(2.2rem, 7vw, 5.5rem); font-weight: 700; letter-spacing: -0.03em; line-height: 1;
text-shadow: 0 2px 30px rgba(0, 0, 0, 0.7); }
.hero p { margin: 0; font-size: clamp(1rem, 2vw, 1.35rem); opacity: 0.65; }
</style>
</head>
<body>
<canvas class="bg" aria-hidden="true"></canvas>
<main class="hero">
<h1>Сила притяжения</h1>
<p>Четверть миллиона частиц кружат вокруг курсора</p>
</main>
<script type="module">
// По мотивам примера three.js webgpu_tsl_compute_attractors_particles
// Copyright © 2010–2026 three.js authors, MIT License
// https://github.com/mrdoob/three.js/blob/dev/examples/webgpu_tsl_compute_attractors_particles.html
import * as THREE from 'three/webgpu';
import { float, If, PI, color, cos, instanceIndex, Loop, mix, mod, sin, instancedArray, Fn, uint, uniform, uniformArray, hash, uv, vec3, vec4 } from 'three/tsl';
// settings
const COUNT = innerWidth < 768 ? 2 ** 17 : 2 ** 18; // particles (phones get half)
const COLOR_SLOW = '#5900ff'; // slow particles
const COLOR_FAST = '#ffa575'; // fast particles
const PARTICLE_SIZE = 0.03;
const ATTRACTOR_MASS = 1e7;
const SPINNING = 2.75; // swirl around each attractor's axis
const MAX_SPEED = 8;
const DAMPING = 0.1;
const GLOW = 0.45; // brightness of one particle (they add up)
const FADE_NEAR = 1.5; // particles closer than this to the centre are fully bright
const FADE_FAR = 3; // ... and fade to nothing by this distance
const BOUND = 8; // particles that leave this box wrap to the other side
const ORBIT_SPEED = 0.05; // camera auto-orbit, rad per second
const reduceMotion = matchMedia('(prefers-reduced-motion: reduce)').matches;
const motion = reduceMotion ? 0.2 : 1;
const canvas = document.querySelector('.bg');
// WebGPU when available, otherwise three.js falls back to WebGL2 (compute runs via transform feedback)
const renderer = new THREE.WebGPURenderer({ canvas, antialias: true });
renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
renderer.setSize(innerWidth, innerHeight, false);
renderer.setClearColor('#000000');
await renderer.init(); // compute needs an initialised backend
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(25, innerWidth / innerHeight, 0.1, 100);
// three attractors: a position and a spin axis each. #0 follows the pointer, #1 and #2 drift on their own
const attractorsPositions = uniformArray([
new THREE.Vector3(-1, 0, 0),
new THREE.Vector3(1, 0, -0.5),
new THREE.Vector3(0, 0.5, 1)
]);
const attractorsRotationAxes = uniformArray([
new THREE.Vector3(0, 1, 0),
new THREE.Vector3(0, 1, 0),
new THREE.Vector3(1, 0, -0.5).normalize()
]);
const attractorsLength = uniform(attractorsPositions.array.length, 'uint');
const home = attractorsPositions.array.map((v) => v.clone());
const attractorMass = uniform(ATTRACTOR_MASS);
const particleGlobalMass = uniform(1e4);
const timeScale = uniform(motion);
const spinningStrength = uniform(SPINNING);
const maxSpeed = uniform(MAX_SPEED);
const gravityConstant = 6.67e-11;
const velocityDamping = uniform(DAMPING);
const scale = uniform(PARTICLE_SIZE);
const boundHalfExtent = uniform(BOUND);
const colorA = uniform(color(COLOR_SLOW));
const colorB = uniform(color(COLOR_FAST));
// GPU buffers: one vec3 position and one vec3 velocity per particle
const positionBuffer = instancedArray(COUNT, 'vec3');
const velocityBuffer = instancedArray(COUNT, 'vec3');
const seed = () => uint(Math.floor(Math.random() * 0xffffff));
const sphericalToVec3 = Fn(([phi, theta]) => {
const s = sin(phi);
return vec3(s.mul(sin(theta)), cos(phi), s.mul(cos(theta)));
});
// init compute: a flat random disc with a tiny random velocity
const initCompute = Fn(() => {
const position = positionBuffer.element(instanceIndex);
const velocity = velocityBuffer.element(instanceIndex);
position.assign(vec3(
hash(instanceIndex.add(seed())), hash(instanceIndex.add(seed())), hash(instanceIndex.add(seed()))
).sub(0.5).mul(vec3(5, 0.2, 5)));
const phi = hash(instanceIndex.add(seed())).mul(PI).mul(2);
const theta = hash(instanceIndex.add(seed())).mul(PI);
velocity.assign(sphericalToVec3(phi, theta).mul(0.05));
})().compute(COUNT);
renderer.compute(initCompute);
const particleMassMultiplier = hash(instanceIndex.add(seed())).remap(0.25, 1).toVar();
const particleMass = particleMassMultiplier.mul(particleGlobalMass).toVar();
// update compute: gravity + swirl from every attractor, speed limit, damping, wrap inside the box
const updateCompute = Fn(() => {
const delta = float(1 / 60).mul(timeScale).toVar(); // fixed step: same look at any frame rate
const position = positionBuffer.element(instanceIndex);
const velocity = velocityBuffer.element(instanceIndex);
const force = vec3(0).toVar();
Loop(attractorsLength, ({ i }) => {
const toAttractor = attractorsPositions.element(i).sub(position);
const distance = toAttractor.length();
const gravityStrength = attractorMass.mul(particleMass).mul(gravityConstant).div(distance.pow(2)).toVar();
force.addAssign(toAttractor.normalize().mul(gravityStrength));
const spinningForce = attractorsRotationAxes.element(i).mul(gravityStrength).mul(spinningStrength);
force.addAssign(spinningForce.cross(toAttractor));
});
velocity.addAssign(force.mul(delta));
If(velocity.length().greaterThan(maxSpeed), () => {
velocity.assign(velocity.normalize().mul(maxSpeed));
});
velocity.mulAssign(velocityDamping.oneMinus());
position.addAssign(velocity.mul(delta));
const half = boundHalfExtent.div(2).toVar();
position.assign(mod(position.add(half), boundHalfExtent).sub(half));
})().compute(COUNT);
// render: additive soft sprites, colour by speed
const material = new THREE.SpriteNodeMaterial({ blending: THREE.AdditiveBlending, depthWrite: false });
material.positionNode = positionBuffer.toAttribute();
material.colorNode = Fn(() => {
const speed = velocityBuffer.toAttribute().length();
const glow = uv().sub(0.5).length().mul(2).oneMinus().clamp(0, 1).pow(2).mul(GLOW) // soft round dot
.mul(positionBuffer.toAttribute().length().smoothstep(FADE_NEAR, FADE_FAR).oneMinus()); // stray dust far from the centre fades out
return vec4(mix(colorA, colorB, speed.div(maxSpeed).smoothstep(0, 0.5)), glow);
})();
material.scaleNode = particleMassMultiplier.mul(scale);
const particles = new THREE.InstancedMesh(new THREE.PlaneGeometry(1, 1), material, COUNT);
particles.frustumCulled = false;
scene.add(particles);
// pointer → attractor #0 on the y = 0 plane; after 3 s without input it returns to its own path
const raycaster = new THREE.Raycaster();
const plane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0);
const ndc = new THREE.Vector2();
const hit = new THREE.Vector3();
let lastInput = -1e9;
addEventListener('pointermove', (e) => {
if (!e.isPrimary) return;
ndc.set(e.clientX / innerWidth * 2 - 1, -(e.clientY / innerHeight) * 2 + 1);
lastInput = performance.now();
}, { passive: true });
function fit() {
camera.aspect = innerWidth / innerHeight;
camera.fov = camera.aspect < 1 ? 25 / Math.max(camera.aspect, 0.45) * 0.8 : 25; // narrow screens: wider lens
camera.updateProjectionMatrix();
renderer.setSize(innerWidth, innerHeight, false);
}
fit();
addEventListener('resize', fit);
const target = new THREE.Vector3();
const timer = new THREE.Timer();
let t = 0;
renderer.setAnimationLoop((now) => {
timer.update(now);
const dt = Math.min(timer.getDelta(), 0.1) * motion;
t += dt;
// camera slowly circles the swarm
const a = 0.36 + t * ORBIT_SPEED;
camera.position.set(Math.sin(a) * 8.5, 5, Math.cos(a) * 8.5);
camera.lookAt(0, 0, 0);
// attractors drift on slow Lissajous paths
const [p0, p1, p2] = attractorsPositions.array;
const auto0 = target.set(home[0].x + Math.sin(t * 0.5) * 0.8, Math.sin(t * 0.7) * 0.3, home[0].z + Math.cos(t * 0.4) * 0.8);
if (now - lastInput < 3000) {
raycaster.setFromCamera(ndc, camera);
if (raycaster.ray.intersectPlane(plane, hit)) auto0.copy(hit.clampLength(0, 3));
}
p0.lerp(auto0, 0.06);
p1.set(home[1].x + Math.sin(t * 0.33 + 1) * 0.7, home[1].y + Math.sin(t * 0.5) * 0.3, home[1].z + Math.cos(t * 0.29) * 0.7);
p2.set(home[2].x + Math.cos(t * 0.27) * 0.6, home[2].y + Math.sin(t * 0.41) * 0.25, home[2].z + Math.sin(t * 0.37) * 0.6);
renderer.compute(updateCompute);
renderer.render(scene, camera);
});
</script>
</body>
</html>


