genshin-engine 4.1.2 → 4.3.1

package/dist/index.js

@@ -1,7 +1,7 @@
 import { A as TERRAIN_RING_INITIAL_TILE_COUNT, C as getCliffBlend, D as TERRAIN_CELL_SIZE, E as GAUSSIAN_REACH_WIDTHS, F as GroundLayer, I as GroundLayers, L as createSeededRandom, M as TILE_INDEX_SPAN, N as createSimplexNoise, O as TERRAIN_HEIGHT_PADDING, P as TerrainFeatureKind, S as getPlateauBlend, T as getTerrainTileLevel, _ as getTerrainTileRow, a as createTerrainFeaturesBlend, b as TerrainFeatureKindBlendMap, c as sampleTerrainResidualFade, d as sampleGroundLayerField, f as getSegmentBounds, g as computeTerrainTile, h as fileByCell, i as createTerrainFeaturesHeight, j as TILE_INDEX_OFFSET, k as TERRAIN_LAYER, l as createGroundPaintColor, m as getGaussianHillBlend, n as createTerrainShapeHeight, o as getTerrainFeatureBounds, p as createGaussianHillsHeight, r as getTerrainShapeLevel, s as createResidualHeight, t as computeScatterPoints, u as createGroundLayerWeights, v as getTerrainTileColumn, w as measureSegment, x as getRidgeBlend, y as blendGridNodes } from "./terrainWorker-DZ04cA3m.js";
 import { AdditiveBlending, BackSide, Bone, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, ClampToEdgeWrapping, Color, CylinderGeometry, Data3DTexture, DataTexture, DataUtils, DirectionalLight, DoubleSide, Euler, Float32BufferAttribute, FloatType, FrontSide, HalfFloatType, InstancedBufferAttribute, InstancedBufferGeometry, InstancedInterleavedBuffer, InstancedMesh, InterleavedBufferAttribute, LinearFilter, LinearMipmapLinearFilter, MathUtils, Matrix3, Matrix4, Mesh, NearestFilter, NoColorSpace, NoToneMapping, OrthographicCamera, PerspectiveCamera, Quaternion, RGBAFormat, RedFormat, RepeatWrapping, SRGBColorSpace, Scene, Skeleton, SkinnedMesh, Sphere, Sprite, Texture, UnsignedByteType, Vector2, Vector3 } from "three";
-import { Fn, If, abs, acos, asin, atan, attribute, cameraFar, cameraNear, cameraPosition, cameraProjectionMatrix, cameraViewMatrix, clamp, color, cos, cross, diffuseColor, dot, exp, exp2, float, getNormalFromDepth, getViewPosition, hash, instanceIndex, instancedBufferAttribute, interleavedGradientNoise, luminance, mat4, max, min, mix, mod, modelViewMatrix, modelWorldMatrix, modelWorldMatrixInverse, mrt, mx_cell_noise_float, mx_fractal_noise_float, mx_noise_float, normalLocal, normalView, normalWorld, normalWorldGeometry, normalize, output, pass, perspectiveDepthToViewZ, positionGeometry, positionLocal, positionView, positionViewDirection, positionWorld, pow, reflect, renderOutput, sample, saturate, screenCoordinate, screenUV, select, sin, smoothstep, step, tangentLocal, texture, texture3D, time, transformNormalToView, uniform, uniformArray, uv, varying, vec2, vec3, vec4, velocity, vertexColor, viewportDepthTexture, viewportSharedTexture } from "three/tsl";
-import { LightingModel, MeshBasicNodeMaterial, MeshToonNodeMaterial, NodeMaterial, RenderPipeline, RenderTarget, SpriteNodeMaterial, StorageInstancedBufferAttribute, ToonOutlinePassNode, WebGPURenderer } from "three/webgpu";
+import { Fn, If, abs, acos, asin, atan, atomicAdd, atomicStore, attribute, cameraFar, cameraNear, cameraPosition, cameraProjectionMatrix, cameraViewMatrix, clamp, color, cos, cross, diffuseColor, distance, dot, exp, exp2, float, fract, getNormalFromDepth, getViewPosition, hash, instanceIndex, instancedBufferAttribute, interleavedGradientNoise, luminance, mat4, max, min, mix, mod, modelViewMatrix, modelWorldMatrix, modelWorldMatrixInverse, mrt, mx_cell_noise_float, mx_fractal_noise_float, mx_noise_float, normalGeometry, normalLocal, normalView, normalViewGeometry, normalWorld, normalWorldGeometry, normalize, output, pass, perspectiveDepthToViewZ, positionGeometry, positionLocal, positionView, positionViewDirection, positionWorld, pow, reflect, renderOutput, sample, saturate, screenCoordinate, screenUV, select, sin, smoothstep, step, storage, tangentLocal, texture, texture3D, time, transformNormal, transformNormalToView, uint, uniform, uniformArray, uv, varying, vec2, vec3, vec4, velocity, vertexColor, viewportDepthTexture, viewportSharedTexture } from "three/tsl";
+import { IndirectStorageBufferAttribute, LightingModel, MeshBasicNodeMaterial, MeshToonNodeMaterial, NodeMaterial, RenderPipeline, RenderTarget, SpriteNodeMaterial, StorageBufferAttribute, StorageInstancedBufferAttribute, ToonOutlinePassNode, WebGPURenderer } from "three/webgpu";
 import { CSMShadowNode } from "three/examples/jsm/csm/CSMShadowNode.js";
 import { MeshBVH } from "three-mesh-bvh";
 import { Capsule } from "three/examples/jsm/math/Capsule.js";
@@ -32,6 +32,7 @@ let WeatherKind = /* @__PURE__ */ function(WeatherKind) {
 	WeatherKind["Rain"] = "Rain";
 	WeatherKind["Sandstorm"] = "Sandstorm";
 	WeatherKind["Snow"] = "Snow";
+	WeatherKind["Snowstorm"] = "Snowstorm";
 	WeatherKind["Thunderstorm"] = "Thunderstorm";
 	return WeatherKind;
 }({});
@@ -80,6 +81,15 @@ const PRECIPITATION_SETTINGS_MAP = {
 		windDrift: .3
 	}
 };
