genshin-engine 3.8.1 → 4.0.0

package/dist/index.js

@@ -1,9 +1,10 @@
-import { Box3, BufferAttribute, BufferGeometry, CanvasTexture, Color, CylinderGeometry, Data3DTexture, DataTexture, DirectionalLight, DoubleSide, ExtrudeGeometry, HalfFloatType, InstancedBufferGeometry, LatheGeometry, LinearFilter, MathUtils, NeutralToneMapping, NoColorSpace, OrthographicCamera, Quaternion, RedFormat, ShapePath, Vector2, Vector3 } from "three";
-import { Fn, If, attribute, cameraFar, cameraNear, cameraPosition, cameraViewMatrix, cos, exp, exp2, float, getViewPosition, hash, instanceIndex, max, mix, modelViewMatrix, modelWorldMatrix, mrt, mx_cell_noise_float, mx_fractal_noise_float, mx_noise_float, normalView, normalWorldGeometry, output, perspectiveDepthToViewZ, positionGeometry, positionLocal, positionView, positionViewDirection, positionWorld, pow, reflect, renderOutput, screenUV, sin, smoothstep, step, texture, texture3D, time, uniform, uv, varying, vec2, vec3, vec4, velocity, viewportDepthTexture, viewportSharedTexture } from "three/tsl";
-import { MeshBasicNodeMaterial, MeshToonNodeMaterial, RenderPipeline, RenderTarget, SpriteNodeMaterial, ToonOutlinePassNode, WebGPURenderer } from "three/webgpu";
+import { Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, ClampToEdgeWrapping, Color, CylinderGeometry, Data3DTexture, DataTexture, DirectionalLight, DoubleSide, FloatType, HalfFloatType, InstancedBufferAttribute, InstancedBufferGeometry, LatheGeometry, LinearFilter, MathUtils, Matrix4, NeutralToneMapping, NoColorSpace, OrthographicCamera, Quaternion, RGBAFormat, RedFormat, Sprite, UnsignedByteType, Vector2, Vector3 } from "three";
+import { Fn, If, abs, asin, attribute, cameraFar, cameraNear, cameraPosition, cameraViewMatrix, clamp, color, cos, diffuseColor, exp, exp2, float, getNormalFromDepth, getViewPosition, hash, instanceIndex, instancedBufferAttribute, luminance, max, min, mix, modelViewMatrix, modelWorldMatrix, mrt, mx_cell_noise_float, mx_fractal_noise_float, mx_noise_float, normalView, normalWorld, normalWorldGeometry, output, perspectiveDepthToViewZ, positionGeometry, positionLocal, positionView, positionViewDirection, positionWorld, pow, reflect, renderOutput, sample, saturate, screenUV, sin, smoothstep, step, texture, texture3D, time, uniform, uniformArray, uv, varying, vec2, vec3, vec4, velocity, viewportDepthTexture, viewportSharedTexture } from "three/tsl";
+import { LightingModel, MeshBasicNodeMaterial, MeshToonNodeMaterial, NodeMaterial, RenderPipeline, RenderTarget, SpriteNodeMaterial, ToonOutlinePassNode, WebGPURenderer } from "three/webgpu";
 import { CSMShadowNode } from "three/examples/jsm/csm/CSMShadowNode.js";
 import { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
 import { voronoi2d } from "three/examples/jsm/tsl/math/voronoiNoise.js";
+import GTAONode from "three/examples/jsm/tsl/display/GTAONode.js";
 import { bilateralBlur } from "three/examples/jsm/tsl/display/BilateralBlurNode.js";
 import { bloom } from "three/examples/jsm/tsl/display/BloomNode.js";
 import { depthAwareBlend } from "three/examples/jsm/tsl/display/depthAwareBlend.js";
@@ -11,52 +12,113 @@ import { godrays } from "three/examples/jsm/tsl/display/GodraysNode.js";
 import { lut3D } from "three/examples/jsm/tsl/display/Lut3DNode.js";
 import { smaa } from "three/examples/jsm/tsl/display/SMAANode.js";
 import { traa } from "three/examples/jsm/tsl/display/TRAANode.js";
-//#region src/post/toSceneColor.ts
+//#region src/atmosphere/constants.ts
+const DEFAULT_SKY_SHAPE = {
+	frontBackBlend: 1,
+	haloHeight: 1,
+	horizonBand: .45,
+	moonSize: 1,
+	sunHaloSize: 1
+};
+const DEFAULT_SAMPLE_COUNT = 33;
+const DEFAULT_SKY_GRADIENT = {
+	green: Array.from({ length: DEFAULT_SAMPLE_COUNT }, () => 0),
+	red: Array.from({ length: DEFAULT_SAMPLE_COUNT }, (_value, index) => 1 - MathUtils.smoothstep(index, 0, 32))
+};
+//#endregion
+//#region src/post/toneMapNeutral.ts
 const TOE_END = .08;
 const TOE_OFFSET = .04;
 const COMPRESSION_START = .76;
 const DESATURATION = .15;
-const INVERSE_STEP_COUNT = 16;
-const SLOPE_NUDGE = 1e-4;
-const SCENE_CHANNEL_LIMIT = 1.5;
-const toneMap = ([red, green, blue]) => {
+const compressChannel = (channel, peak, newPeak, whiteShare) => channel * newPeak / peak + (newPeak - channel * newPeak / peak) * whiteShare;
+const toneMapNeutral = ([red, green, blue], toneMapped = [
+	0,
+	0,
+	0
+]) => {
 	const lowest = Math.min(red, green, blue);
 	const offset = lowest < TOE_END ? lowest - 6.25 * lowest * lowest : TOE_OFFSET;
-	const offsetColor = [
-		red - offset,
-		green - offset,
-		blue - offset
-	];
-	const peak = Math.max(...offsetColor);
-	if (peak < COMPRESSION_START) return offsetColor;
+	const offsetRed = red - offset;
+	const offsetGreen = green - offset;
+	const offsetBlue = blue - offset;
+	const peak = Math.max(offsetRed, offsetGreen, offsetBlue);
+	if (peak < COMPRESSION_START) {
+		toneMapped[0] = offsetRed;
+		toneMapped[1] = offsetGreen;
+		toneMapped[2] = offsetBlue;
+		return toneMapped;
+	}
 	const headroom = .24;
 	const newPeak = 1 - headroom * headroom / (peak + headroom - COMPRESSION_START);
 	const whiteShare = 1 - 1 / (DESATURATION * (peak - newPeak) + 1);
-	return offsetColor.map((channel) => channel * newPeak / peak + (newPeak - channel * newPeak / peak) * whiteShare);
+	toneMapped[0] = compressChannel(offsetRed, peak, newPeak, whiteShare);
+	toneMapped[1] = compressChannel(offsetGreen, peak, newPeak, whiteShare);
+	toneMapped[2] = compressChannel(offsetBlue, peak, newPeak, whiteShare);
+	return toneMapped;
 };
-const toSceneColor = (displayColor) => {
-	const target = [
-		displayColor.r,
-		displayColor.g,
-		displayColor.b
-	];
-	let input = [...target];
+//#endregion
+//#region src/post/toSceneColor.ts
+const INVERSE_STEP_COUNT = 16;
+const SLOPE_NUDGE = 1e-4;
+const SCENE_CHANNEL_LIMIT = 1.5;
+const target = [
+	0,
+	0,
+	0
+];
+const input = [
+	0,
+	0,
+	0
+];
+const output$1 = [
+	0,
+	0,
+	0
+];
+const nudged = [
+	0,
+	0,
+	0
+];
+const nudgedOutput = [
+	0,
+	0,
+	0
+];
+const stepped = [
+	0,
+	0,
+	0
+];
+const toSceneColor = (displayColor, sceneColor = new Color()) => {
+	target[0] = input[0] = displayColor.r;
+	target[1] = input[1] = displayColor.g;
+	target[2] = input[2] = displayColor.b;
 	for (let step = 0; step < INVERSE_STEP_COUNT; step++) {
-		const current = input;
-		const output = toneMap(current);
-		input = current.map((channel, index) => {
-			const nudged = [...current];
+		toneMapNeutral(input, output$1);
+		for (let index = 0; index < 3; index++) {
+			nudged[0] = input[0];
+			nudged[1] = input[1];
+			nudged[2] = input[2];
+			const channel = input[index] ?? 0;
 			nudged[index] = channel + SLOPE_NUDGE;
-			const slope = ((toneMap(nudged)[index] ?? 0) - (output[index] ?? 0)) / SLOPE_NUDGE;
-			return Math.min(Math.max(channel + ((target[index] ?? 0) - (output[index] ?? 0)) / slope, 0), SCENE_CHANNEL_LIMIT);
-		});
+			toneMapNeutral(nudged, nudgedOutput);
+			const slope = ((nudgedOutput[index] ?? 0) - (output$1[index] ?? 0)) / SLOPE_NUDGE;
+			stepped[index] = Math.min(Math.max(channel + ((target[index] ?? 0) - (output$1[index] ?? 0)) / slope, 0), SCENE_CHANNEL_LIMIT);
+		}
+		input[0] = stepped[0];
+		input[1] = stepped[1];
+		input[2] = stepped[2];
 	}
-	return new Color(...input);
+	return sceneColor.setRGB(input[0], input[1], input[2]);
 };
 //#endregion
 //#region src/atmosphere/applySkyState.ts
 const GODRAYS_REDRAW_COSINE = Math.cos(.6 * Math.PI / 180);
 const godraysDirection = new Vector3();
+const BLACK = new Color(0, 0, 0);
 const applySkyState = (skyState, { fogUniforms, godraysLight, hemisphere, light, lightDistance, lightUniforms, postUniforms, skyUniforms }) => {
 	const { horizonColor, lightColor, lightDirection } = skyState;
 	light.position.copy(light.target.position).addScaledVector(lightDirection, lightDistance);
@@ -68,18 +130,32 @@ const applySkyState = (skyState, { fogUniforms, godraysLight, hemisphere, light,
 	lightUniforms.lightColor.value.copy(lightColor);
 	lightUniforms.sunDirection.value.copy(lightDirection);
 	lightUniforms.rimColor.value.copy(horizonColor);
-	fogUniforms.color.value.copy(toSceneColor(skyState.fogColor ?? horizonColor));
-	fogUniforms.scatterColor.value.copy(toSceneColor(lightColor));
+	toSceneColor(skyState.fogColor ?? horizonColor, fogUniforms.color.value);
+	toSceneColor(lightColor, fogUniforms.scatterColor.value);
 	fogUniforms.scatterDirection.value.copy(lightDirection);
 	postUniforms.godraysColor.value.copy(lightColor);
-	skyUniforms.cloudLitColor.value.copy(toSceneColor(skyState.cloudLitColor));
-	skyUniforms.cloudShadeColor.value.copy(toSceneColor(skyState.cloudShadeColor));
-	skyUniforms.horizonColor.value.copy(toSceneColor(horizonColor));
+	toSceneColor(skyState.cloudLitColor, skyUniforms.cloudLitColor.value);
+	toSceneColor(skyState.cloudShadeColor, skyUniforms.cloudShadeColor.value);
+	toSceneColor(skyState.cloudLitBackColor ?? skyState.cloudLitColor, skyUniforms.cloudLitBackColor.value);
+	toSceneColor(skyState.cloudShadeBackColor ?? skyState.cloudShadeColor, skyUniforms.cloudShadeBackColor.value);
+	toSceneColor(horizonColor, skyUniforms.horizonColor.value);
+	toSceneColor(skyState.horizonBackColor ?? horizonColor, skyUniforms.horizonBackColor.value);
+	toSceneColor(skyState.zenithBackColor ?? skyState.zenithColor, skyUniforms.zenithBackColor.value);
+	toSceneColor(skyState.haloColor ?? BLACK, skyUniforms.haloColor.value);
+	toSceneColor(skyState.sunHaloColor ?? BLACK, skyUniforms.sunHaloColor.value);
 	skyUniforms.lightColor.value.copy(lightColor);
 	skyUniforms.moonDirection.value.copy(skyState.moonDirection);
+	toSceneColor(skyState.moonGlowColor ?? BLACK, skyUniforms.moonGlowColor.value);
 	skyUniforms.starIntensity.value = skyState.starIntensity;
 	skyUniforms.sunDirection.value.copy(skyState.sunDirection);
-	skyUniforms.zenithColor.value.copy(toSceneColor(skyState.zenithColor));
+	toSceneColor(skyState.zenithColor, skyUniforms.zenithColor.value);
+	const { frontBackBlend, haloHeight, horizonBand, moonSize, sunHaloSize } = skyState.shape ?? DEFAULT_SKY_SHAPE;
+	skyUniforms.frontBackBlend.value = frontBackBlend;
+	skyUniforms.haloHeight.value = haloHeight;
+	skyUniforms.horizonBand.value = horizonBand;
+	skyUniforms.moonSize.value = moonSize;
+	skyUniforms.sunHaloSize.value = sunHaloSize;
+	if (!godraysLight) return;
 	godraysDirection.subVectors(godraysLight.position, godraysLight.target.position).normalize();
 	if (godraysDirection.dot(lightDirection) >= GODRAYS_REDRAW_COSINE) return;
 	godraysLight.position.copy(godraysLight.target.position).addScaledVector(lightDirection, lightDistance);
@@ -97,31 +173,44 @@ const computeSunDirection = (minutes, tilt, sunDirection) => {
 	return sunDirection.set(Math.sin(hourAngle), height * Math.cos(tilt), height * Math.sin(tilt));
 };
 //#endregion
-//#region src/atmosphere/createCloudAtlasTexture.ts
+//#region src/atmosphere/getCloudAtlasColumns.ts
 const getCloudAtlasColumns = (spriteCount) => Math.ceil(Math.sqrt(spriteCount));
+//#endregion
+//#region src/materials/addSmoothLoop.ts
+const addSmoothLoop = (path, points) => {
+	if (points.length < 3) return;
+	const getMidpoint = (index) => {
+		const [startX = 0, startY = 0] = points[index % points.length] ?? [];
+		const [endX = 0, endY = 0] = points[(index + 1) % points.length] ?? [];
+		return [(startX + endX) / 2, (startY + endY) / 2];
+	};
+	path.moveTo(...getMidpoint(points.length - 1));
+	for (const [index, [x, y]] of points.entries()) path.quadraticCurveTo(x, y, ...getMidpoint(index));
+	path.closePath();
+};
+//#endregion
+//#region src/atmosphere/createCloudAtlasTexture.ts
+const EDGE_BLUR_SHARE = .02;
+const CROWN_BLUR_SHARE = .035;
 const createCloudAtlasTexture = (sprites, cellSize) => {
 	const columns = getCloudAtlasColumns(sprites.length);
 	const canvas = new OffscreenCanvas(columns * cellSize, columns * cellSize);
 	const context = canvas.getContext("2d");
 	if (context) {
 		context.globalCompositeOperation = "lighter";
-		const fill = (loops, column, row, style) => {
+		const fill = (loops, column, row, style, blurShare) => {
+			context.filter = `blur(${cellSize * blurShare}px)`;
 			const path = new Path2D();
-			for (const [first, ...rest] of loops) {
-				if (!first) continue;
-				const toCanvas = ([x, y]) => [(column + x) * cellSize, (row + 1 - y) * cellSize];
-				path.moveTo(...toCanvas(first));
-				for (const point of rest) path.lineTo(...toCanvas(point));
-				path.closePath();
-			}
+			const toCanvas = ([x, y]) => [(column + x) * cellSize, (row + 1 - y) * cellSize];
+			for (const loop of loops) addSmoothLoop(path, loop.map((point) => toCanvas(point)));
 			context.fillStyle = style;
 			context.fill(path, "evenodd");
 		};
 		for (const [index, { lit, outline }] of sprites.entries()) {
 			const column = index % columns;
 			const row = Math.floor(index / columns);
-			fill(outline, column, row, "#f00");
-			fill(lit, column, row, "#0f0");
+			fill(outline, column, row, "#f00", EDGE_BLUR_SHARE);
+			fill(lit, column, row, "#0f0", CROWN_BLUR_SHARE);
 		}
 	}
 	const texture = new CanvasTexture(canvas);
@@ -132,21 +221,124 @@ const createCloudAtlasTexture = (sprites, cellSize) => {
 	return texture;
 };
 //#endregion
-//#region src/atmosphere/createCloudSpriteMaterial.ts
-const createCloudSpriteMaterial = (atlas, { index, spriteCount }, { cloudLitColor, cloudShadeColor }) => {
+//#region src/atmosphere/orderByViewDepth.ts
+const orderByViewDepth = (places, { elements }, depths, order) => {
+	for (let index = 0; index < places.length; index++) {
+		const place = places[index];
+		depths[index] = elements[2] * (place?.[0] ?? 0) + elements[6] * (place?.[1] ?? 0) + elements[10] * (place?.[2] ?? 0) + elements[14];
+	}
+	let isReordered = false;
+	for (let index = 1; index < order.length; index++) {
+		const place = order[index] ?? 0;
+		const depth = depths[place] ?? 0;
+		let slot = index;
+		while (slot > 0) {
+			const nearer = order[slot - 1] ?? 0;
+			const nearerDepth = depths[nearer] ?? 0;
+			if (nearerDepth < depth || nearerDepth === depth && nearer < place) break;
+			order[slot] = nearer;
+			slot--;
+		}
+		if (slot === index) continue;
+		order[slot] = place;
+		isReordered = true;
+	}
+	return isReordered;
+};
+//#endregion
+//#region src/atmosphere/createCloudBandSprite.ts
+const BELOW_FADE_START = .1;
+const BELOW_FADE_SCALE = 5;
+const COVERAGE_LIGHT_SHARE = .4;
+const EDGE_FADE_START = 0;
+const EDGE_FADE_END = 1;
+const DROPPED_COVERAGE = .01;
+const MIN_CROWN_COVER = .05;
+const createCloudBandSprite = (atlas, clouds, { aspect, spriteCount }, skyUniforms) => {
+	const { cloudCoverage, cloudFrontBackBlend, cloudLitBackColor, cloudLitColor, cloudShadeBackColor, cloudShadeColor, cloudSunBrighten, sunDirection } = skyUniforms;
 	const columns = getCloudAtlasColumns(spriteCount);
-	const column = index % columns;
-	const row = Math.floor(index / columns);
-	const cellUv = uv().add(vec2(column, columns - 1 - row)).div(columns);
-	const mask = texture(atlas, cellUv);
+	const places = clouds.map(({ position }) => [...position]);
+	const cloudScales = clouds.map(({ width }) => [width, width / aspect]);
+	const cloudCells = clouds.map(({ spriteIndex }) => [spriteIndex % columns, columns - 1 - Math.floor(spriteIndex / columns)]);
+	const positions = new InstancedBufferAttribute(new Float32Array(clouds.length * 3), 3);
+	const scales = new InstancedBufferAttribute(new Float32Array(clouds.length * 2), 2);
+	const cells = new InstancedBufferAttribute(new Float32Array(clouds.length * 2), 2);
+	const ranks = new InstancedBufferAttribute(new Float32Array(clouds.length), 1);
+	const cover = uniform(1);
+	const mask = texture(atlas, uv().add(instancedBufferAttribute(cells)).div(columns));
+	const place = instancedBufferAttribute(positions);
+	const direction = place.sub(cameraPosition).normalize();
+	const elevation = asin(clamp(direction.y, -1, 1)).mul(2 / Math.PI);
+	const sunCosine = direction.dot(sunDirection);
+	const toward = pow(max(sunCosine.mul(cloudFrontBackBlend).add(float(1).sub(cloudFrontBackBlend)), 0), 3);
+	const lit = mix(cloudLitBackColor, cloudLitColor, toward);
+	const shade = mix(cloudShadeBackColor, cloudShadeColor, toward);
+	const crown = saturate(mask.g.div(max(mask.r, MIN_CROWN_COVER)));
+	const cloudColor = mix(shade, lit, crown).add(lit.mul(cloudCoverage.mul(COVERAGE_LIGHT_SHARE))).mul(float(1).add(cloudSunBrighten.mul(sunCosine.mul(.5).add(.5))));
 	const material = new SpriteNodeMaterial({
 		depthWrite: false,
 		transparent: true
 	});
-	material.colorNode = mix(cloudShadeColor, cloudLitColor, mask.g);
-	material.opacityNode = mask.r;
-	material.alphaTest = .5;
-	return material;
+	material.positionNode = place;
+	material.scaleNode = instancedBufferAttribute(scales);
+	material.colorNode = cloudColor;
+	material.opacityNode = smoothstep(EDGE_FADE_START, EDGE_FADE_END, mask.r).mul(smoothstep(0, 1, saturate(elevation.add(BELOW_FADE_START).mul(BELOW_FADE_SCALE)))).mul(step(instancedBufferAttribute(ranks), cover));
+	material.alphaTest = DROPPED_COVERAGE;
+	const sprite = new Sprite(material);
+	sprite.center.set(.5, 0);
+	sprite.count = clouds.length;
+	sprite.frustumCulled = false;
+	const modelViewMatrix = new Matrix4();
+	const depths = new Float64Array(clouds.length);
+	const order = Uint32Array.from(clouds, (_cloud, index) => index);
+	const layOut = () => {
+		for (let instance = 0; instance < order.length; instance++) {
+			const cloud = order[instance] ?? 0;
+			scales.set(cloudScales[cloud] ?? [], instance * 2);
+			cells.set(cloudCells[cloud] ?? [], instance * 2);
+			ranks.setX(instance, (cloud + .5) / clouds.length);
+		}
+		scales.needsUpdate = true;
+		cells.needsUpdate = true;
+		ranks.needsUpdate = true;
+	};
+	layOut();
+	sprite.onBeforeRender = (_renderer, _scene, camera) => {
+		modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, sprite.matrixWorld);
+		const isReordered = orderByViewDepth(places, modelViewMatrix, depths, order);
+		for (let instance = 0; instance < order.length; instance++) positions.set(places[order[instance] ?? 0] ?? [], instance * 3);
+		positions.needsUpdate = true;
+		if (isReordered) layOut();
+	};
+	return {
+		cover,
+		dispose: () => {
+			material.dispose();
+		},
+		places,
+		sprite
+	};
+};
+//#endregion
+//#region src/constants.ts
+const MAX_BYTE = 255;
+//#endregion
+//#region src/atmosphere/createSkyGradientTexture.ts
+const createSkyGradientTexture = ({ green, red }) => {
+	const width = Math.max(red.length, green.length, 1);
+	const data = new Uint8Array(width * 4);
+	for (let index = 0; index < width; index++) {
+		data[index * 4] = Math.round((red[index] ?? 0) * 255);
+		data[index * 4 + 1] = Math.round((green[index] ?? 0) * 255);
+		data[index * 4 + 3] = 255;
+	}
+	const texture = new DataTexture(data, width, 1, RGBAFormat, UnsignedByteType);
+	texture.magFilter = LinearFilter;
+	texture.minFilter = LinearFilter;
+	texture.wrapS = ClampToEdgeWrapping;
+	texture.wrapT = ClampToEdgeWrapping;
+	texture.needsUpdate = true;
+	return texture;
 };
 //#endregion
 //#region src/atmosphere/createSkyState.ts
@@ -170,14 +362,27 @@ const createSkyState = () => ({
 const createSkyUniforms = () => ({
 	cloudCoverage: uniform(0),
 	cloudDrift: uniform(new Vector2()),
+	cloudFrontBackBlend: uniform(1),
+	cloudLitBackColor: uniform(new Color()),
 	cloudLitColor: uniform(new Color()),
+	cloudShadeBackColor: uniform(new Color()),
 	cloudShadeColor: uniform(new Color()),
-	horizonBand: uniform(.45),
+	cloudSunBrighten: uniform(0),
+	frontBackBlend: uniform(DEFAULT_SKY_SHAPE.frontBackBlend),
+	haloColor: uniform(new Color(0, 0, 0)),
+	haloHeight: uniform(DEFAULT_SKY_SHAPE.haloHeight),
+	horizonBackColor: uniform(new Color()),
+	horizonBand: uniform(DEFAULT_SKY_SHAPE.horizonBand),
 	horizonColor: uniform(new Color()),
 	lightColor: uniform(new Color()),
 	moonDirection: uniform(new Vector3(0, -1, 0)),
+	moonGlowColor: uniform(new Color(0, 0, 0)),
+	moonSize: uniform(DEFAULT_SKY_SHAPE.moonSize),
 	starIntensity: uniform(0),
 	sunDirection: uniform(new Vector3(0, 1, 0)),
+	sunHaloColor: uniform(new Color(0, 0, 0)),
+	sunHaloSize: uniform(DEFAULT_SKY_SHAPE.sunHaloSize),
+	zenithBackColor: uniform(new Color()),
 	zenithColor: uniform(new Color())
 });
 //#endregion
@@ -237,7 +442,6 @@ const placeCloudBand = ({ count, distanceRange: [near, far], heightRange: [low,
 };
 //#endregion
 //#region src/atmosphere/sampleSkyState.ts
-const lerp = (from, to, amount) => from + (to - from) * amount;
 const sampleSkyState = (skyKeyframes, minutes, tilt, skyState) => {
 	let nextIndex = 0;
 	while (nextIndex < skyKeyframes.length && (skyKeyframes[nextIndex]?.minutes ?? 0) <= minutes) nextIndex++;
@@ -250,12 +454,12 @@ const sampleSkyState = (skyKeyframes, minutes, tilt, skyState) => {
 	skyState.cloudLitColor.lerpColors(previous.cloudLitColor, next.cloudLitColor, amount);
 	skyState.cloudShadeColor.lerpColors(previous.cloudShadeColor, next.cloudShadeColor, amount);
 	skyState.hemisphereGroundColor.lerpColors(previous.hemisphereGroundColor, next.hemisphereGroundColor, amount);
-	skyState.hemisphereIntensity = lerp(previous.hemisphereIntensity, next.hemisphereIntensity, amount);
+	skyState.hemisphereIntensity = MathUtils.lerp(previous.hemisphereIntensity, next.hemisphereIntensity, amount);
 	skyState.hemisphereSkyColor.lerpColors(previous.hemisphereSkyColor, next.hemisphereSkyColor, amount);
 	skyState.horizonColor.lerpColors(previous.horizonColor, next.horizonColor, amount);
 	skyState.lightColor.lerpColors(previous.lightColor, next.lightColor, amount);
-	skyState.lightIntensity = lerp(previous.lightIntensity, next.lightIntensity, amount);
-	skyState.starIntensity = lerp(previous.starIntensity, next.starIntensity, amount);
+	skyState.lightIntensity = MathUtils.lerp(previous.lightIntensity, next.lightIntensity, amount);
+	skyState.starIntensity = MathUtils.lerp(previous.starIntensity, next.starIntensity, amount);
 	skyState.zenithColor.lerpColors(previous.zenithColor, next.zenithColor, amount);
 	computeSunDirection(minutes, tilt, skyState.sunDirection);
 	skyState.moonDirection.copy(skyState.sunDirection).negate();
@@ -263,11 +467,309 @@ const sampleSkyState = (skyKeyframes, minutes, tilt, skyState) => {
 	return skyState;
 };
 //#endregion
+//#region src/audio/collectMusicNotes.ts
+const collectMusicNotes = ({ segment, start }, from, to) => segment.voices.flatMap((voice) => voice.notes.flatMap((note) => {
+	const time = start + note.start;
+	return time >= from && time < to ? [{
+		note,
+		time,
+		voice
+	}] : [];
+}));
+//#endregion
+//#region src/audio/collectMusicSegments.ts
+const collectMusicSegments = ({ isLooping, order, segments }, from, to) => {
+	const passDuration = order.reduce((sum, index) => sum + (segments[index]?.duration ?? 0), 0);
+	if (passDuration <= 0) return [];
+	const scheduledSegments = [];
+	const lastPass = isLooping ? Math.ceil(to / passDuration) : 1;
+	for (let pass = Math.max(Math.floor(from / passDuration), 0); pass < lastPass; pass++) {
+		let start = pass * passDuration;
+		for (const index of order) {
+			const segment = segments[index];
+			if (!segment) continue;
+			else if (start >= to) break;
+			else if (start + segment.duration > from) scheduledSegments.push({
+				segment,
+				start
+			});
+			start += segment.duration;
+		}
+	}
+	return scheduledSegments;
+};
+//#endregion
+//#region src/audio/constants.ts
+const MUSIC_LOOKAHEAD_SECONDS = 2;
+const MUSIC_SCHEDULE_INTERVAL_MS = 500;
+const RELEASE_TIME_CONSTANTS = 7;
+const MUSIC_NOISE_LENGTH = 2 ** 16;
+const MUSIC_NOISE_BAND_CENTRES = [
+	63,
+	125,
+	250,
+	500,
+	1e3,
+	2e3,
+	4e3,
+	8e3
+];
+const MUSIC_EXPRESSION_WINDOW_SECONDS = 8;
+const A4_PITCH = 69;
+const A4_FREQUENCY = 440;
+const MIDI_VELOCITY_MAX = 127;
+//#endregion
+//#region src/audio/transformFourier.ts
+const transformFourier = (real, imaginary) => {
+	const { length } = real;
+	for (let index = 1, reversed = 0; index < length; index++) {
+		let bit = length >> 1;
+		for (; reversed & bit; bit >>= 1) reversed ^= bit;
+		reversed ^= bit;
+		if (index < reversed) {
+			[real[index], real[reversed]] = [real[reversed] ?? 0, real[index] ?? 0];
+			[imaginary[index], imaginary[reversed]] = [imaginary[reversed] ?? 0, imaginary[index] ?? 0];
+		}
+	}
+	for (let size = 2; size <= length; size <<= 1) {
+		const half = size >> 1;
+		const angle = -2 * Math.PI / size;
+		for (let offset = 0; offset < half; offset++) {
+			const twiddleReal = Math.cos(angle * offset);
+			const twiddleImaginary = Math.sin(angle * offset);
+			for (let even = offset; even < length; even += size) {
+				const odd = even + half;
+				const oddReal = (real[odd] ?? 0) * twiddleReal - (imaginary[odd] ?? 0) * twiddleImaginary;
+				const oddImaginary = (real[odd] ?? 0) * twiddleImaginary + (imaginary[odd] ?? 0) * twiddleReal;
+				real[odd] = (real[even] ?? 0) - oddReal;
+				imaginary[odd] = (imaginary[even] ?? 0) - oddImaginary;
+				real[even] = (real[even] ?? 0) + oddReal;
+				imaginary[even] = (imaginary[even] ?? 0) + oddImaginary;
+			}
+		}
+	}
+};
+//#endregion
+//#region src/audio/computeNoiseSamples.ts
+const computeNoiseSamples = (noiseBands, sampleRate) => {
+	const real = new Float64Array(MUSIC_NOISE_LENGTH);
+	const imaginary = new Float64Array(MUSIC_NOISE_LENGTH);
+	for (let band = 0; band < noiseBands.length; band++) {
+		const level = noiseBands[band] ?? 0;
+		const centre = MUSIC_NOISE_BAND_CENTRES[band] ?? sampleRate;
+		const lowBin = Math.max(Math.ceil(centre / Math.SQRT2 * MUSIC_NOISE_LENGTH / sampleRate), 1);
+		const highBin = Math.min(Math.floor(centre * Math.SQRT2 * MUSIC_NOISE_LENGTH / sampleRate), MUSIC_NOISE_LENGTH / 2 - 1);
+		if (level <= 0 || lowBin > highBin) continue;
+		const amplitude = level / Math.sqrt(2 * (highBin - lowBin + 1));
+		for (let bin = lowBin; bin <= highBin; bin++) {
+			const hash = Math.sin(bin * 12.9898 + band * 78.233) * 43758.5453;
+			const phase = 2 * Math.PI * (hash - Math.floor(hash));
+			const binReal = amplitude * Math.cos(phase);
+			const binImaginary = amplitude * Math.sin(phase);
+			real[bin] = (real[bin] ?? 0) + binReal;
+			real[MUSIC_NOISE_LENGTH - bin] = (real[MUSIC_NOISE_LENGTH - bin] ?? 0) + binReal;
+			imaginary[bin] = (imaginary[bin] ?? 0) - binImaginary;
+			imaginary[MUSIC_NOISE_LENGTH - bin] = (imaginary[MUSIC_NOISE_LENGTH - bin] ?? 0) + binImaginary;
+		}
+	}
+	transformFourier(real, imaginary);
+	return Float32Array.from(real);
+};
+//#endregion
+//#region src/audio/computeSoundEffectSamples.ts
+const computeSoundEffectSamples = ({ frameSeconds, levels }, sampleRate) => {
+	const samples = new Float32Array(Math.ceil(levels.length * frameSeconds * sampleRate));
+	for (const band of MUSIC_NOISE_BAND_CENTRES.keys()) {
+		if (levels.every((frameLevels) => (frameLevels[band] ?? 0) <= 0)) continue;
+		const noise = computeNoiseSamples(MUSIC_NOISE_BAND_CENTRES.map((_centre, index) => index === band ? 1 : 0), sampleRate);
+		for (let sample = 0; sample < samples.length; sample++) {
+			const position = sample / sampleRate / frameSeconds;
+			const frame = Math.floor(position);
+			const share = position - frame;
+			const level = (levels[frame]?.[band] ?? 0) * (1 - share) + (levels[Math.min(frame + 1, levels.length - 1)]?.[band] ?? 0) * share;
+			samples[sample] = (samples[sample] ?? 0) + level * (noise[sample % MUSIC_NOISE_LENGTH] ?? 0);
+		}
+	}
+	return samples;
+};
+//#endregion
+//#region src/audio/createInstrumentWave.ts
+const createInstrumentWave = (context, harmonics) => context.createPeriodicWave(new Float32Array(harmonics.length + 1), Float32Array.of(0, ...harmonics), { disableNormalization: true });
+//#endregion
+//#region src/audio/createNoiseBuffer.ts
+const createNoiseBuffer = (context, noiseBands) => {
+	if (noiseBands.every((level) => level <= 0)) return void 0;
+	const { sampleRate } = context;
+	const buffer = new AudioBuffer({
+		length: MUSIC_NOISE_LENGTH,
+		sampleRate
+	});
+	buffer.getChannelData(0).set(computeNoiseSamples(noiseBands, sampleRate));
+	return buffer;
+};
+//#endregion
+//#region src/audio/scheduleMusicExpression.ts
+const toAmplitude = (gain) => 10 ** (gain / 20);
+const scheduleMusicExpression = (gain, expression, start) => {
+	const [first = 0, ...rest] = expression;
+	gain.setValueAtTime(toAmplitude(first), start);
+	if (rest.length === 0) return;
+	gain.setValueAtTime(toAmplitude(first), start + 4);
+	for (const [index, windowGain] of rest.entries()) gain.exponentialRampToValueAtTime(toAmplitude(windowGain), start + (index + 1.5) * 8);
+};
+//#endregion
+//#region src/audio/scheduleMusicNote.ts
+const scheduleMusicNote = (context, destination, wave, noiseBuffer, { attack, decay, level, release, sustain, tuning }, { duration, pitch, velocity }, time) => {
+	const peak = level * velocity;
+	const end = time + duration;
+	const oscillator = new OscillatorNode(context, {
+		frequency: 440 * 2 ** ((pitch + tuning - 69) / 12),
+		periodicWave: wave
+	});
+	const gain = new GainNode(context, { gain: 0 });
+	gain.gain.setValueAtTime(0, time);
+	if (duration <= attack) gain.gain.linearRampToValueAtTime(peak * duration / attack, end);
+	else {
+		gain.gain.linearRampToValueAtTime(peak, time + attack);
+		gain.gain.setTargetAtTime(peak * sustain, time + attack, decay);
+		gain.gain.setValueAtTime(peak * (sustain + (1 - sustain) * Math.exp(-(duration - attack) / decay)), end);
+	}
+	gain.gain.setTargetAtTime(0, end, release);
+	oscillator.connect(gain).connect(destination);
+	oscillator.addEventListener("ended", () => {
+		gain.disconnect();
+	});
+	oscillator.start(time);
+	oscillator.stop(end + release * 7);
+	if (!noiseBuffer) return;
+	const noiseSource = new AudioBufferSourceNode(context, {
+		buffer: noiseBuffer,
+		loop: true
+	});
+	noiseSource.connect(gain);
+	noiseSource.start(time, time % noiseBuffer.duration);
+	noiseSource.stop(end + release * 7);
+};
+//#endregion
+//#region src/audio/createMusicPlayer.ts
+const createMusicPlayer = (context, music, destination = context.destination) => {
+	const output = new GainNode(context);
+	const instrumentSoundMap = /* @__PURE__ */ new Map();
+	let origin = 0;
+	let scheduledUntil = 0;
+	let startSegmentOutputMap = /* @__PURE__ */ new Map();
+	let timer;
+	const schedule = () => {
+		const until = context.currentTime - origin + 2;
+		const nextStartSegmentOutputMap = /* @__PURE__ */ new Map();
+		for (const scheduledSegment of collectMusicSegments(music, scheduledUntil, until)) {
+			let segmentOutput = startSegmentOutputMap.get(scheduledSegment.start);
+			if (!segmentOutput) {
+				segmentOutput = new GainNode(context);
+				scheduleMusicExpression(segmentOutput.gain, scheduledSegment.segment.expression, origin + scheduledSegment.start);
+				segmentOutput.connect(output);
+			}
+			nextStartSegmentOutputMap.set(scheduledSegment.start, segmentOutput);
+			for (const { note, time, voice } of collectMusicNotes(scheduledSegment, scheduledUntil, until)) {
+				let sound = instrumentSoundMap.get(voice.instrument);
+				if (!sound) {
+					sound = {
+						noiseBuffer: createNoiseBuffer(context, voice.instrument.noiseBands),
+						wave: createInstrumentWave(context, voice.instrument.harmonics)
+					};
+					instrumentSoundMap.set(voice.instrument, sound);
+				}
+				scheduleMusicNote(context, segmentOutput, sound.wave, sound.noiseBuffer, voice.instrument, note, origin + time);
+			}
+		}
+		startSegmentOutputMap = nextStartSegmentOutputMap;
+		scheduledUntil = until;
+	};
+	return {
+		start: () => {
+			output.connect(destination);
+			origin = context.currentTime;
+			startSegmentOutputMap = /* @__PURE__ */ new Map();
+			scheduledUntil = 0;
+			schedule();
+			timer = setInterval(() => {
+				schedule();
+			}, 500);
+		},
+		stop: () => {
+			clearInterval(timer);
+			output.disconnect();
+		}
+	};
+};
+//#endregion
+//#region src/audio/createSoundEffectBuffer.ts
+const createSoundEffectBuffer = (context, soundEffect) => {
+	const { sampleRate } = context;
+	const samples = computeSoundEffectSamples(soundEffect, sampleRate);
+	const buffer = new AudioBuffer({
+		length: Math.max(samples.length, 1),
+		sampleRate
+	});
+	buffer.getChannelData(0).set(samples);
+	return buffer;
+};
+//#endregion
+//#region src/audio/renderMusicSegment.ts
+const renderMusicSegment = (music, segmentIndex, sampleRate) => {
+	const segment = music.segments[segmentIndex];
+	const context = new OfflineAudioContext({
+		length: Math.max(Math.ceil((segment?.duration ?? 0) * sampleRate), 1),
+		numberOfChannels: 1,
+		sampleRate
+	});
+	const output = new GainNode(context);
+	scheduleMusicExpression(output.gain, segment?.expression ?? [], 0);
+	output.connect(context.destination);
+	for (const { instrument, notes } of segment?.voices ?? []) {
+		const wave = createInstrumentWave(context, instrument.harmonics);
+		const noiseBuffer = createNoiseBuffer(context, instrument.noiseBands);
+		for (const note of notes) scheduleMusicNote(context, output, wave, noiseBuffer, instrument, note, note.start);
+	}
+	return context.startRendering();
+};
+//#endregion
+//#region src/audio/selectMusicSample.ts
+const getOutsideDistance = (value, low, high) => value < low ? low - value : Math.max(value - high, 0);
+const selectMusicSample = (samples, pitch, velocity) => {
+	const midiVelocity = Math.min(Math.max(Math.round(velocity * 127), 1), 127);
+	let selected;
+	let selectedKeyDistance = Infinity;
+	let selectedVelocityDistance = Infinity;
+	for (const sample of samples) {
+		const keyDistance = getOutsideDistance(pitch, sample.lowKey, sample.highKey);
+		const velocityDistance = getOutsideDistance(midiVelocity, sample.lowVelocity, sample.highVelocity);
+		if (keyDistance > selectedKeyDistance || keyDistance === selectedKeyDistance && velocityDistance >= selectedVelocityDistance) continue;
+		selected = sample;
+		selectedKeyDistance = keyDistance;
+		selectedVelocityDistance = velocityDistance;
+	}
+	return selected;
+};
+//#endregion
 //#region src/clock/advanceGameClock.ts
 const advanceGameClock = (gameClock, deltaSeconds) => {
 	gameClock.minutes = (gameClock.minutes + deltaSeconds * gameClock.minutesPerSecond) % MINUTES_PER_DAY;
 };
 //#endregion
+//#region src/kits/mergeGeometryParts.ts
+const mergeGeometryParts = (parts) => {
+	const geometry = mergeGeometries(parts) ?? new BufferGeometry();
+	for (const part of parts) part.dispose();
+	return geometry;
+};
+//#endregion
+//#region src/kits/architecture/createBoxesGeometry.ts
+const createBoxesGeometry = (boxes) => {
+	const parts = boxes.map(([minX = 0, minY = 0, minZ = 0, maxX = 0, maxY = 0, maxZ = 0]) => new BoxGeometry(maxX - minX, maxY - minY, maxZ - minZ).translate((minX + maxX) / 2, (minY + maxY) / 2, (minZ + maxZ) / 2));
+	return mergeGeometryParts(parts);
+};
+//#endregion
 //#region src/kits/architecture/createLatheStackGeometry.ts
 const createLatheStackGeometry = ({ isFaceted, radialSegments, sections }) => {
 	let footHeight = 0;
@@ -276,26 +778,11 @@ const createLatheStackGeometry = ({ isFaceted, radialSegments, sections }) => {
 		footHeight += height;
 		return isFaceted ? part.toNonIndexed() : part;
 	});
-	const stackGeometry = mergeGeometries(parts) ?? new BufferGeometry();
-	for (const part of parts) part.dispose();
+	const stackGeometry = mergeGeometryParts(parts);
 	if (isFaceted) stackGeometry.computeVertexNormals();
 	return stackGeometry;
 };
 //#endregion
-//#region src/kits/architecture/createSilhouetteGeometry.ts
-const createSilhouetteGeometry = ({ contours, depth: [front, back] }) => {
-	const shapePath = new ShapePath();
-	for (const [first, ...rest] of contours) {
-		if (!first) continue;
-		shapePath.moveTo(...first);
-		for (const point of rest) shapePath.lineTo(...point);
-	}
-	return new ExtrudeGeometry(shapePath.toShapes(), {
-		bevelEnabled: false,
-		depth: back - front
-	}).translate(0, 0, front);
-};
-//#endregion
 //#region src/kits/statue/createStatueGeometry.ts
 const PLINTH_SIDES = 8;
 const FIGURE_SEGMENTS = 24;
@@ -313,24 +800,14 @@ const FIGURE_PROFILE = [
 	new Vector2(0, 6.2)
 ];
 const createStatueGeometry = () => {
-	const lowerStep = new CylinderGeometry(3.2, 3.4, .6, PLINTH_SIDES).translate(0, .3, 0);
-	const upperStep = new CylinderGeometry(2.6, 2.8, .6, PLINTH_SIDES).translate(0, .9, 0);
-	const pedestal = new CylinderGeometry(1.8, 2.1, 2.2, PLINTH_SIDES).translate(0, 2.3, 0);
-	const figure = new LatheGeometry(FIGURE_PROFILE, FIGURE_SEGMENTS).translate(0, 3.4, 0);
-	const parts = [
-		lowerStep,
-		upperStep,
-		pedestal,
-		figure
-	].map((part) => part.toNonIndexed());
-	const statueGeometry = mergeGeometries(parts) ?? new BufferGeometry();
-	for (const part of [
-		lowerStep,
-		upperStep,
-		pedestal,
-		figure,
-		...parts
-	]) part.dispose();
+	const indexedParts = [
+		new CylinderGeometry(3.2, 3.4, .6, PLINTH_SIDES).translate(0, .3, 0),
+		new CylinderGeometry(2.6, 2.8, .6, PLINTH_SIDES).translate(0, .9, 0),
+		new CylinderGeometry(1.8, 2.1, 2.2, PLINTH_SIDES).translate(0, 2.3, 0),
+		new LatheGeometry(FIGURE_PROFILE, FIGURE_SEGMENTS).translate(0, 3.4, 0)
+	];
+	const statueGeometry = mergeGeometryParts(indexedParts.map((part) => part.toNonIndexed()));
+	for (const part of indexedParts) part.dispose();
 	statueGeometry.computeVertexNormals();
 	return statueGeometry;
 };
@@ -464,8 +941,7 @@ const createTreeGeometry = (treeOptions) => {
 		segmentGeometry.translate((start.x + end.x) / 2, (start.y + end.y) / 2, (start.z + end.z) / 2);
 		return segmentGeometry;
 	});
-	const branchGeometry = mergeGeometries(segmentGeometries) ?? new BufferGeometry();
-	for (const segmentGeometry of segmentGeometries) segmentGeometry.dispose();
+	const branchGeometry = mergeGeometryParts(segmentGeometries);
 	const { indices, normals, positions, uvs } = computeLeafCards(clusterCenters, treeOptions);
 	const leafGeometry = new BufferGeometry();
 	leafGeometry.setAttribute("position", new BufferAttribute(positions, 3));
@@ -480,14 +956,12 @@ const createTreeGeometry = (treeOptions) => {
 };
 //#endregion
 //#region src/materials/computeRampValues.ts
-const MAX_BYTE$1 = 255;
 const computeRampValues = ({ resolution, softness, terminator }) => {
 	const lowerEdge = terminator - softness / 2;
 	const upperEdge = terminator + softness / 2;
 	return Uint8Array.from({ length: resolution }, (_value, index) => {
 		const coordinate = (index + .5) / resolution;
-		const step = Math.min(Math.max((coordinate - lowerEdge) / (upperEdge - lowerEdge), 0), 1);
-		return Math.round(step * step * (3 - 2 * step) * MAX_BYTE$1);
+		return Math.round(MathUtils.smoothstep(coordinate, lowerEdge, upperEdge) * 255);
 	});
 };
 //#endregion
@@ -501,7 +975,58 @@ const createRampTexture = (rampOptions) => {
 	return rampTexture;
 };
 //#endregion
-//#region src/nodes/ToonNodeMaterial.ts
+//#region src/nodes/constants.ts
+const LEAST_DIVISOR = 1e-4;
+const STONE_SHADOW_EXPONENT = .2;
+const STONE_RAMP_KNOT_COUNT = 16;
+const STONE_HARMONIC_COUNT = 9;
+const STONE_MASK_OUTPUT = "stoneMask";
+const STONE_HEIGHT_FALLOFF = .05;
+//#endregion
+//#region src/nodes/createSunVisibilityNode.ts
+const createSunVisibilityNode = (lightColor, sunRadiance) => luminance(lightColor).div(luminance(sunRadiance).max(LEAST_DIVISOR)).saturate();
+//#endregion
+//#region src/models/nodes/StoneLightingModel.ts
+var StoneLightingModel = class extends LightingModel {
+	stoneLight;
+	constructor(stoneLight) {
+		super();
+		this.stoneLight = stoneLight;
+	}
+	direct({ lightColor, lightDirection, reflectedLight }) {
+		const { ramp, sunRadiance } = this.stoneLight;
+		const visibility = createSunVisibilityNode(lightColor, sunRadiance);
+		const rampU = normalView.dot(lightDirection).mul(visibility.pow(STONE_SHADOW_EXPONENT)).mul(.5).add(.5).mul(15).add(.5).div(16);
+		reflectedLight.directDiffuse.addAssign(texture(ramp, vec2(rampU, .5)).rgb.mul(diffuseColor.rgb));
+	}
+	indirect(builder) {
+		const { harmonics, heightFade } = this.stoneLight;
+		const { x, y, z } = normalWorld;
+		const ambient = harmonics.element(0).add(harmonics.element(1).mul(x)).add(harmonics.element(2).mul(y)).add(harmonics.element(3).mul(z)).add(harmonics.element(4).mul(x.mul(y))).add(harmonics.element(5).mul(y.mul(z))).add(harmonics.element(6).mul(x.mul(z))).add(harmonics.element(7).mul(x.mul(x).sub(z.mul(z)))).add(harmonics.element(8).mul(y.mul(y).mul(3).sub(1))).add(heightFade.mul(positionWorld.y.mul(-.05).exp()));
+		const { reflectedLight } = builder.context;
+		reflectedLight.indirectDiffuse.addAssign(ambient.mul(diffuseColor.rgb));
+	}
+};
+//#endregion
+//#region src/models/nodes/StoneNodeMaterial.ts
+var StoneNodeMaterial = class extends NodeMaterial {
+	emissiveNode = null;
+	stoneLight;
+	constructor(stoneLight) {
+		super();
+		this.lights = true;
+		this.stoneLight = stoneLight;
+		this.mrtNode = mrt({
+			output,
+			[STONE_MASK_OUTPUT]: float(1)
+		});
+	}
+	setupLightingModel() {
+		return new StoneLightingModel(this.stoneLight);
+	}
+};
+//#endregion
+//#region src/models/nodes/ToonNodeMaterial.ts
 var ToonNodeMaterial = class extends MeshToonNodeMaterial {
 	emissiveNode = null;
 	isMeshToonNodeMaterial;
@@ -511,6 +1036,57 @@ var ToonNodeMaterial = class extends MeshToonNodeMaterial {
 	}
 };
 //#endregion
+//#region src/models/renderer/AntialiasingMode.ts
+let AntialiasingMode = /* @__PURE__ */ function(AntialiasingMode) {
+	AntialiasingMode["Smaa"] = "Smaa";
+	AntialiasingMode["Traa"] = "Traa";
+	return AntialiasingMode;
+}({});
+//#endregion
+//#region src/models/renderer/QualityTier.ts
+let QualityTier = /* @__PURE__ */ function(QualityTier) {
+	QualityTier["High"] = "High";
+	QualityTier["Low"] = "Low";
+	QualityTier["Medium"] = "Medium";
+	return QualityTier;
+}({});
+//#endregion
+//#region src/nodes/applyStoneLight.ts
+const applyStoneLight = ({ harmonics, hazeColor, hazeScatterColor, heightFade, ramp }, { harmonics: harmonicsUniform, hazeColor: hazeColorUniform, hazeScatterColor: hazeScatterColorUniform, heightFade: heightFadeUniform, ramp: rampTexture, sunRadiance }, light) => {
+	const { data } = rampTexture.image;
+	if (data) for (const [knot, [red = 0, green = 0, blue = 0]] of ramp.entries()) {
+		data[knot * 4] = red;
+		data[knot * 4 + 1] = green;
+		data[knot * 4 + 2] = blue;
+		data[knot * 4 + 3] = 1;
+	}
+	rampTexture.needsUpdate = true;
+	for (const [term, [red = 0, green = 0, blue = 0]] of harmonics.entries()) {
+		const value = harmonicsUniform.array[term];
+		if (value instanceof Vector3) value.set(red, green, blue);
+	}
+	heightFadeUniform.value.fromArray(heightFade);
+	hazeColorUniform.value.fromArray(hazeColor);
+	hazeScatterColorUniform.value.fromArray(hazeScatterColor);
+	sunRadiance.value.copy(light.color).multiplyScalar(light.intensity);
+};
+//#endregion
+//#region src/nodes/computeStoneHarmonics.ts
+const computeStoneHarmonics = ([x = 0, y = 0, z = 0], harmonics) => {
+	harmonics[0] = 1;
+	harmonics[1] = x;
+	harmonics[2] = y;
+	harmonics[3] = z;
+	harmonics[4] = x * y;
+	harmonics[5] = y * z;
+	harmonics[6] = x * z;
+	harmonics[7] = x * x - z * z;
+	harmonics[8] = 3 * y * y - 1;
+};
+//#endregion
+//#region src/nodes/computeStoneRampCoordinate.ts
+const computeStoneRampCoordinate = (facing, visibility) => .5 + .5 * facing * Math.max(visibility, 0) ** STONE_SHADOW_EXPONENT;
+//#endregion
 //#region src/nodes/createCausticsNode.ts
 const CAUSTIC_SCALE = .35;
 const CAUSTIC_SPEED = .6;
@@ -524,21 +1100,6 @@ const createCausticsNode = ({ lightColor }, { causticStrength, deepDepth, level
 	return lightColor.mul(veins.mul(fade).mul(causticStrength));
 };
 //#endregion
-//#region src/renderer/constants.ts
-const GENSHIN_TONE_MAPPING = NeutralToneMapping;
-//#endregion
-//#region src/nodes/createGenshinRenderer.ts
-const createGenshinRenderer = (canvas) => {
-	const isWindows = window.navigator.userAgent.includes("Windows");
-	const renderer = new WebGPURenderer({
-		antialias: false,
-		canvas,
-		...isWindows ? {} : { powerPreference: "high-performance" }
-	});
-	renderer.toneMapping = GENSHIN_TONE_MAPPING;
-	return renderer;
-};
-//#endregion
 //#region src/nodes/createRimNode.ts
 const RIM_POWER = 4;
 const createRimNode = ({ rimColor, rimStrength, sunDirection }) => {
@@ -598,11 +1159,36 @@ const createLightUniforms = () => ({
 	sunDirection: uniform(new Vector3(0, 1, 0))
 });
 //#endregion
+//#region src/nodes/createSkyColorNode.ts
+const HALO_TOWARD_START = .3;
+const HALO_TOWARD_SPAN = .7;
+const HALO_SUN_HEIGHT_START = .2;
+const HALO_SUN_HEIGHT_SPAN = .3;
+const SUN_HALO_MIDDLE_SPREAD = .1;
+const SUN_HALO_MIDDLE_WEIGHT = .12;
+const SUN_HALO_OUTER_SPREAD = .01;
+const SUN_HALO_OUTER_WEIGHT = .03;
+const createSkyColorNode = ({ frontBackBlend, haloColor, haloHeight, horizonBackColor, horizonBand, horizonColor, sunDirection, sunHaloColor, sunHaloSize, zenithBackColor, zenithColor }, gradient, direction) => {
+	const height = direction.y;
+	const elevation = abs(asin(clamp(height, -1, 1)).mul(2 / Math.PI));
+	const sunCosine = direction.dot(sunDirection);
+	const toward = pow(max(sunCosine.mul(frontBackBlend).add(float(1).sub(frontBackBlend)), 0), 3);
+	const top = mix(zenithBackColor, zenithColor, toward);
+	const bottom = mix(horizonBackColor, horizonColor, toward);
+	const bottomShare = texture(gradient, vec2(elevation.div(max(horizonBand, LEAST_DIVISOR)), .5)).r;
+	const haloShare = texture(gradient, vec2(elevation.div(max(haloHeight, LEAST_DIVISOR)), .5)).g;
+	const sunSide = saturate(sunCosine.mul(.5).add(.5));
+	const towardSun = smoothstep(0, 1, max(sunSide.sub(HALO_TOWARD_START).div(HALO_TOWARD_SPAN), 0));
+	const sunUp = smoothstep(0, 1, saturate(abs(sunDirection.y).sub(HALO_SUN_HEIGHT_START).div(HALO_SUN_HEIGHT_SPAN)));
+	const halo = haloColor.mul(haloShare).mul(sunUp.mul(float(1).sub(towardSun)).add(towardSun));
+	const spread = sunHaloSize.mul(abs(height));
+	const sunHalo = min(pow(sunSide, spread), 1).add(min(pow(sunSide, spread.mul(SUN_HALO_MIDDLE_SPREAD)), 1).mul(SUN_HALO_MIDDLE_WEIGHT)).add(min(pow(sunSide, spread.mul(SUN_HALO_OUTER_SPREAD)), 1).mul(SUN_HALO_OUTER_WEIGHT)).mul(smoothstep(0, 1, max(sunSide.sub(.5).mul(2), 0)));
+	return mix(top, bottom, bottomShare).add(halo).add(sunHaloColor.mul(sunHalo));
+};
+//#endregion
 //#region src/nodes/createSkyNode.ts
 const SUN_DISC_COSINE = Math.cos(.035);
 const MOON_DISC_COSINE = Math.cos(.05);
-const SUN_GLOW_POWER = 12;
-const HORIZON_GLOW_POWER = 3;
 const SUN_DISC_BRIGHTNESS = 6;
 const CLOUD_SCALE = 1.6;
 const CLOUD_MIN_HEIGHT = .04;
@@ -610,26 +1196,58 @@ const CLOUD_EDGE = .04;
 const CLOUD_SHADE_DEPTH = .18;
 const STAR_SCALE = 420;
 const STAR_THRESHOLD = .9975;
-const createSkyNode = ({ cloudCoverage, cloudDrift, cloudLitColor, cloudShadeColor, horizonBand, horizonColor, lightColor, moonDirection, starIntensity, sunDirection, zenithColor }) => Fn(() => {
-	const direction = normalWorldGeometry.normalize();
-	const height = direction.y;
-	const gradient = mix(horizonColor, zenithColor, smoothstep(0, horizonBand, height));
-	const sunCosine = direction.dot(sunDirection);
-	const sunVisibility = smoothstep(-.1, .05, sunDirection.y);
-	const sunGlow = pow(max(sunCosine, 0), SUN_GLOW_POWER).mul(sunVisibility);
-	const horizonGlow = pow(max(sunCosine, 0), HORIZON_GLOW_POWER).mul(float(1).sub(smoothstep(0, .3, height.abs()))).mul(float(1).sub(smoothstep(0, .5, sunDirection.y))).mul(sunVisibility);
-	const sunDisc = smoothstep(SUN_DISC_COSINE - 5e-4, SUN_DISC_COSINE, sunCosine).mul(sunVisibility);
-	const moonDisc = smoothstep(MOON_DISC_COSINE - 5e-4, MOON_DISC_COSINE, direction.dot(moonDirection)).mul(smoothstep(-.05, .05, moonDirection.y));
-	const stars = smoothstep(STAR_THRESHOLD, 1, mx_cell_noise_float(direction.mul(STAR_SCALE))).mul(starIntensity).mul(smoothstep(0, .1, height));
-	const cloudPosition = direction.xz.div(max(height, CLOUD_MIN_HEIGHT)).mul(CLOUD_SCALE).add(cloudDrift);
-	const cloudNoise = mx_fractal_noise_float(vec3(cloudPosition, 0), 4, 2, .5).mul(.5).add(.5);
-	const cloudThreshold = float(1).sub(cloudCoverage);
-	const cloudDensity = smoothstep(cloudThreshold, cloudThreshold.add(CLOUD_EDGE), cloudNoise).mul(smoothstep(0, .12, height));
-	const cloudShade = smoothstep(cloudThreshold.add(CLOUD_SHADE_DEPTH), cloudThreshold.add(.22), cloudNoise);
-	const cloudColor = mix(cloudLitColor, cloudShadeColor, cloudShade).add(lightColor.mul(sunGlow.mul(.6)));
-	const sky = gradient.add(lightColor.mul(sunGlow.mul(.35).add(horizonGlow.mul(.45)))).add(vec3(stars)).add(vec3(.85, .88, 1).mul(moonDisc)).add(lightColor.mul(sunDisc.mul(SUN_DISC_BRIGHTNESS)));
-	return mix(sky, cloudColor, cloudDensity);
-})();
+const MOON_GLOW_SPREAD = .1;
+const MOON_GLOW_POWER = 6;
+const createSkyNode = (uniforms, gradient) => {
+	const { cloudCoverage, cloudDrift, cloudLitColor, cloudShadeColor, lightColor, moonDirection, moonGlowColor, moonSize, starIntensity, sunDirection } = uniforms;
+	return Fn(() => {
+		const direction = normalWorldGeometry.normalize();
+		const height = direction.y;
+		const sunCosine = direction.dot(sunDirection);
+		const gradientColor = createSkyColorNode(uniforms, gradient, direction);
+		const moonCosine = saturate(direction.dot(moonDirection));
+		const moonGlow = pow(max(moonCosine.sub(1).div(max(moonSize.mul(MOON_GLOW_SPREAD), LEAST_DIVISOR)).add(1), 0), MOON_GLOW_POWER);
+		const sunVisibility = smoothstep(-.1, .05, sunDirection.y);
+		const sunDisc = smoothstep(SUN_DISC_COSINE - 5e-4, SUN_DISC_COSINE, sunCosine).mul(sunVisibility);
+		const moonDisc = smoothstep(MOON_DISC_COSINE - 5e-4, MOON_DISC_COSINE, direction.dot(moonDirection)).mul(smoothstep(-.05, .05, moonDirection.y));
+		const stars = smoothstep(STAR_THRESHOLD, 1, mx_cell_noise_float(direction.mul(STAR_SCALE))).mul(starIntensity).mul(smoothstep(0, .1, height));
+		const cloudPosition = direction.xz.div(max(height, CLOUD_MIN_HEIGHT)).mul(CLOUD_SCALE).add(cloudDrift);
+		const cloudNoise = mx_fractal_noise_float(vec3(cloudPosition, 0), 4, 2, .5).mul(.5).add(.5);
+		const cloudThreshold = float(1).sub(cloudCoverage);
+		const cloudDensity = smoothstep(cloudThreshold, cloudThreshold.add(CLOUD_EDGE), cloudNoise).mul(smoothstep(0, .12, height));
+		const cloudShade = smoothstep(cloudThreshold.add(CLOUD_SHADE_DEPTH), cloudThreshold.add(.22), cloudNoise);
+		const cloudColor = mix(cloudLitColor, cloudShadeColor, cloudShade);
+		const sky = gradientColor.add(moonGlowColor.mul(moonGlow)).add(vec3(stars)).add(vec3(.85, .88, 1).mul(moonDisc)).add(lightColor.mul(sunDisc.mul(SUN_DISC_BRIGHTNESS)));
+		return mix(sky, cloudColor, cloudDensity);
+	})();
+};
+//#endregion
+//#region src/nodes/createStoneLightUniforms.ts
+const createStoneLightUniforms = () => {
+	const ramp = new DataTexture(/* @__PURE__ */ new Float32Array(64), 16, 1, RGBAFormat, FloatType);
+	ramp.magFilter = LinearFilter;
+	ramp.minFilter = LinearFilter;
+	ramp.wrapS = ClampToEdgeWrapping;
+	ramp.wrapT = ClampToEdgeWrapping;
+	ramp.needsUpdate = true;
+	return {
+		harmonics: uniformArray(Array.from({ length: 9 }, () => new Vector3()), "vec3"),
+		hazeColor: uniform(new Color()),
+		hazeScatterColor: uniform(new Color()),
+		heightFade: uniform(new Color()),
+		ramp,
+		sunRadiance: uniform(new Color())
+	};
+};
+//#endregion
+//#region src/nodes/createStoneMaterial.ts
+const createStoneMaterial = ({ albedo, rimColor, rimPower, rimStrength }, stoneLight, glowNode = vec3(0)) => {
+	const material = new StoneNodeMaterial(stoneLight);
+	material.colorNode = color(new Color(albedo));
+	const fresnel = float(1).sub(normalView.dot(positionViewDirection).saturate()).pow(rimPower);
+	material.emissiveNode = color(new Color().fromArray(rimColor)).mul(fresnel.mul(rimStrength)).add(glowNode);
+	return material;
+};
 //#endregion
 //#region src/nodes/createWaterMaterial.ts
 const RIPPLE_SCALE = .08;
@@ -726,14 +1344,13 @@ const createSimplexNoise = (seed) => {
 };
 //#endregion
 //#region src/post/computeGradeLut.ts
-const MAX_BYTE = 255;
 const RED_LUMINANCE = .2126;
 const GREEN_LUMINANCE = .7152;
 const BLUE_LUMINANCE = .0722;
 const CONTRAST_PIVOT = .5;
 const toGradedByte = (channel, luminance, saturation, contrast, tint) => {
 	const graded = (luminance + (channel - luminance) * saturation - CONTRAST_PIVOT) * contrast + CONTRAST_PIVOT + tint;
-	return Math.round(Math.min(Math.max(graded, 0), 1) * MAX_BYTE);
+	return Math.round(Math.min(Math.max(graded, 0), 1) * 255);
 };
 const computeGradeLut = ({ contrast, highlightTint, saturation, shadowTint, size }) => {
 	const values = new Uint8Array(size * size * size * 4);
@@ -752,7 +1369,7 @@ const computeGradeLut = ({ contrast, highlightTint, saturation, shadowTint, size
 		values[offset] = toGradedByte(red, luminance, saturation, contrast, redTint);
 		values[offset + 1] = toGradedByte(green, luminance, saturation, contrast, greenTint);
 		values[offset + 2] = toGradedByte(blue, luminance, saturation, contrast, blueTint);
-		values[offset + 3] = MAX_BYTE;
+		values[offset + 3] = 255;
 		offset += 4;
 	}
 	return values;
@@ -764,6 +1381,7 @@ const createFogUniforms = () => ({
 	color: uniform(new Color()),
 	density: uniform(0),
 	heightFalloff: uniform(0),
+	maxOpacity: uniform(1),
 	scatterColor: uniform(new Color()),
 	scatterDirection: uniform(new Vector3(0, 1, 0)),
 	scatterPower: uniform(1),
@@ -799,7 +1417,7 @@ const createGradeLutTexture = (gradeOptions) => {
 //#endregion
 //#region src/post/createHeightFogNode.ts
 const MIN_RAY_CLIMB = 1e-6;
-const createHeightFogNode = (colorNode, depthNode, camera, { baseHeight, color, density, heightFalloff, scatterColor, scatterDirection, scatterPower, scatterStrength, startDistance }) => {
+const createHeightFogNode = (colorNode, depthNode, camera, { baseHeight, color, density, heightFalloff, maxOpacity, scatterColor, scatterDirection, scatterPower, scatterStrength, startDistance }, stoneHaze) => {
 	const cameraWorldMatrix = uniform(camera.matrixWorld);
 	const cameraProjectionMatrixInverse = uniform(camera.projectionMatrixInverse);
 	return Fn(() => {
@@ -819,59 +1437,94 @@ const createHeightFogNode = (colorNode, depthNode, camera, { baseHeight, color,
 			If(climb.abs().greaterThan(MIN_RAY_CLIMB), () => {
 				opticalDepth.assign(densityAtStart.mul(float(1).sub(exp(fogLength.mul(climb).negate()))).div(climb));
 			});
-			const opacity = float(1).sub(exp(opticalDepth.negate()));
-			const scatter = pow(max(ray.normalize().dot(scatterDirection), 0), scatterPower).mul(scatterStrength);
-			output.assign(vec4(mix(output.rgb, mix(color, scatterColor, scatter.min(1)), opacity), output.a));
+			const opacity = float(1).sub(exp(opticalDepth.negate())).mul(maxOpacity);
+			const scatter = pow(max(ray.normalize().dot(scatterDirection), 0), scatterPower).mul(scatterStrength).min(1);
+			const hazeColor = mix(color, scatterColor, scatter);
+			const shownColor = stoneHaze ? mix(hazeColor, mix(stoneHaze.hazeColor, stoneHaze.hazeScatterColor, scatter), stoneHaze.maskNode.sample(uv()).r) : hazeColor;
+			output.assign(vec4(mix(output.rgb, shownColor, opacity), output.a));
 		});
 		return output;
 	})();
 };
 //#endregion
-//#region src/renderer/AntialiasingMode.ts
-let AntialiasingMode = /* @__PURE__ */ function(AntialiasingMode) {
-	AntialiasingMode["Smaa"] = "Smaa";
-	AntialiasingMode["Traa"] = "Traa";
-	return AntialiasingMode;
-}({});
+//#region src/post/createOcclusionNode.ts
+const OCCLUSION_THICKNESS_SHARE = 4;
+const createOcclusionNode = (depthNode, camera, radius) => {
+	const cameraProjectionMatrixInverse = uniform(camera.projectionMatrixInverse);
+	const normalNode = sample((uv) => getNormalFromDepth(uv, depthNode, cameraProjectionMatrixInverse));
+	const occlusionNode = new GTAONode(depthNode, normalNode, camera);
+	occlusionNode.radius.value = radius;
+	occlusionNode.thickness.value = radius * OCCLUSION_THICKNESS_SHARE;
+	return occlusionNode;
+};
 //#endregion
 //#region src/post/createPostPipeline.ts
 const BLOOM_STRENGTH = .35;
 const BLOOM_RADIUS = .4;
 const BLOOM_THRESHOLD = .85;
 const MIN_VIEW_DISTANCE = .001;
-const createPostPipeline = ({ camera, fogUniforms, godraysLight, gradeLutTexture, postUniforms: { godraysColor, gradeIntensity, outlineColor, outlineFadeDistance, outlineThickness }, qualityTierSettings: { antialiasingMode, godraysStepCount, isBloomEnabled }, renderer, scene }) => {
+const createPostPipeline = ({ camera, fogUniforms, godraysLight, gradeLutTexture, isBloomed = true, occlusionRadius, postUniforms: { godraysColor, gradeIntensity, outlineColor, outlineFadeDistance, outlineThickness }, qualityTierSettings: { antialiasingMode, godraysStepCount, isBloomEnabled, isOcclusionEnabled }, renderer, scene, stoneLight }) => {
 	const renderPipeline = new RenderPipeline(renderer);
 	renderPipeline.outputColorTransform = false;
 	const viewDistance = modelViewMatrix.mul(vec4(positionLocal, 1)).z.negate().max(MIN_VIEW_DISTANCE);
 	const thicknessNode = outlineThickness.mul(outlineFadeDistance.div(viewDistance).min(1));
 	const scenePass = new ToonOutlinePassNode(scene, camera, outlineColor, thicknessNode, float(1));
 	const isTraa = antialiasingMode === "Traa";
-	if (isTraa) scenePass.setMRT(mrt({
-		output,
-		velocity
-	}));
+	const sceneOutputs = { output };
+	if (isTraa) sceneOutputs.velocity = velocity;
+	if (stoneLight) sceneOutputs[STONE_MASK_OUTPUT] = float(0);
+	scenePass.setMRT(mrt(sceneOutputs));
 	const sceneColor = scenePass.getTextureNode("output");
 	const sceneDepth = scenePass.getTextureNode("depth");
-	const postPipeline = { renderPipeline };
+	const passNodes = [scenePass];
+	const postPipeline = {
+		dispose: () => {
+			renderPipeline.dispose();
+			for (const passNode of passNodes) passNode.dispose();
+		},
+		renderPipeline
+	};
 	let litNode = sceneColor;
-	if (godraysStepCount > 0) {
+	if (occlusionRadius && isOcclusionEnabled) {
+		const occlusionNode = createOcclusionNode(sceneDepth, camera, occlusionRadius);
+		passNodes.push(occlusionNode);
+		litNode = vec4(sceneColor.rgb.mul(occlusionNode.getTextureNode().r), sceneColor.a);
+	}
+	if (godraysLight && godraysStepCount > 0) {
 		const godraysNode = godrays(sceneDepth, camera, godraysLight);
 		godraysNode.raymarchSteps.value = godraysStepCount;
 		const blurredGodrays = bilateralBlur(godraysNode.getTextureNode());
-		litNode = depthAwareBlend(sceneColor, blurredGodrays.getTextureNode(), sceneDepth, camera, { blendColor: godraysColor });
+		passNodes.push(godraysNode, blurredGodrays);
+		litNode = depthAwareBlend(litNode, blurredGodrays.getTextureNode(), sceneDepth, camera, { blendColor: godraysColor });
 		postPipeline.godraysNode = godraysNode;
 	}
-	const foggedNode = createHeightFogNode(litNode, sceneDepth, camera, fogUniforms);
+	if (stoneLight) scenePass.getTexture(STONE_MASK_OUTPUT).type = UnsignedByteType;
+	const foggedNode = createHeightFogNode(litNode, sceneDepth, camera, fogUniforms, stoneLight && {
+		hazeColor: stoneLight.hazeColor,
+		hazeScatterColor: stoneLight.hazeScatterColor,
+		maskNode: scenePass.getTextureNode("stoneMask")
+	});
 	let bloomedNode = foggedNode;
-	if (isBloomEnabled) {
+	if (isBloomed && isBloomEnabled) {
 		const bloomNode = bloom(foggedNode, BLOOM_STRENGTH, BLOOM_RADIUS, BLOOM_THRESHOLD);
+		passNodes.push(bloomNode);
 		bloomedNode = foggedNode.add(bloomNode);
 		postPipeline.bloomNode = bloomNode;
 	}
-	const resolvedNode = isTraa ? traa(bloomedNode, sceneDepth, scenePass.getTextureNode("velocity"), camera) : bloomedNode;
+	let resolvedNode = bloomedNode;
+	if (isTraa) {
+		const traaNode = traa(bloomedNode, sceneDepth, scenePass.getTextureNode("velocity"), camera);
+		passNodes.push(traaNode);
+		resolvedNode = traaNode;
+	}
 	const displayNode = renderOutput(resolvedNode);
-	const gradedNode = lut3D(displayNode, texture3D(gradeLutTexture), gradeLutTexture.image.width, gradeIntensity);
-	renderPipeline.outputNode = isTraa ? gradedNode : smaa(gradedNode);
+	const gradedNode = gradeLutTexture ? lut3D(displayNode, texture3D(gradeLutTexture), gradeLutTexture.image.width, gradeIntensity) : displayNode;
+	if (isTraa) renderPipeline.outputNode = gradedNode;
+	else {
+		const smaaNode = smaa(gradedNode);
+		passNodes.push(smaaNode);
+		renderPipeline.outputNode = smaaNode;
+	}
 	return postPipeline;
 };
 //#endregion
@@ -884,14 +1537,6 @@ const createPostUniforms = () => ({
 	outlineThickness: uniform(.003)
 });
 //#endregion
-//#region src/renderer/QualityTier.ts
-let QualityTier = /* @__PURE__ */ function(QualityTier) {
-	QualityTier["High"] = "High";
-	QualityTier["Low"] = "Low";
-	QualityTier["Medium"] = "Medium";
-	return QualityTier;
-}({});
-//#endregion
 //#region src/renderer/QualityTierSettingsMap.ts
 const QualityTierSettingsMap = {
 	["High"]: {
@@ -900,6 +1545,7 @@ const QualityTierSettingsMap = {
 		godraysStepCount: 60,
 		grassDensity: 1,
 		isBloomEnabled: true,
+		isOcclusionEnabled: true,
 		maxPixelRatio: 2,
 		shadowMapSize: 2048
 	},
@@ -909,6 +1555,7 @@ const QualityTierSettingsMap = {
 		godraysStepCount: 0,
 		grassDensity: .3,
 		isBloomEnabled: false,
+		isOcclusionEnabled: false,
 		maxPixelRatio: 1,
 		shadowMapSize: 1024
 	},
@@ -918,11 +1565,37 @@ const QualityTierSettingsMap = {
 		godraysStepCount: 30,
 		grassDensity: .6,
 		isBloomEnabled: true,
+		isOcclusionEnabled: false,
 		maxPixelRatio: 1.5,
 		shadowMapSize: 1024
 	}
 };
 //#endregion
+//#region src/renderer/attachInspector.ts
+const attachInspector = async (renderer) => {
+	const { Inspector } = await import("three/examples/jsm/inspector/Inspector.js");
+	if (renderer.inspector instanceof Inspector) return renderer.inspector;
+	const inspector = new Inspector();
+	renderer.inspector = inspector;
+	return inspector;
+};
+//#endregion
+//#region src/renderer/constants.ts
+const GENSHIN_TONE_MAPPING = NeutralToneMapping;
+//#endregion
+//#region src/renderer/createGenshinRenderer.ts
+const createGenshinRenderer = (canvas) => {
+	const isWindows = window.navigator.userAgent.includes("Windows");
+	const renderer = new WebGPURenderer({
+		antialias: false,
+		canvas,
+		...isWindows ? {} : { powerPreference: "high-performance" }
+	});
+	renderer.toneMapping = GENSHIN_TONE_MAPPING;
+	if (import.meta.env?.DEV && !window.navigator.webdriver) attachInspector(renderer);
+	return renderer;
+};
+//#endregion
 //#region src/renderer/getScreenDirection.ts
 const X_AXIS = new Vector3(1, 0, 0);
 const Y_AXIS = new Vector3(0, 1, 0);
@@ -981,27 +1654,30 @@ const createTileStreamer = ({ disposeTile, maxCachedCount, maxPendingCount, requ
 			});
 			evictStale();
 		},
-		update: ({ count, keys }, drawn) => {
+		update: (wanted, drawn, surrounding) => {
 			frame++;
-			let coarsestLevel = 0;
-			for (let index = 0; index < count; index++) {
+			for (const { count, keys } of [
+				wanted,
+				drawn,
+				surrounding
+			]) for (let index = 0; index < count; index++) {
 				const key = keys[index] ?? 0;
 				const cachedTile = cachedTileMap.get(key);
 				if (cachedTile) cachedTile.lastWantedFrame = frame;
-				else {
-					if (pendingWantedFrameMap.has(key)) pendingWantedFrameMap.set(key, frame);
-					coarsestLevel = Math.max(coarsestLevel, getTerrainTileLevel(key));
-				}
-			}
-			for (let index = 0; index < drawn.count; index++) {
-				const cachedTile = cachedTileMap.get(drawn.keys[index] ?? 0);
-				if (cachedTile) cachedTile.lastWantedFrame = frame;
+				else if (pendingWantedFrameMap.has(key)) pendingWantedFrameMap.set(key, frame);
 			}
-			for (let level = coarsestLevel; level >= 0 && pendingWantedFrameMap.size < maxPendingCount; level--) for (let index = 0; index < count && pendingWantedFrameMap.size < maxPendingCount; index++) {
-				const key = keys[index] ?? 0;
-				if (getTerrainTileLevel(key) !== level || cachedTileMap.has(key) || pendingWantedFrameMap.has(key)) continue;
-				pendingWantedFrameMap.set(key, frame);
-				requestTile(key);
+			for (const { count, keys } of [wanted, surrounding]) {
+				let coarsestLevel = 0;
+				for (let index = 0; index < count; index++) {
+					const key = keys[index] ?? 0;
+					if (!cachedTileMap.has(key)) coarsestLevel = Math.max(coarsestLevel, getTerrainTileLevel(key));
+				}
+				for (let level = coarsestLevel; level >= 0 && pendingWantedFrameMap.size < maxPendingCount; level--) for (let index = 0; index < count && pendingWantedFrameMap.size < maxPendingCount; index++) {
+					const key = keys[index] ?? 0;
+					if (getTerrainTileLevel(key) !== level || cachedTileMap.has(key) || pendingWantedFrameMap.has(key)) continue;
+					pendingWantedFrameMap.set(key, frame);
+					requestTile(key);
+				}
 			}
 		}
 	};
@@ -1084,6 +1760,25 @@ const computeTerrainTile = ({ cellsPerSide, finestTileSize, getHeight, key, writ
 	};
 };
 //#endregion
+//#region src/terrain/createGaussianHillsHeight.ts
+const REACH_WIDTHS = 3;
+const CELL_SIZE = 64;
+const toCellKey = (column, row) => `${column},${row}`;
+const createGaussianHillsHeight = ({ base, hills }) => {
+	const filed = hills.flatMap((hill) => {
+		const reach = REACH_WIDTHS * hill.width;
+		const cells = [];
+		for (let column = Math.floor((hill.x - reach) / CELL_SIZE); column <= Math.floor((hill.x + reach) / CELL_SIZE); column++) for (let row = Math.floor((hill.z - reach) / CELL_SIZE); row <= Math.floor((hill.z + reach) / CELL_SIZE); row++) cells.push([toCellKey(column, row), hill]);
+		return cells;
+	});
+	const cellHillsMap = new Map(Array.from(Map.groupBy(filed, ([key]) => key), ([key, entries]) => [key, entries.map(([, hill]) => hill)]));
+	return (x, z) => {
+		let total = base;
+		for (const { height, width, x: hillX, z: hillZ } of cellHillsMap.get(toCellKey(Math.floor(x / CELL_SIZE), Math.floor(z / CELL_SIZE))) ?? []) total += height * Math.exp(-((x - hillX) ** 2 + (z - hillZ) ** 2) / (2 * width * width));
+		return total;
+	};
+};
+//#endregion
 //#region src/terrain/createTerrainMaterial.ts
 const createTerrainMaterial = ({ finestRange, morphShare }, toonMaterialOptions, waterUniforms) => {
 	const terrainMaterial = createToonMaterial({
@@ -1250,7 +1945,7 @@ const createGrassGeometry = (segmentCount, bladeCount) => {
 	const { indices, positions } = computeGrassBlade(segmentCount);
 	const grassGeometry = new InstancedBufferGeometry();
 	grassGeometry.setAttribute("position", new BufferAttribute(positions, 3));
-	grassGeometry.setAttribute("normal", new BufferAttribute(Float32Array.from({ length: positions.length }, (_, index) => index % 3 === 1 ? 1 : 0), 3));
+	grassGeometry.setAttribute("normal", new BufferAttribute(Float32Array.from({ length: positions.length }, (_value, index) => index % 3 === 1 ? 1 : 0), 3));
 	grassGeometry.setIndex(new BufferAttribute(indices, 1));
 	grassGeometry.instanceCount = bladeCount;
 	return grassGeometry;
@@ -1316,7 +2011,7 @@ const createGroundCapture = (size, resolution) => {
 };
 //#endregion
 //#region src/vegetation/renderGroundCapture.ts
-const clearColor = new Color();
+const CLEAR_COLOR = new Color();
 const previousClearColor = new Color();
 const renderGroundCapture = (renderer, scene, { camera, center, material, renderTarget }, { maxHeight }, worldCenter, origin) => {
 	center.value.set(worldCenter.x, worldCenter.z);
@@ -1331,7 +2026,7 @@ const renderGroundCapture = (renderer, scene, { camera, center, material, render
 	const previousBackgroundNode = scene.backgroundNode;
 	scene.overrideMaterial = material;
 	scene.backgroundNode = null;
-	renderer.setClearColor(clearColor, 0);
+	renderer.setClearColor(CLEAR_COLOR, 0);
 	renderer.setRenderTarget(renderTarget);
 	renderer.clear();
 	renderer.render(scene, camera);
@@ -1345,6 +2040,7 @@ const renderGroundCapture = (renderer, scene, { camera, center, material, render
 const createUnderwaterFogState = () => ({
 	aboveDensity: 0,
 	aboveHeightFalloff: 0,
+	aboveMaxOpacity: 1,
 	aboveStartDistance: 0,
 	isUnderwater: false
 });
@@ -1363,18 +2059,21 @@ const createWaterUniforms = () => ({
 });
 //#endregion
 //#region src/water/updateUnderwaterFog.ts
-const updateUnderwaterFog = (eyeHeight, { level, underwaterFogColor, underwaterFogDensity }, { color, density, heightFalloff, startDistance }, underwaterFogState) => {
+const updateUnderwaterFog = (eyeHeight, { level, underwaterFogColor, underwaterFogDensity }, { color, density, heightFalloff, maxOpacity, startDistance }, underwaterFogState) => {
 	const isUnderwater = eyeHeight < level.value;
 	if (isUnderwater && !underwaterFogState.isUnderwater) {
 		underwaterFogState.aboveDensity = density.value;
 		underwaterFogState.aboveHeightFalloff = heightFalloff.value;
+		underwaterFogState.aboveMaxOpacity = maxOpacity.value;
 		underwaterFogState.aboveStartDistance = startDistance.value;
 		density.value = underwaterFogDensity.value;
 		heightFalloff.value = 0;
+		maxOpacity.value = 1;
 		startDistance.value = 0;
 	} else if (!isUnderwater && underwaterFogState.isUnderwater) {
 		density.value = underwaterFogState.aboveDensity;
 		heightFalloff.value = underwaterFogState.aboveHeightFalloff;
+		maxOpacity.value = underwaterFogState.aboveMaxOpacity;
 		startDistance.value = underwaterFogState.aboveStartDistance;
 	}
 	underwaterFogState.isUnderwater = isUnderwater;
@@ -1417,4 +2116,4 @@ const computeOutlineDistance = (outline, x, z) => {
 	return isInside ? 0 : Math.sqrt(nearestSquared);
 };
 //#endregion
-export { AntialiasingMode, GAME_MINUTES_PER_SECOND, GENSHIN_TONE_MAPPING, MINUTES_PER_DAY, QualityTier, QualityTierSettingsMap, TERRAIN_LAYER, TILE_INDEX_OFFSET, TILE_INDEX_SPAN, ToonNodeMaterial, advanceGameClock, applySkyState, computeGradeLut, computeGrassBlade, computeLeafCards, computeOriginShift, computeOutlineDistance, computeRampValues, computeSunDirection, computeTerrainIndices, computeTerrainTile, computeTreeSkeleton, createCausticsNode, createCloudAtlasTexture, createCloudSpriteMaterial, createFogUniforms, createGenshinRenderer, createGodraysLight, createGradeLutTexture, createGrassGeometry, createGrassMaterial, createGroundCapture, createHeightFogNode, createLatheStackGeometry, createLeafMaterial, createLightUniforms, createPostPipeline, createPostUniforms, createRampTexture, createRimNode, createSeededRandom, createSilhouetteGeometry, createSimplexNoise, createSkyNode, createSkyState, createSkyUniforms, createStatueGeometry, createSunLight, createTerrainMaterial, createTerrainSelection, createTerrainTileGeometry, createTileStreamer, createToonMaterial, createTreeGeometry, createUnderwaterFogState, createWaterMaterial, createWaterUniforms, createWindNode, createWindUniforms, getCloudAtlasColumns, getParentTerrainTileKey, getScreenDirection, getTerrainTileColumn, getTerrainTileKey, getTerrainTileLevel, getTerrainTileRow, placeCloudBand, renderGroundCapture, resolveTerrainDraws, sampleSkyState, selectTerrainTiles, toSceneColor, updateUnderwaterFog };
+export { A4_FREQUENCY, A4_PITCH, AntialiasingMode, DEFAULT_SKY_GRADIENT, DEFAULT_SKY_SHAPE, GAME_MINUTES_PER_SECOND, GENSHIN_TONE_MAPPING, LEAST_DIVISOR, MAX_BYTE, MIDI_VELOCITY_MAX, MINUTES_PER_DAY, MUSIC_EXPRESSION_WINDOW_SECONDS, MUSIC_LOOKAHEAD_SECONDS, MUSIC_NOISE_BAND_CENTRES, MUSIC_NOISE_LENGTH, MUSIC_SCHEDULE_INTERVAL_MS, QualityTier, QualityTierSettingsMap, RELEASE_TIME_CONSTANTS, STONE_HARMONIC_COUNT, STONE_HEIGHT_FALLOFF, STONE_MASK_OUTPUT, STONE_RAMP_KNOT_COUNT, STONE_SHADOW_EXPONENT, StoneLightingModel, StoneNodeMaterial, TERRAIN_LAYER, TILE_INDEX_OFFSET, TILE_INDEX_SPAN, ToonNodeMaterial, addSmoothLoop, advanceGameClock, applySkyState, applyStoneLight, attachInspector, collectMusicNotes, collectMusicSegments, computeGradeLut, computeGrassBlade, computeLeafCards, computeNoiseSamples, computeOriginShift, computeOutlineDistance, computeRampValues, computeSoundEffectSamples, computeStoneHarmonics, computeStoneRampCoordinate, computeSunDirection, computeTerrainIndices, computeTerrainTile, computeTreeSkeleton, createBoxesGeometry, createCausticsNode, createCloudAtlasTexture, createCloudBandSprite, createFogUniforms, createGaussianHillsHeight, createGenshinRenderer, createGodraysLight, createGradeLutTexture, createGrassGeometry, createGrassMaterial, createGroundCapture, createHeightFogNode, createInstrumentWave, createLatheStackGeometry, createLeafMaterial, createLightUniforms, createMusicPlayer, createNoiseBuffer, createOcclusionNode, createPostPipeline, createPostUniforms, createRampTexture, createRimNode, createSeededRandom, createSimplexNoise, createSkyColorNode, createSkyGradientTexture, createSkyNode, createSkyState, createSkyUniforms, createSoundEffectBuffer, createStatueGeometry, createStoneLightUniforms, createStoneMaterial, createSunLight, createSunVisibilityNode, createTerrainMaterial, createTerrainSelection, createTerrainTileGeometry, createTileStreamer, createToonMaterial, createTreeGeometry, createUnderwaterFogState, createWaterMaterial, createWaterUniforms, createWindNode, createWindUniforms, getCloudAtlasColumns, getParentTerrainTileKey, getScreenDirection, getTerrainTileColumn, getTerrainTileKey, getTerrainTileLevel, getTerrainTileRow, mergeGeometryParts, orderByViewDepth, placeCloudBand, renderGroundCapture, renderMusicSegment, resolveTerrainDraws, sampleSkyState, scheduleMusicExpression, scheduleMusicNote, selectMusicSample, selectTerrainTiles, toSceneColor, toneMapNeutral, transformFourier, updateUnderwaterFog };