Библиотека дизайна / Фоны

ФоныТёмный3DМинимализмБесплатно

Волна из тысяч точек под первым экраном

Поле из 3600 белых точек катится волнами: на гребнях точки растут, вдали тают в темноте. Камера плывёт за мышью.

Волна из тысяч точек под первым экраном
Промпт
Добавь на мою страницу фон «Волна из тысяч точек» (по мотивам официального примера three.js webgl_points_waves, лицензия MIT). Ниже готовая страница одним файлом: three.js 0.170.0 через importmap с jsdelivr, холст `<canvas class="bg">` закреплён на весь экран, заголовок `.hero` лежит поверх. Сначала перенеси как есть и проверь, что точки катятся волной и камера реагирует на мышь, потом подгоняй.

Как устроен код. Сетка `AMOUNT_X × AMOUNT_Y` точек с шагом `SEPARATION` лежит в одной `BufferGeometry`: атрибут `position` (координаты) и свой атрибут `scale` (размер каждой точки). На каждом кадре цикл пересчитывает высоту `y` и размер точки по сумме двух синусов, вдоль ширины и вдоль глубины, со сдвигом фазы `phase`; одни и те же значения задают и высоту, и размер, поэтому гребни выглядят «надутыми». `ShaderMaterial` рисует точки: вершинный шейдер задаёт `gl_PointSize` пропорционально `scale`, делит на расстояние до камеры (перспектива) и умножает на `pixelRatio`; фрагментный шейдер отбрасывает углы квадрата (`discard`), чтобы точка была круглой, и гасит цвет между `fogNear` и `fogFar`. Камера стоит на высоте `CAMERA_HEIGHT`, плавно смещается к курсору (`PARALLAX`, сглаживание 0.05) и всегда смотрит в центр поля; пока мыши нет, её ведут два медленных синуса.

Что менять: цвет `COLOR` и фон `background` у `body` (на светлом фоне поменяй затухание: смешивай цвет с фоном, а не с чёрным), число точек `AMOUNT_X` и `AMOUNT_Y` (60 × 60 = 3600; до 100 × 100 работает и на телефоне), шаг `SEPARATION`, высоту волн `AMPLITUDE`, размер точек `DOT`, скорость `SPEED`, длину волн (множители 0.3 и 0.5 в цикле), высоту камеры `CAMERA_HEIGHT` и силу параллакса `PARALLAX`, дальность затухания `fogNear` и `fogFar`.

Если проект на React: холст в компоненте, инициализацию в `useEffect` с пустым списком зависимостей и `ref` на холст. При размонтировании вызови `renderer.setAnimationLoop(null)`, `geometry.dispose()`, `material.dispose()`, `renderer.dispose()` и сними слушатели `pointermove` и `resize`. Не убирай `pixelRatio` в шейдере (без него на ретине точки вдвое мельче), `particles.frustumCulled = false`, ограничение `devicePixelRatio` двойкой и ветку `prefers-reduced-motion`, которая замедляет волну.
Покажи, как поставить этот фон под первый экран моего сайта, и подбери цвет точек под мой бренд.

Код скопируется вместе с промптом

Чёрный экран, а под заголовком раскинулось поле из белых точек, по которому бегут две пересекающиеся волны. На гребнях точки поднимаются и раздуваются, во впадинах сжимаются, ближние ряды крупные, дальние мелкие и гаснут в темноте, поэтому плоскость читается как объём. Камера смотрит на поле сверху и плывёт за курсором, а без мыши сама медленно покачивается. Это официальный пример three.js webgl_points_waves: одна геометрия Points и маленький шейдер, который рисует круглые точки нужного размера. В стенде добавлены затухание дальних рядов, поправка на плотность пикселей экрана (на ретине точки не мельчают), возвышенная камера и мягкий автопролёт. Подойдёт для музыкальных и аудио-продуктов, конференций, AI-сервисов, любых тёмных минималистичных лендингов.

Код
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Points wave</title>
<script type="importmap">{ "imports": { "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js" } }</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: 16vh 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; }
  .hero p { margin: 0; font-size: clamp(1rem, 2vw, 1.35rem); opacity: 0.6; }
</style>
</head>
<body>
<canvas class="bg" aria-hidden="true"></canvas>
<main class="hero">
  <h1>На одной волне</h1>
  <p>Тысячи точек дышат в такт</p>
</main>

<script type="module">
// По мотивам примера three.js webgl_points_waves
// Copyright © 2010–2026 three.js authors, MIT License
// https://github.com/mrdoob/three.js/blob/dev/examples/webgl_points_waves.html
import * as THREE from 'three';

