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

Фоны3DЯркийМинимализмБесплатно

Объёмное облако в небе за заголовком

Настоящее объёмное облако на шейдере: медленно поворачивается в голубом небе, дышит и показывает другой бок, если повести мышью.

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

Как устроен код. Небо — большая сфера изнутри с текстурой-градиентом 1×32, нарисованной на canvas из цветов `SKY`. Облако — куб 1×1×1 с `RawShaderMaterial` (GLSL3, `side: BackSide`, прозрачный). При загрузке JavaScript заполняет `Data3DTexture` размером `SIZE³` (128³, около 2 млн значений, считается доли секунды): значение — шум Перлина `ImprovedNoise`, умноженный на квадрат расстояния до края, поэтому к граням куба облако истончается. Фрагментный шейдер находит, где луч из камеры входит в куб и выходит из него (`hitBox`), делит отрезок на `STEPS` шагов и на каждом берёт плотность из текстуры, обрезает её мягким порогом (`smoothstep` вокруг `threshold` шириной `range`), умножает на `OPACITY` и складывает цвет спереди назад, пока непрозрачность не дойдёт до 0.95. Освещение — разность плотности в двух точках по диагонали (`shading`), плюс лёгкий градиент по высоте; база цвета `CLOUD_BASE`. Случайный сдвиг старта луча на каждом кадре (`wang_hash` от координат пикселя и номера кадра) прячет полосы между шагами. Позицию камеры шейдер получает в `cameraPos` и сам переводит в систему куба, поэтому облако можно двигать и вращать как обычный объект. «Дыхание» — порог `threshold` плавно поднимается на `BREATHE` и возвращается.

Что менять: цвета неба `SKY` (и `background` у `body`, он виден до первого кадра), тень облака `CLOUD_BASE`, порог `THRESHOLD` (больше — облако тоньше и рваней), размах `BREATHE` (опускать порог ниже `THRESHOLD` не стоит: проступят плоские грани куба), плотность `OPACITY`, число шагов `STEPS` (60 заметно быстрее на слабых телефонах, но появятся полосы), масштаб шума `NOISE_SCALE` (больше — мельче клубы), скорость вращения `SPIN_SPEED`, обход камеры `PARALLAX`, расстояние камеры (1.5) и высоту облака (`cloud.position.y`). Для нескольких облаков создай несколько кубов с тем же материалом и разным масштабом и поворотом. Для закатного неба поменяй `SKY` на персиковые тона и `CLOUD_BASE` на тёплый серо-розовый.

Если проект на React: холст в компоненте, инициализацию в `useEffect` с пустым списком зависимостей и `ref` на холст. При размонтировании вызови `renderer.setAnimationLoop(null)`, `texture.dispose()`, `skyMap.dispose()`, `dispose()` у геометрий и материалов, `renderer.dispose()` и сними слушатели `pointermove` и `resize`. Не убирай `glslVersion: THREE.GLSL3` (шейдер использует `sampler3D` и `in/out`), `side: THREE.BackSide` (иначе облако пропадёт, когда камера окажется внутри куба), строку `cameraPos.copy(camera.position)` в цикле, ограничение `devicePixelRatio` двойкой (ray marching дорогой, на экранах 3× он заметно тормозит) и ветку `prefers-reduced-motion`, которая замедляет вращение и дыхание.
Покажи, как поставить это облако под первый экран моего сайта, и подбери цвета неба и облака под мой бренд.

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

Голубое небо, а под заголовком висит пушистое облако. Это не картинка и не набор спрайтов: облако объёмное, у него есть светлая верхушка и тень снизу, сквозь тонкие края просвечивает небо. Оно медленно поворачивается и понемногу «дышит»: края то тают, то снова набирают плотность. Если повести мышью, камера обходит облако, и видно его с другого бока. Это официальный пример three.js webgl_volume_cloud: шум Перлина записан в 3D-текстуру 128×128×128, а фрагментный шейдер пускает из камеры луч через куб и шагами накапливает плотность (ray marching), свет — разность плотности в двух соседних точках. В стенде убраны панель настроек и OrbitControls, вместо них автоповорот, «дыхание» порога плотности и обход камеры за мышью, облако опущено под заголовок, на узких экранах камера отходит дальше. Подойдёт для сервисов про погоду, облачные хранилища и SaaS, детских и образовательных проектов, приложений для сна и медитации.