+const SNOW_WEATHER_SETTINGS = {
+	cloudCoverage: .8,
+	fogDensity: .001,
+	precipitation: {
+		density: .5,
+		kind: "Snow"
+	},
+	wetness: 0
+};
 const WEATHER_SETTINGS_MAP = {
 	["Clear"]: {
 		cloudCoverage: 0,
@@ -115,15 +125,8 @@ const WEATHER_SETTINGS_MAP = {
 		},
 		wetness: 0
 	},
-	["Snow"]: {
-		cloudCoverage: .8,
-		fogDensity: .001,
-		precipitation: {
-			density: .5,
-			kind: "Snow"
-		},
-		wetness: 0
-	},
+	["Snow"]: SNOW_WEATHER_SETTINGS,
+	["Snowstorm"]: { ...SNOW_WEATHER_SETTINGS },
 	["Thunderstorm"]: {
 		cloudCoverage: 1,
 		fogDensity: .002,
@@ -818,6 +821,7 @@ const FREE_CAMERA_MAX_PITCH = Math.PI / 2 - .01;
 const FOLLOW_CAMERA_DEFAULT_SETTINGS = {
 	defaultDistance: 5,
 	horizontalSensitivity: 3,
+	slopePitch: false,
 	verticalSensitivity: 3
 };
 const FOLLOW_CAMERA_NEUTRAL_SENSITIVITY = 3;
@@ -829,6 +833,7 @@ const FOLLOW_CAMERA_MIN_DISTANCE = 1;
 const FOLLOW_CAMERA_MAX_DISTANCE = 6;
 const FOLLOW_CAMERA_DISTANCE_PER_ZOOM_STEP = .5;
 const FOLLOW_CAMERA_EASE_OUT_SPEED = 4;
+const FOLLOW_CAMERA_SLOPE_PITCH_SPEED = 4;
 const FOLLOW_CAMERA_CLEARANCE = .2;
 const FOLLOW_CAMERA_ARM_STEP = .25;
 //#endregion
@@ -1572,23 +1577,35 @@ let InputAction = /* @__PURE__ */ function(InputAction) {
 const InputActions = Object.values(InputAction);
 //#endregion
 //#region src/camera/createFollowCamera.ts
+const clampPitch = (value) => Math.max(FOLLOW_CAMERA_MIN_PITCH, Math.min(FOLLOW_CAMERA_MAX_PITCH, value));
 const createFollowCamera = ({ camera, ground, landmarkCollider, settings }) => {
 	const euler = new Euler().setFromQuaternion(camera.quaternion, "YXZ");
 	const armDirection = new Vector3();
 	let yaw = euler.y;
 	let pitch = 0;
+	let slopeBaseline = 0;
+	let lookOffset = 0;
 	let distance = settings.defaultDistance;
 	let armLength = distance;
 	camera.fov = 45;
 	camera.updateProjectionMatrix();
+	const settlePitch = () => {
+		lookOffset = clampPitch(slopeBaseline + lookOffset) - slopeBaseline;
+		pitch = slopeBaseline + lookOffset;
+	};
 	const turn = () => {
 		euler.set(pitch, yaw, 0, "YXZ");
 		camera.quaternion.setFromEuler(euler);
 	};
+	const returnToDefaultDistance = () => {
+		distance = settings.defaultDistance;
+	};
 	const reset = (facing) => {
 		yaw = facing;
 		pitch = 0;
-		distance = settings.defaultDistance;
+		slopeBaseline = 0;
+		lookOffset = 0;
+		returnToDefaultDistance();
 		turn();
 	};
 	const computeGroundReach = (pivot, reach) => {
@@ -1600,11 +1617,23 @@ const createFollowCamera = ({ camera, ground, landmarkCollider, settings }) => {
 		}
 		return reach;
 	};
+	const computeSlopePitch = (pivot) => {
+		const runX = Math.sin(yaw) * distance;
+		const runZ = Math.cos(yaw) * distance;
+		const rise = ground.getGround(pivot.x + runX, pivot.z + runZ).height - ground.getGround(pivot.x, pivot.z).height;
+		return -Math.atan2(rise, distance);
+	};
 	return {
 		follow: (pivot, origin, frameSeconds) => {
+			if (settings.slopePitch) {
+				const settle = 1 - Math.exp(-4 * frameSeconds);
+				slopeBaseline += (computeSlopePitch(pivot) - slopeBaseline) * settle;
+				settlePitch();
+				turn();
+			}
 			armDirection.set(Math.sin(yaw) * Math.cos(pitch), -Math.sin(pitch), Math.cos(yaw) * Math.cos(pitch));
 			const landmarkReach = landmarkCollider.castSphere(pivot, armDirection, distance, FOLLOW_CAMERA_CLEARANCE);
-			const reach = Math.max(1, computeGroundReach(pivot, landmarkReach));
+			const reach = computeGroundReach(pivot, Math.max(1, landmarkReach));
 			armLength = reach < armLength ? reach : Math.min(reach, armLength + 4 * frameSeconds);
 			camera.position.copy(pivot).addScaledVector(armDirection, armLength).sub(origin);
 		},
@@ -1614,11 +1643,13 @@ const createFollowCamera = ({ camera, ground, landmarkCollider, settings }) => {
 				return;
 			}
 			yaw += input.lookYaw * (settings.horizontalSensitivity / 3);
-			pitch = Math.max(FOLLOW_CAMERA_MIN_PITCH, Math.min(FOLLOW_CAMERA_MAX_PITCH, pitch + input.lookPitch * (settings.verticalSensitivity / 3)));
+			lookOffset += input.lookPitch * (settings.verticalSensitivity / 3);
+			settlePitch();
 			distance = Math.max(1, Math.min(6, distance + input.zoomSteps * FOLLOW_CAMERA_DISTANCE_PER_ZOOM_STEP));
 			turn();
 		},
 		reset,
+		returnToDefaultDistance,
 		get yaw() {
 			return yaw;
 		}
@@ -1653,6 +1684,18 @@ const createFreeCamera = ({ camera, ground }) => {
 	};
 };
 //#endregion
+//#region src/models/character/PmxSphereMode.ts
+let PmxSphereMode = /* @__PURE__ */ function(PmxSphereMode) {
+	PmxSphereMode[PmxSphereMode["Disabled"] = 0] = "Disabled";
+	PmxSphereMode[PmxSphereMode["Multiply"] = 1] = "Multiply";
+	PmxSphereMode[PmxSphereMode["Add"] = 2] = "Add";
+	PmxSphereMode[PmxSphereMode["AdditionalUv"] = 3] = "AdditionalUv";
+	return PmxSphereMode;
+}({});
+//#endregion
+//#region src/character/checkIsPmxSphereDrawn.ts
+const checkIsPmxSphereDrawn = (sphereMode) => sphereMode === 1 || sphereMode === 2;
+//#endregion
 //#region src/character/checkTransparentTexels.ts
 const checkTransparentTexels = (image) => {
 	const context = new OffscreenCanvas(image.width, image.height).getContext("2d", { willReadFrequently: true });
@@ -1667,7 +1710,6 @@ const checkTransparentTexels = (image) => {
 };
 //#endregion
 //#region src/character/constants.ts
-const PMX_UNIT_METRES = .08;
 const SHARED_TOON_RAMP_SHADES = [
 	.4,
 	.45,
@@ -1699,6 +1741,18 @@ const MINIMUM_RAMP_WIDTH_VERTEX = .01;
 const MINIMUM_OUTLINE_KNOT_SPAN = .001;
 const OUTLINE_PROJECTION_SCALE = 2.414;
 const OUTLINE_WIDTH_SCALE = .41425;
+const UNIT_OUTLINE_WIDTH_KNOTS = {
+	depths: [
+		1,
+		2,
+		3
+	],
+	scales: [
+		1,
+		1,
+		1
+	]
+};
 const OUTLINE_MAIN_TEXTURE_SHARE = .2;
 const DESATURATION_WEIGHTS = [
 	.0397,
@@ -1809,16 +1863,7 @@ const createCharacterShadingInputs = (overrides) => {
 		lightArea: DEFAULT_LIGHT_AREA,
 		metalDarkColor: BLACK,
 		metalLightColor: WHITE,
-		outlineDepths: [
-			1,
-			2,
-			3
-		],
-		outlineScales: [
-			1,
-			1,
-			1
-		],
+		outlineWidthKnots: UNIT_OUTLINE_WIDTH_KNOTS,
 		rampLayout: 0,
 		rampWidth: DEFAULT_RAMP_WIDTH,
 		regionTints: {
@@ -1940,6 +1985,10 @@ const selectRegionNode = (region, toRegionNode) => LATER_REGIONS.reduce((current
 //#endregion
 //#region src/character/shading/createCharacterShadingNode.ts
 const toVec3 = ([red, green, blue]) => vec3(red, green, blue);
+const laySphere = (diffuse, sphere) => {
+	const sample = texture(sphere.texture, vec2(normalView.x, normalView.y.negate()).mul(.5).add(.5)).rgb;
+	return sphere.mode === 2 ? diffuse.add(sample) : diffuse.mul(sample);
+};
 const selectRegionColor = (region, colors) => selectRegionNode(region, (regionName) => toVec3(colors[regionName]));
 const createShadowMultiplyNode = (region, inputs) => {
 	const firstShadow = selectRegionColor(region, inputs.shadowMultiplyColors);
@@ -1957,7 +2006,8 @@ const createCharacterShadingNode = (inputs, { lightColor, sunDirection }) => {
 		one: color
 	});
 	const mainSample = inputs.mainTexture ? texture(inputs.mainTexture, uv()) : vec4(1);
-	const materialColour = mainSample.rgb.mul(tint);
+	const diffuseColour = mainSample.rgb.mul(tint);
+	const materialColour = inputs.sphere ? laySphere(diffuseColour, inputs.sphere) : diffuseColour;
 	const sunTerm = normalView.dot(sunDirectionView).mul(HALF_LAMBERT_SCALE).add(HALF_LAMBERT_OFFSET);
 	const threshold = createToonThresholdNode({
 		isLightMapAo: inputs.isLightMapAo,
@@ -2019,19 +2069,11 @@ const getToneColour = (colour, desaturateScale, contrastScale) => {
 	return new Vector3(.5 + (desaturated.x - .5) * gain, .5 + (desaturated.y - .5) * gain, .5 + (desaturated.z - .5) * gain);
 };
 //#endregion
-//#region src/models/character/PmxSphereMode.ts
-let PmxSphereMode = /* @__PURE__ */ function(PmxSphereMode) {
-	PmxSphereMode[PmxSphereMode["Disabled"] = 0] = "Disabled";
-	PmxSphereMode[PmxSphereMode["Multiply"] = 1] = "Multiply";
-	PmxSphereMode[PmxSphereMode["Add"] = 2] = "Add";
-	PmxSphereMode[PmxSphereMode["AdditionalUv"] = 3] = "AdditionalUv";
-	return PmxSphereMode;
-}({});
-//#endregion
 //#region src/models/nodes/ToonNodeMaterial.ts
 var ToonNodeMaterial = class extends MeshToonNodeMaterial {
 	edge;
 	emissiveNode = null;
+	instanceMatrix;
 	isMeshToonMaterial;
 	isMeshToonNodeMaterial;
 	sphereMap;
@@ -2055,11 +2097,14 @@ const createCharacterMaterial = ({ isTextureTransparent, lightUniforms, pmxMater
 	const shadingInputs = createCharacterShadingInputs({
 		color,
 		mainTexture: diffuseTexture,
-		metalTexture: sphereTexture && sphereMode !== 0 ? sphereTexture : void 0,
 		rampLayout: packToonTexture ? 1 : 0,
 		rampTexture: packToonTexture ?? (isToonShared ? getSharedToonRamp(toonIndex) : void 0) ?? rampTexture,
 		shininess: specularity,
 		specularColor,
+		sphere: sphereTexture && checkIsPmxSphereDrawn(sphereMode) ? {
+			mode: sphereMode,
+			texture: sphereTexture
+		} : void 0,
 		...gameShadingInputs
 	});
 	const toned = getToneColour(new Vector3(red * edgeColor[0], green * edgeColor[1], blue * edgeColor[2]), shadingInputs.desaturateScale, shadingInputs.contrastScale);
@@ -2080,14 +2125,11 @@ const createCharacterMaterial = ({ isTextureTransparent, lightUniforms, pmxMater
 		isVertexWeighted: shadingInputs.isOutlineVertexWeighted,
 		offset: shadingInputs.outlineOffset,
 		size: edgeSize,
-		widthKnots: {
-			depths: shadingInputs.outlineDepths,
-			scales: shadingInputs.outlineScales
-		}
+		widthKnots: shadingInputs.outlineWidthKnots
 	} : void 0);
 	characterMaterial.lights = false;
 	characterMaterial.outputNode = vec4(createCharacterShadingNode(shadingInputs, lightUniforms), alpha);
-	if (sphereTexture && sphereMode !== 0) characterMaterial.sphereMap = sphereTexture;
+	if (sphereTexture && checkIsPmxSphereDrawn(sphereMode)) characterMaterial.sphereMap = sphereTexture;
 	return characterMaterial;
 };
 //#endregion
@@ -2143,13 +2185,13 @@ const createPmxSkeleton = (pmxBones) => {
 };
 //#endregion
 //#region src/character/createPmxMesh.ts
-const createPmxMesh = (pmxModel, materials) => {
+const createPmxMesh = (pmxModel, materials, unitMetres) => {
 	const geometry = createPmxGeometry(pmxModel);
 	const mesh = new SkinnedMesh(geometry, materials);
 	const skeleton = createPmxSkeleton(pmxModel.bones);
 	for (const bone of skeleton.bones) if (!bone.parent) mesh.add(bone);
 	mesh.normalizeSkinWeights();
-	mesh.scale.setScalar(PMX_UNIT_METRES);
+	mesh.scale.setScalar(unitMetres);
 	mesh.bind(skeleton);
 	return mesh;
 };
@@ -3115,6 +3157,80 @@ const createLandmarkCollider = () => {
 	};
 };
 //#endregion
+//#region src/culling/constants.ts
+const CULLING_FRUSTUM_MARGIN = .1;
+const CULLING_INDIRECT_ARGUMENT_COUNT = 5;
+const CULLING_INDEX_COUNT_INDEX = 0;
+const CULLING_INSTANCE_COUNT_INDEX = 1;
+const CULLING_MIN_SIZE = 1e-4;
+const CULLING_MATRIX_COLUMN_COUNT = 4;
+const CULLING_MATRIX_ELEMENT_COUNT = 16;
+//#endregion
+//#region src/culling/createFrustumVisibility.ts
+const createFrustumVisibility = (clipFromModel, point) => {
+	const clip = clipFromModel.mul(vec4(point, 1));
+	const limit = clip.w.mul(1.1);
+	return step(0, clip.w).mul(step(clip.x.abs(), limit)).mul(step(clip.y.abs(), limit)).mul(step(0, clip.z)).mul(step(clip.z, limit));
+};
+//#endregion
+//#region src/culling/createSurvivorIndices.ts
+const createSurvivorIndices = (count) => Uint32Array.from({ length: count }, (_value, index) => index);
+//#endregion
+//#region src/culling/createInstanceCulling.ts
+const createInstanceCulling = ({ count, indexCount, isVisible }) => {
+	const indirectArray = /* @__PURE__ */ new Uint32Array(5);
+	indirectArray[0] = indexCount;
+	const indirect = new IndirectStorageBufferAttribute(indirectArray, 1);
+	const survivorAttribute = new StorageBufferAttribute(createSurvivorIndices(count), 1);
+	const counter = storage(indirect, "uint", 5).toAtomic();
+	const survivors = storage(survivorAttribute, "uint", count);
+	const resetCount = Fn(() => {
+		atomicStore(counter.element(1), uint(0));
+	})().compute(1);
+	const cullInstances = Fn(() => {
+		If(isVisible(float(instanceIndex)).greaterThan(0), () => {
+			const slot = atomicAdd(counter.element(1), uint(1));
+			survivors.element(slot).assign(uint(instanceIndex));
+		});
+	})().compute(count);
+	return {
+		cull: (renderer) => {
+			renderer.compute(resetCount);
+			renderer.compute(cullInstances);
+		},
+		dispose: () => {
+			indirect.dispose();
+			survivorAttribute.dispose();
+		},
+		indirect,
+		survivor: float(storage(survivorAttribute, "uint", count).toReadOnly().element(instanceIndex))
+	};
+};
+//#endregion
+//#region src/culling/createInstanceMatrixBuffer.ts
+const createInstanceMatrixBuffer = (matrices) => {
+	const array = new Float32Array(matrices.length * 16);
+	for (const [index, matrix] of matrices.entries()) array.set(matrix.elements, index * 16);
+	return new StorageBufferAttribute(array, 4);
+};
+//#endregion
+//#region src/culling/createInstanceMatrixNode.ts
+const createInstanceMatrixNode = (attribute, instance) => {
+	const columns = storage(attribute, "vec4", attribute.count).toReadOnly();
+	const firstColumn = uint(instance).mul(uint(4));
+	const column = (offset) => columns.element(firstColumn.add(uint(offset)));
+	return mat4(column(0), column(1), column(2), column(3));
+};
+//#endregion
+//#region src/culling/createInstancedGeometry.ts
+const createInstancedGeometry = (geometry, instanceCount) => {
+	const instancedGeometry = new InstancedBufferGeometry();
+	for (const [name, attribute] of Object.entries(geometry.attributes)) instancedGeometry.setAttribute(name, attribute);
+	instancedGeometry.setIndex(geometry.getIndex());
+	instancedGeometry.instanceCount = instanceCount;
+	return instancedGeometry;
+};
+//#endregion
 //#region src/models/input/GamepadButton.ts
 let GamepadButton = /* @__PURE__ */ function(GamepadButton) {
 	GamepadButton["Back"] = "GamepadBack";
@@ -3660,8 +3776,50 @@ const SURFACE_DETAIL_BAND_SIGMAS = [
 	4,
 	8
 ];
-const SURFACE_OCTAVE_TEXEL_FREQUENCIES = [...SURFACE_DETAIL_BAND_SIGMAS.map((sigma) => 1 / (2 * Math.PI * sigma)), 1 / (4 * Math.PI * (SURFACE_DETAIL_BAND_SIGMAS.at(-1) ?? 0))];
-const SURFACE_DETAIL_RENDER_GAIN = 4;
+const SURFACE_OCTAVE_TEXEL_FREQUENCIES = [
+	.9,
+	.3,
+	.1,
+	.033,
+	.011
+];
+const SURFACE_OCTAVE_RESPONSES = [
+	[
+		.0529,
+		.00115,
+		13e-5,
+		385e-7,
+		.0618
+	],
+	[
+		.0162,
+		.00896,
+		.00235,
+		251e-6,
+		.0605
+	],
+	[
+		543e-6,
+		.00257,
+		.00927,
+		.00654,
+		.0626
+	],
+	[
+		99e-7,
+		654e-7,
+		742e-6,
+		.0048,
+		.0534
+	],
+	[
+		419e-9,
+		155e-8,
+		169e-7,
+		188e-6,
+		.0379
+	]
+];
 const OBJECT_SURFACE_KEY = "surface";
 const OBJECT_FADE_KEY = "fade";
 const LEAF_SHAPE_WIDTH = .8;
@@ -4024,6 +4182,9 @@ const createStamina = (maximum, getStaminaConsumptionMultiplier = () => 1) => {
 		refill: () => {
 			stamina.value = stamina.maximum;
 		},
+		restore: (amount) => {
+			stamina.value = Math.min(stamina.maximum, stamina.value + amount);
+		},
 		spend: (amount) => {
 			stamina.value = Math.max(0, stamina.value - getCost(amount));
 			restSeconds = 0;
@@ -4050,7 +4211,8 @@ const getSpeed = (state, locomotion) => {
 	else if (state === "SwimDash") return locomotion.swimDashSpeed;
 	else return locomotion.runSpeed;
 };
-const createCharacterController = ({ getStaminaConsumptionMultiplier, ground, landmarkCollider, position, staminaMaximum }) => {
+const createCharacterController = (options) => {
+	const { ground, landmarkCollider, position } = options;
 	const previousPosition = position.clone();
 	const lastFullPosition = position.clone();
 	const velocity = new Vector3();
@@ -4065,7 +4227,7 @@ const createCharacterController = ({ getStaminaConsumptionMultiplier, ground, la
 		state: "Idle",
 		stateSeconds: 0
 	};
-	const stamina = createStamina(staminaMaximum, getStaminaConsumptionMultiplier);
+	const stamina = options.stamina === void 0 ? createStamina(options.staminaMaximum, options.getStaminaConsumptionMultiplier) : options.stamina;
 	const contact = {
 		isFacingWall: false,
 		isGrounded: true,
@@ -4291,14 +4453,16 @@ var ObjectSurface = class {
 };
 //#endregion
 //#region src/models/nodes/createOutlineMaterial.ts
-const createOutlineMaterial = (colorNode, thicknessNode) => {
+const createOutlineMaterial = (colorNode, thicknessNode, instanceMatrix) => {
 	const material = Object.assign(new NodeMaterial(), { isMeshToonOutlineMaterial: true });
 	material.name = "Toon_Outline";
 	material.side = BackSide;
 	const outlineNormal = normalLocal.negate();
+	const outlineDirection = instanceMatrix ? transformNormal(outlineNormal, instanceMatrix) : outlineNormal;
+	const placed = (point) => instanceMatrix ? instanceMatrix.mul(vec4(point, 1)).xyz : point;
 	const mvp = cameraProjectionMatrix.mul(modelViewMatrix);
-	const pos = mvp.mul(vec4(positionLocal, 1));
-	const pos2 = mvp.mul(vec4(positionLocal.add(outlineNormal), 1));
+	const pos = mvp.mul(vec4(placed(positionLocal), 1));
+	const pos2 = pos.add(mvp.mul(vec4(outlineDirection, 0)));
 	const norm = normalize(pos.sub(pos2));
 	material.vertexNode = pos.add(norm.mul(thicknessNode).mul(pos.w));
 	material.colorNode = colorNode;
@@ -4322,10 +4486,14 @@ const createGameOutlineMaterial = (colorNode, widthNode, offsetNode) => {
 var SharedToonOutlinePassNode = class extends ToonOutlinePassNode {
 	#drawn;
 	#edgeOutlineMaterials = /* @__PURE__ */ new Map();
+	#instancedOutlineMaterials = /* @__PURE__ */ new WeakMap();
 	#outlineMaterial;
 	#pixelEdgeOutlineMaterials = /* @__PURE__ */ new WeakMap();
 	_getOutlineMaterial(originalMaterial) {
-		if (originalMaterial instanceof ToonNodeMaterial && originalMaterial.edge) return this.#getEdgeOutlineMaterial(originalMaterial.edge);
+		if (originalMaterial instanceof ToonNodeMaterial) {
+			if (originalMaterial.instanceMatrix) return this.#getInstancedOutlineMaterial(originalMaterial.instanceMatrix);
+			if (originalMaterial.edge) return this.#getEdgeOutlineMaterial(originalMaterial.edge);
+		}
 		return this.#getSharedOutlineMaterial();
 	}
 	async compileAsync(renderer) {
@@ -4362,6 +4530,14 @@ var SharedToonOutlinePassNode = class extends ToonOutlinePassNode {
 		}
 		return edgeOutlineMaterial;
 	}
+	#getInstancedOutlineMaterial(instanceMatrix) {
+		let instancedOutlineMaterial = this.#instancedOutlineMaterials.get(instanceMatrix);
+		if (instancedOutlineMaterial === void 0) {
+			instancedOutlineMaterial = createOutlineMaterial(vec4(this.colorNode, this.alphaNode), this.thicknessNode, instanceMatrix);
+			this.#instancedOutlineMaterials.set(instanceMatrix, instancedOutlineMaterial);
+		}
+		return instancedOutlineMaterial;
+	}
 	#getSharedOutlineMaterial() {
 		this.#outlineMaterial ??= createOutlineMaterial(vec4(this.colorNode, this.alphaNode), this.thicknessNode);
 		return this.#outlineMaterial;
@@ -4478,12 +4654,7 @@ const computeStoneRampCoordinate = (facing, visibility) => .5 + .5 * facing * Ma
 //#region src/nodes/computeSurfaceOctaves.ts
 const SOLVE_ITERATIONS = 300;
 const SOLVE_START_ENERGY = 1e-6;
-const BAND_EDGE_SIGMAS = [0, ...SURFACE_DETAIL_BAND_SIGMAS];
-const computeBandResponse = (fineSigma, coarseSigma, texelFrequency) => {
-	const decay = 2 * Math.PI ** 2 * texelFrequency ** 2;
-	return (Math.exp(-decay * fineSigma ** 2) - Math.exp(-decay * coarseSigma ** 2)) ** 2 / 2;
-};
-const computeResponses = (targets) => SURFACE_OCTAVE_TEXEL_FREQUENCIES.map((texelFrequency) => [...BAND_EDGE_SIGMAS.slice(0, -1).map((fineSigma, band) => computeBandResponse(fineSigma, BAND_EDGE_SIGMAS[band + 1] ?? 0, texelFrequency)), .5]).map((responses) => responses.map((response, row) => targets[row] ? response / targets[row] : 0));
+const computeResponses = (targets) => SURFACE_OCTAVE_RESPONSES.map((responses) => responses.map((response, row) => targets[row] ? response / targets[row] : 0));
 const solveOctaveEnergies = (responses, targets) => {
 	const energies = responses.map(() => SOLVE_START_ENERGY);
 	for (let iteration = 0; iteration < SOLVE_ITERATIONS; iteration++) {
@@ -4505,6 +4676,12 @@ const computeSurfaceOctaves = ({ bands, metresPerTexel, variance }) => {
 	}));
 };
 //#endregion
+//#region src/nodes/computeWindGust.ts
+const computeWindGust = (downwind, time, { gustSpeed, gustStrength, gustWidth }) => {
+	const gustPhase = (downwind - time * gustSpeed) / gustWidth * Math.PI * 2;
+	return MathUtils.smoothstep(Math.sin(gustPhase) * .5 + .5, .2, 1) * gustStrength;
+};
+//#endregion
 //#region src/nodes/createCausticsNode.ts
 const CAUSTIC_SCALE = .35;
 const CAUSTIC_SPEED = .6;
@@ -4607,9 +4784,12 @@ const createDitherFadeNode = (visibility) => interleavedGradientNoise(screenCoor
 //#region src/nodes/createSurfaceDetailNode.ts
 const createSurfaceDetailNode = (amplitudes, texelsPerMetre) => {
 	const texelPosition = vec3(positionWorld.mul(texelsPerMetre));
-	return SURFACE_OCTAVE_TEXEL_FREQUENCIES.reduce((node, texelFrequency, octave) => node.add(mx_noise_float(texelPosition.mul(texelFrequency)).mul((amplitudes[octave] ?? float(0)).mul(4))), float(1));
+	return SURFACE_OCTAVE_TEXEL_FREQUENCIES.reduce((node, texelFrequency, octave) => node.add(mx_noise_float(texelPosition.mul(texelFrequency)).mul(amplitudes[octave] ?? float(0))), float(1));
 };
 //#endregion
+//#region src/nodes/createMaterialDetailNode.ts
+const createMaterialDetailNode = (detail) => createSurfaceDetailNode(computeSurfaceOctaves(detail).map(({ amplitude }) => uniform(amplitude)), uniform(1 / detail.metresPerTexel));
+//#endregion
 //#region src/nodes/createObjectSurfaceNode.ts
 const DEFAULT_SURFACE = new ObjectSurface(new Color(16777215), [], 0);
 const readObjectSurface = (object) => {
@@ -4643,9 +4823,9 @@ const createWetSheenNode = ({ lightColor, sunDirection, wetness }) => {
 const createMaterialSurfaceNode = (color, detail) => {
 	const colorUniform = uniform(new Color(color ?? 16777215));
 	if (detail === void 0) return colorUniform;
-	return colorUniform.mul(createSurfaceDetailNode(computeSurfaceOctaves(detail).map(({ amplitude }) => uniform(amplitude)), uniform(1 / detail.metresPerTexel)));
+	return colorUniform.mul(createMaterialDetailNode(detail));
 };
-const createToonMaterial = ({ color, detail, isObjectSurface = false, isOutlined = true, isVertexColors = false, lightUniforms, rampTexture }) => {
+const createToonMaterial = ({ color, detail, instanceMatrix, isObjectSurface = false, isOutlined = true, isVertexColors = false, lightUniforms, rampTexture }) => {
 	const toonMaterial = new ToonNodeMaterial({
 		...color === void 0 ? {} : { color },
 		gradientMap: rampTexture,
@@ -4653,24 +4833,32 @@ const createToonMaterial = ({ color, detail, isObjectSurface = false, isOutlined
 	}, isOutlined);
 	toonMaterial.colorNode = (isObjectSurface ? createObjectSurfaceNode() : createMaterialSurfaceNode(color, detail)).mul(createWetDarkeningNode(lightUniforms));
 	toonMaterial.emissiveNode = createRimNode(lightUniforms).add(createWetSheenNode(lightUniforms));
+	if (instanceMatrix) {
+		toonMaterial.instanceMatrix = instanceMatrix;
+		toonMaterial.positionNode = instanceMatrix.mul(vec4(positionGeometry, 1)).xyz;
+		toonMaterial.normalNode = transformNormalToView(transformNormal(normalGeometry, instanceMatrix)).normalize();
+	}
 	return toonMaterial;
 };
 //#endregion
 //#region src/nodes/createImpostorMaterial.ts
 const IMPOSTOR_ALPHA_TEST = .5;
-const createImpostorMaterial = ({ fade, impostor, lightUniforms, rampTexture }) => {
+const createImpostorMaterial = ({ fade, impostor, instanceMatrix, lightUniforms, rampTexture }) => {
 	const impostorMaterial = createToonMaterial({
 		isOutlined: false,
 		lightUniforms,
 		rampTexture
 	});
-	const eye = modelWorldMatrixInverse.mul(vec4(cameraPosition, 1)).xyz;
+	const eyeInModel = modelWorldMatrixInverse.mul(vec4(cameraPosition, 1));
+	const eye = instanceMatrix ? instanceMatrix.inverse().mul(eyeInModel).xyz : eyeInModel.xyz;
 	const forward = vec3(eye.x, 0, eye.z).normalize();
 	const right = vec3(forward.z, 0, forward.x.negate());
-	impostorMaterial.positionNode = right.mul(positionGeometry.x).add(vec3(0, positionGeometry.y, 0));
+	const cardPoint = right.mul(positionGeometry.x).add(vec3(0, positionGeometry.y, 0));
+	impostorMaterial.positionNode = instanceMatrix ? instanceMatrix.mul(vec4(cardPoint, 1)).xyz : cardPoint;
 	const albedo = texture(impostor.albedoTarget.texture, uv());
 	const bakedNormal = texture(impostor.normalTarget.texture, uv()).xyz.mul(2).sub(1);
-	impostorMaterial.normalNode = transformNormalToView(right.mul(bakedNormal.x).add(vec3(0, bakedNormal.y, 0)).add(forward.mul(bakedNormal.z))).normalize();
+	const cardNormal = right.mul(bakedNormal.x).add(vec3(0, bakedNormal.y, 0)).add(forward.mul(bakedNormal.z));
+	impostorMaterial.normalNode = transformNormalToView(instanceMatrix ? transformNormal(cardNormal, instanceMatrix) : cardNormal).normalize();
 	impostorMaterial.colorNode = albedo.rgb.mul(createWetDarkeningNode(lightUniforms));
 	impostorMaterial.maskNode = albedo.a.greaterThan(IMPOSTOR_ALPHA_TEST).and(createDitherFadeNode(fade));
 	impostorMaterial.side = DoubleSide;
@@ -4681,7 +4869,7 @@ const createImpostorMaterial = ({ fade, impostor, lightUniforms, rampTexture })
 const createLeafShapeNode = () => {
 	const centered = uv().sub(.5).mul(2);
 	const width = float(1).sub(centered.y.abs().pow(2)).mul(LEAF_SHAPE_WIDTH);
-	return step(0, width.sub(centered.x.abs()));
+	return centered.x.abs().lessThanEqual(width);
 };
 //#endregion
 //#region src/nodes/createWindNode.ts
@@ -4695,17 +4883,17 @@ const createWindNode = ({ direction, gustSpeed, gustStrength, gustWidth, strengt
 };
 //#endregion
 //#region src/nodes/createLeafMaterial.ts
-const LEAF_ALPHA_TEST = .5;
 const SWAY_PER_WIND = .03;
 const FLUTTER = .06;
-const createLeafMaterial = (toonMaterialOptions, windUniforms) => {
+const createLeafMaterial = (toonMaterialOptions, windUniforms, maskNode) => {
 	const leafMaterial = createToonMaterial({
 		...toonMaterialOptions,
 		isOutlined: false
 	});
-	leafMaterial.opacityNode = createLeafShapeNode();
-	leafMaterial.alphaTest = LEAF_ALPHA_TEST;
+	const leafShape = createLeafShapeNode();
+	leafMaterial.maskNode = maskNode ? leafShape.and(maskNode) : leafShape;
 	leafMaterial.side = DoubleSide;
+	leafMaterial.normalNode = normalViewGeometry;
 	if (windUniforms) {
 		const worldPosition = modelWorldMatrix.mul(vec4(positionLocal, 1)).xyz;
 		const lean = createWindNode(windUniforms, worldPosition.xz).mul(positionLocal.y.mul(SWAY_PER_WIND));
@@ -4775,6 +4963,62 @@ const createPrecipitationMaterial = ({ lightUniforms, precipitationUniforms, win
 	return precipitationMaterial;
 };
 //#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 }, { direction, speed }, bendFoam = float(0)) => {
+	const waterMaterial = new MeshBasicNodeMaterial({
+		side: DoubleSide,
+		transparent: true
+	});
+	const flowedPosition = positionWorld.xz.sub(direction.mul(speed).mul(time));
+	const ripplePosition = flowedPosition.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(flowedPosition.mul(FOAM_SCALE), time.mul(.3)), 2).mul(.5).add(.5);
+	const gathered = shore.max(bendFoam);
+	const foam = smoothstep(.55, .6, foamNoise.add(gathered.mul(.5))).mul(gathered);
+	waterMaterial.colorNode = mix(reflected, foamColor, foam).add(glints);
+	return waterMaterial;
+};
+//#endregion
+//#region src/water/constants.ts
+const RIVER_BEND_FOAM_ATTRIBUTE = "bendFoam";
+const BEND_FOAM_FULL_RADIUS_WIDTHS = 2;
+//#endregion
+//#region src/water/createWaterFlowUniforms.ts
+const createWaterFlowUniforms = () => ({
+	direction: uniform(new Vector2()),
+	speed: uniform(0)
+});
+//#endregion
+//#region src/nodes/createRiverMaterial.ts
+const createRiverMaterial = (lightUniforms, skyUniforms, waterUniforms) => createWaterMaterial(lightUniforms, skyUniforms, waterUniforms, createWaterFlowUniforms(), attribute(RIVER_BEND_FOAM_ATTRIBUTE, "float"));
+//#endregion
 //#region src/nodes/createSkyColorNode.ts
 const HALO_TOWARD_START = .3;
 const HALO_TOWARD_SPAN = .7;
@@ -4911,49 +5155,6 @@ const createStoneMaterial = (options, stoneLight, glowNode = vec3(0)) => {
 	return material;
 };
 //#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 }, { direction, speed }, bendFoam = float(0)) => {
-	const waterMaterial = new MeshBasicNodeMaterial({
-		side: DoubleSide,
-		transparent: true
-	});
-	const flowedPosition = positionWorld.xz.sub(direction.mul(speed).mul(time));
-	const ripplePosition = flowedPosition.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(flowedPosition.mul(FOAM_SCALE), time.mul(.3)), 2).mul(.5).add(.5);
-	const gathered = shore.max(bendFoam);
-	const foam = smoothstep(.55, .6, foamNoise.add(gathered.mul(.5))).mul(gathered);
-	waterMaterial.colorNode = mix(reflected, foamColor, foam).add(glints);
-	return waterMaterial;
-};
-//#endregion
 //#region src/nodes/createWaterfallMaterial.ts
 const STREAK_DENSITY = 14;
 const STREAK_LENGTH = .25;
@@ -4972,6 +5173,38 @@ const createWaterfallMaterial = ({ foamColor }) => {
 	return waterfallMaterial;
 };
 //#endregion
+//#region src/vegetation/constants.ts
+const IMPOSTOR_RESOLUTION = 256;
+const IMPOSTOR_SWITCH_HEIGHTS = 10;
+const IMPOSTOR_CROSSFADE_SHARE = .1;
+const FLOWER_BEND_PER_WIND = .12;
+const FLOWER_MATRIX_ATTRIBUTE_NAMES = [
+	"flowerMatrix0",
+	"flowerMatrix1",
+	"flowerMatrix2",
+	"flowerMatrix3"
+];
+const FLOWER_COLOR_ATTRIBUTE_NAME = "flowerColor";
+const GRASS_TRAIL_EXTENT = 16;
+const GRASS_TRAIL_TEXELS = 64;
+const GRASS_TRAIL_TEXEL_SIZE = 16 / 64;
+const GRASS_TRAIL_STAMP_RADIUS = .6;
+const GRASS_TRAIL_FADE_SECONDS = 1.5;
+const GRASS_TRAIL_BEND_SHARE = .9;
+const GRASS_TRAIL_FADE_START_SHARE = .8;
+const GRASS_TRAIL_FADE_END_SHARE = .95;
+const GRASS_BEND_PER_WIND = .9;
+const GRASS_DIP_PER_BEND = .3;
+//#endregion
+//#region src/nodes/sampleGrassTrail.ts
+const sampleGrassTrail = (grassTrail, ground) => {
+	const encoded = texture(grassTrail.texture, fract(ground.div(16))).level(float(0));
+	const offset = ground.sub(grassTrail.center).abs();
+	const reachShare = max(offset.x, offset.y).div(8);
+	const reachFade = float(1).sub(smoothstep(GRASS_TRAIL_FADE_START_SHARE, GRASS_TRAIL_FADE_END_SHARE, reachShare));
+	return encoded.xy.mul(2).sub(1).mul(reachFade);
+};
+//#endregion
 //#region src/nodes/setObjectFade.ts
 const setObjectFade = (object, fade) => {
 	object.userData[OBJECT_FADE_KEY] = fade;
@@ -5360,6 +5593,7 @@ const createTileStreamer = ({ disposeTile, maxCachedCount, maxPendingCount, requ
 		return cachedTile !== void 0 && !cachedTile.isStale || givenUpKeySet.has(key);
 	};
 	return {
+		checkIsSettled,
 		dispose: () => {
 			isDisposed = true;
 			for (const { tile } of cachedTileMap.values()) disposeTile(tile);
@@ -5380,8 +5614,6 @@ const createTileStreamer = ({ disposeTile, maxCachedCount, maxPendingCount, requ
 		},
 		get: (key) => cachedTileMap.get(key)?.tile,
 		has: (key) => cachedTileMap.has(key),
-		isSettled: checkIsSettled,
-		pendingKeys: () => [...pendingWantedFrameMap.keys()],
 		receive: (key, tile) => {
 			const lastWantedFrame = pendingWantedFrameMap.get(key) ?? frame;
 			pendingWantedFrameMap.delete(key);
@@ -5503,11 +5735,9 @@ const createTerrainMaterial = (terrainOptions, eye, toonMaterialOptions, waterUn
 		normalLocal.assign(mix(normalLocal, attribute("coarseNormal", "vec3"), morphAmount).normalize());
 		return mix(positionGeometry, coarsePosition.xyz, morphAmount);
 	})();
-	terrainMaterial.colorNode = vec4(varying(mix(attribute("color", "vec3"), attribute("coarseColor", "vec3"), morphAmount)).mul(createWetDarkeningNode(toonMaterialOptions.lightUniforms)), 1);
-	if (waterUniforms) {
-		const { lightUniforms } = toonMaterialOptions;
-		terrainMaterial.emissiveNode = createRimNode(lightUniforms).add(createWetSheenNode(lightUniforms)).add(createCausticsNode(lightUniforms, waterUniforms));
-	}
+	const { lightUniforms } = toonMaterialOptions;
+	terrainMaterial.colorNode = vec4(varying(mix(attribute("color", "vec3"), attribute("coarseColor", "vec3"), morphAmount)).mul(createWetDarkeningNode(lightUniforms)), 1);
+	if (waterUniforms) terrainMaterial.emissiveNode = createRimNode(lightUniforms).add(createWetSheenNode(lightUniforms)).add(createCausticsNode(lightUniforms, waterUniforms));
 	return terrainMaterial;
 };
 //#endregion
@@ -5835,12 +6065,12 @@ const bakeImpostor = (renderer, parts, resolution) => {
 	camera.position.z = radius + 1;
 	camera.updateMatrixWorld();
 	const bakeScene = new Scene();
-	const bakeMeshes = parts.map(({ color: partColor, geometry, opacityNode }) => {
+	const bakeMeshes = parts.map(({ color: partColor, geometry, maskNode }) => {
 		const albedoMaterial = new MeshBasicNodeMaterial({ side: DoubleSide });
 		const normalMaterial = new MeshBasicNodeMaterial({ side: DoubleSide });
 		albedoMaterial.outputNode = vec4(color(new Color(partColor)), 1);
-		normalMaterial.outputNode = vec4(normalView.mul(.5).add(.5), 1);
-		if (opacityNode) albedoMaterial.maskNode = normalMaterial.maskNode = opacityNode.greaterThan(.5);
+		normalMaterial.outputNode = vec4(normalViewGeometry.mul(.5).add(.5), 1);
+		if (maskNode) albedoMaterial.maskNode = normalMaterial.maskNode = maskNode;
 		const mesh = new Mesh(geometry, albedoMaterial);
 		bakeScene.add(mesh);
 		return {
@@ -5909,18 +6139,21 @@ const computeGrassBlade = (segmentCount) => {
 	};
 };
 //#endregion
-//#region src/vegetation/constants.ts
-const IMPOSTOR_RESOLUTION = 256;
-const IMPOSTOR_SWITCH_HEIGHTS = 10;
-const IMPOSTOR_CROSSFADE_SHARE = .1;
-const FLOWER_BEND_PER_WIND = .12;
-const FLOWER_MATRIX_ATTRIBUTE_NAMES = [
-	"flowerMatrix0",
-	"flowerMatrix1",
-	"flowerMatrix2",
-	"flowerMatrix3"
-];
-const FLOWER_COLOR_ATTRIBUTE_NAME = "flowerColor";
+//#region src/vegetation/computeGrassTrailCell.ts
+const computeGrassTrailCell = (coordinate, texelSize) => Math.floor(coordinate / texelSize);
+//#endregion
+//#region src/vegetation/computeGrassTrailTexel.ts
+const computeGrassTrailTexel = (cell) => (cell % 64 + 64) % 64;
+//#endregion
+//#region src/vegetation/computeGrassTrailTexelIndex.ts
+const computeGrassTrailTexelIndex = (cellX, cellZ) => computeGrassTrailTexel(cellZ) * 64 + computeGrassTrailTexel(cellX);
+//#endregion
+//#region src/vegetation/computeImpostorFade.ts
+const computeImpostorFade = (distance, impostorHeight) => {
+	const switchDistance = impostorHeight * 10;
+	const halfBand = switchDistance * IMPOSTOR_CROSSFADE_SHARE / 2;
+	return MathUtils.smoothstep(distance, switchDistance - halfBand, switchDistance + halfBand);
+};
 //#endregion
 //#region src/vegetation/createFlowerGeometry.ts
 const createFlowerGeometry = () => {
@@ -6035,6 +6268,70 @@ const createFlowerTileGeometry = (matrices, colors) => {
 	return geometry;
 };
 //#endregion
+//#region src/vegetation/createGrassBladePoint.ts
+const createGrassBladePoint = ({ bladeHeight, captured, grassTrail, ground, offset, size, up, windUniforms }) => {
+	const bend = up.mul(up);
+	const wind = createWindNode(windUniforms, ground).mul(GRASS_BEND_PER_WIND).mul(bend);
+	const trailBend = sampleGrassTrail(grassTrail, ground).mul(GRASS_TRAIL_BEND_SHARE).mul(bend);
+	const trailOffset = trailBend.mul(bladeHeight).mul(size);
+	const height = up.mul(bladeHeight).mul(size).sub(wind.length().mul(bladeHeight).mul(size).mul(GRASS_DIP_PER_BEND)).sub(trailBend.length().mul(bladeHeight).mul(size).mul(GRASS_DIP_PER_BEND));
+	return vec3(ground.x.add(offset.x).add(wind.x.mul(bladeHeight).mul(size)).add(trailOffset.x), captured.a.add(height), ground.y.add(offset.y).add(wind.y.mul(bladeHeight).mul(size)).add(trailOffset.y));
+};
+//#endregion
+//#region src/vegetation/createGrassCell.ts
+const MIN_GREENNESS = .05;
+const createGrassCell = ({ cameraGround, density, groundCapture, index, ring, waterUniforms }) => {
+	const { cellsPerSide, fadeEnd, fadeStart, innerRadius, scale, spacing } = ring;
+	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 { captured, isInsideCapture } = sampleGroundCapture(groundCapture, ground);
+	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);
+	return {
+		angle: hash(seed.add(4)).mul(Math.PI * 2),
+		captured,
+		ground,
+		size
+	};
+};
+//#endregion
+//#region src/vegetation/createGrassCulling.ts
+const createGrassCulling = ({ bladeHeight, cameraGround, clipFromModel, density, grassTrail, groundCapture, ring, segmentCount, waterUniforms, windUniforms }) => createInstanceCulling({
+	count: ring.cellsPerSide * ring.cellsPerSide,
+	indexCount: computeGrassBlade(segmentCount).indices.length,
+	isVisible: (index) => {
+		const { captured, ground, size } = createGrassCell({
+			cameraGround,
+			density,
+			groundCapture,
+			index,
+			ring,
+			waterUniforms
+		});
+		const isInView = (up) => createFrustumVisibility(clipFromModel, createGrassBladePoint({
+			bladeHeight,
+			captured,
+			grassTrail,
+			ground,
+			offset: vec2(0),
+			size,
+			up,
+			windUniforms
+		}));
+		const root = createFrustumVisibility(clipFromModel, vec3(ground.x, captured.a, ground.y));
+		const tip = isInView(float(1));
+		const top = createFrustumVisibility(clipFromModel, vec3(ground.x, captured.a.add(size.mul(bladeHeight)), ground.y));
+		return step(CULLING_MIN_SIZE, size).mul(max(max(root, top), tip));
+	}
+});
+//#endregion
 //#region src/vegetation/createGrassGeometry.ts
 const createGrassGeometry = (segmentCount, bladeCount) => {
 	const { indices, positions } = computeGrassBlade(segmentCount);
@@ -6047,9 +6344,7 @@ const createGrassGeometry = (segmentCount, bladeCount) => {
 };
 //#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 createGrassMaterial = ({ bladeHeight, bladeWidth, cameraGround, cellIndex, density, grassTrail, groundCapture, lightUniforms, rampTexture, ring, waterUniforms, windUniforms }) => {
 	const grassMaterial = createToonMaterial({
 		isOutlined: false,
 		lightUniforms,
@@ -6057,32 +6352,50 @@ const createGrassMaterial = ({ bladeHeight, bladeWidth, cameraGround, density, g
 	});
 	grassMaterial.emissiveNode = createWetSheenNode(lightUniforms);
 	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 { captured, isInsideCapture } = sampleGroundCapture(groundCapture, ground);
-	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 { angle, captured, ground, size } = createGrassCell({
+		cameraGround,
+		density,
+		groundCapture,
+		index: cellIndex,
+		ring,
+		waterUniforms
+	});
 	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.positionNode = createGrassBladePoint({
+		bladeHeight,
+		captured,
+		grassTrail,
+		ground,
+		offset: vec2(cos(angle), sin(angle)).mul(positionGeometry.x.mul(bladeWidth).mul(size)),
+		size,
+		up,
+		windUniforms
+	});
 	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).mul(createWetDarkeningNode(lightUniforms));
 	return grassMaterial;
 };
 //#endregion
+//#region src/vegetation/createGrassTrail.ts
+const createGrassTrail = () => {
+	const texelCount = 4096;
+	const data = new Uint8Array(texelCount * 4);
+	for (let index = 0; index < data.length; index++) data[index] = index % 4 === 3 ? 255 : 128;
+	const texture = new DataTexture(data, 64, 64, RGBAFormat);
+	texture.magFilter = LinearFilter;
+	texture.minFilter = LinearFilter;
+	texture.wrapS = RepeatWrapping;
+	texture.wrapT = RepeatWrapping;
+	return {
+		bends: new Float32Array(texelCount * 2),
+		cells: new Float64Array(texelCount * 2).fill(NaN),
+		center: uniform(new Vector2()),
+		data,
+		texture
+	};
+};
+//#endregion
 //#region src/vegetation/createGroundCapture.ts
 const createGroundCapture = (size, resolution) => {
 	const renderTarget = new RenderTarget(resolution, resolution, { type: HalfFloatType });
@@ -6103,6 +6416,52 @@ const createGroundCapture = (size, resolution) => {
 	};
 };
 //#endregion
+//#region src/vegetation/createPlantCulling.ts
+const createPlantCulling = ({ attribute, bounds: { bottom, halfWidth, height }, clipFromModel, drawDistance, eye, indexCount }) => {
+	const middle = bottom + height / 2;
+	const boxPoints = [
+		[
+			0,
+			bottom,
+			0
+		],
+		[
+			0,
+			bottom + height,
+			0
+		],
+		[
+			halfWidth,
+			middle,
+			0
+		],
+		[
+			-halfWidth,
+			middle,
+			0
+		],
+		[
+			0,
+			middle,
+			halfWidth
+		],
+		[
+			0,
+			middle,
+			-halfWidth
+		]
+	];
+	return createInstanceCulling({
+		count: attribute.count / 4,
+		indexCount,
+		isVisible: (instance) => {
+			const instanceMatrix = createInstanceMatrixNode(attribute, instance);
+			const isNear = step(distance(instanceMatrix.mul(vec4(0, 0, 0, 1)).xyz, eye), drawDistance);
+			return boxPoints.map(([x, y, z]) => createFrustumVisibility(clipFromModel, instanceMatrix.mul(vec4(x, y, z, 1)).xyz)).reduce((visible, point) => max(visible, point)).mul(isNear);
+		}
+	});
+};
+//#endregion
 //#region src/vegetation/renderGroundCapture.ts
 const CLEAR_COLOR = new Color();
 const previousClearColor = new Color();
@@ -6129,9 +6488,44 @@ const renderGroundCapture = (renderer, scene, { camera, center, material, render
 	scene.backgroundNode = previousBackgroundNode;
 };
 //#endregion
-//#region src/water/constants.ts
-const RIVER_BEND_FOAM_ATTRIBUTE = "bendFoam";
-const BEND_FOAM_FULL_RADIUS_WIDTHS = 2;
+//#region src/vegetation/stepGrassTrail.ts
+const encodeBend = (bend) => Math.round((Math.min(Math.max(bend, -1), 1) * .5 + .5) * 255);
+const stepGrassTrail = (trail, position, velocity, delta) => {
+	const { bends, cells, data, texture } = trail;
+	const decay = Math.exp(-delta / GRASS_TRAIL_FADE_SECONDS);
+	for (let index = 0; index < bends.length; index++) bends[index] = (bends[index] ?? 0) * decay;
+	const centreCellX = computeGrassTrailCell(position.x, GRASS_TRAIL_TEXEL_SIZE);
+	const centreCellZ = computeGrassTrailCell(position.y, GRASS_TRAIL_TEXEL_SIZE);
+	trail.center.value.set((centreCellX + .5) * GRASS_TRAIL_TEXEL_SIZE, (centreCellZ + .5) * GRASS_TRAIL_TEXEL_SIZE);
+	const firstCellOffset = -32;
+	for (let row = 0; row < 64; row++) for (let column = 0; column < 64; column++) {
+		const cellX = centreCellX + firstCellOffset + column;
+		const cellZ = centreCellZ + firstCellOffset + row;
+		const texelIndex = computeGrassTrailTexelIndex(cellX, cellZ);
+		if (cells[texelIndex * 2] === cellX && cells[texelIndex * 2 + 1] === cellZ) continue;
+		cells[texelIndex * 2] = cellX;
+		cells[texelIndex * 2 + 1] = cellZ;
+		bends[texelIndex * 2] = 0;
+		bends[texelIndex * 2 + 1] = 0;
+	}
+	const speed = Math.hypot(velocity.x, velocity.y);
+	if (speed > 0) {
+		const stampCellRadius = Math.ceil(GRASS_TRAIL_STAMP_RADIUS / GRASS_TRAIL_TEXEL_SIZE);
+		for (let offsetZ = -3; offsetZ <= stampCellRadius; offsetZ++) for (let offsetX = -3; offsetX <= stampCellRadius; offsetX++) {
+			const cellX = centreCellX + offsetX;
+			const cellZ = centreCellZ + offsetZ;
+			if (Math.hypot((cellX + .5) * .25 - position.x, (cellZ + .5) * .25 - position.y) > .6) continue;
+			const texelIndex = computeGrassTrailTexelIndex(cellX, cellZ);
+			bends[texelIndex * 2] = velocity.x / speed;
+			bends[texelIndex * 2 + 1] = velocity.y / speed;
+		}
+	}
+	for (let index = 0; index < bends.length / 2; index++) {
+		data[index * 4] = encodeBend(bends[index * 2] ?? 0);
+		data[index * 4 + 1] = encodeBend(bends[index * 2 + 1] ?? 0);
+	}
+	texture.needsUpdate = true;
+};
 //#endregion
 //#region src/water/createRiverGeometry.ts
 const createRiverGeometry = (course) => {
@@ -6194,12 +6588,6 @@ const createUnderwaterFogState = () => ({
 	underwaterDensity: 0
 });
 //#endregion
-//#region src/water/createWaterFlowUniforms.ts
-const createWaterFlowUniforms = () => ({
-	direction: uniform(new Vector2()),
-	speed: uniform(0)
-});
-//#endregion
 //#region src/water/createWaterUniforms.ts
 const createWaterUniforms = () => ({
 	causticStrength: uniform(0),
@@ -6314,4 +6702,4 @@ const computeOutlineDistance = (outline, x, z) => {
 	return isInside ? 0 : Math.sqrt(nearestSquared);
 };
 //#endregion
-export { A4_FREQUENCY, A4_PITCH, AIR_LOCOMOTION_STATES, AnchoredCascadeShadowNode, AntialiasingMode, BEND_FOAM_FULL_RADIUS_WIDTHS, CLIMB_JUMP_STAMINA_COST, CLIMB_LOCOMOTION_STATES, CLIMB_REGRAB_SECONDS, CLIMB_STAMINA_PER_SECOND, CLIMB_START_STAMINA, COOL_RAMP_ROW_BASE, CharacterMaterialKind, DASH_STAMINA_COST, DEFAULT_LIGHT_AREA, DEFAULT_RAMP_WIDTH, DEFAULT_SKY_GRADIENT, DEFAULT_SKY_SHAPE, DESATURATION_WEIGHTS, EMISSION_ALPHA_FLOOR, FIELD_SELECTOR, FLAT_LIGHT_MAP, FLOWER_BEND_PER_WIND, FLOWER_COLOR_ATTRIBUTE_NAME, FLOWER_MATRIX_ATTRIBUTE_NAMES, FOCUS_KEY_CODES, FOLLOW_CAMERA_ARM_STEP, FOLLOW_CAMERA_CLEARANCE, FOLLOW_CAMERA_DEFAULT_SETTINGS, FOLLOW_CAMERA_DISTANCE_PER_ZOOM_STEP, FOLLOW_CAMERA_EASE_OUT_SPEED, FOLLOW_CAMERA_FOV, FOLLOW_CAMERA_MAX_DISTANCE, FOLLOW_CAMERA_MAX_PITCH, FOLLOW_CAMERA_MIN_DISTANCE, FOLLOW_CAMERA_MIN_PITCH, FOLLOW_CAMERA_NEUTRAL_SENSITIVITY, FOLLOW_CAMERA_PIVOT_SHARE, FREE_CAMERA_BASE_SPEED, FREE_CAMERA_CLEARANCE, FREE_CAMERA_MAX_PITCH, FREE_CAMERA_SPEED_PER_HEIGHT, GAMEPAD_BUTTONS, GAMEPAD_LOOK_RADIANS_PER_SECOND, GAMEPAD_STICK_DEADZONE, GAME_MINUTES_PER_SECOND, GAUSSIAN_REACH_WIDTHS, GENSHIN_TONE_CONTRAST, GENSHIN_TONE_EXPOSURE, GENSHIN_TONE_MAPPING, GLIDE_STAMINA_PER_SECOND, GROUND_CONTACT_DISTANCE, GROUND_LOCOMOTION_STATES, GROUND_NORMAL_SPAN, GROUND_PRESS_SPEED, GamepadButton, GroundLayer, GroundLayers, HALF_LAMBERT_OFFSET, HALF_LAMBERT_SCALE, IMPOSTOR_CROSSFADE_SHARE, IMPOSTOR_RESOLUTION, IMPOSTOR_SWITCH_HEIGHTS, InputAction, InputActionBindingMap, InputActions, KEY_CODE_BACKWARD, KEY_CODE_DOWN, KEY_CODE_FORWARD, KEY_CODE_LEFT, KEY_CODE_RIGHT, KEY_CODE_UP, LEAF_SHAPE_KEPT_SHARE, LEAF_SHAPE_WIDTH, LEAST_DIVISOR, LIGHTNING_BOLT_BRIGHTNESS, LIGHTNING_BOLT_COLOR, LIGHTNING_BOLT_OPTIONS, LIGHTNING_FLASH_AMBIENT, LIGHTNING_FLASH_COLOR, LIGHTNING_FLASH_DECAY_SECONDS, LIGHTNING_FLASH_END, LIGHTNING_FLASH_PULSES, LIGHTNING_FLASH_SKY, LIGHTNING_MAX_DISTANCE, LIGHTNING_MIN_DISTANCE, LocomotionState, MAXIMUM_FACE_THRESHOLD, MAXIMUM_WINDOW_FLOOR, MAX_BYTE, MAX_STEPS_PER_FRAME, MAX_TILE_ATTEMPTS, MIDI_VELOCITY_MAX, MINIMUM_FACE_THRESHOLD, MINIMUM_OUTLINE_KNOT_SPAN, MINIMUM_RAMP_WIDTH_VERTEX, MINUTES_PER_DAY, MMD_BONE_NAME_MAP, MOUSE_BUTTONS, MOUSE_LOOK_MAX_PIXELS_PER_EVENT, MOUSE_LOOK_RADIANS_PER_PIXEL, MUSIC_EXPRESSION_WINDOW_SECONDS, MUSIC_LOOKAHEAD_SECONDS, MUSIC_NOISE_BAND_CENTRES, MUSIC_NOISE_LENGTH, MUSIC_SCHEDULE_INTERVAL_MS, MmdBoneName, MouseButton, NEUTRAL_LIGHT_MAP_GREEN, OBJECT_FADE_KEY, OBJECT_SURFACE_KEY, OUTLINE_MAIN_TEXTURE_SHARE, OUTLINE_PROJECTION_SCALE, OUTLINE_WIDTH_SCALE, ObjectSurface, PMX_UNIT_METRES, POSE_AIR_STANCES, POSE_ARM_BEND_RADIANS, POSE_ARM_CHAINS, POSE_ARM_LOWER_RADIANS, POSE_BREATH_SECONDS, POSE_CHEST_BREATH_RADIANS, POSE_CROSSFADE_SECONDS, POSE_GAITS, POSE_SHOULDER_BREATH_RADIANS, PRECIPITATION_COUNT, PRECIPITATION_SETTINGS_MAP, PRECIPITATION_SWAY_SPEED, PRECIPITATION_VOLUME_HEIGHT, PRECIPITATION_VOLUME_SIZE, PmxBoneFlag, PmxJointKind, PmxMaterialFlag, PmxMorphKind, PmxPhysicsMode, PmxReader, PmxRigidBodyShape, PmxSphereMode, PmxTextEncoding, PmxWeightDeform, PrecipitationKind, QualityTier, QualityTierSettingsMap, RAMP_ROW_BASE, RAMP_ROW_STEP, REGION_FLOORS, RELEASE_TIME_CONSTANTS, RIVER_BEND_FOAM_ATTRIBUTE, RampLayout, RoofKind, SHARED_TOON_RAMP_SHADES, SOUND_EFFECT_BAND_EDGES, SOUND_EFFECT_FRAME_LENGTH, SPECTRAL_ANGULAR_BIN_COUNT, SPECTRAL_RADIAL_BIN_COUNT, SPHERE_CAST_STRIDE_SHARE, SPLASH_COUNT, SPLASH_LIFETIME, SPLASH_LIFT, SPLASH_OPACITY, SPLASH_RADIUS, SPLASH_SIZE, SPRINT_STAMINA_PER_SECOND, STAMINA_MAX, STAMINA_REFILL_DELAY_SECONDS, STAMINA_REFILL_PER_SECOND, STAMINA_REFILL_STATES, STEEP_SLIDE_SPEED, STONE_DARKENING_TOP, STONE_HARMONIC_COUNT, STONE_HEIGHT_FALLOFF, STONE_MASK_OUTPUT, STONE_RAMP_KNOT_COUNT, STONE_SHADOW_EXPONENT, SUN_REDRAW_COSINE, SURFACE_DETAIL_BAND_SIGMAS, SURFACE_DETAIL_RENDER_GAIN, SURFACE_OCTAVE_TEXEL_FREQUENCIES, SWIM_DASH_STAMINA_COST, SWIM_DASH_STAMINA_PER_SECOND, SWIM_STROKE_SECONDS, SWIM_STROKE_STAMINA_COST, SharedToonOutlinePassNode, StoneLightingModel, StoneNodeMaterial, TERRAIN_CELL_SIZE, TERRAIN_HEIGHT_PADDING, TERRAIN_LAYER, TERRAIN_RING_INITIAL_TILE_COUNT, TILE_INDEX_OFFSET, TILE_INDEX_SPAN, TONE_CONTRAST_OFFSET, TONE_CURVE_FLOOR, TONE_CURVE_LIFT, TOON_HIGH, TOON_LOW, TerrainFeatureKind, TerrainFeatureKindBlendMap, ToonNodeMaterial, WALK_MOVE_MAGNITUDE, WALL_PRESS_SPEED, WALL_PROBE_DISTANCE, WATER_LOCOMOTION_STATES, WEATHER_SETTINGS_MAP, WEATHER_TRANSITION_SECONDS, WET_DARKENING, WET_SHEEN_POWER, WET_SHEEN_STRENGTH, WeatherKind, addSmoothLoop, advanceGameClock, advanceStridePhase, applyLightningFlash, applyPrecipitationSettings, applySkyState, applyStoneLight, applyWeatherState, attachInspector, bakeImpostor, blendGridNodes, blendWeatherState, checkSunTurned, checkTerrainBoundsOverlap, checkTerrainDrawsChanged, checkTerrainTileCasts, checkTransparentTexels, collectMusicNotes, collectMusicSegments, computeCharacterPose, computeGradeLut, computeGrassBlade, computeLeafCards, computeLightningBolt, computeLightningFlash, computeLocomotionState, computeNoiseSamples, computeOriginShift, computeOutlineDistance, computeRampValues, computeScatterPoints, computeSoundEffectSamples, computeStatueSurface, computeStoneDarkening, computeStoneHarmonics, computeStoneRampCoordinate, computeSunDirection, computeSurfaceOctaves, computeTerrainIndices, computeTerrainTile, computeTreeTubes, computeWhiteBalance, createBoxesGeometry, createBuildingGeometry, createCausticsNode, createCharacterController, createCharacterMaterial, createCharacterPoseRotations, createCharacterPoser, createCharacterShadingInputs, createCharacterShadingNode, createCloudAtlasTexture, createCloudBandSprite, createCloudLayerNode, createCloudLayerProfileTexture, createCloudLayerTexture, createCloudLayerTextures, createCloudLayerUniforms, createDitherFadeNode, createFaceDraw, createFaceShadeNode, createFixedStepLoop, createFlowerGeometry, createFlowerMaterial, createFlowerTileGeometry, createFogUniforms, createFollowCamera, createFreeCamera, createGameOutlineMaterial, createGaussianHillsHeight, createGenshinRenderer, createGodraysLight, createGradeLutTexture, createGrassGeometry, createGrassMaterial, createGroundCapture, createGroundLayerWeights, createGroundPaintColor, createGroundQuery, createHeightFogNode, createImpostorMaterial, createIndexedGeometry, createInput, createInstancedMesh, createInstrumentWave, createLandmarkCollider, createLatheStackGeometry, createLeafMaterial, createLeafShapeNode, createLightUniforms, createLightningBoltGeometry, createLightningBoltMaterial, createMusicPlayer, createNoiseBuffer, createObjectFadeNode, createObjectSurfaceNode, createOcclusionNode, createOutlineColorNode, createOutlineMaterial, createOutlineScaleNode, createPavingGeometry, createPavingStoneGeometry, createPmxGeometry, createPmxMesh, createPmxSkeleton, createPmxTexture, createPmxToonTexture, createPostPipeline, createPostUniforms, createPrecipitationGeometry, createPrecipitationMaterial, createPrecipitationUniforms, createRampColumnNode, createRampTexture, createRampUvNode, createResidualHeight, createRimNode, createRiverGeometry, createSeededRandom, createShadingRegionNode, createSightNode, createSightUniforms, createSimplexNoise, createSkyColorNode, createSkyGradientTexture, createSkyNode, createSkyState, createSkyUniforms, createSoundEffectBuffer, createSplashMaterial, createStamina, createStatueGeometries, createStoneGlowNode, createStoneLightUniforms, createStoneMaterial, createSunLight, createSunVisibilityNode, createSurfaceDetailNode, createTerrainFeaturesBlend, createTerrainFeaturesHeight, createTerrainMaterial, createTerrainRing, createTerrainSelection, createTerrainShapeHeight, createTerrainTileGeometry, createTileStreamer, createToneNode, createToonMaterial, createToonThresholdNode, createTreeGeometry, createUnderwaterFogState, createWaterFlowUniforms, createWaterMaterial, createWaterUniforms, createWaterfallGeometry, createWaterfallMaterial, createWetDarkeningNode, createWetSheenNode, createWindNode, createWindUniforms, fileByCell, findSkinnedMesh, getCliffBlend, getCloudAtlasColumns, getCloudSunColors, getDesaturatedColour, getGameOutlineOffset, getGaussianHillBlend, getMusicRecordingGain, getMusicRecordingRate, getOutlineDepth, getOutlineScale, getParentTerrainTileKey, getPlateauBlend, getRampColumn, getRampRow, getRampWidth, getRidgeBlend, getScreenDirection, getSegmentBounds, getShadingRegion, getSharedToonRamp, getSoundEffectBandBins, getSpectralBin, getTerrainFeatureBounds, getTerrainMorphStart, getTerrainOverlayBounds, getTerrainShapeLevel, getTerrainTileBounds, getTerrainTileColumn, getTerrainTileKey, getTerrainTileLevel, getTerrainTileRow, getToneColour, getToonThreshold, measureSegment, mergeGeometryParts, orderByViewDepth, parsePmx, parsePmxBones, parsePmxJoints, parsePmxMaterials, parsePmxMorphs, parsePmxRigidBodies, parsePmxVertices, placeCloudBand, renderGroundCapture, renderMusicSegment, resolveTerrainDraws, sampleGroundCapture, sampleGroundLayerField, sampleSkyState, sampleTerrainResidualFade, sampleTreeNormalField, scheduleMusicExpression, scheduleMusicNote, scheduleMusicRecording, selectMusicSample, selectRegionNode, selectTerrainTiles, setObjectFade, setObjectSurface, synthesizeCloudLayerTextures, synthesizeSpectralNoise, toSceneColor, toneMapGenshin, toneMapGenshinNode, transformFourier, transformFourierGrid, updateFaceDraw, updateUnderwaterFog, writeCloudLayerTexture, writeQuadIndices, writeTerrainRingIndices, writeTerrainRingTile };
+export { A4_FREQUENCY, A4_PITCH, AIR_LOCOMOTION_STATES, AnchoredCascadeShadowNode, AntialiasingMode, BEND_FOAM_FULL_RADIUS_WIDTHS, CLIMB_JUMP_STAMINA_COST, CLIMB_LOCOMOTION_STATES, CLIMB_REGRAB_SECONDS, CLIMB_STAMINA_PER_SECOND, CLIMB_START_STAMINA, COOL_RAMP_ROW_BASE, CULLING_FRUSTUM_MARGIN, CULLING_INDEX_COUNT_INDEX, CULLING_INDIRECT_ARGUMENT_COUNT, CULLING_INSTANCE_COUNT_INDEX, CULLING_MATRIX_COLUMN_COUNT, CULLING_MATRIX_ELEMENT_COUNT, CULLING_MIN_SIZE, CharacterMaterialKind, DASH_STAMINA_COST, DEFAULT_LIGHT_AREA, DEFAULT_RAMP_WIDTH, DEFAULT_SKY_GRADIENT, DEFAULT_SKY_SHAPE, DESATURATION_WEIGHTS, EMISSION_ALPHA_FLOOR, FIELD_SELECTOR, FLAT_LIGHT_MAP, FLOWER_BEND_PER_WIND, FLOWER_COLOR_ATTRIBUTE_NAME, FLOWER_MATRIX_ATTRIBUTE_NAMES, FOCUS_KEY_CODES, FOLLOW_CAMERA_ARM_STEP, FOLLOW_CAMERA_CLEARANCE, FOLLOW_CAMERA_DEFAULT_SETTINGS, FOLLOW_CAMERA_DISTANCE_PER_ZOOM_STEP, FOLLOW_CAMERA_EASE_OUT_SPEED, FOLLOW_CAMERA_FOV, FOLLOW_CAMERA_MAX_DISTANCE, FOLLOW_CAMERA_MAX_PITCH, FOLLOW_CAMERA_MIN_DISTANCE, FOLLOW_CAMERA_MIN_PITCH, FOLLOW_CAMERA_NEUTRAL_SENSITIVITY, FOLLOW_CAMERA_PIVOT_SHARE, FOLLOW_CAMERA_SLOPE_PITCH_SPEED, FREE_CAMERA_BASE_SPEED, FREE_CAMERA_CLEARANCE, FREE_CAMERA_MAX_PITCH, FREE_CAMERA_SPEED_PER_HEIGHT, GAMEPAD_BUTTONS, GAMEPAD_LOOK_RADIANS_PER_SECOND, GAMEPAD_STICK_DEADZONE, GAME_MINUTES_PER_SECOND, GAUSSIAN_REACH_WIDTHS, GENSHIN_TONE_CONTRAST, GENSHIN_TONE_EXPOSURE, GENSHIN_TONE_MAPPING, GLIDE_STAMINA_PER_SECOND, GRASS_BEND_PER_WIND, GRASS_DIP_PER_BEND, GRASS_TRAIL_BEND_SHARE, GRASS_TRAIL_EXTENT, GRASS_TRAIL_FADE_END_SHARE, GRASS_TRAIL_FADE_SECONDS, GRASS_TRAIL_FADE_START_SHARE, GRASS_TRAIL_STAMP_RADIUS, GRASS_TRAIL_TEXELS, GRASS_TRAIL_TEXEL_SIZE, GROUND_CONTACT_DISTANCE, GROUND_LOCOMOTION_STATES, GROUND_NORMAL_SPAN, GROUND_PRESS_SPEED, GamepadButton, GroundLayer, GroundLayers, HALF_LAMBERT_OFFSET, HALF_LAMBERT_SCALE, IMPOSTOR_CROSSFADE_SHARE, IMPOSTOR_RESOLUTION, IMPOSTOR_SWITCH_HEIGHTS, InputAction, InputActionBindingMap, InputActions, KEY_CODE_BACKWARD, KEY_CODE_DOWN, KEY_CODE_FORWARD, KEY_CODE_LEFT, KEY_CODE_RIGHT, KEY_CODE_UP, LEAF_SHAPE_KEPT_SHARE, LEAF_SHAPE_WIDTH, LEAST_DIVISOR, LIGHTNING_BOLT_BRIGHTNESS, LIGHTNING_BOLT_COLOR, LIGHTNING_BOLT_OPTIONS, LIGHTNING_FLASH_AMBIENT, LIGHTNING_FLASH_COLOR, LIGHTNING_FLASH_DECAY_SECONDS, LIGHTNING_FLASH_END, LIGHTNING_FLASH_PULSES, LIGHTNING_FLASH_SKY, LIGHTNING_MAX_DISTANCE, LIGHTNING_MIN_DISTANCE, LocomotionState, MAXIMUM_FACE_THRESHOLD, MAXIMUM_WINDOW_FLOOR, MAX_BYTE, MAX_STEPS_PER_FRAME, MAX_TILE_ATTEMPTS, MIDI_VELOCITY_MAX, MINIMUM_FACE_THRESHOLD, MINIMUM_OUTLINE_KNOT_SPAN, MINIMUM_RAMP_WIDTH_VERTEX, MINUTES_PER_DAY, MMD_BONE_NAME_MAP, MOUSE_BUTTONS, MOUSE_LOOK_MAX_PIXELS_PER_EVENT, MOUSE_LOOK_RADIANS_PER_PIXEL, MUSIC_EXPRESSION_WINDOW_SECONDS, MUSIC_LOOKAHEAD_SECONDS, MUSIC_NOISE_BAND_CENTRES, MUSIC_NOISE_LENGTH, MUSIC_SCHEDULE_INTERVAL_MS, MmdBoneName, MouseButton, NEUTRAL_LIGHT_MAP_GREEN, OBJECT_FADE_KEY, OBJECT_SURFACE_KEY, OUTLINE_MAIN_TEXTURE_SHARE, OUTLINE_PROJECTION_SCALE, OUTLINE_WIDTH_SCALE, ObjectSurface, POSE_AIR_STANCES, POSE_ARM_BEND_RADIANS, POSE_ARM_CHAINS, POSE_ARM_LOWER_RADIANS, POSE_BREATH_SECONDS, POSE_CHEST_BREATH_RADIANS, POSE_CROSSFADE_SECONDS, POSE_GAITS, POSE_SHOULDER_BREATH_RADIANS, PRECIPITATION_COUNT, PRECIPITATION_SETTINGS_MAP, PRECIPITATION_SWAY_SPEED, PRECIPITATION_VOLUME_HEIGHT, PRECIPITATION_VOLUME_SIZE, PmxBoneFlag, PmxJointKind, PmxMaterialFlag, PmxMorphKind, PmxPhysicsMode, PmxReader, PmxRigidBodyShape, PmxSphereMode, PmxTextEncoding, PmxWeightDeform, PrecipitationKind, QualityTier, QualityTierSettingsMap, RAMP_ROW_BASE, RAMP_ROW_STEP, REGION_FLOORS, RELEASE_TIME_CONSTANTS, RIVER_BEND_FOAM_ATTRIBUTE, RampLayout, RoofKind, SHARED_TOON_RAMP_SHADES, SOUND_EFFECT_BAND_EDGES, SOUND_EFFECT_FRAME_LENGTH, SPECTRAL_ANGULAR_BIN_COUNT, SPECTRAL_RADIAL_BIN_COUNT, SPHERE_CAST_STRIDE_SHARE, SPLASH_COUNT, SPLASH_LIFETIME, SPLASH_LIFT, SPLASH_OPACITY, SPLASH_RADIUS, SPLASH_SIZE, SPRINT_STAMINA_PER_SECOND, STAMINA_MAX, STAMINA_REFILL_DELAY_SECONDS, STAMINA_REFILL_PER_SECOND, STAMINA_REFILL_STATES, STEEP_SLIDE_SPEED, STONE_DARKENING_TOP, STONE_HARMONIC_COUNT, STONE_HEIGHT_FALLOFF, STONE_MASK_OUTPUT, STONE_RAMP_KNOT_COUNT, STONE_SHADOW_EXPONENT, SUN_REDRAW_COSINE, SURFACE_DETAIL_BAND_SIGMAS, SURFACE_OCTAVE_RESPONSES, SURFACE_OCTAVE_TEXEL_FREQUENCIES, SWIM_DASH_STAMINA_COST, SWIM_DASH_STAMINA_PER_SECOND, SWIM_STROKE_SECONDS, SWIM_STROKE_STAMINA_COST, SharedToonOutlinePassNode, StoneLightingModel, StoneNodeMaterial, TERRAIN_CELL_SIZE, TERRAIN_HEIGHT_PADDING, TERRAIN_LAYER, TERRAIN_RING_INITIAL_TILE_COUNT, TILE_INDEX_OFFSET, TILE_INDEX_SPAN, TONE_CONTRAST_OFFSET, TONE_CURVE_FLOOR, TONE_CURVE_LIFT, TOON_HIGH, TOON_LOW, TerrainFeatureKind, TerrainFeatureKindBlendMap, ToonNodeMaterial, UNIT_OUTLINE_WIDTH_KNOTS, WALK_MOVE_MAGNITUDE, WALL_PRESS_SPEED, WALL_PROBE_DISTANCE, WATER_LOCOMOTION_STATES, WEATHER_SETTINGS_MAP, WEATHER_TRANSITION_SECONDS, WET_DARKENING, WET_SHEEN_POWER, WET_SHEEN_STRENGTH, WeatherKind, addSmoothLoop, advanceGameClock, advanceStridePhase, applyLightningFlash, applyPrecipitationSettings, applySkyState, applyStoneLight, applyWeatherState, attachInspector, bakeImpostor, blendGridNodes, blendWeatherState, checkIsPmxSphereDrawn, checkSunTurned, checkTerrainBoundsOverlap, checkTerrainDrawsChanged, checkTerrainTileCasts, checkTransparentTexels, collectMusicNotes, collectMusicSegments, computeCharacterPose, computeGradeLut, computeGrassBlade, computeGrassTrailCell, computeGrassTrailTexel, computeGrassTrailTexelIndex, computeImpostorFade, computeLeafCards, computeLightningBolt, computeLightningFlash, computeLocomotionState, computeNoiseSamples, computeOriginShift, computeOutlineDistance, computeRampValues, computeScatterPoints, computeSoundEffectSamples, computeStatueSurface, computeStoneDarkening, computeStoneHarmonics, computeStoneRampCoordinate, computeSunDirection, computeSurfaceOctaves, computeTerrainIndices, computeTerrainTile, computeTreeTubes, computeWhiteBalance, computeWindGust, createBoxesGeometry, createBuildingGeometry, createCausticsNode, createCharacterController, createCharacterMaterial, createCharacterPoseRotations, createCharacterPoser, createCharacterShadingInputs, createCharacterShadingNode, createCloudAtlasTexture, createCloudBandSprite, createCloudLayerNode, createCloudLayerProfileTexture, createCloudLayerTexture, createCloudLayerTextures, createCloudLayerUniforms, createDitherFadeNode, createFaceDraw, createFaceShadeNode, createFixedStepLoop, createFlowerGeometry, createFlowerMaterial, createFlowerTileGeometry, createFogUniforms, createFollowCamera, createFreeCamera, createFrustumVisibility, createGameOutlineMaterial, createGaussianHillsHeight, createGenshinRenderer, createGodraysLight, createGradeLutTexture, createGrassBladePoint, createGrassCell, createGrassCulling, createGrassGeometry, createGrassMaterial, createGrassTrail, createGroundCapture, createGroundLayerWeights, createGroundPaintColor, createGroundQuery, createHeightFogNode, createImpostorMaterial, createIndexedGeometry, createInput, createInstanceCulling, createInstanceMatrixBuffer, createInstanceMatrixNode, createInstancedGeometry, createInstancedMesh, createInstrumentWave, createLandmarkCollider, createLatheStackGeometry, createLeafMaterial, createLeafShapeNode, createLightUniforms, createLightningBoltGeometry, createLightningBoltMaterial, createMaterialDetailNode, createMusicPlayer, createNoiseBuffer, createObjectFadeNode, createObjectSurfaceNode, createOcclusionNode, createOutlineColorNode, createOutlineMaterial, createOutlineScaleNode, createPavingGeometry, createPavingStoneGeometry, createPlantCulling, createPmxGeometry, createPmxMesh, createPmxSkeleton, createPmxTexture, createPmxToonTexture, createPostPipeline, createPostUniforms, createPrecipitationGeometry, createPrecipitationMaterial, createPrecipitationUniforms, createRampColumnNode, createRampTexture, createRampUvNode, createResidualHeight, createRimNode, createRiverGeometry, createRiverMaterial, createSeededRandom, createShadingRegionNode, createSightNode, createSightUniforms, createSimplexNoise, createSkyColorNode, createSkyGradientTexture, createSkyNode, createSkyState, createSkyUniforms, createSoundEffectBuffer, createSplashMaterial, createStamina, createStatueGeometries, createStoneGlowNode, createStoneLightUniforms, createStoneMaterial, createSunLight, createSunVisibilityNode, createSurfaceDetailNode, createSurvivorIndices, createTerrainFeaturesBlend, createTerrainFeaturesHeight, createTerrainMaterial, createTerrainRing, createTerrainSelection, createTerrainShapeHeight, createTerrainTileGeometry, createTileStreamer, createToneNode, createToonMaterial, createToonThresholdNode, createTreeGeometry, createUnderwaterFogState, createWaterFlowUniforms, createWaterMaterial, createWaterUniforms, createWaterfallGeometry, createWaterfallMaterial, createWetDarkeningNode, createWetSheenNode, createWindNode, createWindUniforms, fileByCell, findSkinnedMesh, getCliffBlend, getCloudAtlasColumns, getCloudSunColors, getDesaturatedColour, getGameOutlineOffset, getGaussianHillBlend, getMusicRecordingGain, getMusicRecordingRate, getOutlineDepth, getOutlineScale, getParentTerrainTileKey, getPlateauBlend, getRampColumn, getRampRow, getRampWidth, getRidgeBlend, getScreenDirection, getSegmentBounds, getShadingRegion, getSharedToonRamp, getSoundEffectBandBins, getSpectralBin, getTerrainFeatureBounds, getTerrainMorphStart, getTerrainOverlayBounds, getTerrainShapeLevel, getTerrainTileBounds, getTerrainTileColumn, getTerrainTileKey, getTerrainTileLevel, getTerrainTileRow, getToneColour, getToonThreshold, measureSegment, mergeGeometryParts, orderByViewDepth, parsePmx, parsePmxBones, parsePmxJoints, parsePmxMaterials, parsePmxMorphs, parsePmxRigidBodies, parsePmxVertices, placeCloudBand, renderGroundCapture, renderMusicSegment, resolveTerrainDraws, sampleGrassTrail, sampleGroundCapture, sampleGroundLayerField, sampleSkyState, sampleTerrainResidualFade, sampleTreeNormalField, scheduleMusicExpression, scheduleMusicNote, scheduleMusicRecording, selectMusicSample, selectRegionNode, selectTerrainTiles, setObjectFade, setObjectSurface, stepGrassTrail, synthesizeCloudLayerTextures, synthesizeSpectralNoise, toSceneColor, toneMapGenshin, toneMapGenshinNode, transformFourier, transformFourierGrid, updateFaceDraw, updateUnderwaterFog, writeCloudLayerTexture, writeQuadIndices, writeTerrainRingIndices, writeTerrainRingTile };