// settings
const COLOR = 0xffffff;     // dot colour
const SEPARATION = 100;     // distance between dots
const AMOUNT_X = 60;        // dots across
const AMOUNT_Y = 60;        // dots in depth
const AMPLITUDE = 50;       // wave height (two waves, so the peak is twice this)
const DOT = 20;             // dot size multiplier
const SPEED = 0.1;          // wave phase step per frame at 60 fps
const CAMERA_HEIGHT = 380;  // resting camera height above the wave
const PARALLAX = 0.6;       // how strongly the camera follows the pointer

const reduceMotion = matchMedia('(prefers-reduced-motion: reduce)').matches;
const motion = reduceMotion ? 0.15 : 1;

const canvas = document.querySelector('.bg');
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
const dpr = Math.min(devicePixelRatio, 2);
renderer.setPixelRatio(dpr);
renderer.setSize(innerWidth, innerHeight, false);

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, innerWidth / innerHeight, 1, 10000);
camera.position.set(0, CAMERA_HEIGHT, 1000);

// one vertex per dot; the wave changes y and the per-dot scale every frame
const count = AMOUNT_X * AMOUNT_Y;
const positions = new Float32Array(count * 3);
const scales = new Float32Array(count);
for (let ix = 0, i = 0; ix < AMOUNT_X; ix++) {
  for (let iy = 0; iy < AMOUNT_Y; iy++, i++) {
    positions[i * 3] = ix * SEPARATION - (AMOUNT_X * SEPARATION) / 2;
    positions[i * 3 + 2] = iy * SEPARATION - (AMOUNT_Y * SEPARATION) / 2;
  }
}
const geometry = new THREE.BufferGeometry();
geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3).setUsage(THREE.DynamicDrawUsage));
geometry.setAttribute('scale', new THREE.BufferAttribute(scales, 1).setUsage(THREE.DynamicDrawUsage));

const material = new THREE.ShaderMaterial({
  uniforms: {
    color: { value: new THREE.Color(COLOR) },
    pixelRatio: { value: dpr },
    fogNear: { value: 1200 },
    fogFar: { value: 4200 }
  },
  vertexShader: /* glsl */`
    attribute float scale;
    uniform float pixelRatio;
    varying float vDepth;
    void main() {
      vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
      gl_PointSize = scale * pixelRatio * (300.0 / -mvPosition.z); // perspective: far dots are smaller
      vDepth = -mvPosition.z;
      gl_Position = projectionMatrix * mvPosition;
    }`,
  fragmentShader: /* glsl */`
    uniform vec3 color;
    uniform float fogNear, fogFar;
    varying float vDepth;
    void main() {
      if (length(gl_PointCoord - vec2(0.5)) > 0.475) discard; // round dot
      float fade = 1.0 - smoothstep(fogNear, fogFar, vDepth);  // far rows melt into the background
      gl_FragColor = vec4(color * fade, 1.0);
    }`
});
const particles = new THREE.Points(geometry, material);
particles.frustumCulled = false;
scene.add(particles);

// pointer → camera parallax; with no pointer the camera drifts on its own
const pointer = { x: 0, y: 0, active: false };
addEventListener('pointermove', (e) => {
  if (!e.isPrimary) return;
  pointer.x = e.clientX - innerWidth / 2;
  pointer.y = e.clientY - innerHeight / 2;
  pointer.active = true;
}, { passive: true });

addEventListener('resize', () => {
  camera.aspect = innerWidth / innerHeight;
  camera.updateProjectionMatrix();
  renderer.setSize(innerWidth, innerHeight, false);
});

const clock = new THREE.Clock();
let phase = 0, t = 0;
renderer.setAnimationLoop(() => {
  const dt = Math.min(clock.getDelta(), 0.1);
  t += dt * motion;
  phase += SPEED * dt * 60 * motion;

  const tx = pointer.active ? pointer.x * PARALLAX : Math.sin(t * 0.3) * 300;
  const ty = pointer.active ? -pointer.y * PARALLAX : Math.sin(t * 0.21) * 80;
  camera.position.x += (tx - camera.position.x) * 0.05;
  camera.position.y += (CAMERA_HEIGHT + ty - camera.position.y) * 0.05;
  camera.lookAt(scene.position);

  // two sine waves along x and depth; the same values drive height and dot size
  for (let ix = 0, i = 0; ix < AMOUNT_X; ix++) {
    const wx = Math.sin((ix + phase) * 0.3);
    for (let iy = 0; iy < AMOUNT_Y; iy++, i++) {
      const wy = Math.sin((iy + phase) * 0.5);
      positions[i * 3 + 1] = (wx + wy) * AMPLITUDE;
      scales[i] = ((wx + 1) + (wy + 1)) * DOT;
    }
  }
  geometry.attributes.position.needsUpdate = true;
  geometry.attributes.scale.needsUpdate = true;
  renderer.render(scene, camera);
});
</script>
</body>
</html>

Похожие