Код
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Volume cloud</title>
<link rel="icon" href="data:,">
<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: #0a4d86; 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: 11vh 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(1, 40, 80, 0.45); }
  .hero p { margin: 0; font-size: clamp(1rem, 2vw, 1.35rem); opacity: 0.8; }
</style>
</head>
<body>
<canvas class="bg" aria-hidden="true"></canvas>
<main class="hero">
  <h1>Голова в облаках</h1>
  <p>Настоящее объёмное облако прямо в браузере</p>
</main>

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

// settings
const SIZE = 128;                       // 3D noise texture side (128³ voxels)
const NOISE_SCALE = 0.05;               // bigger → more, smaller puffs
const SKY = ['#014a84', '#0561a0', '#5b8fc7']; // sky gradient: top, middle, bottom
const CLOUD_BASE = 0x798aa0;            // shadow colour of the cloud
const THRESHOLD = 0.25;                 // density cut-off: higher → thinner cloud
const BREATHE = 0.06;                   // how far the threshold rises (the cloud "breathes"); never below THRESHOLD, or cube faces show
const OPACITY = 0.25;                   // density per step
const STEPS = 100;                      // ray-march steps (fewer = faster, more banding)
const SPIN_SPEED = 0.13;                // cloud rotation, rad per second
const PARALLAX = 0.5;                   // 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 });
renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
renderer.setSize(innerWidth, innerHeight, false);

const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 100);

// sky: a big sphere with a 1×32 gradient texture drawn on a canvas
const skyCanvas = document.createElement('canvas');
skyCanvas.width = 1; skyCanvas.height = 32;
const ctx = skyCanvas.getContext('2d');
const gradient = ctx.createLinearGradient(0, 0, 0, 32);
SKY.forEach((c, i) => gradient.addColorStop(i / (SKY.length - 1), c));
ctx.fillStyle = gradient; ctx.fillRect(0, 0, 1, 32);
const skyMap = new THREE.CanvasTexture(skyCanvas);
skyMap.colorSpace = THREE.SRGBColorSpace;
scene.add(new THREE.Mesh(new THREE.SphereGeometry(10), new THREE.MeshBasicMaterial({ map: skyMap, side: THREE.BackSide })));

// 3D texture: Perlin noise faded towards the cube edges, so the cloud is a round puff
const data = new Uint8Array(SIZE * SIZE * SIZE);
const perlin = new ImprovedNoise();
const v = new THREE.Vector3();
for (let z = 0, i = 0; z < SIZE; z++) for (let y = 0; y < SIZE; y++) for (let x = 0; x < SIZE; x++) {
  const d = 1 - v.set(x, y, z).subScalar(SIZE / 2).divideScalar(SIZE).length();
  data[i++] = (128 + 128 * perlin.noise(x * NOISE_SCALE / 1.5, y * NOISE_SCALE, z * NOISE_SCALE / 1.5)) * d * d;
}
const texture = new THREE.Data3DTexture(data, SIZE, SIZE, SIZE);
texture.format = THREE.RedFormat;
texture.minFilter = texture.magFilter = THREE.LinearFilter;
texture.unpackAlignment = 1;
texture.needsUpdate = true;

const vertexShader = /* glsl */`
  in vec3 position;
  uniform mat4 modelMatrix, modelViewMatrix, projectionMatrix;
  uniform vec3 cameraPos;
  out vec3 vOrigin;
  out vec3 vDirection;
  void main() {
    vOrigin = vec3(inverse(modelMatrix) * vec4(cameraPos, 1.0)).xyz; // camera in the cube's local space
    vDirection = position - vOrigin;
    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
  }`;

