Тёмно-зелёная ночь, ёлка со светящейся звездой и густой снегопад. Снежинки не пролетают сквозь сцену: каждая падает со своим покачиванием, ложится на ярус ёлки или на землю и остаётся там, поэтому через полминуты ветки белеют, а вокруг вырастает сугроб. Снег идёт бесконечно, камера медленно кружит вокруг ёлки и наклоняется за мышью. Это официальный пример three.js webgpu_compute_particles_snow: движение 100 000 снежинок считает compute-шейдер на TSL, а чтобы снег ложился, ортографическая камера каждый кадр сверху снимает карту высот сцены, и снежинка останавливается, когда опускается ниже неё. Лёгшие снежинки сами попадают в эту карту, поэтому сугробы растут слоями. В стенде чайник-«звезда» из оригинала заменён настоящей звездой, снег падает бесконечно (лёгшая снежинка оставляет копию и снова появляется в небе), убраны панель отладки и OrbitControls, вместо них автооблёт и параллакс, снежинки у самого объектива прячутся. Подойдёт для новогодней акции, праздничного лендинга, зимней распродажи, катка, горнолыжного курорта или поздравительной страницы.
Снегопад, который засыпает ёлку
Сто тысяч снежинок падают на ёлку со звездой и ложатся на ветки и землю: сугробы растут, камера кружит вокруг. Фон для новогоднего лендинга.

