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

Промпт
Добавь на мою страницу фон «Пролёт над горами в тумане» (по мотивам официального примера 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`, которая почти останавливает полёт. Покажи, как поставить этот фон под первый экран моего сайта, и подбери цвет тумана и гор под мой бренд.
Код скопируется вместе с промптом
Код
<!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>Похожие


Протопланетный диск: из пыли слипаются планеты
Three.js · Шейдер

Живое небо: солнце садится и встаёт за заголовком
Three.js · Шейдер

Полёт по неоновому тоннелю-узлу
Three.js · Шейдер