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

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

Пролёт над горами в тумане: ландшафт из шума

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

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

Как устроен код. `generateHeight` строит карту высот `GRID × GRID` из четырёх октав шума Перлина: каждая следующая в 5 раз крупнее и сильнее, поэтому получаются и большие хребты, и мелкие складки. Случайные числа идут из своего генератора `rand()` с зерном `SEED`, так что пейзаж одинаков при каждой загрузке. Плоскость `PlaneGeometry(SIZE, SIZE)` поворачивается горизонтально, и высота каждой вершины берётся из карты, умноженной на `HEIGHT`. `generateTexture` красит рельеф: считает нормаль по соседним высотам, освещает её неподвижным «солнцем», цвет зависит от высоты, затем текстура увеличивается в 4 раза и получает лёгкое зерно. Материал `MeshBasicMaterial` без источников света, весь свет уже в текстуре, поэтому эффект дешёвый. Туман `FogExp2` того же цвета, что и фон, прячет края карты. В цикле камера движется по кругу радиуса `RADIUS`, функция `groundAt` смотрит высоту рельефа под камерой и чуть впереди, и камера плавно держится на `ALTITUDE` выше самой высокой точки, чтобы не врезаться в склон. Взгляд направлен по касательной к кругу и смещается за курсором (`look`, сглаживание 0.04).

Что менять: цвет неба и тумана `SKY` (и `background` у `body`, они должны совпадать), плотность тумана `FOG` (больше — ближе горизонт), высоту гор `HEIGHT`, зерно пейзажа `SEED`, высоту полёта `ALTITUDE`, скорость `SPEED`, радиус круга `RADIUS` (не больше 2500, иначе камера вылетит к краю карты). Цвет склонов задают три формулы в `generateTexture` (числа 96, 128, 32 для красного, зелёного и синего): для холодных синих гор поменяй их местами и возьми голубой `SKY`. Цвет заголовка подбери под фон.

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

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

Спокойный кинематографичный фон: камера низко летит над горной грядой, ближние склоны тёплые и рельефные, дальние растворяются в персиковом тумане. Ни одной картинки: рельеф строится в браузере из нескольких слоёв шума Перлина (ImprovedNoise из three.js), а освещение «запекается» в текстуру по наклону склонов. Это официальный пример three.js webgl_geometry_terrain, но вместо управления с клавиатуры (FirstPersonControls) камера сама облетает карту по кругу, держится над рельефом и слегка поворачивает взгляд за курсором. Каждая загрузка показывает один и тот же пейзаж, а смена одного числа даёт новый. Подойдёт для первого экрана путешествий, ретритов, outdoor-брендов, спокойных сервисов про фокус и медитацию, а также для страниц «о нас», где нужен воздух.

Код
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Procedural terrain flyover</title>
<script type="importmap">{ "imports": {
  "three": "https://cdn.jsdelivr.net/npm/three@0.170.0/build/three.module.js",
  "three/addons/": "https://cdn.jsdelivr.net/npm/three@0.170.0/examples/jsm/"
} }</script>
<style>
  *, *::before, *::after { box-sizing: border-box; }
  html, body { height: 100%; margin: 0; overflow: hidden; background: #efd1b5; color: #3a2414;
               font-family: system-ui, -apple-system, "Segoe UI", sans-serif; }
  .bg { position: fixed; inset: 0; width: 100%; height: 100%; display: block; }
  .hero { position: relative; z-index: 1; min-height: 100%; display: grid; place-content: start center; gap: 1rem;
          padding: 18vh 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.7; }
</style>
</head>
<body>
<canvas class="bg" aria-hidden="true"></canvas>
<main class="hero">
  <h1>Сквозь туман</h1>
  <p>Ландшафт, который рождается из шума</p>
</main>

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

// settings
const SKY = 0xefd1b5;          // background and fog colour (fog hides the edges of the map)
const FOG = 0.0016;            // fog density: more = closer horizon
const GRID = 256;              // height map resolution, GRID × GRID vertices
const SIZE = 7500;             // world size of the plane
const HEIGHT = 10;             // height multiplier
const RADIUS = 1800;           // radius of the camera's circular flight
const ALTITUDE = 160;          // how high above the ground the camera flies
const SPEED = 0.04;            // radians per second along the circle
const SEED = 42;               // change it to get a different landscape

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

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

const scene = new THREE.Scene();
scene.background = new THREE.Color(SKY);
scene.fog = new THREE.FogExp2(SKY, FOG);
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 1, 10000);

// seeded random, so the landscape is the same on every load (the original patched Math.random)
let s = SEED;
const rand = () => { const x = Math.sin(s++) * 10000; return x - Math.floor(x); };