Промпт
Добавь на мою страницу фон «Снегопад, который засыпает ёлку» (по мотивам официального примера three.js webgpu_compute_particles_snow, лицензия MIT). Ниже готовая страница одним файлом: three.js 0.184.0 через importmap с jsdelivr (`three/webgpu`, `three/tsl` и дополнение `GaussianBlurNode`), внешних картинок и моделей нет. Холст `<canvas class="bg">` закреплён на весь экран, заголовок `.hero` лежит поверх. Сначала перенеси как есть, открой через локальный сервер и проверь, что снег падает и ложится на ёлку, а камера реагирует на мышь, потом подгоняй. Как устроен код. Рендерер — `WebGPURenderer`: где есть WebGPU, работает через него, где нет — сам откатывается на WebGL2, картинка та же. Снежинки живут в буферах на видеокарте (`instancedArray`): позиция, размер, место последней посадки и данные (домашняя точка, скорость падения, случайное число). `computeInit` один раз раскидывает снежинки по колонне `AREA × AREA` высотой `SKY_HEIGHT`. Каждый кадр идут три шага. 1) Карта высот: ортографическая `collisionCamera` смотрит сверху и рисует сцену в `collisionRT` (1024×1024, один канал) материалом, который пишет мировую высоту `positionWorld.y`; в эту карту попадают ёлка, звезда, пол и уже лёгший снег (слой 1). 2) `computeUpdate`: если снежинка выше карты высот в своей точке, она покачивается вокруг домашней точки (синусы от `uTime`) и опускается на свою скорость, умноженную на `uStep` (шаг не зависит от частоты кадров); если ниже — её позиция копируется в буфер лёгшего снега, а сама снежинка снова появляется в небе между `SPAWN_FROM` и `SKY_HEIGHT`. 3) Картинка: два `InstancedMesh`-а из маленьких сфер — падающий снег (слой 2) и лёгший (слой 1), положение берётся из буферов через `positionNode`; около камеры снежинки уменьшаются до нуля (`nearFade`). Ёлка — стопка конусов `TREE_TIERS` на цилиндре, звезда — `ExtrudeGeometry` из пятиконечного контура. Постобработка `RenderPipeline`: сцена плюс слегка размытая копия (дымка), виньетка и отдельный проход звезды с сильным размытием — это свечение. Что менять: число снежинок `COUNT` (100 000 на компьютере и 50 000 на телефоне; на слабых телефонах ставь 30 000), высоту колонны `SKY_HEIGHT` (меньше — гуще снегопад и быстрее растут сугробы), скорость `FALL_SPEED`, площадь `AREA`, число ярусов `TREE_TIERS`, цвета ёлки `COLOR_TREE`, звезды `COLOR_STAR` и фона `COLOR_BG_CENTER` и `COLOR_BG_EDGE` (и цвет тумана `scene.fog`, он должен быть близок к фону), облёт `ORBIT_SPEED`, параллакс `PARALLAX`, расстояние камеры (28) и точку взгляда (`lookAt`). Вместо ёлки можно поставить любую свою геометрию — логотип, буквы через `TextGeometry`, подарок из кубов: снег будет ложиться и на неё, если объект в слое 0. Если проект на React: холст в компоненте, инициализацию в `useEffect` с пустым списком зависимостей и `ref` на холст (код асинхронный из-за `await renderer.init()`, оберни его в async-функцию и проверяй флаг размонтирования). При размонтировании вызови `renderer.setAnimationLoop(null)`, `collisionRT.dispose()`, `renderPipeline.dispose()`, `dispose()` у геометрий и материалов, `renderer.dispose()` и сними слушатели `pointermove` и `resize`. Не меняй порядок шагов в цикле (карта высот → compute → картинка), не убирай `frustumCulled = false` у снега (позиции считаются на видеокарте), слои камер (`layers`: иначе падающий снег попадёт в карту высот и снежинки будут садиться друг на друга в воздухе), ограничение `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>Snowfall tree</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: #060a0d; 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: 9vh 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.6); }
.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 webgpu_compute_particles_snow
// Copyright © 2010–2026 three.js authors, MIT License
// https://github.com/mrdoob/three.js/blob/dev/examples/webgpu_compute_particles_snow.html
import * as THREE from 'three/webgpu';
import { Fn, texture, vec2, vec3, pass, color, uint, screenUV, instancedArray, positionWorld, positionLocal,
hash, instanceIndex, If, uniform, smoothstep, cameraPosition } from 'three/tsl';
import { gaussianBlur } from 'three/addons/tsl/display/GaussianBlurNode.js';
// settings
const COUNT = innerWidth < 700 ? 50000 : 100000; // snowflakes (fewer on phones)
const AREA = 100; // snow falls over AREA × AREA around the tree
const SKY_HEIGHT = 200; // flakes live in a tall column: the taller, the sparser the snowfall
const SPAWN_FROM = 30; // landed flakes respawn between SPAWN_FROM and SKY_HEIGHT (above the view)
const FALL_SPEED = 1; // 1 = original speed
const TREE_TIERS = 8; // cones in the tree
const COLOR_TREE = 0x0d492c;
const COLOR_STAR = 0xfcfb9e;
const COLOR_BG_CENTER = 0x0f4140, COLOR_BG_EDGE = 0x060a0d;
const ORBIT_SPEED = 0.12; // camera auto-orbit, rad per second
const PARALLAX = 0.45; // how strongly the camera follows the pointer
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 by itself
const renderer = new THREE.WebGPURenderer({ canvas, antialias: true });
renderer.toneMapping = THREE.ACESFilmicToneMapping;
renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
renderer.setSize(innerWidth, innerHeight, false);
await renderer.init();
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 100);
camera.layers.enable(1); // landed snow
camera.layers.enable(2); // falling snow
const scene = new THREE.Scene();
scene.fog = new THREE.Fog(0x0f3c37, 5, 40);
scene.backgroundNode = screenUV.distance(0.5).mul(2).mix(color(COLOR_BG_CENTER), color(COLOR_BG_EDGE));
const sun = new THREE.DirectionalLight(0xf9ff9b, 9);
sun.position.set(10, 10, 0);
scene.add(sun, new THREE.HemisphereLight(0x0f3c37, 0x080d10, 100));
// collision map: an orthographic camera looks down and writes the height (world y) of everything below
const half = AREA / 2;
const collisionCamera = new THREE.OrthographicCamera(-half, half, half, -half, 0.1, 50);
collisionCamera.position.y = 50;
collisionCamera.lookAt(0, 0, 0);
collisionCamera.layers.enable(1); // landed snow counts as ground, so it piles up
const collisionRT = new THREE.RenderTarget(1024, 1024);
Object.assign(collisionRT.texture, { format: THREE.RedFormat, type: THREE.HalfFloatType,
magFilter: THREE.NearestFilter, minFilter: THREE.NearestFilter, generateMipmaps: false });
const collisionMaterial = new THREE.MeshBasicNodeMaterial({ blending: THREE.NoBlending, fog: false, toneMapped: false });
collisionMaterial.colorNode = positionWorld.y;
// GPU buffers: one element per flake
const positionBuffer = instancedArray(COUNT, 'vec3');
const scaleBuffer = instancedArray(COUNT, 'vec3');
const landedBuffer = instancedArray(COUNT, 'vec3'); // where the flake last landed
const dataBuffer = instancedArray(COUNT, 'vec4'); // x: home x, y: fall velocity, z: home z, w: random
const randUint = () => uint(Math.random() * 0xFFFFFF);
const computeInit = Fn(() => {
const position = positionBuffer.element(instanceIndex);
const data = dataBuffer.element(instanceIndex);
const randX = hash(instanceIndex), randY = hash(instanceIndex.add(randUint())), randZ = hash(instanceIndex.add(randUint()));
position.x = randX.mul(AREA).sub(half);
position.y = randY.mul(SKY_HEIGHT).add(3);
position.z = randZ.mul(AREA).sub(half);
scaleBuffer.element(instanceIndex).xyz = hash(instanceIndex.add(Math.random())).mul(0.8).add(0.2);
landedBuffer.element(instanceIndex).assign(vec3(1000, 10000, 1000)); // far away until the first landing
data.x = position.x; data.y = randY.mul(-0.1).sub(0.02); data.z = position.z; data.w = randX;
})().compute(COUNT);
const uTime = uniform(0);
const uStep = uniform(1); // frame-rate independent: dt × 60 × speed
const surfaceOffset = 0.2;
const computeUpdate = Fn(() => {
const position = positionBuffer.element(instanceIndex);
const scale = scaleBuffer.element(instanceIndex);
const data = dataBuffer.element(instanceIndex);
const random = data.w;
const ground = texture(collisionRT.texture, position.xz.add(half).div(AREA)).r.add(scale.x.mul(surfaceOffset));
If(position.y.greaterThan(ground), () => {
// falling: sway around the home point, sink with its own velocity
position.x = data.x.add(uTime.mul(random.mul(random)).mul(0.4).sin().mul(3));
position.z = data.z.add(uTime.mul(random).mul(0.4).cos().mul(random.mul(10)));
position.y = position.y.add(data.y.mul(uStep));
}).Else(() => {
// landed: leave a copy on the ground and start again from the sky
landedBuffer.element(instanceIndex).assign(position);
position.y = hash(instanceIndex.add(uTime.mul(1000).toUint())).mul(SKY_HEIGHT - SPAWN_FROM).add(SPAWN_FROM);
});
});
const computeParticles = computeUpdate().compute(COUNT);
// flakes: tiny low-poly spheres, instanced by the buffers
const flakeGeometry = new THREE.SphereGeometry(surfaceOffset, 5, 5);
function snow(buffer, layer) {
const material = new THREE.MeshStandardNodeMaterial({ color: 0xeeeeee, roughness: 0.9, metalness: 0 });
const center = buffer.toAttribute();
// flakes right in front of the lens shrink away, otherwise they show up as huge low-poly balls
const nearFade = smoothstep(3, 9, center.distance(cameraPosition));
material.positionNode = positionLocal.mul(scaleBuffer.toAttribute()).mul(nearFade).add(center);
const mesh = new THREE.Mesh(flakeGeometry, material);
mesh.count = COUNT;
mesh.frustumCulled = false;
mesh.layers.set(layer);
return mesh;
}
scene.add(snow(positionBuffer, 2), snow(landedBuffer, 1));
// floor that fades out at the edges
const floorGeometry = new THREE.PlaneGeometry(AREA, AREA).rotateX(-Math.PI / 2);
const floor = new THREE.Mesh(floorGeometry, new THREE.MeshStandardNodeMaterial({ color: 0x0c1e1e, roughness: 0.5, transparent: true }));
floor.material.opacityNode = positionLocal.xz.mul(0.05).distance(0).saturate().oneMinus();
scene.add(floor);
// tree: a stack of cones on a trunk
const treeMaterial = new THREE.MeshStandardNodeMaterial({ color: COLOR_TREE, roughness: 0.6 });
const tree = new THREE.Group();
for (let i = 0; i < TREE_TIERS; i++) {
const r = 1 + i;
const cone = new THREE.Mesh(new THREE.ConeGeometry(r * 0.95, r * 1.25, 32), treeMaterial);
cone.position.y = (TREE_TIERS - i) * 1.5 + TREE_TIERS * 0.6;
tree.add(cone);
}
const trunk = new THREE.Mesh(new THREE.CylinderGeometry(1, 1, TREE_TIERS, 32), treeMaterial);
trunk.position.y = TREE_TIERS / 2;
tree.add(trunk);
scene.add(tree);
// star on top (the original has a glowing teapot here)
const shape = new THREE.Shape();
for (let i = 0; i < 10; i++) {
const r = i % 2 ? 0.45 : 1.1, a = i / 10 * Math.PI * 2 + Math.PI / 2;
i ? shape.lineTo(Math.cos(a) * r, Math.sin(a) * r) : shape.moveTo(Math.cos(a) * r, Math.sin(a) * r);
}
const starGeometry = new THREE.ExtrudeGeometry(shape, { depth: 0.3, bevelEnabled: false }).center();
const star = new THREE.Mesh(starGeometry, new THREE.MeshBasicNodeMaterial({ color: COLOR_STAR }));
star.position.y = 18.3;
scene.add(star);
// post: scene + soft blur haze, vignette, and a separate blurred pass of the star for the glow
const renderPipeline = new THREE.RenderPipeline(renderer);
const scenePass = pass(scene, camera);
const sceneColor = scenePass.getTextureNode();
const sceneBlur = gaussianBlur(sceneColor);
sceneBlur.resolutionScale = 0.5;
sceneBlur.directionNode = vec2(1);
const starPass = pass(star, camera).getTextureNode();
const starBlur = gaussianBlur(starPass, vec2(1), 6);
starBlur.resolutionScale = 0.2;
const vignette = screenUV.distance(0.5).mul(1.35).clamp().oneMinus();
renderPipeline.outputNode = sceneColor.add(sceneBlur.mul(0.1)).mul(vignette).add(starPass.mul(10).add(starBlur));
renderer.compute(computeInit);
// pointer → camera parallax
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 = 28;
function fit() {
camera.aspect = innerWidth / innerHeight;
camera.fov = camera.aspect < 1 ? 70 : 60;
distance = camera.aspect < 1 ? 28 / Math.max(camera.aspect, 0.5) * 0.62 : 28; // portrait: step back
camera.updateProjectionMatrix();
renderer.setSize(innerWidth, innerHeight, false);
}
fit();
addEventListener('resize', fit);
const timer = new THREE.Timer();
let orbit = 0.8;
renderer.setAnimationLoop((now) => {
timer.update(now);
const dt = Math.min(timer.getDelta(), 0.1) * motion;
uTime.value += dt;
uStep.value = dt * 60 * FALL_SPEED;
orbit += dt * ORBIT_SPEED;
star.rotation.y += dt * 0.6;
eased.x += (pointer.x - eased.x) * 0.04;
eased.y += (pointer.y - eased.y) * 0.04;
const a = orbit + eased.x * PARALLAX;
camera.position.set(Math.sin(a) * distance, 4 + eased.y * 5, Math.cos(a) * distance);
camera.lookAt(0, 11, 0);
// 1) heights from above → 2) move flakes → 3) final image
scene.overrideMaterial = collisionMaterial;
renderer.setRenderTarget(collisionRT);
renderer.render(scene, collisionCamera);
scene.overrideMaterial = null;
renderer.setRenderTarget(null);
renderer.compute(computeParticles);
renderPipeline.render();
});
</script>
</body>
</html>Похожие



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

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