genshin-engine 3.6.0

package/dist/index.js

@@ -0,0 +1,1258 @@
+import { Box3, BufferAttribute, BufferGeometry, Color, CylinderGeometry, Data3DTexture, DataTexture, DirectionalLight, DoubleSide, HalfFloatType, InstancedBufferGeometry, LatheGeometry, LinearFilter, OrthographicCamera, Quaternion, RedFormat, 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 { CSMShadowNode } from "three/examples/jsm/csm/CSMShadowNode.js";
+import { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { MeshBasicNodeMaterial, MeshToonNodeMaterial, NeutralToneMapping, RenderPipeline, RenderTarget, ToonOutlinePassNode, WebGPURenderer } from "three/webgpu";
+import { voronoi2d } from "three/examples/jsm/tsl/math/voronoiNoise.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";
+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/atmosphere/applySkyState.ts
+const GODRAYS_REDRAW_COSINE = Math.cos(.6 * Math.PI / 180);
+const godraysDirection = new Vector3();
+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);
+	light.color.copy(lightColor);
+	light.intensity = skyState.lightIntensity;
+	hemisphere.color.copy(skyState.hemisphereSkyColor);
+	hemisphere.groundColor.copy(skyState.hemisphereGroundColor);
+	hemisphere.intensity = skyState.hemisphereIntensity;
+	lightUniforms.lightColor.value.copy(lightColor);
+	lightUniforms.sunDirection.value.copy(lightDirection);
+	lightUniforms.rimColor.value.copy(horizonColor);
+	fogUniforms.color.value.copy(horizonColor);
+	postUniforms.godraysColor.value.copy(lightColor);
+	skyUniforms.cloudLitColor.value.copy(skyState.cloudLitColor);
+	skyUniforms.cloudShadeColor.value.copy(skyState.cloudShadeColor);
+	skyUniforms.horizonColor.value.copy(horizonColor);
+	skyUniforms.lightColor.value.copy(lightColor);
+	skyUniforms.moonDirection.value.copy(skyState.moonDirection);
+	skyUniforms.starIntensity.value = skyState.starIntensity;
+	skyUniforms.sunDirection.value.copy(skyState.sunDirection);
+	skyUniforms.zenithColor.value.copy(skyState.zenithColor);
+	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);
+	godraysLight.shadow.needsUpdate = true;
+};
+//#endregion
+//#region src/clock/constants.ts
+const MINUTES_PER_DAY = 1440;
+const GAME_MINUTES_PER_SECOND = 1;
+//#endregion
+//#region src/atmosphere/computeSunDirection.ts
+const computeSunDirection = (minutes, tilt, sunDirection) => {
+	const hourAngle = minutes / MINUTES_PER_DAY * Math.PI * 2;
+	const height = -Math.cos(hourAngle);
+	return sunDirection.set(Math.sin(hourAngle), height * Math.cos(tilt), height * Math.sin(tilt));
+};
+//#endregion
+//#region src/atmosphere/createSkyState.ts
+const createSkyState = () => ({
+	cloudLitColor: new Color(),
+	cloudShadeColor: new Color(),
+	hemisphereGroundColor: new Color(),
+	hemisphereIntensity: 0,
+	hemisphereSkyColor: new Color(),
+	horizonColor: new Color(),
+	lightColor: new Color(),
+	lightDirection: new Vector3(),
+	lightIntensity: 0,
+	moonDirection: new Vector3(),
+	starIntensity: 0,
+	sunDirection: new Vector3(),
+	zenithColor: new Color()
+});
+//#endregion
+//#region src/atmosphere/createSkyUniforms.ts
+const createSkyUniforms = () => ({
+	cloudCoverage: uniform(0),
+	cloudDrift: uniform(new Vector2()),
+	cloudLitColor: uniform(new Color()),
+	cloudShadeColor: uniform(new Color()),
+	horizonColor: uniform(new Color()),
+	lightColor: uniform(new Color()),
+	moonDirection: uniform(new Vector3(0, -1, 0)),
+	starIntensity: uniform(0),
+	sunDirection: uniform(new Vector3(0, 1, 0)),
+	zenithColor: uniform(new Color())
+});
+//#endregion
+//#region src/atmosphere/createSunLight.ts
+const LIGHT_MARGIN = 100;
+const SHADOW_BIAS = -5e-4;
+const SHADOW_NORMAL_BIAS = .05;
+const createSunLight = ({ cascadeCount, maxFar, shadowMapSize }) => {
+	const light = new DirectionalLight();
+	light.castShadow = true;
+	light.shadow.mapSize.set(shadowMapSize, shadowMapSize);
+	light.shadow.bias = SHADOW_BIAS;
+	light.shadow.normalBias = SHADOW_NORMAL_BIAS;
+	light.shadow.camera.far = maxFar + 200;
+	const cascadedShadowNode = new CSMShadowNode(light, {
+		cascades: cascadeCount,
+		lightMargin: LIGHT_MARGIN,
+		maxFar,
+		mode: "practical"
+	});
+	cascadedShadowNode.fade = true;
+	light.shadow.shadowNode = cascadedShadowNode;
+	return {
+		cascadedShadowNode,
+		light
+	};
+};
+//#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++;
+	if (nextIndex === skyKeyframes.length) nextIndex = 0;
+	const previous = skyKeyframes.at(nextIndex - 1) ?? skyKeyframes[nextIndex];
+	const next = skyKeyframes[nextIndex];
+	if (!previous || !next) return skyState;
+	const span = (next.minutes - previous.minutes + 1440) % 1440 || 1440;
+	const amount = (minutes - previous.minutes + MINUTES_PER_DAY) % MINUTES_PER_DAY / span;
+	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.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.zenithColor.lerpColors(previous.zenithColor, next.zenithColor, amount);
+	computeSunDirection(minutes, tilt, skyState.sunDirection);
+	skyState.moonDirection.copy(skyState.sunDirection).negate();
+	skyState.lightDirection.copy(skyState.sunDirection.y >= 0 ? skyState.sunDirection : skyState.moonDirection);
+	return skyState;
+};
+//#endregion
+//#region src/clock/advanceGameClock.ts
+const advanceGameClock = (gameClock, deltaSeconds) => {
+	gameClock.minutes = (gameClock.minutes + deltaSeconds * gameClock.minutesPerSecond) % MINUTES_PER_DAY;
+};
+//#endregion
+//#region src/kits/statue/createStatueGeometry.ts
+const PLINTH_SIDES = 8;
+const FIGURE_SEGMENTS = 24;
+const FIGURE_PROFILE = [
+	new Vector2(0, 0),
+	new Vector2(1.5, 0),
+	new Vector2(1.25, .8),
+	new Vector2(.85, 2.6),
+	new Vector2(.7, 3.6),
+	new Vector2(.95, 4.3),
+	new Vector2(.6, 4.7),
+	new Vector2(.45, 5.1),
+	new Vector2(.5, 5.5),
+	new Vector2(.3, 6),
+	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();
+	statueGeometry.computeVertexNormals();
+	return statueGeometry;
+};
+//#endregion
+//#region src/random/createSeededRandom.ts
+const createSeededRandom = (seed) => {
+	let state = seed;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let mixed = Math.imul(state ^ state >>> 15, 1 | state);
+		mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, 61 | mixed);
+		return ((mixed ^ mixed >>> 14) >>> 0) / 2 ** 32;
+	};
+};
+//#endregion
+//#region src/kits/tree/computeLeafCards.ts
+const VERTICES_PER_CARD = 4;
+const INDICES_PER_CARD = 6;
+const CORNER_SIGNS = [
+	[-1, -1],
+	[1, -1],
+	[1, 1],
+	[-1, 1]
+];
+const computeLeafCards = (clusterCenters, { cardSize, cardsPerCluster, clusterRadius, seed }) => {
+	const random = createSeededRandom(seed + 1);
+	const cardCount = clusterCenters.length * cardsPerCluster;
+	const positions = new Float32Array(cardCount * VERTICES_PER_CARD * 3);
+	const normals = new Float32Array(cardCount * VERTICES_PER_CARD * 3);
+	const uvs = new Float32Array(cardCount * VERTICES_PER_CARD * 2);
+	const indices = new Uint32Array(cardCount * INDICES_PER_CARD);
+	let card = 0;
+	for (const { x: centerX, y: centerY, z: centerZ } of clusterCenters) for (let cardIndex = 0; cardIndex < cardsPerCluster; cardIndex++, card++) {
+		let offsetX;
+		let offsetY;
+		let offsetZ;
+		do {
+			offsetX = random() * 2 - 1;
+			offsetY = random() * 2 - 1;
+			offsetZ = random() * 2 - 1;
+		} while (offsetX * offsetX + offsetY * offsetY + offsetZ * offsetZ > 1);
+		const cardX = centerX + offsetX * clusterRadius;
+		const cardY = centerY + offsetY * clusterRadius * .7;
+		const cardZ = centerZ + offsetZ * clusterRadius;
+		const facingAngle = random() * Math.PI * 2;
+		const tiltAngle = (random() - .5) * Math.PI;
+		const tangentX = Math.cos(facingAngle);
+		const tangentZ = Math.sin(facingAngle);
+		const bitangentX = -Math.sin(tiltAngle) * tangentZ;
+		const bitangentY = Math.cos(tiltAngle);
+		const bitangentZ = Math.sin(tiltAngle) * tangentX;
+		const vertexStart = card * VERTICES_PER_CARD;
+		for (const [cornerIndex, [tangentSign, bitangentSign]] of CORNER_SIGNS.entries()) {
+			const vertex = vertexStart + cornerIndex;
+			const x = cardX + (tangentX * tangentSign + bitangentX * bitangentSign) * cardSize;
+			const y = cardY + bitangentY * bitangentSign * cardSize;
+			const z = cardZ + (tangentZ * tangentSign + bitangentZ * bitangentSign) * cardSize;
+			const normalX = x - centerX;
+			const normalY = y - centerY;
+			const normalZ = z - centerZ;
+			const length = Math.hypot(normalX, normalY, normalZ) || 1;
+			positions[vertex * 3] = x;
+			positions[vertex * 3 + 1] = y;
+			positions[vertex * 3 + 2] = z;
+			normals[vertex * 3] = normalX / length;
+			normals[vertex * 3 + 1] = normalY / length;
+			normals[vertex * 3 + 2] = normalZ / length;
+			uvs[vertex * 2] = (tangentSign + 1) / 2;
+			uvs[vertex * 2 + 1] = (bitangentSign + 1) / 2;
+		}
+		const indexStart = card * INDICES_PER_CARD;
+		indices[indexStart] = vertexStart;
+		indices[indexStart + 1] = vertexStart + 1;
+		indices[indexStart + 2] = vertexStart + 2;
+		indices[indexStart + 3] = vertexStart;
+		indices[indexStart + 4] = vertexStart + 2;
+		indices[indexStart + 5] = vertexStart + 3;
+	}
+	return {
+		indices,
+		normals,
+		positions,
+		uvs
+	};
+};
+//#endregion
+//#region src/kits/tree/computeTreeSkeleton.ts
+const TRUNK_LEAN = .08;
+const FORKS_PER_BRANCH = 2;
+const computeTreeSkeleton = ({ branchLength, mainBranchCount, seed, trunkHeight, trunkRadius }) => {
+	const random = createSeededRandom(seed);
+	const trunkTop = new Vector3((random() - .5) * TRUNK_LEAN * trunkHeight, trunkHeight, (random() - .5) * TRUNK_LEAN * trunkHeight);
+	const branchSegments = [{
+		end: trunkTop,
+		endRadius: trunkRadius * .6,
+		start: new Vector3(),
+		startRadius: trunkRadius
+	}];
+	const clusterCenters = [trunkTop.clone().setY(trunkTop.y + branchLength * .6)];
+	for (let branchIndex = 0; branchIndex < mainBranchCount; branchIndex++) {
+		const angle = branchIndex / mainBranchCount * Math.PI * 2 + (random() - .5);
+		const start = new Vector3().lerpVectors(new Vector3(), trunkTop, .75 + random() * .25);
+		const direction = new Vector3(Math.cos(angle), .45 + random() * .4, Math.sin(angle)).normalize();
+		const end = start.clone().addScaledVector(direction, branchLength * (.75 + random() * .25));
+		branchSegments.push({
+			end,
+			endRadius: trunkRadius * .18,
+			start,
+			startRadius: trunkRadius * .45
+		});
+		for (let forkIndex = 0; forkIndex < FORKS_PER_BRANCH; forkIndex++) {
+			const forkAngle = angle + (forkIndex - .5) * .9 + (random() - .5) * .3;
+			const forkDirection = new Vector3(Math.cos(forkAngle), .6 + random() * .4, Math.sin(forkAngle)).normalize();
+			const forkEnd = end.clone().addScaledVector(forkDirection, branchLength * (.45 + random() * .2));
+			branchSegments.push({
+				end: forkEnd,
+				endRadius: trunkRadius * .05,
+				start: end,
+				startRadius: trunkRadius * .18
+			});
+			clusterCenters.push(forkEnd);
+		}
+	}
+	return {
+		branchSegments,
+		clusterCenters
+	};
+};
+//#endregion
+//#region src/kits/tree/createTreeGeometry.ts
+const BRANCH_RADIAL_SEGMENTS = 7;
+const UP = new Vector3(0, 1, 0);
+const createTreeGeometry = (treeOptions) => {
+	const { branchSegments, clusterCenters } = computeTreeSkeleton(treeOptions);
+	const direction = new Vector3();
+	const rotation = new Quaternion();
+	const segmentGeometries = branchSegments.map(({ end, endRadius, start, startRadius }) => {
+		direction.subVectors(end, start);
+		const length = direction.length();
+		const segmentGeometry = new CylinderGeometry(endRadius, startRadius, length, BRANCH_RADIAL_SEGMENTS, 1, true);
+		segmentGeometry.applyQuaternion(rotation.setFromUnitVectors(UP, direction.normalize()));
+		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 { indices, normals, positions, uvs } = computeLeafCards(clusterCenters, treeOptions);
+	const leafGeometry = new BufferGeometry();
+	leafGeometry.setAttribute("position", new BufferAttribute(positions, 3));
+	leafGeometry.setAttribute("normal", new BufferAttribute(normals, 3));
+	leafGeometry.setAttribute("uv", new BufferAttribute(uvs, 2));
+	leafGeometry.setIndex(new BufferAttribute(indices, 1));
+	leafGeometry.computeBoundingSphere();
+	return {
+		branchGeometry,
+		leafGeometry
+	};
+};
+//#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);
+	});
+};
+//#endregion
+//#region src/materials/createRampTexture.ts
+const createRampTexture = (rampOptions) => {
+	const rampValues = computeRampValues(rampOptions);
+	const rampTexture = new DataTexture(rampValues, rampOptions.resolution, 1, RedFormat);
+	rampTexture.magFilter = LinearFilter;
+	rampTexture.minFilter = LinearFilter;
+	rampTexture.needsUpdate = true;
+	return rampTexture;
+};
+//#endregion
+//#region src/nodes/ToonNodeMaterial.ts
+var ToonNodeMaterial = class extends MeshToonNodeMaterial {
+	emissiveNode = null;
+	isMeshToonNodeMaterial;
+	constructor(parameters, isOutlined) {
+		super(parameters);
+		this.isMeshToonNodeMaterial = isOutlined;
+	}
+};
+//#endregion
+//#region src/nodes/createCausticsNode.ts
+const CAUSTIC_SCALE = .35;
+const CAUSTIC_SPEED = .6;
+const createCausticsNode = ({ lightColor }, { causticStrength, deepDepth, level }) => {
+	const floorPosition = positionWorld.xz.mul(CAUSTIC_SCALE);
+	const drift = time.mul(CAUSTIC_SPEED);
+	const cells = voronoi2d(floorPosition, drift).mul(voronoi2d(floorPosition.mul(1.7), drift.mul(1.3)));
+	const veins = smoothstep(.35, .45, cells);
+	const depthBelow = level.sub(positionWorld.y);
+	const fade = smoothstep(0, .3, depthBelow).mul(float(1).sub(smoothstep(0, deepDepth, depthBelow)));
+	return lightColor.mul(veins.mul(fade).mul(causticStrength));
+};
+//#endregion
+//#region src/nodes/createGenshinRenderer.ts
+const createGenshinRenderer = (canvas) => {
+	const renderer = new WebGPURenderer({
+		antialias: false,
+		canvas,
+		powerPreference: "high-performance"
+	});
+	renderer.toneMapping = NeutralToneMapping;
+	return renderer;
+};
+//#endregion
+//#region src/nodes/createRimNode.ts
+const RIM_POWER = 4;
+const createRimNode = ({ rimColor, rimStrength, sunDirection }) => {
+	const sunDirectionView = cameraViewMatrix.mul(vec4(sunDirection, 0)).xyz.normalize();
+	const fresnel = float(1).sub(normalView.dot(positionViewDirection).saturate()).pow(RIM_POWER);
+	const litMask = normalView.dot(sunDirectionView).saturate();
+	return rimColor.mul(fresnel.mul(litMask).mul(rimStrength));
+};
+//#endregion
+//#region src/nodes/createToonMaterial.ts
+const createToonMaterial = ({ color, isOutlined = true, isVertexColors = false, lightUniforms, rampTexture }) => {
+	const toonMaterial = new ToonNodeMaterial({
+		color,
+		gradientMap: rampTexture,
+		vertexColors: isVertexColors
+	}, isOutlined);
+	toonMaterial.emissiveNode = createRimNode(lightUniforms);
+	return toonMaterial;
+};
+//#endregion
+//#region src/nodes/createWindNode.ts
+const TURBULENCE_SCALE = .07;
+const TURBULENCE_SPEED = .4;
+const createWindNode = ({ direction, gustSpeed, gustStrength, gustWidth, strength }, groundPosition) => {
+	const gustPhase = groundPosition.dot(direction).sub(time.mul(gustSpeed)).div(gustWidth).mul(Math.PI * 2);
+	const gust = smoothstep(.2, 1, sin(gustPhase).mul(.5).add(.5)).mul(gustStrength);
+	const turbulence = mx_noise_float(vec3(groundPosition.mul(TURBULENCE_SCALE), time.mul(TURBULENCE_SPEED))).mul(.35);
+	return direction.mul(strength.add(gust).mul(turbulence.add(1)));
+};
+//#endregion
+//#region src/nodes/createLeafMaterial.ts
+const LEAF_ALPHA_TEST = .5;
+const SWAY_PER_WIND = .03;
+const FLUTTER = .06;
+const createLeafMaterial = (toonMaterialOptions, windUniforms) => {
+	const leafMaterial = createToonMaterial(toonMaterialOptions);
+	const centered = uv().sub(.5).mul(2);
+	const width = float(1).sub(centered.y.abs().pow(2)).mul(.8);
+	leafMaterial.opacityNode = step(0, width.sub(centered.x.abs()));
+	leafMaterial.alphaTest = LEAF_ALPHA_TEST;
+	leafMaterial.side = DoubleSide;
+	if (windUniforms) {
+		const worldPosition = modelWorldMatrix.mul(vec4(positionLocal, 1)).xyz;
+		const lean = createWindNode(windUniforms, worldPosition.xz).mul(positionLocal.y.mul(SWAY_PER_WIND));
+		const phase = hash(worldPosition.x.mul(12.9).add(worldPosition.z.mul(78.2)).floor()).mul(Math.PI * 2);
+		const flutter = sin(time.mul(3).add(phase)).mul(FLUTTER).mul(windUniforms.strength.add(windUniforms.gustStrength));
+		leafMaterial.positionNode = positionLocal.add(vec3(lean.x, flutter, lean.y));
+	}
+	return leafMaterial;
+};
+//#endregion
+//#region src/nodes/createLightUniforms.ts
+const createLightUniforms = () => ({
+	lightColor: uniform(new Color()),
+	rimColor: uniform(new Color()),
+	rimStrength: uniform(0),
+	sunDirection: uniform(new Vector3(0, 1, 0))
+});
+//#endregion
+//#region src/nodes/createSkyNode.ts
+const HORIZON_BAND = .45;
+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;
+const CLOUD_EDGE = .04;
+const CLOUD_SHADE_DEPTH = .18;
+const STAR_SCALE = 420;
+const STAR_THRESHOLD = .9975;
+const createSkyNode = ({ cloudCoverage, cloudDrift, cloudLitColor, cloudShadeColor, horizonColor, lightColor, moonDirection, starIntensity, sunDirection, zenithColor }) => Fn(() => {
+	const direction = normalWorldGeometry.normalize();
+	const height = direction.y;
+	const gradient = mix(horizonColor, zenithColor, smoothstep(0, HORIZON_BAND, 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);
+})();
+//#endregion
+//#region src/nodes/createWaterMaterial.ts
+const RIPPLE_SCALE = .08;
+const RIPPLE_SPEED = .05;
+const REFRACTION_STRENGTH = .015;
+const GLINT_POWER = 180;
+const GLINT_BRIGHTNESS = 5;
+const FOAM_SCALE = .6;
+const REFLECTION_STRENGTH = .55;
+const createWaterMaterial = ({ lightColor, sunDirection }, { horizonColor, zenithColor }, { deepColor, deepDepth, foamColor, foamDepth, shallowColor }) => {
+	const waterMaterial = new MeshBasicNodeMaterial({
+		side: DoubleSide,
+		transparent: true
+	});
+	const ripplePosition = positionWorld.xz.mul(RIPPLE_SCALE);
+	const drift = time.mul(RIPPLE_SPEED);
+	const sampleRipples = (offset) => mx_fractal_noise_float(vec3(ripplePosition.add(offset).add(vec2(drift, drift.mul(.6))), 0), 3).add(mx_fractal_noise_float(vec3(ripplePosition.add(offset).mul(1.9).sub(vec2(drift.mul(.8), drift)), 1), 2)).mul(.5);
+	const ripple = sampleRipples(vec2(0, 0));
+	const slopeX = sampleRipples(vec2(.02, 0)).sub(ripple);
+	const slopeZ = sampleRipples(vec2(0, .02)).sub(ripple);
+	const normal = vec3(slopeX.mul(-.35 / .02), 1, slopeZ.mul(-.35 / .02)).normalize();
+	const refractedUV = screenUV.add(normal.xz.mul(REFRACTION_STRENGTH));
+	const floorUV = perspectiveDepthToViewZ(viewportDepthTexture(refractedUV), cameraNear, cameraFar).greaterThan(positionView.z).select(screenUV, refractedUV);
+	const depth = positionView.z.sub(perspectiveDepthToViewZ(viewportDepthTexture(floorUV), cameraNear, cameraFar)).max(0);
+	const deepness = smoothstep(0, deepDepth, depth);
+	const waterColor = mix(shallowColor, deepColor, deepness);
+	const floorColor = viewportSharedTexture(floorUV).rgb;
+	const clarity = float(1).sub(smoothstep(0, deepDepth.mul(.6), depth));
+	const tinted = mix(waterColor, floorColor.mul(shallowColor.mul(1.4)), clarity.mul(.8));
+	const eyeDirection = cameraPosition.sub(positionWorld).normalize();
+	const fresnel = pow(float(1).sub(normal.dot(eyeDirection).abs().saturate()), 4);
+	const skyColor = mix(horizonColor, zenithColor, .35);
+	const reflected = mix(tinted, skyColor, fresnel.mul(REFLECTION_STRENGTH));
+	const highlight = pow(reflect(sunDirection.negate(), normal).dot(eyeDirection).max(0), GLINT_POWER);
+	const glints = lightColor.mul(smoothstep(.45, .5, highlight).mul(GLINT_BRIGHTNESS));
+	const shore = float(1).sub(smoothstep(0, foamDepth, depth));
+	const foamNoise = mx_fractal_noise_float(vec3(positionWorld.xz.mul(FOAM_SCALE), time.mul(.3)), 2).mul(.5).add(.5);
+	const foam = smoothstep(.55, .6, foamNoise.add(shore.mul(.5))).mul(shore);
+	waterMaterial.colorNode = mix(reflected, foamColor, foam).add(glints);
+	return waterMaterial;
+};
+//#endregion
+//#region src/noise/createSimplexNoise.ts
+const SKEW = (Math.sqrt(3) - 1) / 2;
+const UNSKEW = (3 - Math.sqrt(3)) / 6;
+const GRADIENTS_X = [
+	1,
+	-1,
+	1,
+	-1,
+	1,
+	-1,
+	0,
+	0
+];
+const GRADIENTS_Y = [
+	1,
+	1,
+	-1,
+	-1,
+	0,
+	0,
+	1,
+	-1
+];
+const NOISE_SCALE = 70;
+const getCornerContribution = (gradientIndex, offsetX, offsetY) => {
+	const falloff = .5 - offsetX * offsetX - offsetY * offsetY;
+	if (falloff < 0) return 0;
+	const gradient = gradientIndex & 7;
+	return falloff ** 4 * ((GRADIENTS_X[gradient] ?? 0) * offsetX + (GRADIENTS_Y[gradient] ?? 0) * offsetY);
+};
+const createSimplexNoise = (seed) => {
+	const random = createSeededRandom(seed);
+	const table = Uint8Array.from({ length: 256 }, (_value, index) => index);
+	for (let index = table.length - 1; index > 0; index--) {
+		const swapIndex = Math.floor(random() * (index + 1));
+		[table[index], table[swapIndex]] = [table[swapIndex] ?? 0, table[index] ?? 0];
+	}
+	const permutation = Uint8Array.from({ length: 512 }, (_value, index) => table[index & 255] ?? 0);
+	return (x, y) => {
+		const skew = (x + y) * SKEW;
+		const cellX = Math.floor(x + skew);
+		const cellY = Math.floor(y + skew);
+		const unskew = (cellX + cellY) * UNSKEW;
+		const offsetX = x - cellX + unskew;
+		const offsetY = y - cellY + unskew;
+		const middleX = offsetX > offsetY ? 1 : 0;
+		const middleY = 1 - middleX;
+		const tableX = cellX & 255;
+		const tableY = cellY & 255;
+		return NOISE_SCALE * (getCornerContribution(permutation[tableX + (permutation[tableY] ?? 0)] ?? 0, offsetX, offsetY) + getCornerContribution(permutation[tableX + middleX + (permutation[tableY + middleY] ?? 0)] ?? 0, offsetX - middleX + UNSKEW, offsetY - middleY + UNSKEW) + getCornerContribution(permutation[tableX + 1 + (permutation[tableY + 1] ?? 0)] ?? 0, offsetX - 1 + 2 * UNSKEW, offsetY - 1 + 2 * UNSKEW));
+	};
+};
+//#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);
+};
+const computeGradeLut = ({ contrast, highlightTint, saturation, shadowTint, size }) => {
+	const values = new Uint8Array(size * size * size * 4);
+	const step = 1 / (size - 1);
+	let offset = 0;
+	for (let blueIndex = 0; blueIndex < size; blueIndex++) for (let greenIndex = 0; greenIndex < size; greenIndex++) for (let redIndex = 0; redIndex < size; redIndex++) {
+		const red = redIndex * step;
+		const green = greenIndex * step;
+		const blue = blueIndex * step;
+		const luminance = red * RED_LUMINANCE + green * GREEN_LUMINANCE + blue * BLUE_LUMINANCE;
+		const shadowWeight = (1 - luminance) * (1 - luminance);
+		const highlightWeight = luminance * luminance;
+		const redTint = shadowTint[0] * shadowWeight + highlightTint[0] * highlightWeight;
+		const greenTint = shadowTint[1] * shadowWeight + highlightTint[1] * highlightWeight;
+		const blueTint = shadowTint[2] * shadowWeight + highlightTint[2] * highlightWeight;
+		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;
+		offset += 4;
+	}
+	return values;
+};
+//#endregion
+//#region src/post/createFogUniforms.ts
+const createFogUniforms = () => ({
+	baseHeight: uniform(0),
+	color: uniform(new Color()),
+	density: uniform(0),
+	heightFalloff: uniform(0),
+	startDistance: uniform(0)
+});
+//#endregion
+//#region src/post/createGodraysLight.ts
+const createGodraysLight = (shadowMapSize, halfExtent) => {
+	const godraysLight = new DirectionalLight(16777215, 0);
+	godraysLight.castShadow = true;
+	godraysLight.shadow.autoUpdate = false;
+	godraysLight.shadow.needsUpdate = true;
+	godraysLight.shadow.mapSize.set(shadowMapSize, shadowMapSize);
+	const { camera } = godraysLight.shadow;
+	camera.left = -halfExtent;
+	camera.right = halfExtent;
+	camera.top = halfExtent;
+	camera.bottom = -halfExtent;
+	camera.far = halfExtent * 4;
+	return godraysLight;
+};
+//#endregion
+//#region src/post/createGradeLutTexture.ts
+const createGradeLutTexture = (gradeOptions) => {
+	const { size } = gradeOptions;
+	const gradeLutTexture = new Data3DTexture(computeGradeLut(gradeOptions), size, size, size);
+	gradeLutTexture.magFilter = LinearFilter;
+	gradeLutTexture.minFilter = LinearFilter;
+	gradeLutTexture.needsUpdate = true;
+	return gradeLutTexture;
+};
+//#endregion
+//#region src/post/createHeightFogNode.ts
+const MIN_RAY_CLIMB = 1e-6;
+const createHeightFogNode = (colorNode, depthNode, camera, { baseHeight, color, density, heightFalloff, startDistance }) => {
+	const cameraWorldMatrix = uniform(camera.matrixWorld);
+	const cameraProjectionMatrixInverse = uniform(camera.projectionMatrixInverse);
+	return Fn(() => {
+		const depth = depthNode.sample(uv()).r;
+		const output = colorNode.toVar();
+		If(depth.lessThan(1), () => {
+			const viewPosition = getViewPosition(uv(), depth, cameraProjectionMatrixInverse);
+			const eye = cameraWorldMatrix.mul(vec4(0, 0, 0, 1)).xyz;
+			const ray = cameraWorldMatrix.mul(vec4(viewPosition, 1)).xyz.sub(eye);
+			const rayLength = ray.length();
+			const fogLength = max(rayLength.sub(startDistance), 0);
+			const slope = ray.y.div(rayLength);
+			const startHeight = eye.y.add(slope.mul(rayLength.min(startDistance)));
+			const densityAtStart = density.mul(exp(startHeight.sub(baseHeight).mul(heightFalloff).negate()));
+			const climb = slope.mul(heightFalloff);
+			const opticalDepth = densityAtStart.mul(fogLength).toVar();
+			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()));
+			output.assign(vec4(mix(output.rgb, color, opacity), output.a));
+		});
+		return output;
+	})();
+};
+//#endregion
+//#region src/renderer/AntialiasingMode.ts
+let AntialiasingMode = /* @__PURE__ */ function(AntialiasingMode) {
+	AntialiasingMode["Smaa"] = "Smaa";
+	AntialiasingMode["Traa"] = "Traa";
+	return AntialiasingMode;
+}({});
+//#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 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 sceneColor = scenePass.getTextureNode("output");
+	const sceneDepth = scenePass.getTextureNode("depth");
+	const postPipeline = { renderPipeline };
+	let litNode = sceneColor;
+	if (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 });
+		postPipeline.godraysNode = godraysNode;
+	}
+	const foggedNode = createHeightFogNode(litNode, sceneDepth, camera, fogUniforms);
+	let bloomedNode = foggedNode;
+	if (isBloomEnabled) {
+		const bloomNode = bloom(foggedNode, BLOOM_STRENGTH, BLOOM_RADIUS, BLOOM_THRESHOLD);
+		bloomedNode = foggedNode.add(bloomNode);
+		postPipeline.bloomNode = bloomNode;
+	}
+	const resolvedNode = isTraa ? traa(bloomedNode, sceneDepth, scenePass.getTextureNode("velocity"), camera) : bloomedNode;
+	const displayNode = renderOutput(resolvedNode);
+	const gradedNode = lut3D(displayNode, texture3D(gradeLutTexture), gradeLutTexture.image.width, gradeIntensity);
+	renderPipeline.outputNode = isTraa ? gradedNode : smaa(gradedNode);
+	return postPipeline;
+};
+//#endregion
+//#region src/post/createPostUniforms.ts
+const createPostUniforms = () => ({
+	godraysColor: uniform(new Color(16773590)),
+	gradeIntensity: uniform(1),
+	outlineColor: uniform(new Color(2761272)),
+	outlineFadeDistance: uniform(40),
+	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"]: {
+		antialiasingMode: "Traa",
+		cascadeCount: 4,
+		godraysStepCount: 60,
+		grassDensity: 1,
+		isBloomEnabled: true,
+		maxPixelRatio: 2,
+		shadowMapSize: 2048
+	},
+	["Low"]: {
+		antialiasingMode: "Smaa",
+		cascadeCount: 2,
+		godraysStepCount: 0,
+		grassDensity: .3,
+		isBloomEnabled: false,
+		maxPixelRatio: 1,
+		shadowMapSize: 1024
+	},
+	["Medium"]: {
+		antialiasingMode: "Smaa",
+		cascadeCount: 3,
+		godraysStepCount: 30,
+		grassDensity: .6,
+		isBloomEnabled: true,
+		maxPixelRatio: 1.5,
+		shadowMapSize: 1024
+	}
+};
+//#endregion
+//#region src/terrain/constants.ts
+const TILE_INDEX_OFFSET = 2 ** 19;
+const TILE_INDEX_SPAN = 2 ** 20;
+const TERRAIN_LAYER = 1;
+//#endregion
+//#region src/terrain/getTerrainTileLevel.ts
+const getTerrainTileLevel = (key) => Math.floor(key / TILE_INDEX_SPAN / TILE_INDEX_SPAN);
+//#endregion
+//#region src/streaming/createTileStreamer.ts
+const createTileStreamer = ({ disposeTile, maxCachedCount, maxPendingCount, requestTile }) => {
+	const cachedTileMap = /* @__PURE__ */ new Map();
+	const pendingWantedFrameMap = /* @__PURE__ */ new Map();
+	let frame = 0;
+	let isDisposed = false;
+	const evictStale = () => {
+		while (cachedTileMap.size > maxCachedCount) {
+			let staleKey;
+			let staleFrame = frame;
+			for (const [key, { lastWantedFrame }] of cachedTileMap) if (lastWantedFrame < staleFrame) {
+				staleKey = key;
+				staleFrame = lastWantedFrame;
+			}
+			if (staleKey === void 0) return;
+			const staleTile = cachedTileMap.get(staleKey);
+			cachedTileMap.delete(staleKey);
+			if (staleTile) disposeTile(staleTile.tile);
+		}
+	};
+	return {
+		dispose: () => {
+			isDisposed = true;
+			for (const { tile } of cachedTileMap.values()) disposeTile(tile);
+			cachedTileMap.clear();
+			pendingWantedFrameMap.clear();
+		},
+		get: (key) => cachedTileMap.get(key)?.tile,
+		has: (key) => cachedTileMap.has(key),
+		receive: (key, tile) => {
+			const lastWantedFrame = pendingWantedFrameMap.get(key) ?? frame;
+			pendingWantedFrameMap.delete(key);
+			if (isDisposed) {
+				disposeTile(tile);
+				return;
+			}
+			cachedTileMap.set(key, {
+				lastWantedFrame,
+				tile
+			});
+			evictStale();
+		},
+		update: ({ count, keys }, drawn) => {
+			frame++;
+			let coarsestLevel = 0;
+			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;
+			}
+			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);
+			}
+		}
+	};
+};
+//#endregion
+//#region src/terrain/computeTerrainIndices.ts
+const MAX_UINT16_VERTEX_COUNT = 2 ** 16;
+const computeTerrainIndices = (cellsPerSide) => {
+	const side = cellsPerSide + 1;
+	const indexCount = cellsPerSide * cellsPerSide * 6;
+	const indices = side * side > MAX_UINT16_VERTEX_COUNT ? new Uint32Array(indexCount) : new Uint16Array(indexCount);
+	let cursor = 0;
+	for (let row = 0; row < cellsPerSide; row++) for (let column = 0; column < cellsPerSide; column++) {
+		const topLeft = row * side + column;
+		const bottomLeft = topLeft + side;
+		indices[cursor++] = topLeft;
+		indices[cursor++] = bottomLeft;
+		indices[cursor++] = topLeft + 1;
+		indices[cursor++] = topLeft + 1;
+		indices[cursor++] = bottomLeft;
+		indices[cursor++] = bottomLeft + 1;
+	}
+	return indices;
+};
+//#endregion
+//#region src/terrain/getTerrainTileColumn.ts
+const getTerrainTileColumn = (key) => key % TILE_INDEX_SPAN - TILE_INDEX_OFFSET;
+//#endregion
+//#region src/terrain/getTerrainTileRow.ts
+const getTerrainTileRow = (key) => Math.floor(key / TILE_INDEX_SPAN) % TILE_INDEX_SPAN - TILE_INDEX_OFFSET;
+//#endregion
+//#region src/terrain/computeTerrainTile.ts
+const computeTerrainTile = ({ cellsPerSide, finestTileSize, getHeight, key, writeColor }) => {
+	const level = getTerrainTileLevel(key);
+	const size = finestTileSize * 2 ** level;
+	const step = size / cellsPerSide;
+	const left = getTerrainTileColumn(key) * size;
+	const back = getTerrainTileRow(key) * size;
+	const side = cellsPerSide + 1;
+	const paddedSide = side + 2;
+	const heights = new Float32Array(paddedSide * paddedSide);
+	for (let row = 0; row < paddedSide; row++) for (let column = 0; column < paddedSide; column++) heights[row * paddedSide + column] = getHeight(left + (column - 1) * step, back + (row - 1) * step);
+	const vertexCount = side * side;
+	const positions = new Float32Array(vertexCount * 3);
+	const normals = new Float32Array(vertexCount * 3);
+	const colors = new Float32Array(vertexCount * 3);
+	const coarsePositions = new Float32Array(vertexCount * 4);
+	for (let row = 0; row < side; row++) for (let column = 0; column < side; column++) {
+		const paddedIndex = (row + 1) * paddedSide + column + 1;
+		const height = heights[paddedIndex] ?? 0;
+		const normalX = (heights[paddedIndex - 1] ?? height) - (heights[paddedIndex + 1] ?? height);
+		const normalY = 2 * step;
+		const normalZ = (heights[paddedIndex - paddedSide] ?? height) - (heights[paddedIndex + paddedSide] ?? height);
+		const length = Math.hypot(normalX, normalY, normalZ);
+		const index = row * side + column;
+		const offset = index * 3;
+		const x = column * step;
+		const z = row * step;
+		positions[offset] = x;
+		positions[offset + 1] = height;
+		positions[offset + 2] = z;
+		normals[offset] = normalX / length;
+		normals[offset + 1] = normalY / length;
+		normals[offset + 2] = normalZ / length;
+		writeColor(colors, offset, height, 1 - normalY / length, left + x, back + z);
+		const coarseColumn = column - column % 2;
+		const coarseRow = row - row % 2;
+		const coarseOffset = index * 4;
+		coarsePositions[coarseOffset] = coarseColumn * step;
+		coarsePositions[coarseOffset + 1] = heights[(coarseRow + 1) * paddedSide + coarseColumn + 1] ?? height;
+		coarsePositions[coarseOffset + 2] = coarseRow * step;
+		coarsePositions[coarseOffset + 3] = level;
+	}
+	return {
+		coarsePositions,
+		colors,
+		key,
+		normals,
+		positions
+	};
+};
+//#endregion
+//#region src/terrain/createTerrainMaterial.ts
+const createTerrainMaterial = ({ finestRange, morphShare }, toonMaterialOptions, waterUniforms) => {
+	const terrainMaterial = createToonMaterial({
+		...toonMaterialOptions,
+		isOutlined: false,
+		isVertexColors: true
+	});
+	const coarsePosition = attribute("coarsePosition", "vec4");
+	const morphEnd = exp2(coarsePosition.w).mul(finestRange);
+	const morphStart = morphEnd.mul(1 - morphShare);
+	const morphAmount = modelWorldMatrix.mul(vec4(positionLocal, 1)).xyz.distance(cameraPosition).sub(morphStart).div(morphEnd.sub(morphStart)).saturate();
+	terrainMaterial.positionNode = mix(positionLocal, coarsePosition.xyz, morphAmount);
+	if (waterUniforms) {
+		const { lightUniforms } = toonMaterialOptions;
+		terrainMaterial.emissiveNode = createRimNode(lightUniforms).add(createCausticsNode(lightUniforms, waterUniforms));
+	}
+	return terrainMaterial;
+};
+//#endregion
+//#region src/terrain/createTerrainSelection.ts
+const createTerrainSelection = (capacity) => ({
+	count: 0,
+	keys: new Float64Array(capacity)
+});
+//#endregion
+//#region src/terrain/createTerrainTileGeometry.ts
+const createTerrainTileGeometry = ({ coarsePositions, colors, normals, positions }, index) => {
+	const geometry = new BufferGeometry();
+	geometry.setAttribute("position", new BufferAttribute(positions, 3));
+	geometry.setAttribute("normal", new BufferAttribute(normals, 3));
+	geometry.setAttribute("color", new BufferAttribute(colors, 3));
+	geometry.setAttribute("coarsePosition", new BufferAttribute(coarsePositions, 4));
+	geometry.setIndex(index);
+	geometry.computeBoundingBox();
+	geometry.computeBoundingSphere();
+	return geometry;
+};
+//#endregion
+//#region src/terrain/getTerrainTileKey.ts
+const getTerrainTileKey = (level, column, row) => (level * TILE_INDEX_SPAN + row + TILE_INDEX_OFFSET) * TILE_INDEX_SPAN + column + TILE_INDEX_OFFSET;
+//#endregion
+//#region src/terrain/getParentTerrainTileKey.ts
+const getParentTerrainTileKey = (key) => {
+	const level = getTerrainTileLevel(key);
+	const column = getTerrainTileColumn(key);
+	const row = getTerrainTileRow(key);
+	return getTerrainTileKey(level + 1, Math.floor(column / 2), Math.floor(row / 2));
+};
+//#endregion
+//#region src/terrain/resolveTerrainDraws.ts
+const fallbackKeys = /* @__PURE__ */ new Set();
+const checkFallbackAncestor = (key, levelCount) => {
+	if (fallbackKeys.size === 0) return false;
+	let ancestorKey = key;
+	for (let level = getTerrainTileLevel(key) + 1; level < levelCount; level++) {
+		ancestorKey = getParentTerrainTileKey(ancestorKey);
+		if (fallbackKeys.has(ancestorKey)) return true;
+	}
+	return false;
+};
+const resolveTerrainDraws = ({ levelCount }, wanted, checkTileLoaded, draws) => {
+	fallbackKeys.clear();
+	for (let index = 0; index < wanted.count; index++) {
+		let key = wanted.keys[index] ?? 0;
+		if (checkTileLoaded(key)) continue;
+		for (let level = getTerrainTileLevel(key) + 1; level < levelCount; level++) {
+			key = getParentTerrainTileKey(key);
+			if (!checkTileLoaded(key)) continue;
+			fallbackKeys.add(key);
+			break;
+		}
+	}
+	draws.count = 0;
+	for (let index = 0; index < wanted.count && draws.count < draws.keys.length; index++) {
+		const key = wanted.keys[index] ?? 0;
+		if (!checkTileLoaded(key) || checkFallbackAncestor(key, levelCount)) continue;
+		draws.keys[draws.count] = key;
+		draws.count++;
+	}
+	for (const key of fallbackKeys) {
+		if (draws.count === draws.keys.length || checkFallbackAncestor(key, levelCount)) continue;
+		draws.keys[draws.count] = key;
+		draws.count++;
+	}
+	return draws;
+};
+//#endregion
+//#region src/terrain/selectTerrainTiles.ts
+const tileBox = new Box3();
+const addKey = (selection, key) => {
+	if (selection.count === selection.keys.length) return;
+	selection.keys[selection.count] = key;
+	selection.count++;
+};
+const selectTile = (terrainOptions, eye, frustum, selection, level, column, row) => {
+	const { finestRange, finestTileSize, maxHeight, minHeight } = terrainOptions;
+	const size = finestTileSize * 2 ** level;
+	const left = column * size;
+	const back = row * size;
+	const distanceX = Math.max(left - eye.x, 0, eye.x - left - size);
+	const distanceY = Math.max(minHeight - eye.y, 0, eye.y - maxHeight);
+	const distanceZ = Math.max(back - eye.z, 0, eye.z - back - size);
+	const distance = Math.hypot(distanceX, distanceY, distanceZ);
+	const range = finestRange * 2 ** level;
+	if (distance > range) return false;
+	if (frustum) {
+		tileBox.min.set(left, minHeight, back);
+		tileBox.max.set(left + size, maxHeight, back + size);
+		if (!frustum.intersectsBox(tileBox)) return true;
+	}
+	if (level === 0 || distance > range / 2) {
+		addKey(selection, getTerrainTileKey(level, column, row));
+		return true;
+	}
+	for (let childRow = row * 2; childRow < row * 2 + 2; childRow++) for (let childColumn = column * 2; childColumn < column * 2 + 2; childColumn++) if (!selectTile(terrainOptions, eye, frustum, selection, level - 1, childColumn, childRow)) addKey(selection, getTerrainTileKey(level - 1, childColumn, childRow));
+	return true;
+};
+const selectTerrainTiles = (terrainOptions, eye, frustum, selection) => {
+	const { finestRange, finestTileSize, levelCount } = terrainOptions;
+	const level = levelCount - 1;
+	const size = finestTileSize * 2 ** level;
+	const range = finestRange * 2 ** level;
+	selection.count = 0;
+	for (let row = Math.floor((eye.z - range) / size); row <= Math.floor((eye.z + range) / size); row++) for (let column = Math.floor((eye.x - range) / size); column <= Math.floor((eye.x + range) / size); column++) selectTile(terrainOptions, eye, frustum, selection, level, column, row);
+	return selection;
+};
+//#endregion
+//#region src/vegetation/computeGrassBlade.ts
+const computeGrassBlade = (segmentCount) => {
+	const positions = new Float32Array((segmentCount * 2 + 1) * 3);
+	for (let segment = 0; segment < segmentCount; segment++) {
+		const height = segment / segmentCount;
+		const halfWidth = (1 - height) / 2;
+		const offset = segment * 6;
+		positions[offset] = -halfWidth;
+		positions[offset + 1] = height;
+		positions[offset + 3] = halfWidth;
+		positions[offset + 4] = height;
+	}
+	positions[segmentCount * 6 + 1] = 1;
+	const indices = new Uint16Array((segmentCount - 1) * 6 + 3);
+	let cursor = 0;
+	for (let segment = 0; segment < segmentCount - 1; segment++) {
+		const left = segment * 2;
+		indices[cursor++] = left;
+		indices[cursor++] = left + 1;
+		indices[cursor++] = left + 2;
+		indices[cursor++] = left + 2;
+		indices[cursor++] = left + 1;
+		indices[cursor++] = left + 3;
+	}
+	const lastLeft = (segmentCount - 1) * 2;
+	indices[cursor++] = lastLeft;
+	indices[cursor++] = lastLeft + 1;
+	indices[cursor] = segmentCount * 2;
+	return {
+		indices,
+		positions
+	};
+};
+//#endregion
+//#region src/vegetation/createGrassGeometry.ts
+const createGrassGeometry = (segmentCount, bladeCount) => {
+	const { indices, positions } = computeGrassBlade(segmentCount);
+	const grassGeometry = new InstancedBufferGeometry();
+	grassGeometry.setAttribute("position", new BufferAttribute(positions, 3));
+	grassGeometry.setIndex(new BufferAttribute(indices, 1));
+	grassGeometry.instanceCount = bladeCount;
+	return grassGeometry;
+};
+//#endregion
+//#region src/vegetation/createGrassMaterial.ts
+const MIN_GREENNESS = .05;
+const BEND_PER_WIND = .9;
+const createGrassMaterial = ({ bladeHeight, bladeWidth, cameraGround, density, groundCapture, lightUniforms, rampTexture, ring, waterUniforms, windUniforms }) => {
+	const grassMaterial = createToonMaterial({
+		isOutlined: false,
+		lightUniforms,
+		rampTexture
+	});
+	grassMaterial.emissiveNode = null;
+	grassMaterial.side = DoubleSide;
+	const { cellsPerSide, fadeEnd, fadeStart, innerRadius, scale, spacing } = ring;
+	const index = float(instanceIndex);
+	const row = index.div(cellsPerSide).floor();
+	const column = index.sub(row.mul(cellsPerSide));
+	const gridOrigin = cameraGround.div(spacing).floor().mul(spacing);
+	const cell = vec2(column, row).sub(cellsPerSide / 2).mul(spacing).add(gridOrigin);
+	const seed = cell.x.mul(127.1).add(cell.y.mul(311.7));
+	const ground = cell.add(vec2(hash(seed), hash(seed.add(1))).sub(.5).mul(spacing));
+	const captureUV = vec2(ground.x.sub(groundCapture.center.x).div(groundCapture.size).add(.5), float(.5).sub(ground.y.sub(groundCapture.center.y).div(groundCapture.size)));
+	const captured = texture(groundCapture.renderTarget.texture, captureUV).level(float(0));
+	const isInsideCapture = step(0, captureUV.x).mul(step(captureUV.x, 1)).mul(step(0, captureUV.y)).mul(step(captureUV.y, 1));
+	const greenness = captured.g.sub(captured.r.max(captured.b));
+	const isGrown = isInsideCapture.mul(step(MIN_GREENNESS, greenness)).mul(step(waterUniforms.level, captured.a)).mul(step(hash(seed.add(2)), density));
+	const distance = ground.distance(cameraGround);
+	const fade = smoothstep(innerRadius, innerRadius + spacing * 4, distance).mul(float(1).sub(smoothstep(fadeStart, fadeEnd, distance)));
+	const size = hash(seed.add(3)).mul(.5).add(.75).mul(fade).mul(isGrown).mul(scale);
+	const angle = hash(seed.add(4)).mul(Math.PI * 2);
+	const across = positionGeometry.x.mul(bladeWidth).mul(size);
+	const up = positionGeometry.y;
+	const wind = createWindNode(windUniforms, ground).mul(BEND_PER_WIND).mul(up.mul(up));
+	const bladeHeightNode = up.mul(bladeHeight).mul(size).sub(wind.length().mul(bladeHeight).mul(size).mul(.3));
+	grassMaterial.positionNode = vec3(ground.x.add(across.mul(cos(angle))).add(wind.x.mul(bladeHeight).mul(size)), captured.a.add(bladeHeightNode), ground.y.add(across.mul(sin(angle))).add(wind.y.mul(bladeHeight).mul(size)));
+	grassMaterial.normalNode = cameraViewMatrix.mul(vec4(0, 1, 0, 0)).xyz;
+	const groundColor = varying(captured.rgb);
+	grassMaterial.colorNode = mix(groundColor.mul(.72), groundColor.mul(1.12).add(vec3(.03, .03, 0)), up);
+	return grassMaterial;
+};
+//#endregion
+//#region src/vegetation/createGroundCapture.ts
+const createGroundCapture = (size, resolution) => {
+	const renderTarget = new RenderTarget(resolution, resolution, { type: HalfFloatType });
+	renderTarget.texture.magFilter = LinearFilter;
+	renderTarget.texture.minFilter = LinearFilter;
+	const halfSize = size / 2;
+	const camera = new OrthographicCamera(-halfSize, halfSize, halfSize, -halfSize);
+	camera.rotation.x = -Math.PI / 2;
+	camera.layers.set(1);
+	const material = new MeshBasicNodeMaterial();
+	material.outputNode = vec4(attribute("color", "vec3"), positionWorld.y);
+	return {
+		camera,
+		center: uniform(new Vector2()),
+		material,
+		renderTarget,
+		size
+	};
+};
+//#endregion
+//#region src/vegetation/renderGroundCapture.ts
+const clearColor = new Color();
+const previousClearColor = new Color();
+const renderGroundCapture = (renderer, scene, { camera, center, material, renderTarget }, { maxHeight }, worldCenter, origin) => {
+	center.value.set(worldCenter.x, worldCenter.z);
+	camera.position.set(worldCenter.x - origin.x, maxHeight + 1, worldCenter.z - origin.z);
+	camera.far = maxHeight * 4;
+	camera.updateProjectionMatrix();
+	camera.updateMatrixWorld();
+	const previousRenderTarget = renderer.getRenderTarget();
+	const previousClearAlpha = renderer.getClearAlpha();
+	renderer.getClearColor(previousClearColor);
+	const previousOverrideMaterial = scene.overrideMaterial;
+	const previousBackgroundNode = scene.backgroundNode;
+	scene.overrideMaterial = material;
+	scene.backgroundNode = null;
+	renderer.setClearColor(clearColor, 0);
+	renderer.setRenderTarget(renderTarget);
+	renderer.clear();
+	renderer.render(scene, camera);
+	renderer.setRenderTarget(previousRenderTarget);
+	renderer.setClearColor(previousClearColor, previousClearAlpha);
+	scene.overrideMaterial = previousOverrideMaterial;
+	scene.backgroundNode = previousBackgroundNode;
+};
+//#endregion
+//#region src/water/createUnderwaterFogState.ts
+const createUnderwaterFogState = () => ({
+	aboveDensity: 0,
+	aboveHeightFalloff: 0,
+	aboveStartDistance: 0,
+	isUnderwater: false
+});
+//#endregion
+//#region src/water/createWaterUniforms.ts
+const createWaterUniforms = () => ({
+	causticStrength: uniform(0),
+	deepColor: uniform(new Color()),
+	deepDepth: uniform(1),
+	foamColor: uniform(new Color(16777215)),
+	foamDepth: uniform(0),
+	level: uniform(0),
+	shallowColor: uniform(new Color()),
+	underwaterFogColor: uniform(new Color()),
+	underwaterFogDensity: uniform(0)
+});
+//#endregion
+//#region src/water/updateUnderwaterFog.ts
+const updateUnderwaterFog = (eyeHeight, { level, underwaterFogColor, underwaterFogDensity }, { color, density, heightFalloff, startDistance }, underwaterFogState) => {
+	const isUnderwater = eyeHeight < level.value;
+	if (isUnderwater && !underwaterFogState.isUnderwater) {
+		underwaterFogState.aboveDensity = density.value;
+		underwaterFogState.aboveHeightFalloff = heightFalloff.value;
+		underwaterFogState.aboveStartDistance = startDistance.value;
+		density.value = underwaterFogDensity.value;
+		heightFalloff.value = 0;
+		startDistance.value = 0;
+	} else if (!isUnderwater && underwaterFogState.isUnderwater) {
+		density.value = underwaterFogState.aboveDensity;
+		heightFalloff.value = underwaterFogState.aboveHeightFalloff;
+		startDistance.value = underwaterFogState.aboveStartDistance;
+	}
+	underwaterFogState.isUnderwater = isUnderwater;
+	if (isUnderwater) color.value.copy(underwaterFogColor.value);
+};
+//#endregion
+//#region src/wind/createWindUniforms.ts
+const createWindUniforms = () => ({
+	direction: uniform(new Vector2(1, 0)),
+	gustSpeed: uniform(0),
+	gustStrength: uniform(0),
+	gustWidth: uniform(1),
+	strength: uniform(0)
+});
+//#endregion
+//#region src/world/computeOriginShift.ts
+const computeOriginShift = (cameraPosition, threshold, step, shift) => {
+	if (Math.hypot(cameraPosition.x, cameraPosition.z) <= threshold) return false;
+	shift.set(Math.round(cameraPosition.x / step) * step, 0, Math.round(cameraPosition.z / step) * step);
+	return shift.x !== 0 || shift.z !== 0;
+};
+//#endregion
+//#region src/world/computeOutlineDistance.ts
+const computeOutlineDistance = (outline, x, z) => {
+	let isInside = false;
+	let nearestSquared = Infinity;
+	for (let index = 0, previousIndex = outline.length - 1; index < outline.length; previousIndex = index++) {
+		const start = outline[previousIndex];
+		const end = outline[index];
+		if (!start || !end) continue;
+		if (end.z > z !== start.z > z && x < (start.x - end.x) * (z - end.z) / (start.z - end.z) + end.x) isInside = !isInside;
+		const edgeX = start.x - end.x;
+		const edgeZ = start.z - end.z;
+		const lengthSquared = edgeX * edgeX + edgeZ * edgeZ;
+		const along = lengthSquared === 0 ? 0 : Math.min(Math.max(((x - end.x) * edgeX + (z - end.z) * edgeZ) / lengthSquared, 0), 1);
+		const offsetX = x - end.x - along * edgeX;
+		const offsetZ = z - end.z - along * edgeZ;
+		nearestSquared = Math.min(nearestSquared, offsetX * offsetX + offsetZ * offsetZ);
+	}
+	return isInside ? 0 : Math.sqrt(nearestSquared);
+};
+//#endregion
+export { AntialiasingMode, GAME_MINUTES_PER_SECOND, 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, createFogUniforms, createGenshinRenderer, createGodraysLight, createGradeLutTexture, createGrassGeometry, createGrassMaterial, createGroundCapture, createHeightFogNode, createLeafMaterial, createLightUniforms, createPostPipeline, createPostUniforms, createRampTexture, createRimNode, createSeededRandom, createSimplexNoise, createSkyNode, createSkyState, createSkyUniforms, createStatueGeometry, createSunLight, createTerrainMaterial, createTerrainSelection, createTerrainTileGeometry, createTileStreamer, createToonMaterial, createTreeGeometry, createUnderwaterFogState, createWaterMaterial, createWaterUniforms, createWindNode, createWindUniforms, getParentTerrainTileKey, getTerrainTileColumn, getTerrainTileKey, getTerrainTileLevel, getTerrainTileRow, renderGroundCapture, resolveTerrainDraws, sampleSkyState, selectTerrainTiles, updateUnderwaterFog };