// ray-marching: walk through the unit cube, accumulate density front-to-back
const fragmentShader = /* glsl */`
  precision highp float;
  precision highp sampler3D;
  in vec3 vOrigin;
  in vec3 vDirection;
  out vec4 color;
  uniform vec3 base;
  uniform sampler3D map;
  uniform float threshold, range, opacity, steps, frame;

  uint wang_hash(uint seed) {
    seed = (seed ^ 61u) ^ (seed >> 16u); seed *= 9u; seed = seed ^ (seed >> 4u);
    seed *= 0x27d4eb2du; seed = seed ^ (seed >> 15u); return seed;
  }
  float randomFloat(inout uint seed) { return float(wang_hash(seed)) / 4294967296.; }
  vec2 hitBox(vec3 orig, vec3 dir) {
    vec3 inv = 1.0 / dir;
    vec3 t0 = (vec3(-0.5) - orig) * inv, t1 = (vec3(0.5) - orig) * inv;
    vec3 tmin = min(t0, t1), tmax = max(t0, t1);
    return vec2(max(tmin.x, max(tmin.y, tmin.z)), min(tmax.x, min(tmax.y, tmax.z)));
  }
  float sample1(vec3 p) { return texture(map, p).r; }
  float shading(vec3 c) { return sample1(c + vec3(-0.01)) - sample1(c + vec3(0.01)); } // light from the top corner
  vec4 linearToSRGB(vec4 c) {
    return vec4(mix(pow(c.rgb, vec3(0.41666)) * 1.055 - vec3(0.055), c.rgb * 12.92, vec3(lessThanEqual(c.rgb, vec3(0.0031308)))), c.a);
  }
  void main() {
    vec3 rayDir = normalize(vDirection);
    vec2 bounds = hitBox(vOrigin, rayDir);
    if (bounds.x > bounds.y) discard;
    bounds.x = max(bounds.x, 0.0);
    float stepSize = (bounds.y - bounds.x) / steps;
    // per-pixel jitter of the start point hides the banding between steps
    uint seed = uint(gl_FragCoord.x) * 1973u + uint(gl_FragCoord.y) * 9277u + uint(frame) * 26699u;
    vec3 p = vOrigin + bounds.x * rayDir;
    p += rayDir * (randomFloat(seed) * 2.0 - 1.0) * (1.0 / vec3(textureSize(map, 0)));
    vec4 ac = vec4(base, 0.0);
    for (float i = 0.0; i < steps; i += 1.0) {
      float d = smoothstep(threshold - range, threshold + range, sample1(p + 0.5)) * opacity;
      float col = shading(p + 0.5) * 3.0 + (p.x + p.y) * 0.25 + 0.2;
      ac.rgb += (1.0 - ac.a) * d * col;
      ac.a += (1.0 - ac.a) * d;
      if (ac.a >= 0.95) break;
      p += rayDir * stepSize;
    }
    color = linearToSRGB(ac);
    if (color.a == 0.0) discard;
  }`;

const material = new THREE.RawShaderMaterial({
  glslVersion: THREE.GLSL3,
  uniforms: {
    base: { value: new THREE.Color(CLOUD_BASE) }, map: { value: texture }, cameraPos: { value: new THREE.Vector3() },
    threshold: { value: THRESHOLD }, opacity: { value: OPACITY }, range: { value: 0.1 },
    steps: { value: STEPS }, frame: { value: 0 },
  },
  vertexShader, fragmentShader, side: THREE.BackSide, transparent: true,
});
const cloud = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), material);
cloud.position.y = -0.12; // a little lower: room for the headline
scene.add(cloud);

// pointer → camera orbit
const pointer = { x: 0, y: 0 }, eased = { x: 0, y: 0 };
addEventListener('pointermove', (e) => {
  if (!e.isPrimary) return;
  pointer.x = e.clientX / innerWidth * 2 - 1;
  pointer.y = e.clientY / innerHeight * 2 - 1;
}, { passive: true });

let distance = 1.5;
function fit() {
  camera.aspect = innerWidth / innerHeight;
  camera.updateProjectionMatrix();
  distance = camera.aspect < 1 ? 1.5 / Math.max(camera.aspect, 0.55) * 0.8 : 1.5; // narrow screens: step back
  renderer.setSize(innerWidth, innerHeight, false);
}
fit();
addEventListener('resize', fit);

const clock = new THREE.Clock();
let t = 0;
renderer.setAnimationLoop(() => {
  const dt = Math.min(clock.getDelta(), 0.1) * motion;
  t += dt;
  cloud.rotation.y -= dt * SPIN_SPEED;
  material.uniforms.threshold.value = THRESHOLD + (1 - Math.cos(t * 0.35)) * 0.5 * BREATHE;
  material.uniforms.frame.value++;

  eased.x += (pointer.x - eased.x) * 0.04;
  eased.y += (pointer.y - eased.y) * 0.04;
  const a = eased.x * PARALLAX, b = 0.1 + eased.y * PARALLAX * 0.6;
  camera.position.set(Math.sin(a) * Math.cos(b) * distance, Math.sin(b) * distance, Math.cos(a) * Math.cos(b) * distance);
  camera.lookAt(0, 0.05, 0);
  material.uniforms.cameraPos.value.copy(camera.position);
  renderer.render(scene, camera);
});
</script>
</body>
</html>

Похожие