// height map: four octaves of Perlin noise, each 5× larger and stronger than the previous
function generateHeight(w, h) {
  const data = new Uint8Array(w * h);
  const perlin = new ImprovedNoise(), z = rand() * 100;
  let quality = 1;
  for (let o = 0; o < 4; o++) {
    for (let i = 0; i < w * h; i++) {
      const x = i % w, y = (i / w) | 0;
      data[i] += Math.abs(perlin.noise(x / quality, y / quality, z) * quality * 1.75);
    }
    quality *= 5;
  }
  return data;
}

// texture: baked light from a fixed sun + colour by height, then upscaled 4× with grain
function generateTexture(data, w, h) {
  const canvas = document.createElement('canvas');
  canvas.width = w; canvas.height = h;
  let ctx = canvas.getContext('2d');
  let image = ctx.createImageData(w, h);
  const px = image.data, n = new THREE.Vector3(), sun = new THREE.Vector3(1, 1, 1).normalize();
  for (let i = 0, j = 0; i < px.length; i += 4, j++) {
    n.set((data[j - 2] ?? 0) - (data[j + 2] ?? 0), 2, (data[j - w * 2] ?? 0) - (data[j + w * 2] ?? 0)).normalize();
    const shade = n.dot(sun), k = 0.5 + data[j] * 0.007;
    px[i] = (96 + shade * 128) * k;
    px[i + 1] = (32 + shade * 96) * k;
    px[i + 2] = shade * 96 * k;
    px[i + 3] = 255;
  }
  ctx.putImageData(image, 0, 0);
  const big = document.createElement('canvas');
  big.width = w * 4; big.height = h * 4;
  ctx = big.getContext('2d');
  ctx.scale(4, 4);
  ctx.drawImage(canvas, 0, 0);
  image = ctx.getImageData(0, 0, big.width, big.height);
  for (let i = 0; i < image.data.length; i += 4) {
    const v = (rand() * 5) | 0;
    image.data[i] += v; image.data[i + 1] += v; image.data[i + 2] += v;
  }
  ctx.putImageData(image, 0, 0);
  return big;
}

const data = generateHeight(GRID, GRID);
const geometry = new THREE.PlaneGeometry(SIZE, SIZE, GRID - 1, GRID - 1);
geometry.rotateX(-Math.PI / 2);
const vtx = geometry.attributes.position.array;
for (let i = 0, j = 0; i < data.length; i++, j += 3) vtx[j + 1] = data[i] * HEIGHT;

const texture = new THREE.CanvasTexture(generateTexture(data, GRID, GRID));
texture.colorSpace = THREE.SRGBColorSpace;
texture.anisotropy = renderer.capabilities.getMaxAnisotropy();
scene.add(new THREE.Mesh(geometry, new THREE.MeshBasicMaterial({ map: texture })));

// ground height under a world point (nearest vertex of the height map)
function groundAt(x, z) {
  const gx = Math.round((x / SIZE + 0.5) * (GRID - 1));
  const gz = Math.round((z / SIZE + 0.5) * (GRID - 1));
  if (gx < 0 || gz < 0 || gx >= GRID || gz >= GRID) return 0;
  return data[gz * GRID + gx] * HEIGHT;
}

// pointer → small look-around offset (parallax), eased every frame
const pointer = { x: 0, y: 0 }, look = { x: 0, y: 0 };
addEventListener('pointermove', (e) => {
  pointer.x = e.clientX / innerWidth * 2 - 1;
  pointer.y = e.clientY / innerHeight * 2 - 1;
}, { passive: true });

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

const clock = new THREE.Clock();
let angle = 0.6, altitude = 0;
const ahead = new THREE.Vector3();

renderer.setAnimationLoop(() => {
  const dt = Math.min(clock.getDelta(), 0.1);
  angle += dt * SPEED * motion;
  look.x += (pointer.x - look.x) * 0.04;
  look.y += (pointer.y - look.y) * 0.04;

  // fly along a circle; look along the tangent, turned a little by the pointer
  const x = Math.cos(angle) * RADIUS, z = Math.sin(angle) * RADIUS;
  // highest ground around and in front of the camera, so it never dives into a hill
  let ground = 0;
  for (let k = 0; k <= 3; k++) {
    const a = angle + k * 0.06;
    ground = Math.max(ground, groundAt(Math.cos(a) * RADIUS, Math.sin(a) * RADIUS));
  }
  const target = ground + ALTITUDE;
  altitude = altitude ? altitude + (target - altitude) * Math.min(dt * 0.8, 1) : target;
  camera.position.set(x, altitude, z);

  const heading = angle + Math.PI / 2 - look.x * 0.5;
  ahead.set(x + Math.cos(heading) * 500, altitude - 120 - look.y * 140, z + Math.sin(heading) * 500);
  camera.lookAt(ahead);
  renderer.render(scene, camera);
});
</script>
</body>
</html>

Похожие