genshin-engine 4.4.0 → 4.6.0

package/dist/index.d.ts

@@ -0,0 +1,1917 @@
+import { A as CliffFeature, C as GroundLayerField, D as GroundBand, E as GroundLayers, O as GaussianHills, S as GroundPathSegment, T as GroundLayer, _ as TerrainOptions, a as createTerrainShapeHeight, b as PlateauFeature, c as computeTerrainTile, d as TerrainTileOptions, f as TerrainShape, g as TerrainResidualClearing, h as TerrainResidualFade, i as getTerrainTileColumn, j as TerrainFeatureKind, k as GaussianHill, l as createSeededRandom, m as TerrainResidual, n as getTerrainTileRow, o as createGroundPaintColor, p as TerrainTile, r as getTerrainTileLevel, s as createGroundLayerWeights, t as computeScatterPoints, u as ScatterOptions, v as TerrainFeature, w as GroundLayerColors, x as GroundPaint, y as RidgeFeature } from "./terrainWorker-BjxpqdfH.js";
+import { Box3, BufferAttribute, BufferGeometry, Camera, CanvasTexture, Color, ColorRepresentation, Data3DTexture, DataTexture, DirectionalLight, Frustum, HemisphereLight, InstancedBufferGeometry, InstancedMesh, Material, Matrix3, Matrix4, Mesh, Object3D, OrthographicCamera, PerspectiveCamera, Quaternion, Scene, Skeleton, SkinnedMesh, Sprite, Texture, ToneMapping, Vector2, Vector3, Vector3Like, Vector3Tuple, Vector4Tuple } from "three";
+import { IndirectStorageBufferAttribute, LightingModel, LightingModelDirectInput, Material as Material$1, MeshBasicNodeMaterial, MeshToonNodeMaterial, MeshToonNodeMaterialParameters, Node, NodeBuilder, NodeFrame, NodeMaterial, PassNode, RenderPipeline, RenderTarget, Renderer, StorageBufferAttribute, Texture as Texture$1, TextureNode, ToonOutlinePassNode, UniformArrayNode, UniformNode, WebGPURenderer } from "three/webgpu";
+import { CSMShadowNode, CSMShadowNodeData } from "three/examples/jsm/csm/CSMShadowNode.js";
+import { Capsule } from "three/examples/jsm/math/Capsule.js";
+import GTAONode from "three/examples/jsm/tsl/display/GTAONode.js";
+import GodraysNode from "three/examples/jsm/tsl/display/GodraysNode.js";
+export interface SkyUniforms {
+  cloudCoverage: UniformNode<"float", number>;
+  cloudDrift: UniformNode<"vec2", Vector2>;
+  cloudFrontBackBlend: UniformNode<"float", number>;
+  cloudLitBackColor: UniformNode<"color", Color>;
+  cloudLitColor: UniformNode<"color", Color>;
+  cloudShadeBackColor: UniformNode<"color", Color>;
+  cloudShadeColor: UniformNode<"color", Color>;
+  cloudSunBrighten: UniformNode<"float", number>;
+  frontBackBlend: UniformNode<"float", number>;
+  haloColor: UniformNode<"color", Color>;
+  haloHeight: UniformNode<"float", number>;
+  horizonBackColor: UniformNode<"color", Color>;
+  horizonBand: UniformNode<"float", number>;
+  horizonColor: UniformNode<"color", Color>;
+  lightColor: UniformNode<"color", Color>;
+  moonDirection: UniformNode<"vec3", Vector3>;
+  moonGlowColor: UniformNode<"color", Color>;
+  moonSize: UniformNode<"float", number>;
+  starIntensity: UniformNode<"float", number>;
+  sunDirection: UniformNode<"vec3", Vector3>;
+  sunHaloColor: UniformNode<"color", Color>;
+  sunHaloSize: UniformNode<"float", number>;
+  zenithBackColor: UniformNode<"color", Color>;
+  zenithColor: UniformNode<"color", Color>;
+}
+export declare const applyLightningFlash: (flash: number, flashColor: Color, skyUniforms: SkyUniforms, hemisphere: HemisphereLight) => void;
+export interface PrecipitationSettings {
+  fallSpeed: number;
+  length: number;
+  opacity: number;
+  sway: number;
+  width: number;
+  windDrift: number;
+}
+export interface PrecipitationUniforms {
+  density: UniformNode<"float", number>;
+  eye: UniformNode<"vec3", Vector3>;
+  fallSpeed: UniformNode<"float", number>;
+  length: UniformNode<"float", number>;
+  opacity: UniformNode<"float", number>;
+  splashDensity: UniformNode<"float", number>;
+  sway: UniformNode<"float", number>;
+  width: UniformNode<"float", number>;
+  windDrift: UniformNode<"float", number>;
+}
+export declare const applyPrecipitationSettings: ({ fallSpeed, length, opacity, sway, width, windDrift }: PrecipitationSettings, precipitationUniforms: PrecipitationUniforms) => void;
+export interface BaseSkyState {
+  cloudLitColor: Color;
+  cloudShadeColor: Color;
+  hemisphereGroundColor: Color;
+  hemisphereIntensity: number;
+  hemisphereSkyColor: Color;
+  horizonColor: Color;
+  lightColor: Color;
+  lightIntensity: number;
+  starIntensity: number;
+  zenithColor: Color;
+}
+export interface SkyShape {
+  frontBackBlend: number;
+  haloHeight: number;
+  horizonBand: number;
+  moonSize: number;
+  sunHaloSize: number;
+}
+export interface WhiteBalance {
+  temperature: number;
+  tint: number;
+}
+export interface SkyState extends BaseSkyState {
+  cloudLitBackColor?: Color;
+  cloudShadeBackColor?: Color;
+  fogColor?: Color;
+  fogDensity?: number;
+  fogHeightFalloff?: number;
+  fogMaxOpacity?: number;
+  haloColor?: Color;
+  horizonBackColor?: Color;
+  lightDirection: Vector3;
+  moonDirection: Vector3;
+  moonGlowColor?: Color;
+  shape?: SkyShape;
+  sunDirection: Vector3;
+  sunHaloColor?: Color;
+  whiteBalance?: WhiteBalance;
+  zenithBackColor?: Color;
+}
+export interface LightUniforms {
+  lightColor: UniformNode<"color", Color>;
+  rimColor: UniformNode<"color", Color>;
+  rimStrength: UniformNode<"float", number>;
+  sunDirection: UniformNode<"vec3", Vector3>;
+  wetness: UniformNode<"float", number>;
+}
+export interface FogUniforms {
+  baseHeight: UniformNode<"float", number>;
+  color: UniformNode<"color", Color>;
+  density: UniformNode<"float", number>;
+  heightFalloff: UniformNode<"float", number>;
+  maxOpacity: UniformNode<"float", number>;
+  scatterColor: UniformNode<"color", Color>;
+  scatterDirection: UniformNode<"vec3", Vector3>;
+  scatterPower: UniformNode<"float", number>;
+  scatterStrength: UniformNode<"float", number>;
+  startDistance: UniformNode<"float", number>;
+}
+export interface PostUniforms {
+  godraysColor: UniformNode<"color", Color>;
+  gradeIntensity: UniformNode<"float", number>;
+  outlineColor: UniformNode<"color", Color>;
+  outlineFadeDistance: UniformNode<"float", number>;
+  outlineThickness: UniformNode<"float", number>;
+  whiteBalance: UniformNode<"mat3", Matrix3>;
+}
+export interface SkyTargets {
+  fogUniforms: FogUniforms;
+  godraysLight?: DirectionalLight;
+  hemisphere: HemisphereLight;
+  light: DirectionalLight;
+  lightDistance: number;
+  lightUniforms: LightUniforms;
+  postUniforms: PostUniforms;
+  skyUniforms: SkyUniforms;
+}
+export declare const applySkyState: (skyState: SkyState, { fogUniforms, godraysLight, hemisphere, light, lightDistance, lightUniforms, postUniforms, skyUniforms }: SkyTargets) => void;
+export declare enum PrecipitationKind {
+  Rain = "Rain",
+  Sand = "Sand",
+  Snow = "Snow"
+}
+export interface WeatherState {
+  cloudCoverage: number;
+  fogColor: number;
+  fogColorAmount: number;
+  fogDensity: number;
+  lightningRate: number;
+  precipitationDensity: number;
+  precipitationKind: PrecipitationKind;
+  wetness: number;
+}
+export interface WeatherTargets {
+  fogUniforms: FogUniforms;
+  lightUniforms: LightUniforms;
+  precipitationUniforms: PrecipitationUniforms;
+  skyUniforms: SkyUniforms;
+}
+export declare const applyWeatherState: ({ cloudCoverage, fogDensity, precipitationDensity, precipitationKind, wetness }: WeatherState, { fogUniforms, lightUniforms, precipitationUniforms, skyUniforms }: WeatherTargets, baseCloudCoverage: number, baseFogDensity: number) => void;
+export interface WeatherPrecipitation {
+  density: number;
+  kind: PrecipitationKind;
+}
+export interface WeatherSettings {
+  cloudCoverage: number;
+  fogColor?: number;
+  fogDensity: number;
+  lightningRate?: number;
+  precipitation?: WeatherPrecipitation;
+  wetness: number;
+}
+export declare const blendWeatherState: (from: Readonly<WeatherState>, { cloudCoverage, fogColor, fogDensity, lightningRate, precipitation, wetness }: WeatherSettings, amount: number, weatherState: WeatherState) => void;
+export declare const checkSunTurned: (drawnDirection: Vector3, direction: Vector3) => boolean;
+export interface LightningBolt {
+  directions: Float32Array;
+  indices: Uint32Array;
+  positions: Float32Array;
+  sides: Float32Array;
+}
+export interface LightningBoltOptions {
+  branchCount: number;
+  height: number;
+  roughness: number;
+  seed: number;
+  segmentCount: number;
+  width: number;
+}
+export declare const computeLightningBolt: ({ branchCount, height, roughness, seed, segmentCount, width }: LightningBoltOptions) => LightningBolt;
+export declare const computeLightningFlash: (elapsed: number) => number;
+export declare const computeSunDirection: (minutes: number, tilt: number, sunDirection: Vector3) => Vector3;
+export interface LightningFlashPulse {
+  seconds: number;
+  strength: number;
+}
+export interface SkyGradient {
+  green: readonly number[];
+  red: readonly number[];
+}
+export declare enum WeatherKind {
+  Clear = "Clear",
+  Cloudy = "Cloudy",
+  Eruption = "Eruption",
+  Fog = "Fog",
+  Rain = "Rain",
+  Sandstorm = "Sandstorm",
+  Snow = "Snow",
+  Snowstorm = "Snowstorm",
+  Thunderstorm = "Thunderstorm"
+}
+export declare const SUN_REDRAW_COSINE: number;
+export declare const DEFAULT_SKY_SHAPE: Readonly<SkyShape>;
+export declare const DEFAULT_SKY_GRADIENT: Readonly<SkyGradient>;
+export declare const PRECIPITATION_COUNT = 2048;
+export declare const PRECIPITATION_VOLUME_SIZE = 60;
+export declare const PRECIPITATION_VOLUME_HEIGHT = 30;
+export declare const PRECIPITATION_SWAY_SPEED = 1.3;
+export declare const PRECIPITATION_SETTINGS_MAP: Readonly<Record<PrecipitationKind, PrecipitationSettings>>;
+export declare const WEATHER_SETTINGS_MAP: Readonly<Record<WeatherKind, WeatherSettings>>;
+export declare const WEATHER_TRANSITION_SECONDS = 9;
+export declare const LIGHTNING_FLASH_PULSES: readonly LightningFlashPulse[];
+export declare const LIGHTNING_FLASH_DECAY_SECONDS = .08;
+export declare const LIGHTNING_FLASH_COLOR = 14344191;
+export declare const LIGHTNING_FLASH_SKY = .6;
+export declare const LIGHTNING_FLASH_AMBIENT = 1.2;
+export declare const LIGHTNING_FLASH_END = .01;
+export declare const LIGHTNING_BOLT_OPTIONS: Readonly<Pick<LightningBoltOptions, "branchCount" | "height" | "roughness" | "segmentCount" | "width">>;
+export declare const LIGHTNING_BOLT_COLOR = 15263487;
+export declare const LIGHTNING_BOLT_BRIGHTNESS = 3;
+export declare const LIGHTNING_MIN_DISTANCE = 150;
+export declare const LIGHTNING_MAX_DISTANCE = 600;
+export declare const SPLASH_COUNT = 768;
+export declare const SPLASH_RADIUS = 16;
+export declare const SPLASH_LIFETIME = .35;
+export declare const SPLASH_SIZE = .4;
+export declare const SPLASH_OPACITY = .5;
+export declare const SPLASH_LIFT = .03;
+export interface CloudSprite {
+  lit: [number, number][][];
+  outline: [number, number][][];
+}
+export declare const createCloudAtlasTexture: (sprites: readonly CloudSprite[], cellSize: number) => CanvasTexture<OffscreenCanvas>;
+export interface CloudBandSprite {
+  cover: UniformNode<"float", number>;
+  dispose: () => void;
+  places: [number, number, number][];
+  sprite: Sprite;
+}
+export interface CloudBandSpriteOptions {
+  aspect: number;
+  spriteCount: number;
+}
+export interface CloudPlacement {
+  position: [number, number, number];
+  spriteIndex: number;
+  width: number;
+}
+export declare const createCloudBandSprite: (atlas: Texture, clouds: readonly CloudPlacement[], { aspect, spriteCount }: CloudBandSpriteOptions, skyUniforms: SkyUniforms) => CloudBandSprite;
+export interface CloudLayerDome {
+  center: readonly number[];
+  elevations: readonly number[];
+  far: readonly number[];
+  near: readonly number[];
+  normalElevations: readonly number[];
+  turn: number;
+  wisps: readonly number[];
+  wispsTurn: number;
+}
+export declare const createCloudLayerProfileTexture: ({ elevations, far, near, normalElevations, wisps }: Pick<CloudLayerDome, "elevations" | "far" | "near" | "normalElevations" | "wisps">) => DataTexture;
+export interface SpectralNoiseChannel {
+  amplitudes: number[];
+  correlation?: {
+    channel: number;
+    share: number;
+  };
+  mean: number;
+  quantiles?: number[][];
+}
+export interface SpectralNoiseProfile {
+  channels: SpectralNoiseChannel[];
+  height: number;
+  width: number;
+}
+export declare const createCloudLayerTexture: ({ height, width }: Pick<SpectralNoiseProfile, "height" | "width">) => DataTexture;
+export interface CloudLayerTextureProfiles {
+  curl: SpectralNoiseProfile;
+  density: SpectralNoiseProfile;
+  normal: {
+    bias: number[];
+    height: SpectralNoiseProfile;
+  };
+  wisps: SpectralNoiseProfile;
+}
+export declare const createCloudLayerTextures: ({ curl, density, normal, wisps }: CloudLayerTextureProfiles) => {
+  curl: DataTexture;
+  density: DataTexture;
+  normal: DataTexture;
+  wisps: DataTexture;
+};
+export interface CloudLayerUniforms {
+  center: UniformNode<"vec2", Vector2>;
+  curl: TextureNode;
+  curlAmplitude: UniformNode<"float", number>;
+  curlSpeed: UniformNode<"float", number>;
+  curlTiling: UniformNode<"float", number>;
+  density: TextureNode;
+  direction: UniformNode<"vec2", Vector2>;
+  elapsedTime: UniformNode<"float", number>;
+  height: UniformNode<"float", number>;
+  lightDirection: UniformNode<"vec3", Vector3>;
+  normal: TextureNode;
+  normalYScale: UniformNode<"float", number>;
+  opacity: UniformNode<"float", number>;
+  profile: TextureNode;
+  smoothness: UniformNode<"vec2", Vector2>;
+  sunBrightness: UniformNode<"float", number>;
+  sunRimLightRadius: UniformNode<"float", number>;
+  tiling: UniformNode<"float", number>;
+  turn: UniformNode<"float", number>;
+  weather: UniformNode<"vec3", Vector3>;
+  wisps: TextureNode;
+  wispsCoverage: UniformNode<"float", number>;
+  wispsElapsedTime: UniformNode<"float", number>;
+  wispsOpacity: UniformNode<"float", number>;
+  wispsTurn: UniformNode<"float", number>;
+}
+export declare const createCloudLayerUniforms: ({ center, turn, wispsTurn, ...profiles }: CloudLayerDome, textures: Record<"curl" | "density" | "normal" | "wisps", Texture>) => CloudLayerUniforms;
+export declare const createLightningBoltGeometry: ({ directions, indices, positions, sides }: LightningBolt) => BufferGeometry;
+export declare const createPrecipitationGeometry: (particleCount: number) => InstancedBufferGeometry;
+export declare const createPrecipitationUniforms: () => PrecipitationUniforms;
+export declare const createSkyGradientTexture: ({ green, red }: SkyGradient) => DataTexture;
+export declare const createSkyState: () => SkyState;
+export declare const createSkyUniforms: () => SkyUniforms;
+export declare class AnchoredCascadeShadowNode extends CSMShadowNode {
+  #private;
+  anchor: Vector3;
+  constructor(light: DirectionalLight, data: CSMShadowNodeData);
+  override updateBefore(frame: NodeFrame): undefined;
+}
+export interface SunLight {
+  cascadedShadowNode: AnchoredCascadeShadowNode;
+  light: DirectionalLight;
+}
+export interface SunLightOptions {
+  cascadeCount: number;
+  maxFar: number;
+  shadowMapSize: number;
+}
+export declare const createSunLight: ({ cascadeCount, maxFar, shadowMapSize }: SunLightOptions) => SunLight;
+export declare const getCloudAtlasColumns: (spriteCount: number) => number;
+export declare const orderByViewDepth: (places: readonly (readonly number[])[], { elements }: Matrix4, depths: Float64Array, order: Uint32Array) => boolean;
+export interface CloudBandOptions {
+  count: number;
+  distanceRange: [number, number];
+  heightRange: [number, number];
+  seed: number;
+  widthRange: [number, number];
+}
+export declare const placeCloudBand: ({ count, distanceRange: [near, far], heightRange: [low, high], seed, widthRange: [narrow, wide] }: CloudBandOptions, spriteCount: number) => CloudPlacement[];
+export interface SkyKeyframe extends BaseSkyState {
+  minutes: number;
+}
+export declare const sampleSkyState: (skyKeyframes: readonly SkyKeyframe[], minutes: number, tilt: number, skyState: SkyState) => SkyState;
+export declare const synthesizeCloudLayerTextures: ({ curl, density, normal, wisps }: CloudLayerTextureProfiles, textures: Record<"curl" | "density" | "normal" | "wisps", DataTexture>) => Promise<void>;
+export declare const writeCloudLayerTexture: (texture: DataTexture, readTexel: (index: number) => readonly number[]) => void;
+export interface MusicNote {
+  duration: number;
+  pitch: number;
+  start: number;
+  velocity: number;
+}
+export interface MusicSampleRange {
+  highKey: number;
+  highVelocity: number;
+  lowKey: number;
+  lowVelocity: number;
+}
+export interface MusicRecording extends MusicSampleRange {
+  file: string;
+  gain: number;
+  keyCenter: number;
+  tune: number;
+}
+export interface Instrument {
+  attack: number;
+  decay: number;
+  harmonics: number[];
+  level: number;
+  noiseBands: number[];
+  recordingLevel: number;
+  recordings: MusicRecording[];
+  release: number;
+  sustain: number;
+  tuning: number;
+}
+export interface MusicVoice {
+  instrument: Instrument;
+  notes: MusicNote[];
+}
+export interface ScheduledMusicNote {
+  note: MusicNote;
+  time: number;
+  voice: MusicVoice;
+}
+export interface MusicSegment {
+  duration: number;
+  expression: number[];
+  voices: MusicVoice[];
+  volume: number;
+}
+export interface ScheduledMusicSegment {
+  segment: MusicSegment;
+  start: number;
+}
+export declare const collectMusicNotes: ({ segment, start }: ScheduledMusicSegment, from: number, to: number) => ScheduledMusicNote[];
+export interface Music {
+  isLooping: boolean;
+  order: number[];
+  segments: MusicSegment[];
+}
+export declare const collectMusicSegments: ({ isLooping, order, segments }: Music, from: number, to: number) => ScheduledMusicSegment[];
+export declare const computeNoiseSamples: (noiseBands: readonly number[], sampleRate: number) => Float32Array;
+export interface SoundEffect {
+  frameSeconds: number;
+  leftLevels: number[][];
+  rightLevels: number[][];
+  sharedLevels: number[][];
+}
+export declare const computeSoundEffectSamples: ({ frameSeconds, leftLevels, rightLevels, sharedLevels }: SoundEffect, sampleRate: number, seed?: number) => [Float32Array, Float32Array];
+export declare const MUSIC_LOOKAHEAD_SECONDS = 2;
+export declare const MUSIC_SCHEDULE_INTERVAL_MS = 500;
+export declare const RELEASE_TIME_CONSTANTS = 7;
+export declare const MUSIC_NOISE_LENGTH: number;
+export declare const MUSIC_NOISE_BAND_CENTRES: number[];
+export declare const MUSIC_EXPRESSION_WINDOW_SECONDS = 8;
+export declare const A4_PITCH = 69;
+export declare const A4_FREQUENCY = 440;
+export declare const MIDI_VELOCITY_MAX = 127;
+export declare const SOUND_EFFECT_BAND_EDGES: number[];
+export declare const SOUND_EFFECT_FRAME_LENGTH = 2048;
+export declare const createInstrumentWave: (context: BaseAudioContext, harmonics: number[]) => PeriodicWave;
+export interface MusicPlayer {
+  start: () => void;
+  stop: () => void;
+}
+export declare const createMusicPlayer: (context: AudioContext, music: Music, recordingBufferMap: ReadonlyMap<string, AudioBuffer>, destination?: AudioNode) => MusicPlayer;
+export declare const createNoiseBuffer: (context: BaseAudioContext, noiseBands: number[]) => AudioBuffer | undefined;
+export declare const createSoundEffectBuffer: (context: BaseAudioContext, soundEffect: SoundEffect) => AudioBuffer;
+export declare const getMusicRecordingGain: ({ gain }: Pick<MusicRecording, "gain">, velocity: number) => number;
+export declare const getMusicRecordingRate: ({ keyCenter, tune }: Pick<MusicRecording, "keyCenter" | "tune">, pitch: number, tuning: number) => number;
+export declare const getSoundEffectBandBins: (sampleRate: number) => (readonly [number, number])[];
+export declare const renderMusicSegment: (music: Music, segmentIndex: number, sampleRate: number, recordingBufferMap: ReadonlyMap<string, AudioBuffer>) => Promise<AudioBuffer>;
+export declare const scheduleMusicExpression: (gain: AudioParam, expression: number[], start: number) => void;
+export declare const scheduleMusicNote: (context: BaseAudioContext, destination: AudioNode, wave: PeriodicWave, noiseBuffer: AudioBuffer | undefined, { attack, decay, level, release, sustain, tuning }: Instrument, { duration, pitch, velocity }: MusicNote, time: number) => void;
+export declare const scheduleMusicRecording: (context: BaseAudioContext, destination: AudioNode, recordingBufferMap: ReadonlyMap<string, AudioBuffer>, { recordingLevel, recordings, release, tuning }: Instrument, { duration, pitch, velocity }: MusicNote, time: number) => void;
+export declare const selectMusicSample: <T extends MusicSampleRange>(samples: T[], pitch: number, velocity: number) => T | undefined;
+export declare const transformFourier: (real: Float64Array, imaginary: Float64Array) => void;
+export interface FollowCameraSettings {
+  defaultDistance: number;
+  horizontalSensitivity: number;
+  slopePitch: boolean;
+  verticalSensitivity: number;
+}
+export declare const FREE_CAMERA_BASE_SPEED = 8;
+export declare const FREE_CAMERA_SPEED_PER_HEIGHT = .5;
+export declare const FREE_CAMERA_CLEARANCE = 1.5;
+export declare const FREE_CAMERA_MAX_PITCH: number;
+export declare const FOLLOW_CAMERA_DEFAULT_SETTINGS: Readonly<FollowCameraSettings>;
+export declare const FOLLOW_CAMERA_NEUTRAL_SENSITIVITY = 3;
+export declare const FOLLOW_CAMERA_PIVOT_SHARE = .7;
+export declare const FOLLOW_CAMERA_FOV = 45;
+export declare const FOLLOW_CAMERA_MIN_PITCH: number;
+export declare const FOLLOW_CAMERA_MAX_PITCH: number;
+export declare const FOLLOW_CAMERA_MIN_DISTANCE = 1;
+export declare const FOLLOW_CAMERA_MAX_DISTANCE = 6;
+export declare const FOLLOW_CAMERA_DISTANCE_PER_ZOOM_STEP = .5;
+export declare const FOLLOW_CAMERA_EASE_OUT_SPEED = 4;
+export declare const FOLLOW_CAMERA_SLOPE_PITCH_SPEED = 4;
+export declare const FOLLOW_CAMERA_CLEARANCE = .2;
+export declare const FOLLOW_CAMERA_ARM_STEP = .25;
+export declare enum InputAction {
+  Aim = "Aim",
+  Cancel = "Cancel",
+  Confirm = "Confirm",
+  Drop = "Drop",
+  ElementalBurst = "ElementalBurst",
+  ElementalSight = "ElementalSight",
+  ElementalSkill = "ElementalSkill",
+  HideInterface = "HideInterface",
+  Interact = "Interact",
+  Jump = "Jump",
+  NormalAttack = "NormalAttack",
+  OpenAdventurerHandbook = "OpenAdventurerHandbook",
+  OpenBattlePass = "OpenBattlePass",
+  OpenCharacter = "OpenCharacter",
+  OpenChat = "OpenChat",
+  OpenCoOp = "OpenCoOp",
+  OpenEvents = "OpenEvents",
+  OpenFriends = "OpenFriends",
+  OpenInventory = "OpenInventory",
+  OpenMap = "OpenMap",
+  OpenPaimonMenu = "OpenPaimonMenu",
+  OpenPartySetup = "OpenPartySetup",
+  OpenQuests = "OpenQuests",
+  OpenShortcutWheel = "OpenShortcutWheel",
+  OpenWish = "OpenWish",
+  QuestNavigation = "QuestNavigation",
+  QuickUseGadget = "QuickUseGadget",
+  ResetCamera = "ResetCamera",
+  ShowCursor = "ShowCursor",
+  Sprint = "Sprint",
+  SwitchToPartyMember1 = "SwitchToPartyMember1",
+  SwitchToPartyMember2 = "SwitchToPartyMember2",
+  SwitchToPartyMember3 = "SwitchToPartyMember3",
+  SwitchToPartyMember4 = "SwitchToPartyMember4",
+  SwitchToPartyMemberAndBurst1 = "SwitchToPartyMemberAndBurst1",
+  SwitchToPartyMemberAndBurst2 = "SwitchToPartyMemberAndBurst2",
+  SwitchToPartyMemberAndBurst3 = "SwitchToPartyMemberAndBurst3",
+  SwitchToPartyMemberAndBurst4 = "SwitchToPartyMemberAndBurst4",
+  SwitchWalkRun = "SwitchWalkRun"
+}
+export declare const InputActions: readonly InputAction[];
+export interface InputState {
+  heldActions: ReadonlySet<InputAction>;
+  lookPitch: number;
+  lookYaw: number;
+  menuDown: number;
+  menuRight: number;
+  menuTabSteps: number;
+  moveForward: number;
+  moveRight: number;
+  moveUp: number;
+  pressedActions: ReadonlySet<InputAction>;
+  zoomSteps: number;
+}
+export interface FollowCamera {
+  follow: (pivot: Vector3, origin: Vector3, frameSeconds: number) => void;
+  look: (input: InputState, facing: number) => void;
+  reset: (facing: number) => void;
+  returnToDefaultDistance: () => void;
+  readonly yaw: number;
+}
+export interface GroundSample {
+  height: number;
+  normal: Vector3;
+}
+export interface GroundQuery {
+  getGround: (x: number, z: number) => GroundSample;
+  getWaterLevel: () => number;
+}
+export interface CapsulePush {
+  depth: number;
+  normal: Vector3;
+}
+export interface LandmarkCollider {
+  castSphere: (origin: Vector3, direction: Vector3, distance: number, radius: number) => number;
+  pushCapsule: (capsule: Capsule) => CapsulePush | undefined;
+  syncLandmarks: (root: Object3D) => void;
+}
+export interface FollowCameraOptions {
+  camera: PerspectiveCamera;
+  ground: GroundQuery;
+  landmarkCollider: LandmarkCollider;
+  settings: FollowCameraSettings;
+}
+export declare const createFollowCamera: ({ camera, ground, landmarkCollider, settings }: FollowCameraOptions) => FollowCamera;
+export interface FreeCamera {
+  look: (input: InputState) => void;
+  step: (input: InputState, stepSeconds: number) => void;
+}
+export interface FreeCameraOptions {
+  camera: PerspectiveCamera;
+  ground: GroundQuery;
+}
+export declare const createFreeCamera: ({ camera, ground }: FreeCameraOptions) => FreeCamera;
+export declare enum PmxSphereMode {
+  Disabled = 0,
+  Multiply = 1,
+  Add = 2,
+  AdditionalUv = 3
+}
+export declare const checkIsPmxSphereDrawn: (sphereMode: PmxSphereMode) => sphereMode is PmxSphereMode.Add | PmxSphereMode.Multiply;
+export declare const checkTransparentTexels: (image: ImageBitmap) => boolean;
+export declare const SHARED_TOON_RAMP_SHADES: readonly number[];
+export declare enum CharacterMaterialKind {
+  Body = 0,
+  Face = 1,
+  Hair = 2
+}
+export interface FaceDraw {
+  flip: UniformNode<"float", number>;
+  flipFactor: number;
+  rotateOffset: number;
+  threshold: UniformNode<"float", number>;
+}
+export type ShadingRegionColours = Record<"five" | "four" | "one" | "three" | "two", Vector3Tuple>;
+export interface OutlineRegions {
+  colors: ShadingRegionColours;
+  intensities: Record<keyof ShadingRegionColours, number>;
+}
+export declare enum RampLayout {
+  Horizontal = 0,
+  Vertical = 1
+}
+export interface ShadingRegionToggles {
+  five: boolean;
+  four: boolean;
+  three: boolean;
+  two: boolean;
+}
+export interface OutlineWidthKnots {
+  depths: Vector3Tuple;
+  scales: Vector3Tuple;
+}
+export interface CharacterShadingInputs {
+  brightness: number;
+  color: Vector3Tuple;
+  contrastScale: number;
+  coolShadowMultiplyColors: ShadingRegionColours;
+  coolShadowTone: number;
+  desaturateScale: number;
+  emissionColor: Vector3Tuple;
+  emissionScaler: number;
+  faceDraw: FaceDraw;
+  faceMap?: Texture;
+  faceSoftness: number;
+  isCoolShadow: boolean;
+  isEmissionFromAlpha: boolean;
+  isLightMapAo: boolean;
+  isOutlineVertexWeighted: boolean;
+  isVertexAo: boolean;
+  isVertexRampWidth: boolean;
+  kind: CharacterMaterialKind;
+  lightArea: number;
+  lightMapTexture?: Texture;
+  mainTexture?: Texture;
+  metalDarkColor: Vector3Tuple;
+  metalLightColor: Vector3Tuple;
+  metalTexture?: Texture;
+  outlineOffset?: {
+    blockBChannel: number;
+    size: number;
+  };
+  outlineRegions?: OutlineRegions;
+  outlineWidthKnots: OutlineWidthKnots;
+  rampLayout: RampLayout;
+  rampTexture: Texture;
+  rampWidth: number;
+  regionTints: Record<"five" | "four" | "three" | "two", Vector3Tuple>;
+  regionToggles: ShadingRegionToggles;
+  shadowMultiplyColors: ShadingRegionColours;
+  shininess: number;
+  specularColor: Vector3Tuple;
+  specularInShadow: number;
+  specularMultiplier: number;
+  sphere?: {
+    mode: PmxSphereMode.Add | PmxSphereMode.Multiply;
+    texture: Texture;
+  };
+  vertexAo: number;
+  vertexRampWidth: number;
+}
+export interface PmxMaterial {
+  ambientColor: Vector3Tuple;
+  diffuseColor: Vector4Tuple;
+  edgeColor: Vector4Tuple;
+  edgeSize: number;
+  indexCount: number;
+  isDoubleSided: boolean;
+  isOutlined: boolean;
+  isToonShared: boolean;
+  name: string;
+  specularColor: Vector3Tuple;
+  specularity: number;
+  sphereMode: PmxSphereMode;
+  sphereTextureIndex: number;
+  textureIndex: number;
+  toonIndex: number;
+}
+export interface CharacterMaterialOptions {
+  isTextureTransparent?: boolean;
+  lightUniforms: LightUniforms;
+  pmxMaterial: PmxMaterial;
+  rampTexture: DataTexture;
+  shadingInputs?: Partial<CharacterShadingInputs>;
+  sphereTexture?: Texture;
+  texture?: Texture;
+  toonTexture?: Texture;
+}
+export interface ToonEdge {
+  color: Node<"vec4"> | Vector4Tuple;
+  isVertexWeighted?: boolean;
+  offset?: {
+    blockBChannel: number;
+    size: number;
+  };
+  size: number;
+  widthKnots: OutlineWidthKnots;
+}
+export declare class ToonNodeMaterial extends MeshToonNodeMaterial {
+  edge?: ToonEdge;
+  instanceMatrix?: Node<"mat4">;
+  readonly isMeshToonMaterial: boolean;
+  override readonly isMeshToonNodeMaterial: boolean;
+  sphereMap?: Texture$1;
+  constructor(parameters: MeshToonNodeMaterialParameters, isOutlined: boolean, edge?: ToonEdge);
+}
+export declare const createCharacterMaterial: ({ isTextureTransparent, lightUniforms, pmxMaterial: { diffuseColor: [red, green, blue, opacity], edgeColor, edgeSize, isDoubleSided, isOutlined, isToonShared, specularColor, specularity, sphereMode, toonIndex }, rampTexture, shadingInputs: gameShadingInputs, sphereTexture, texture: diffuseTexture, toonTexture }: CharacterMaterialOptions) => ToonNodeMaterial;
+type CharacterShadingOverrides = Partial<CharacterShadingInputs> & {
+  rampTexture: Texture;
+};
+export declare const createCharacterShadingInputs: (overrides: CharacterShadingOverrides) => CharacterShadingInputs;
+export interface PmxBone {
+  name: string;
+  parentIndex: number;
+  position: Vector3Tuple;
+}
+export declare enum PmxJointKind {
+  SpringSixDegreesOfFreedom = 0,
+  SixDegreesOfFreedom = 1,
+  PointToPoint = 2,
+  ConeTwist = 3,
+  Slider = 4,
+  Hinge = 5
+}
+export interface PmxJoint {
+  firstRigidBodyIndex: number;
+  kind: PmxJointKind;
+  name: string;
+  position: Vector3Tuple;
+  rotation: Vector3Tuple;
+  rotationMaximum: Vector3Tuple;
+  rotationMinimum: Vector3Tuple;
+  rotationSpring: Vector3Tuple;
+  secondRigidBodyIndex: number;
+  translationMaximum: Vector3Tuple;
+  translationMinimum: Vector3Tuple;
+  translationSpring: Vector3Tuple;
+}
+export declare enum PmxMorphKind {
+  Group = 0,
+  Vertex = 1,
+  Bone = 2,
+  Uv = 3,
+  AdditionalUv1 = 4,
+  AdditionalUv2 = 5,
+  AdditionalUv3 = 6,
+  AdditionalUv4 = 7,
+  Material = 8,
+  Flip = 9,
+  Impulse = 10
+}
+export interface PmxMorph {
+  indices: Uint32Array;
+  kind: PmxMorphKind;
+  name: string;
+  values: Float32Array;
+}
+export declare enum PmxPhysicsMode {
+  FollowBone = 0,
+  Physics = 1,
+  PhysicsWithBone = 2
+}
+export declare enum PmxRigidBodyShape {
+  Sphere = 0,
+  Box = 1,
+  Capsule = 2
+}
+export interface PmxRigidBody {
+  angularDamping: number;
+  boneIndex: number;
+  friction: number;
+  group: number;
+  linearDamping: number;
+  mass: number;
+  name: string;
+  nonCollidingGroups: number;
+  physicsMode: PmxPhysicsMode;
+  position: Vector3Tuple;
+  restitution: number;
+  rotation: Vector3Tuple;
+  shape: PmxRigidBodyShape;
+  size: Vector3Tuple;
+}
+export interface PmxVertices {
+  normals: Float32Array;
+  positions: Float32Array;
+  skinIndices: Uint16Array;
+  skinWeights: Float32Array;
+  subUvs: Float32Array;
+  uvs: Float32Array;
+}
+export interface PmxModel {
+  bones: PmxBone[];
+  indices: Uint32Array;
+  joints: PmxJoint[];
+  materials: PmxMaterial[];
+  morphs: PmxMorph[];
+  name: string;
+  rigidBodies: PmxRigidBody[];
+  textures: string[];
+  vertices: PmxVertices;
+}
+export declare const createPmxGeometry: ({ indices, materials, vertices: { normals, positions, skinIndices, skinWeights, subUvs, uvs } }: Pick<PmxModel, "indices" | "materials" | "vertices">) => BufferGeometry;
+export declare const createPmxMesh: <TMaterial extends Material>(pmxModel: PmxModel, materials: TMaterial[], unitMetres: number) => SkinnedMesh<BufferGeometry, TMaterial[]>;
+export declare const createPmxSkeleton: (pmxBones: readonly PmxBone[]) => Skeleton;
+export declare const createPmxTexture: (blob: Blob) => Promise<Texture>;
+export declare const createPmxToonTexture: (blob: Blob) => Promise<Texture>;
+export declare const getSharedToonRamp: (toonIndex: number) => DataTexture | undefined;
+export declare const parsePmx: (buffer: ArrayBuffer) => PmxModel;
+export declare class PmxReader {
+  #private;
+  readonly additionalVectorCount: number;
+  readonly boneIndexSize: number;
+  readonly materialIndexSize: number;
+  readonly morphIndexSize: number;
+  readonly rigidBodyIndexSize: number;
+  readonly textureIndexSize: number;
+  readonly vertexIndexSize: number;
+  constructor(buffer: ArrayBuffer);
+  readBoneIndex(): number;
+  readFloat32(): number;
+  readInt32(): number;
+  readMaterialIndex(): number;
+  readMirroredRotation(): Vector3Tuple;
+  readMirroredVector3(): Vector3Tuple;
+  readMirroredVector3Into(target: Float32Array, offset: number): void;
+  readMorphIndex(): number;
+  readRigidBodyIndex(): number;
+  readText(): string;
+  readTextureIndex(): number;
+  readUint8(): number;
+  readUint16(): number;
+  readVector3(): Vector3Tuple;
+  readVertexIndex(): number;
+  skip(byteCount: number): void;
+}
+export declare const parsePmxBones: (reader: PmxReader) => PmxBone[];
+export declare const parsePmxJoints: (reader: PmxReader) => PmxJoint[];
+export declare const parsePmxMaterials: (reader: PmxReader) => PmxMaterial[];
+export declare const parsePmxMorphs: (reader: PmxReader) => PmxMorph[];
+export declare const parsePmxRigidBodies: (reader: PmxReader) => PmxRigidBody[];
+export declare const parsePmxVertices: (reader: PmxReader) => PmxVertices;
+export declare const advanceStridePhase: (stridePhase: number, speed: number, strideMetres: number, delta: number) => number;
+export declare enum LocomotionState {
+  Climb = "Climb",
+  ClimbJump = "ClimbJump",
+  Dash = "Dash",
+  Drown = "Drown",
+  Fall = "Fall",
+  Glide = "Glide",
+  Idle = "Idle",
+  Jump = "Jump",
+  Plunge = "Plunge",
+  Run = "Run",
+  Sprint = "Sprint",
+  Swim = "Swim",
+  SwimDash = "SwimDash",
+  Walk = "Walk"
+}
+export interface CharacterPoseInput {
+  elapsed: number;
+  state: LocomotionState;
+  stridePhase: number;
+}
+export declare enum MmdBoneName {
+  Center = "センター",
+  Head = "頭",
+  LeftAnkle = "左足首",
+  LeftArm = "左腕",
+  LeftElbow = "左ひじ",
+  LeftKnee = "左ひざ",
+  LeftLeg = "左足",
+  LeftShoulder = "左肩",
+  LeftWrist = "左手首",
+  Lower = "下半身",
+  Neck = "首",
+  RightAnkle = "右足首",
+  RightArm = "右腕",
+  RightElbow = "右ひじ",
+  RightKnee = "右ひざ",
+  RightLeg = "右足",
+  RightShoulder = "右肩",
+  RightWrist = "右手首",
+  Upper = "上半身",
+  Upper2 = "上半身2"
+}
+export type CharacterPoseRotations = Record<MmdBoneName, Quaternion>;
+export declare const computeCharacterPose: ({ elapsed, state, stridePhase }: CharacterPoseInput, rotations: CharacterPoseRotations) => void;
+export declare const POSE_BREATH_SECONDS = 4;
+export declare const POSE_CHEST_BREATH_RADIANS = .02;
+export declare const POSE_SHOULDER_BREATH_RADIANS = .02;
+export declare const POSE_ARM_LOWER_RADIANS = 1.2;
+export declare const POSE_ARM_CHAINS: readonly {
+  arm: MmdBoneName;
+  elbow: MmdBoneName;
+  tDirection: Vector3Tuple;
+}[];
+export declare const POSE_ARM_BEND_RADIANS = .2;
+export declare const POSE_CROSSFADE_SECONDS = .25;
+export interface PoseGait {
+  armBendRadians: number;
+  armSwingRadians: number;
+  kneeBendRadians: number;
+  leanRadians: number;
+  legSwingRadians: number;
+  strideMetres: number;
+}
+export declare const POSE_GAITS: Partial<Record<LocomotionState, PoseGait>>;
+export interface PoseAirStance {
+  armLowerRadians: number;
+  kneeBendRadians: number;
+  leanRadians: number;
+}
+export declare const POSE_AIR_STANCES: Partial<Record<LocomotionState, PoseAirStance>>;
+export declare const MMD_BONE_NAME_MAP: Record<MmdBoneName, string>;
+export type CharacterBoneNameMap = Partial<Record<MmdBoneName, string>>;
+export interface Locomotion {
+  capsuleHeight: number;
+  capsuleRadius: number;
+  climbJumpHeight: number;
+  climbJumpSeconds: number;
+  climbSpeed: number;
+  dashSeconds: number;
+  dashSpeed: number;
+  drownSeconds: number;
+  glideForwardSpeed: number;
+  glideMinHeight: number;
+  glideSinkSpeed: number;
+  gravity: number;
+  jumpHeight: number;
+  maxFallSpeed: number;
+  maxWalkableSlope: number;
+  plungeSpeed: number;
+  runSpeed: number;
+  sprintSpeed: number;
+  stepHeight: number;
+  swimDashSpeed: number;
+  swimDepth: number;
+  swimSpeed: number;
+  walkSpeed: number;
+}
+export interface LocomotionPhase {
+  state: LocomotionState;
+  stateSeconds: number;
+}
+export interface CharacterPoser {
+  update: (update: CharacterPoseUpdate) => void;
+}
+interface CharacterPoseUpdate {
+  delta: number;
+  locomotion: Locomotion;
+  phase: LocomotionPhase;
+}
+export declare const createCharacterPoser: (skinnedMesh: SkinnedMesh, boneNameMap?: CharacterBoneNameMap) => CharacterPoser;
+export declare const createCharacterPoseRotations: () => CharacterPoseRotations;
+export declare const findSkinnedMesh: (object: Object3D) => SkinnedMesh | undefined;
+export declare const REGION_FLOORS: {
+  readonly five: 0.6;
+  readonly four: 0.2;
+  readonly three: 0.4;
+  readonly two: 0.8;
+};
+export declare const RAMP_ROW_BASE = .05;
+export declare const COOL_RAMP_ROW_BASE = .55;
+export declare const RAMP_ROW_STEP = .1;
+export declare const NEUTRAL_LIGHT_MAP_GREEN = .5;
+export declare const EMISSION_ALPHA_FLOOR = .01;
+export declare const TOON_LOW = .05;
+export declare const TOON_HIGH = .95;
+export declare const MINIMUM_RAMP_WIDTH_VERTEX = .01;
+export declare const MINIMUM_OUTLINE_KNOT_SPAN = .001;
+export declare const OUTLINE_PROJECTION_SCALE = 2.414;
+export declare const OUTLINE_WIDTH_SCALE = .41425;
+export declare const UNIT_OUTLINE_WIDTH_KNOTS: OutlineWidthKnots;
+export declare const OUTLINE_MAIN_TEXTURE_SHARE = .2;
+export declare const DESATURATION_WEIGHTS: readonly [number, number, number];
+export declare const HALF_LAMBERT_SCALE = .4975;
+export declare const HALF_LAMBERT_OFFSET = .5;
+export declare const DEFAULT_LIGHT_AREA: number;
+export declare const DEFAULT_RAMP_WIDTH: number;
+export declare const MINIMUM_FACE_THRESHOLD = 1e-4;
+export declare const MAXIMUM_FACE_THRESHOLD = .9999;
+export declare const MAXIMUM_WINDOW_FLOOR = .9989;
+export declare const FLAT_LIGHT_MAP: Readonly<[number, number, number, number]>;
+export declare const createCharacterShadingNode: (inputs: CharacterShadingInputs, { lightColor, sunDirection }: Pick<LightUniforms, "lightColor" | "sunDirection">) => Node<"vec3">;
+export declare const createFaceShadeNode: (faceMap: Texture | undefined, softness: number, { flip, threshold }: FaceDraw) => Node<"float">;
+export declare const createOutlineColorNode: ({ color, contrastScale, desaturateScale, lightMapTexture, mainTexture, regionTints, regionToggles }: CharacterShadingInputs, { colors, intensities }: OutlineRegions) => Node<"vec3">;
+export declare const createOutlineScaleNode: (depths: Vector3Tuple, scales: Vector3Tuple) => Node<"float">;
+export declare const createRampColumnNode: (threshold: Node<"float">, lightArea: number, rampWidth: Node<"float">) => Node<"float">;
+export declare const createRampUvNode: (layout: RampLayout, column: Node<"float">, row: Node<"float">) => Node<"vec2">;
+export declare const createShadingRegionNode: (alpha: Node<"float">, toggles: ShadingRegionToggles) => Node<"float">;
+export declare const createToneNode: (colour: Node<"vec3">, desaturateScale: number, contrastScale: number) => Node<"vec3">;
+export interface ToonThresholdNodeInputs {
+  isLightMapAo: boolean;
+  isVertexAo: boolean;
+  lightMapGreen: Node<"float">;
+  sunTerm: Node<"float">;
+  vertexAo: number;
+}
+export declare const createToonThresholdNode: ({ isLightMapAo, isVertexAo, lightMapGreen, sunTerm, vertexAo }: ToonThresholdNodeInputs) => Node<"float">;
+export declare const getDesaturatedColour: (colour: Vector3, desaturateScale: number) => Vector3;
+export declare const getOutlineDepth: (viewZ: number, projectionYScale: number) => number;
+export declare const getOutlineScale: (depth: number, knotDepths: Vector3, knotScales: Vector3) => number;
+export declare const getRampColumn: (threshold: number, lightArea: number, rampWidth: number) => number;
+export declare const getRampRow: (region: number, isCoolShadow: boolean) => number;
+export interface RampWidthInputs {
+  isVertexRampWidth: boolean;
+  rampWidth: number;
+  vertexRampWidth: number;
+}
+export declare const getRampWidth: ({ isVertexRampWidth, rampWidth, vertexRampWidth }: RampWidthInputs) => number;
+export declare const getShadingRegion: (alpha: number, toggles: ShadingRegionToggles) => number;
+export declare const getToneColour: (colour: Vector3, desaturateScale: number, contrastScale: number) => Vector3;
+interface ToonThresholdInputs {
+  isLightMapAo: boolean;
+  isVertexAo: boolean;
+  lightMapGreen: number;
+  sunTerm: number;
+  vertexAo: number;
+}
+export declare const getToonThreshold: ({ isLightMapAo, isVertexAo, lightMapGreen, sunTerm, vertexAo }: ToonThresholdInputs) => number;
+export declare const selectRegionNode: <TNodeType>(region: Node<"float">, toRegionNode: (regionName: keyof ShadingRegionColours) => Node<TNodeType>) => Node<TNodeType>;
+export declare const createFaceDraw: ({ flipFactor, rotateOffset }?: Partial<Pick<FaceDraw, "flipFactor" | "rotateOffset">>) => FaceDraw;
+export declare const updateFaceDraw: (faceDraw: FaceDraw, lightDirection: Vector3, rootRotation: Quaternion) => void;
+export interface GameClock {
+  minutes: number;
+  minutesPerSecond: number;
+}
+export declare const advanceGameClock: (gameClock: GameClock, deltaSeconds: number) => void;
+export declare const MINUTES_PER_DAY = 1440;
+export declare const GAME_MINUTES_PER_SECOND = 1;
+export declare const GROUND_NORMAL_SPAN = .1;
+export declare const SPHERE_CAST_STRIDE_SHARE = .5;
+export declare const createGroundQuery: (getHeight: (x: number, z: number) => number, waterLevel: number) => GroundQuery;
+export declare const createLandmarkCollider: () => LandmarkCollider;
+export declare const MAX_BYTE = 255;
+export declare const CULLING_FRUSTUM_MARGIN = .1;
+export declare const CULLING_INDIRECT_ARGUMENT_COUNT = 5;
+export declare const CULLING_INDEX_COUNT_INDEX = 0;
+export declare const CULLING_INSTANCE_COUNT_INDEX = 1;
+export declare const CULLING_MIN_SIZE = 1e-4;
+export declare const CULLING_MATRIX_COLUMN_COUNT = 4;
+export declare const CULLING_MATRIX_ELEMENT_COUNT: number;
+export declare const createFrustumVisibility: (clipFromModel: UniformNode<"mat4", Matrix4>, point: Node<"vec3">) => Node<"float">;
+export interface InstanceCulling {
+  cull: (renderer: Renderer) => void;
+  dispose: () => void;
+  indirect: IndirectStorageBufferAttribute;
+  survivor: Node<"float">;
+}
+interface InstanceCullingOptions {
+  count: number;
+  indexCount: number;
+  isVisible: (instance: Node<"float">) => Node<"float">;
+}
+export declare const createInstanceCulling: ({ count, indexCount, isVisible }: InstanceCullingOptions) => InstanceCulling;
+export declare const createInstancedGeometry: (geometry: BufferGeometry, instanceCount: number) => InstancedBufferGeometry;
+export declare const createInstanceMatrixBuffer: (matrices: Matrix4[]) => StorageBufferAttribute;
+export declare const createInstanceMatrixNode: (attribute: StorageBufferAttribute, instance: Node<"float">) => Node<"mat4">;
+export declare const createSurvivorIndices: (count: number) => Uint32Array;
+export declare enum GamepadButton {
+  Back = "GamepadBack",
+  DirectionalPadDown = "GamepadDirectionalPadDown",
+  DirectionalPadLeft = "GamepadDirectionalPadLeft",
+  DirectionalPadRight = "GamepadDirectionalPadRight",
+  DirectionalPadUp = "GamepadDirectionalPadUp",
+  FaceBottom = "GamepadFaceBottom",
+  FaceLeft = "GamepadFaceLeft",
+  FaceRight = "GamepadFaceRight",
+  FaceTop = "GamepadFaceTop",
+  LeftBumper = "GamepadLeftBumper",
+  LeftStick = "GamepadLeftStick",
+  LeftTrigger = "GamepadLeftTrigger",
+  RightBumper = "GamepadRightBumper",
+  RightStick = "GamepadRightStick",
+  RightTrigger = "GamepadRightTrigger",
+  Start = "GamepadStart"
+}
+export declare enum MouseButton {
+  Auxiliary = "MouseAuxiliary",
+  Primary = "MousePrimary",
+  Secondary = "MouseSecondary"
+}
+export declare const KEY_CODE_FORWARD = "KeyW";
+export declare const KEY_CODE_BACKWARD = "KeyS";
+export declare const KEY_CODE_LEFT = "KeyA";
+export declare const KEY_CODE_RIGHT = "KeyD";
+export declare const KEY_CODE_UP = "Space";
+export declare const KEY_CODE_DOWN = "ShiftLeft";
+export declare const FOCUS_KEY_CODES: readonly string[];
+export declare const FIELD_SELECTOR = "input, select, textarea, [contenteditable=\"true\"]";
+export declare const GAMEPAD_BUTTONS: readonly GamepadButton[];
+export declare const MOUSE_BUTTONS: readonly MouseButton[];
+export declare const MOUSE_LOOK_RADIANS_PER_PIXEL = .002;
+export declare const MOUSE_LOOK_MAX_PIXELS_PER_EVENT: number;
+export declare const GAMEPAD_LOOK_RADIANS_PER_SECOND = 2.5;
+export declare const GAMEPAD_STICK_DEADZONE = .15;
+export declare const createIdleInputState: () => InputState;
+export interface Input {
+  dispose: () => void;
+  press: (code: string) => void;
+  readInput: (frameSeconds: number) => InputState;
+  release: (code: string) => void;
+  setTouchStick: (x: number, y: number) => void;
+  turn: (lookYaw: number, lookPitch: number) => void;
+}
+export interface InputGamepad {
+  axes: readonly number[];
+  buttons: readonly {
+    pressed: boolean;
+  }[];
+}
+export interface InputTarget extends Pick<Window, "addEventListener"> {
+  document: {
+    activeElement: null | {
+      matches: (selectors: string) => boolean;
+    };
+    pointerLockElement: null | object;
+  };
+  navigator: {
+    getGamepads: () => (InputGamepad | null)[];
+  };
+}
+export declare const createInput: (target: InputTarget) => Input;
+export declare const InputActionBindingMap: Readonly<Record<InputAction, readonly (readonly string[])[]>>;
+export declare const toAxis: (positive: boolean, negative: boolean) => number;
+export declare const toClamped: (axis: number) => number;
+export declare const toDeadzoned: (stickAxis: number) => number;
+export declare const createBoxesGeometry: (boxes: readonly (readonly number[])[]) => BufferGeometry;
+export declare enum RoofKind {
+  Conical = "Conical",
+  Flat = "Flat"
+}
+export interface BuildingOptions {
+  depth: number;
+  platformHeight: number;
+  roofHeight: number;
+  roofKind: RoofKind;
+  wallHeight: number;
+  wallThickness: number;
+  width: number;
+}
+export declare const createBuildingGeometry: ({ depth, platformHeight, roofHeight, roofKind, wallHeight, wallThickness, width }: BuildingOptions) => BufferGeometry;
+export interface LatheSection {
+  bottomRadius: number;
+  height: number;
+  topRadius: number;
+}
+export interface LatheStackOptions {
+  isFaceted: boolean;
+  radialSegments: number;
+  sections: LatheSection[];
+}
+export declare const createLatheStackGeometry: ({ isFaceted, radialSegments, sections }: LatheStackOptions) => BufferGeometry;
+export interface PavingStoneShape {
+  bottom: number;
+  radii: readonly number[];
+  top: number;
+}
+export interface PavingStone {
+  position: readonly number[];
+  quaternion: readonly number[];
+  scale: readonly number[];
+  shape: PavingStoneShape;
+}
+export declare const createPavingGeometry: (stones: readonly PavingStone[]) => BufferGeometry;
+export declare const createPavingStoneGeometry: ({ bottom, radii, top }: PavingStoneShape) => BufferGeometry;
+export interface LeafCards {
+  indices: Uint32Array;
+  normals: Float32Array;
+  positions: Float32Array;
+  uvs: Float32Array;
+}
+export declare const createIndexedGeometry: ({ indices, normals, positions, uvs }: LeafCards) => BufferGeometry;
+export declare const mergeGeometryParts: (parts: BufferGeometry[]) => BufferGeometry;
+export interface StatueSection {
+  centre: readonly number[];
+  colors: readonly number[];
+  height: number;
+  radii: readonly number[];
+}
+export interface StatueSurface {
+  colors: Float32Array;
+  indices: Uint32Array;
+  positions: Float32Array;
+}
+export declare const computeStatueSurface: (sections: readonly StatueSection[]) => StatueSurface;
+export interface StatueStack {
+  position: readonly number[];
+  rotation: readonly number[];
+  sections: StatueSection[];
+}
+export interface StatuePart extends StatueStack {
+  part: string;
+}
+export declare const createStatueGeometries: (parts: readonly StatuePart[]) => Record<string, BufferGeometry>;
+export interface TreeCluster {
+  leafArea: number;
+  radius: number;
+  x: number;
+  y: number;
+  z: number;
+}
+export interface TreeNormalField {
+  cellSize: number;
+  normals: readonly number[];
+  origin: readonly number[];
+  size: readonly number[];
+}
+export interface TreeTubePoint {
+  radius: number;
+  x: number;
+  y: number;
+  z: number;
+}
+export type TreeTube = readonly [TreeTubePoint, TreeTubePoint, ...TreeTubePoint[]];
+export interface TreeOptions {
+  cardSize: number;
+  clusters: readonly TreeCluster[];
+  leafAreaScale: number;
+  limbs: readonly TreeTube[];
+  normalField?: TreeNormalField;
+  roots: readonly TreeTube[];
+  seed: number;
+}
+export declare const computeLeafCards: (clusters: readonly TreeCluster[], { cardSize, leafAreaScale, normalField, seed }: Pick<TreeOptions, "cardSize" | "leafAreaScale" | "normalField" | "seed">) => LeafCards;
+export interface TreeTubes {
+  indices: Uint32Array;
+  normals: Float32Array;
+  positions: Float32Array;
+  uvs: Float32Array;
+}
+export declare const computeTreeTubes: (tubes: readonly TreeTube[]) => TreeTubes;
+export interface TreeGeometry {
+  branchGeometry: BufferGeometry;
+  leafGeometry: BufferGeometry;
+}
+export declare const createTreeGeometry: ({ limbs, roots, ...treeOptions }: TreeOptions) => TreeGeometry;
+export declare const sampleTreeNormalField: ({ cellSize, normals, origin, size }: TreeNormalField, position: [number, number, number]) => [number, number, number] | undefined;
+export declare const writeQuadIndices: (indices: Uint32Array, indexStart: number, vertexStart: number) => void;
+export interface LocomotionContact {
+  isFacingWall: boolean;
+  isGrounded: boolean;
+  isHighAboveGround: boolean;
+  isInDeepWater: boolean;
+  isRising: boolean;
+}
+export interface LocomotionInput {
+  isSprintHeld: boolean;
+  isWalking: boolean;
+  moveForward: number;
+  moveRight: number;
+  pressedActions: ReadonlySet<InputAction>;
+}
+export declare const computeLocomotionState: (phase: LocomotionPhase, input: LocomotionInput, contact: LocomotionContact, stamina: number, locomotion: Locomotion) => LocomotionState;
+export declare const STAMINA_MAX = 100;
+export declare const STAMINA_REFILL_PER_SECOND = 25;
+export declare const STAMINA_REFILL_DELAY_SECONDS = 1.5;
+export declare const DASH_STAMINA_COST = 18;
+export declare const SPRINT_STAMINA_PER_SECOND = 18;
+export declare const CLIMB_JUMP_STAMINA_COST = 25;
+export declare const SWIM_STROKE_STAMINA_COST = 4;
+export declare const SWIM_DASH_STAMINA_COST = 2;
+export declare const SWIM_DASH_STAMINA_PER_SECOND = 10.2;
+export declare const CLIMB_START_STAMINA = 5;
+export declare const GLIDE_STAMINA_PER_SECOND = 3;
+export declare const CLIMB_STAMINA_PER_SECOND = 2;
+export declare const SWIM_STROKE_SECONDS = 1.67;
+export declare const STAMINA_REFILL_STATES: readonly LocomotionState[];
+export declare const AIR_LOCOMOTION_STATES: readonly LocomotionState[];
+export declare const CLIMB_LOCOMOTION_STATES: readonly LocomotionState[];
+export declare const WATER_LOCOMOTION_STATES: readonly LocomotionState[];
+export declare const GROUND_LOCOMOTION_STATES: readonly LocomotionState[];
+export declare const WALK_MOVE_MAGNITUDE = .5;
+export declare const GROUND_CONTACT_DISTANCE = .05;
+export declare const GROUND_PRESS_SPEED = 1;
+export declare const WALL_PRESS_SPEED = 1;
+export declare const WALL_PROBE_DISTANCE = .1;
+export declare const STEEP_SLIDE_SPEED = 4;
+export declare const CLIMB_REGRAB_SECONDS = .5;
+export interface Stamina {
+  checkCanSpend: (amount: number) => boolean;
+  maximum: number;
+  refill: () => void;
+  restore: (amount: number) => void;
+  spend: (amount: number) => void;
+  step: (phase: LocomotionPhase, isEntered: boolean, isMoving: boolean, stepSeconds: number) => void;
+  value: number;
+}
+export interface CharacterController {
+  face: (facing: number) => void;
+  readonly facing: number;
+  readonly heldPresses: ReadonlySet<InputAction>;
+  holdPresses: (input: InputState) => void;
+  readonly phase: Readonly<LocomotionPhase>;
+  place: (position: Vector3, facing: number) => void;
+  readonly position: Vector3;
+  readonly previousPosition: Vector3;
+  readonly stamina: Stamina;
+  step: (input: InputState, cameraYaw: number, locomotion: Locomotion, stepSeconds: number) => void;
+}
+export type CharacterControllerOptions = ({
+  getStaminaConsumptionMultiplier?: () => number;
+  stamina?: never;
+  staminaMaximum: number;
+} | {
+  getStaminaConsumptionMultiplier?: never;
+  stamina: Stamina;
+  staminaMaximum?: never;
+}) & {
+  ground: GroundQuery;
+  landmarkCollider: LandmarkCollider;
+  position: Vector3;
+};
+export declare const createCharacterController: (options: CharacterControllerOptions) => CharacterController;
+export declare const createStamina: (maximum: number, getStaminaConsumptionMultiplier?: () => number) => Stamina;
+export declare const addSmoothLoop: (path: Path2D, points: readonly (readonly [number, number])[]) => void;
+export interface RampOptions {
+  resolution: number;
+  shade: number;
+  softness: number;
+  terminator: number;
+}
+export declare const computeRampValues: ({ resolution, shade, softness, terminator }: RampOptions) => Uint8Array;
+export declare const createRampTexture: (rampOptions: RampOptions) => DataTexture;
+export declare enum PmxBoneFlag {
+  IndexedTail = 1,
+  InverseKinematics = 32,
+  InheritRotation = 256,
+  InheritTranslation = 512,
+  FixedAxis = 1024,
+  LocalAxes = 2048,
+  ExternalParent = 8192
+}
+export declare enum PmxMaterialFlag {
+  DoubleSided = 1,
+  Outlined = 16
+}
+export declare enum PmxTextEncoding {
+  Utf16LittleEndian = 0,
+  Utf8 = 1
+}
+export declare enum PmxWeightDeform {
+  OneBone = 0,
+  TwoBones = 1,
+  FourBones = 2,
+  Spherical = 3,
+  DualQuaternion = 4
+}
+export interface PlantCullingOptions {
+  attribute: StorageBufferAttribute;
+  bounds: {
+    bottom: number;
+    halfWidth: number;
+    height: number;
+  };
+  clipFromModel: UniformNode<"mat4", Matrix4>;
+  drawDistance: number;
+  eye: UniformNode<"vec3", Vector3>;
+  indexCount: number;
+}
+export declare const createOutlineMaterial: (colorNode: Node<"vec4">, thicknessNode: Node<"float">, instanceMatrix?: Node<"mat4">) => NodeMaterial;
+export declare const createGameOutlineMaterial: (colorNode: Node<"vec4">, widthNode: Node<"float">, offsetNode: Node<"float">) => NodeMaterial;
+declare module "three/webgpu" {
+  interface NodeBuilder {
+    getSharedContext: () => Record<string, unknown>;
+  }
+}
+export declare class GameBloomNode extends Node<"vec4"> {
+  #private;
+  constructor(inputNode: Node<"vec4">);
+  override dispose(): void;
+  override setup(builder: NodeBuilder): Node<"vec4">;
+  override updateBefore(frame: NodeFrame): boolean | undefined;
+}
+export declare const getGameOutlineOffset: (viewPosition: Vector3, blue: number, blockBChannel: number, size: number) => Vector3;
+export interface Impostor {
+  albedoTarget: RenderTarget;
+  bottom: number;
+  height: number;
+  normalTarget: RenderTarget;
+  width: number;
+}
+export interface ImpostorMaterialOptions {
+  fade: Node<"float">;
+  impostor: Impostor;
+  instanceMatrix?: Node<"mat4">;
+  lightUniforms: LightUniforms;
+  rampTexture: DataTexture;
+}
+export declare class ObjectSurface {
+  amplitudes: number[];
+  color: Color;
+  texelsPerMetre: number;
+  constructor(color: Color, amplitudes: number[], texelsPerMetre: number);
+}
+export interface WindUniforms {
+  direction: UniformNode<"vec2", Vector2>;
+  gustSpeed: UniformNode<"float", number>;
+  gustStrength: UniformNode<"float", number>;
+  gustWidth: UniformNode<"float", number>;
+  strength: UniformNode<"float", number>;
+}
+export interface PrecipitationMaterialOptions {
+  lightUniforms: LightUniforms;
+  precipitationUniforms: PrecipitationUniforms;
+  windUniforms: WindUniforms;
+}
+export declare class SharedToonOutlinePassNode extends ToonOutlinePassNode {
+  #private;
+  alphaNode: Node<"float">;
+  colorNode: Node<"vec3">;
+  thicknessNode: Node<"float">;
+  _getOutlineMaterial(originalMaterial: Material$1): NodeMaterial;
+  override compileAsync(renderer: Renderer): Promise<void>;
+  override updateBefore(frame: NodeFrame): boolean | undefined;
+}
+export interface GroundCapture {
+  camera: OrthographicCamera;
+  center: UniformNode<"vec2", Vector2>;
+  material: MeshBasicNodeMaterial;
+  renderTarget: RenderTarget;
+  size: number;
+}
+export interface WaterUniforms {
+  causticStrength: UniformNode<"float", number>;
+  deepColor: UniformNode<"color", Color>;
+  deepDepth: UniformNode<"float", number>;
+  foamColor: UniformNode<"color", Color>;
+  foamDepth: UniformNode<"float", number>;
+  level: UniformNode<"float", number>;
+  shallowColor: UniformNode<"color", Color>;
+  underwaterFogColor: UniformNode<"color", Color>;
+  underwaterFogDensity: UniformNode<"float", number>;
+}
+export interface SplashMaterialOptions {
+  groundCapture: GroundCapture;
+  lightUniforms: LightUniforms;
+  precipitationUniforms: PrecipitationUniforms;
+  waterUniforms: WaterUniforms;
+}
+export interface StoneLight {
+  harmonics: (readonly number[])[];
+  hazeColor: readonly number[];
+  hazeScatterColor: readonly number[];
+  heightDarkening: number;
+  heightFade: readonly number[];
+  ramp: (readonly number[])[];
+}
+export interface StoneLightUniforms {
+  harmonics: UniformArrayNode<"vec3">;
+  hazeColor: UniformNode<"color", Color>;
+  hazeScatterColor: UniformNode<"color", Color>;
+  heightDarkening: UniformNode<"float", number>;
+  heightFade: UniformNode<"color", Color>;
+  ramp: DataTexture;
+  sunRadiance: UniformNode<"color", Color>;
+}
+export declare class StoneLightingModel extends LightingModel {
+  readonly stoneLight: StoneLightUniforms;
+  constructor(stoneLight: StoneLightUniforms);
+  createDarkeningNode(): Node<"float">;
+  override direct({ lightColor, lightDirection, reflectedLight }: LightingModelDirectInput): void;
+  override indirect(builder: NodeBuilder): void;
+}
+export interface StoneMaterialOptions {
+  albedo: string;
+  glowRange: number;
+  rimColor: readonly number[];
+  rimPower: number;
+  rimStrength: number;
+  smoothness: number;
+  specularColor: readonly number[];
+}
+export declare class StoneNodeMaterial extends NodeMaterial {
+  emissiveNode: Node | null;
+  readonly stoneLight: StoneLightUniforms;
+  constructor(stoneLight: StoneLightUniforms);
+  override setupLightingModel(): StoneLightingModel;
+}
+export interface SurfaceDetail {
+  bands: number[];
+  metresPerTexel: number;
+  variance: number;
+}
+export interface ToonMaterialOptions {
+  color?: ColorRepresentation;
+  detail?: SurfaceDetail;
+  instanceMatrix?: Node<"mat4">;
+  isObjectSurface?: boolean;
+  isOutlined?: boolean;
+  isVertexColors?: boolean;
+  lightUniforms: LightUniforms;
+  rampTexture: DataTexture;
+}
+export interface GradeOptions {
+  contrast: number;
+  highlightTint: readonly [number, number, number];
+  saturation: number;
+  shadowTint: readonly [number, number, number];
+  size: number;
+}
+export interface PostPipeline {
+  compileAsync: () => Promise<void>;
+  dispose: () => void;
+  godraysNode?: GodraysNode;
+  renderPipeline: RenderPipeline;
+}
+export interface SightUniforms {
+  origin: UniformNode<"vec2", Vector2>;
+  radius: UniformNode<"float", number>;
+  strength: UniformNode<"float", number>;
+}
+export declare enum AntialiasingMode {
+  Smaa = "Smaa",
+  Traa = "Traa"
+}
+export interface QualityTierSettings {
+  antialiasingMode: AntialiasingMode;
+  cascadeCount: number;
+  godraysStepCount: number;
+  grassDensity: number;
+  isBloomEnabled: boolean;
+  isOcclusionEnabled: boolean;
+  maxPixelRatio: number;
+  shadowMapSize: number;
+}
+export interface PostPipelineOptions {
+  camera: Camera;
+  fogUniforms: FogUniforms;
+  godraysLight?: DirectionalLight;
+  gradeLutTexture?: Data3DTexture;
+  isBloomed?: boolean;
+  occlusionRadius?: number;
+  postUniforms: PostUniforms;
+  qualityTierSettings: QualityTierSettings;
+  renderer: Renderer;
+  scene: Scene;
+  sight?: {
+    litScene: Scene;
+    uniforms: SightUniforms;
+  };
+  stoneLight?: StoneLightUniforms;
+}
+export declare enum QualityTier {
+  High = "High",
+  Low = "Low",
+  Medium = "Medium"
+}
+export interface ScreenCamera {
+  aspect: number;
+  fov: number;
+  pitch: number;
+  yaw: number;
+}
+export interface SceneMaterial {
+  colors: Record<string, [number, number, number, number]>;
+  floats: Record<string, number>;
+  keywords: string[];
+  name: string;
+  shader?: string;
+  textures: Record<string, {
+    name: string;
+    offset: [number, number];
+    scale: [number, number];
+  }>;
+}
+export interface ScenePlacement {
+  materials: string[];
+  mesh: string;
+  position: [number, number, number];
+  rotation: [number, number, number, number];
+  scale: [number, number, number];
+}
+export interface SceneLayout {
+  materials: Record<string, SceneMaterial>;
+  placements: ScenePlacement[];
+}
+export interface FixedStepLoop {
+  advance: (deltaSeconds: number) => void;
+  getStepShare: () => number;
+}
+export interface TerrainSelection {
+  count: number;
+  keys: Float64Array;
+}
+export interface TileStreamer<TTile> {
+  checkIsSettled: (key: number) => boolean;
+  dispose: () => void;
+  fail: (key: number) => boolean;
+  get: (key: number) => TTile | undefined;
+  has: (key: number) => boolean;
+  pendingCount: () => number;
+  receive: (key: number, tile: TTile) => void;
+  refresh: (checkIsChanged: (key: number) => boolean) => void;
+  update: (wanted: TerrainSelection, drawn: TerrainSelection, surrounding: TerrainSelection) => void;
+}
+export interface TileStreamerOptions<TTile> {
+  disposeTile: (tile: TTile) => void;
+  maxCachedCount: number;
+  maxPendingCount: number;
+  requestTile: (key: number) => void;
+}
+export interface TerrainBounds {
+  maxX: number;
+  maxZ: number;
+  minX: number;
+  minZ: number;
+}
+export interface TerrainRing {
+  add: (tile: TerrainTile) => void;
+  dispose: () => void;
+  draw: (keys: readonly number[]) => void;
+  mesh: Mesh;
+  remove: (key: number) => void;
+}
+export type TerrainTileArrays = Pick<TerrainTile, "coarseColors" | "coarseNormals" | "coarsePositions" | "colors" | "normals" | "positions">;
+export interface GrassBlade {
+  indices: Uint16Array;
+  positions: Float32Array;
+}
+export interface GrassCell {
+  angle: Node<"float">;
+  captured: Node<"vec4">;
+  ground: Node<"vec2">;
+  size: Node<"float">;
+}
+export interface GrassRing {
+  cellsPerSide: number;
+  fadeEnd: number;
+  fadeStart: number;
+  innerRadius: number;
+  scale: number;
+  spacing: number;
+}
+export interface GrassCellOptions {
+  cameraGround: UniformNode<"vec2", Vector2>;
+  density: UniformNode<"float", number>;
+  groundCapture: GroundCapture;
+  index: Node<"float">;
+  ring: GrassRing;
+  waterUniforms: Pick<WaterUniforms, "level">;
+}
+export interface GrassTrail {
+  bends: Float32Array;
+  cells: Float64Array;
+  center: UniformNode<"vec2", Vector2>;
+  data: Uint8Array;
+  texture: DataTexture;
+}
+export interface GrassCullingOptions {
+  bladeHeight: number;
+  cameraGround: UniformNode<"vec2", Vector2>;
+  clipFromModel: UniformNode<"mat4", Matrix4>;
+  density: UniformNode<"float", number>;
+  grassTrail: GrassTrail;
+  groundCapture: GroundCapture;
+  ring: GrassRing;
+  segmentCount: number;
+  waterUniforms: Pick<WaterUniforms, "level">;
+  windUniforms: WindUniforms;
+}
+export interface GrassOptions {
+  bladeHeight: number;
+  bladeWidth: number;
+  cameraGround: UniformNode<"vec2", Vector2>;
+  cellIndex: Node<"float">;
+  density: UniformNode<"float", number>;
+  grassTrail: GrassTrail;
+  groundCapture: GroundCapture;
+  lightUniforms: LightUniforms;
+  rampTexture: DataTexture;
+  ring: GrassRing;
+  waterUniforms: Pick<WaterUniforms, "level">;
+  windUniforms: WindUniforms;
+}
+export interface ImpostorPart {
+  color: ColorRepresentation;
+  geometry: BufferGeometry;
+  maskNode?: Node<"bool">;
+}
+export interface RiverCoursePoint {
+  level: number;
+  width: number;
+  x: number;
+  z: number;
+}
+export interface UnderwaterFogState {
+  aboveDensity: number;
+  aboveHeightFalloff: number;
+  aboveMaxOpacity: number;
+  aboveStartDistance: number;
+  isUnderwater: boolean;
+  underwaterDensity: number;
+}
+export interface WaterfallSheet {
+  across: Vector3;
+  drop: number;
+  lip: Vector3;
+  width: number;
+}
+export interface WaterFlow {
+  direction: UniformNode<"vec2", Vector2>;
+  speed: UniformNode<"float", number>;
+}
+export interface GroundPoint {
+  x: number;
+  z: number;
+}
+export declare const applyStoneLight: ({ harmonics, hazeColor, hazeScatterColor, heightDarkening, heightFade, ramp }: StoneLight, { harmonics: harmonicsUniform, hazeColor: hazeColorUniform, hazeScatterColor: hazeScatterColorUniform, heightDarkening: heightDarkeningUniform, heightFade: heightFadeUniform, ramp: rampTexture, sunRadiance }: StoneLightUniforms, light: DirectionalLight) => void;
+export declare const computeStoneDarkening: (height: number, heightDarkening: number) => number;
+export declare const computeStoneHarmonics: ([x, y, z]: readonly number[], harmonics: number[]) => void;
+export declare const computeStoneRampCoordinate: (facing: number, visibility: number) => number;
+interface SurfaceOctave {
+  amplitude: number;
+  frequency: number;
+}
+export declare const computeSurfaceOctaves: ({ bands, metresPerTexel, variance }: SurfaceDetail) => SurfaceOctave[];
+export declare const computeWindGust: (downwind: number, time: number, { gustSpeed, gustStrength, gustWidth }: {
+  gustSpeed: number;
+  gustStrength: number;
+  gustWidth: number;
+}) => number;
+export declare const LEAST_DIVISOR = 1e-4;
+export declare const STONE_SHADOW_EXPONENT = .2;
+export declare const STONE_RAMP_KNOT_COUNT = 16;
+export declare const STONE_HARMONIC_COUNT = 9;
+export declare const STONE_MASK_OUTPUT = "stoneMask";
+export declare const STONE_HEIGHT_FALLOFF = .05;
+export declare const STONE_DARKENING_TOP = 20;
+export declare const WET_DARKENING = .35;
+export declare const WET_SHEEN_POWER = 32;
+export declare const WET_SHEEN_STRENGTH = .25;
+export declare const SURFACE_DETAIL_BAND_SIGMAS: number[];
+export declare const SURFACE_OCTAVE_TEXEL_FREQUENCIES: number[];
+export declare const SURFACE_OCTAVE_RESPONSES: number[][];
+export declare const OBJECT_SURFACE_KEY = "surface";
+export declare const OBJECT_FADE_KEY = "fade";
+export declare const LEAF_SHAPE_WIDTH = .8;
+export declare const LEAF_SHAPE_KEPT_SHARE: number;
+export declare const createCausticsNode: ({ lightColor }: Pick<LightUniforms, "lightColor">, { causticStrength, deepDepth, level }: Pick<WaterUniforms, "causticStrength" | "deepDepth" | "level">) => Node<"vec3">;
+export declare const createCloudLayerNode: ({ center, curl, curlAmplitude, curlSpeed, curlTiling, density, direction: cloudDirection, elapsedTime, height: layerHeight, lightDirection, normal, normalYScale, opacity, profile, smoothness, sunBrightness, sunRimLightRadius, tiling, turn, weather, wisps, wispsCoverage, wispsElapsedTime, wispsOpacity, wispsTurn }: CloudLayerUniforms, { cloudCoverage, cloudFrontBackBlend, cloudLitBackColor, cloudLitColor, cloudShadeBackColor, cloudShadeColor, cloudSunBrighten, moonDirection, moonGlowColor, sunDirection, sunHaloColor, sunHaloSize }: SkyUniforms, direction: Node<"vec3">) => Node<"vec4">;
+export declare const createDitherFadeNode: (visibility: Node<"float">) => Node<"bool">;
+export declare const createImpostorMaterial: ({ fade, impostor, instanceMatrix, lightUniforms, rampTexture }: ImpostorMaterialOptions) => ToonNodeMaterial;
+export declare const createLeafMaterial: (toonMaterialOptions: ToonMaterialOptions, windUniforms?: WindUniforms, maskNode?: Node<"bool">) => ToonNodeMaterial;
+export declare const createLeafShapeNode: () => Node<"bool">;
+export declare const createLightningBoltMaterial: (flash: UniformNode<"float", number>) => MeshBasicNodeMaterial;
+export declare const createLightUniforms: () => LightUniforms;
+export declare const createMaterialDetailNode: (detail: SurfaceDetail) => Node<"float">;
+export declare const createObjectFadeNode: () => Node<"float">;
+export declare const createObjectSurfaceNode: () => Node<"vec3">;
+export declare const createPrecipitationMaterial: ({ lightUniforms, precipitationUniforms, windUniforms }: PrecipitationMaterialOptions) => MeshBasicNodeMaterial;
+export declare const createRimNode: ({ rimColor, rimStrength, sunDirection }: LightUniforms) => Node<"vec3">;
+export declare const createRiverMaterial: (lightUniforms: LightUniforms, skyUniforms: SkyUniforms, waterUniforms: WaterUniforms) => MeshBasicNodeMaterial;
+export declare const createSkyColorNode: ({ frontBackBlend, haloColor, haloHeight, horizonBackColor, horizonBand, horizonColor, sunDirection, sunHaloColor, sunHaloSize, zenithBackColor, zenithColor }: SkyUniforms, gradient: Texture, direction: Node<"vec3">) => Node<"vec3">;
+export declare const createSkyNode: (uniforms: SkyUniforms, gradient: Texture, cloudLayer?: CloudLayerUniforms) => Node<"vec3">;
+export declare const createSplashMaterial: ({ groundCapture, lightUniforms, precipitationUniforms, waterUniforms }: SplashMaterialOptions) => MeshBasicNodeMaterial;
+export declare const createStoneGlowNode: ({ glowRange, rimColor, rimPower, rimStrength }: Pick<StoneMaterialOptions, "glowRange" | "rimColor" | "rimPower" | "rimStrength">) => Node<"vec3">;
+export declare const createStoneLightUniforms: () => StoneLightUniforms;
+export declare const createStoneMaterial: (options: StoneMaterialOptions, stoneLight: StoneLightUniforms, glowNode?: Node<"vec3">) => StoneNodeMaterial;
+export declare const createSunVisibilityNode: (lightColor: Node, sunRadiance: UniformNode<"color", Color>) => Node<"float">;
+export declare const createSurfaceDetailNode: (amplitudes: Node<"float">[], texelsPerMetre: Node<"float">) => Node<"float">;
+export declare const createToonMaterial: ({ color, detail, instanceMatrix, isObjectSurface, isOutlined, isVertexColors, lightUniforms, rampTexture }: ToonMaterialOptions) => ToonNodeMaterial;
+export declare const createWaterfallMaterial: ({ foamColor }: Pick<WaterUniforms, "foamColor">) => MeshBasicNodeMaterial;
+export declare const createWaterMaterial: ({ lightColor, sunDirection }: Pick<LightUniforms, "lightColor" | "sunDirection">, { horizonColor, zenithColor }: Pick<SkyUniforms, "horizonColor" | "zenithColor">, { deepColor, deepDepth, foamColor, foamDepth, shallowColor }: WaterUniforms, { direction, speed }: WaterFlow, bendFoam?: Node<"float">) => MeshBasicNodeMaterial;
+export declare const createWetDarkeningNode: ({ wetness }: Pick<LightUniforms, "wetness">) => Node<"float">;
+export declare const createWetSheenNode: ({ lightColor, sunDirection, wetness }: LightUniforms) => Node<"vec3">;
+export declare const createWindNode: ({ direction, gustSpeed, gustStrength, gustWidth, strength }: WindUniforms, groundPosition: Node<"vec2">) => Node<"vec2">;
+export declare const getCloudSunColors: ({ cloudFrontBackBlend, cloudLitBackColor, cloudLitColor, cloudShadeBackColor, cloudShadeColor }: Pick<SkyUniforms, "cloudFrontBackBlend" | "cloudLitBackColor" | "cloudLitColor" | "cloudShadeBackColor" | "cloudShadeColor">, sunCosine: Node<"float">) => {
+  lit: Node<"vec3">;
+  shade: Node<"vec3">;
+};
+export declare const sampleGrassTrail: (grassTrail: GrassTrail, ground: Node<"vec2">) => Node<"vec2">;
+export declare const sampleGroundCapture: (groundCapture: GroundCapture, ground: Node<"vec2">) => {
+  captured: Node<"vec4">;
+  isInsideCapture: Node<"float">;
+};
+export declare const setObjectFade: (object: Object3D, fade: number) => void;
+export declare const setObjectSurface: (object: Object3D, color: ColorRepresentation, detail?: SurfaceDetail) => void;
+export declare const SPECTRAL_RADIAL_BIN_COUNT = 16;
+export declare const SPECTRAL_ANGULAR_BIN_COUNT = 8;
+export declare const createSimplexNoise: (seed: number) => ((x: number, y: number) => number);
+export declare const getSpectralBin: (column: number, row: number, width: number, height: number) => number | undefined;
+export declare const synthesizeSpectralNoise: ({ channels, height, width }: SpectralNoiseProfile, random: () => number) => Float32Array[];
+export declare const transformFourierGrid: (real: Float64Array, imaginary: Float64Array, width: number, height: number) => void;
+export declare const computeBloomPrefilter: (channel: number) => number;
+export declare const computeGradeLut: ({ contrast, highlightTint, saturation, shadowTint, size }: GradeOptions) => Uint8Array;
+export declare const computeWhiteBalance: ({ temperature, tint }: WhiteBalance, whiteBalance?: Matrix3) => Matrix3;
+export declare const createFogUniforms: () => FogUniforms;
+export declare const createGodraysLight: (shadowMapSize: number, halfExtent: number) => DirectionalLight;
+export declare const createGradeLutTexture: (gradeOptions: GradeOptions) => Data3DTexture;
+export declare const createHeightFogNode: (colorNode: Node<"vec4">, depthNode: TextureNode, camera: Camera, { baseHeight, color, density, heightFalloff, maxOpacity, scatterColor, scatterDirection, scatterPower, scatterStrength, startDistance }: FogUniforms, stoneHaze?: Pick<StoneLightUniforms, "hazeColor" | "hazeScatterColor"> & {
+  maskNode: TextureNode;
+}) => Node<"vec4">;
+export declare const createOcclusionNode: (depthNode: TextureNode, camera: Camera, radius: number) => GTAONode;
+export declare const createPostPipeline: ({ camera, fogUniforms, godraysLight, gradeLutTexture, isBloomed, occlusionRadius, postUniforms: { godraysColor, gradeIntensity, outlineColor, outlineFadeDistance, outlineThickness, whiteBalance }, qualityTierSettings: { antialiasingMode, godraysStepCount, isBloomEnabled, isOcclusionEnabled }, renderer, scene, sight, stoneLight }: PostPipelineOptions) => PostPipeline;
+export declare const createPostUniforms: () => PostUniforms;
+export declare const createSightNode: (colorNode: Node<"vec4">, depthNode: TextureNode, camera: Camera, litPass: PassNode, { origin, radius, strength }: SightUniforms) => Node<"vec4">;
+export declare const createSightUniforms: () => SightUniforms;
+export declare const toneMapGenshin: (sceneColor: readonly [number, number, number], toneMapped?: [number, number, number]) => [number, number, number];
+export declare const toneMapGenshinNode: (sceneColor: Node<"vec3">) => Node<"vec3">;
+export declare const toSceneColor: (displayColor: Color, sceneColor?: Color) => Color;
+export declare const GENSHIN_TONE_MAPPING: ToneMapping;
+export declare const GENSHIN_TONE_CONTRAST = .5;
+export declare const GENSHIN_TONE_EXPOSURE = 1;
+export declare const TONE_CONTRAST_OFFSET = .01;
+export declare const TONE_CURVE_LIFT = 1e-4;
+export declare const TONE_CURVE_FLOOR: number;
+export declare const GENSHIN_BLOOM_THRESHOLD = .75;
+export declare const GENSHIN_BLOOM_SCALER = 2.5;
+export declare const GENSHIN_BLOOM_INTENSITY = .75;
+export declare const GENSHIN_BLOOM_WEIGHTS: readonly number[];
+export declare const BLOOM_BLUR_TEXELS: readonly number[];
+export declare const createGenshinRenderer: (canvas: HTMLCanvasElement) => WebGPURenderer;
+export declare const createInstancedMesh: <TGeometry extends BufferGeometry, TMaterial extends Material | Material[]>(geometry: TGeometry, material: TMaterial, count: number) => InstancedMesh<TGeometry, TMaterial>;
+export declare const getScreenDirection: ({ aspect, fov, pitch, yaw }: ScreenCamera, [x, y]: [number, number]) => Vector3;
+export declare const QualityTierSettingsMap: Readonly<Record<QualityTier, QualityTierSettings>>;
+export declare const MAX_STEPS_PER_FRAME = 5;
+export declare const createFixedStepLoop: (stepSeconds: number, step: () => void) => FixedStepLoop;
+export declare const MAX_TILE_ATTEMPTS = 3;
+export declare const createTileStreamer: <TTile>({ disposeTile, maxCachedCount, maxPendingCount, requestTile }: TileStreamerOptions<TTile>) => TileStreamer<TTile>;
+export declare const blendGridNodes: (values: readonly number[], sizeX: number, sizeZ: number, column: number, row: number) => number;
+export declare const checkTerrainBoundsOverlap: (first: TerrainBounds, second: TerrainBounds) => boolean;
+export declare const checkTerrainDrawsChanged: ({ finestTileSize }: Pick<TerrainOptions, "finestTileSize">, previous: TerrainSelection, next: TerrainSelection, center: Vector3Like, halfSize: number) => boolean;
+export declare const checkTerrainTileCasts: ({ finestRange }: Pick<TerrainOptions, "finestRange">, key: number, shadowReach: number) => boolean;
+export declare const computeTerrainIndices: (cellsPerSide: number) => Uint16Array | Uint32Array;
+export declare const TILE_INDEX_OFFSET: number;
+export declare const TILE_INDEX_SPAN: number;
+export declare const TERRAIN_LAYER = 1;
+export declare const TERRAIN_RING_INITIAL_TILE_COUNT = 64;
+export declare const TERRAIN_CELL_SIZE = 64;
+export declare const GAUSSIAN_REACH_WIDTHS = 3;
+export declare const TERRAIN_HEIGHT_PADDING = 2;
+export declare const createGaussianHillsHeight: ({ base, hills }: GaussianHills) => ((x: number, z: number) => number);
+export declare const createResidualHeight: ({ amplitude, fade, octaves, scale, seed }: TerrainResidual) => ((x: number, z: number) => number);
+export declare const createTerrainFeaturesBlend: (features: readonly TerrainFeature[]) => ((x: number, z: number) => number);
+export declare const createTerrainFeaturesHeight: (features: readonly TerrainFeature[]) => ((x: number, z: number) => number);
+export declare const createTerrainMaterial: (terrainOptions: Pick<TerrainOptions, "finestRange" | "finestTileSize" | "maxHeight" | "minHeight">, eye: UniformNode<"vec3", Vector3>, toonMaterialOptions: Pick<ToonMaterialOptions, "lightUniforms" | "rampTexture">, waterUniforms?: WaterUniforms) => ToonNodeMaterial;
+export declare const createTerrainRing: ({ cellsPerSide, finestTileSize }: Pick<TerrainOptions, "cellsPerSide" | "finestTileSize">, tileIndices: Uint16Array | Uint32Array, material: Material) => TerrainRing;
+export declare const createTerrainSelection: (capacity: number) => TerrainSelection;
+export declare const createTerrainTileGeometry: ({ coarseColors, coarseNormals, coarsePositions, colors, normals, positions }: TerrainTileArrays, index: BufferAttribute, boundingBox: Box3) => BufferGeometry;
+export declare const fileByCell: <T>(items: readonly T[], getBounds: (item: T) => TerrainBounds) => ((x: number, z: number) => readonly T[]);
+export declare const getCliffBlend: (feature: CliffFeature, x: number, z: number) => number;
+export declare const getGaussianHillBlend: ({ width, x: hillX, z: hillZ }: Pick<GaussianHill, "width" | "x" | "z">, x: number, z: number) => number;
+export declare const getParentTerrainTileKey: (key: number) => number;
+export declare const getPlateauBlend: (feature: PlateauFeature, x: number, z: number) => number;
+export declare const getRidgeBlend: (feature: RidgeFeature, x: number, z: number) => number;
+export declare const getSegmentBounds: (startX: number, startZ: number, endX: number, endZ: number, reach: number) => TerrainBounds;
+export declare const getTerrainFeatureBounds: (feature: TerrainFeature) => TerrainBounds;
+export declare const getTerrainMorphStart: ({ finestRange, finestTileSize }: Pick<TerrainOptions, "finestRange" | "finestTileSize">) => number;
+export declare const getTerrainOverlayBounds: (shape: TerrainShape) => TerrainBounds;
+export declare const getTerrainShapeLevel: ({ base, hills }: GaussianHills, baseUnder: number) => PlateauFeature | undefined;
+export declare const getTerrainTileBounds: (key: number, finestTileSize: number, cellsPerSide: number) => TerrainBounds;
+export declare const getTerrainTileKey: (level: number, column: number, row: number) => number;
+export declare const measureSegment: ({ endX, endZ, startX, startZ }: Pick<RidgeFeature, "endX" | "endZ" | "startX" | "startZ">, x: number, z: number) => Float64Array;
+export declare const resolveTerrainDraws: ({ levelCount }: Pick<TerrainOptions, "levelCount">, wanted: TerrainSelection, checkTileLoaded: (key: number) => boolean, draws: TerrainSelection) => TerrainSelection;
+export declare const sampleGroundLayerField: ({ cellSize, layers, origin, size }: GroundLayerField, x: number, z: number, weights: Record<GroundLayer, number>) => void;
+export declare const sampleTerrainResidualFade: ({ cellSize, clearings, origin, size, weights }: TerrainResidualFade, x: number, z: number) => number;
+export declare const selectTerrainTiles: (terrainOptions: TerrainOptions, eye: Vector3Like, frustum: Frustum | undefined, selection: TerrainSelection) => TerrainSelection;
+export declare const TerrainFeatureKindBlendMap: { [K in TerrainFeatureKind]: (feature: Extract<TerrainFeature, {
+  kind: K;
+}>, x: number, z: number) => number; };
+export declare const writeTerrainRingIndices: (ringIndices: Uint32Array, tileIndices: Uint16Array | Uint32Array, drawnOrdinals: readonly number[], vertexCount: number) => number;
+export declare const writeTerrainRingTile: (ring: TerrainTileArrays, base: number, tile: TerrainTile, finestTileSize: number) => void;
+export declare const bakeImpostor: (renderer: Renderer, parts: readonly ImpostorPart[], resolution: number) => Impostor;
+export declare const computeGrassBlade: (segmentCount: number) => GrassBlade;
+export declare const computeGrassTrailCell: (coordinate: number, texelSize: number) => number;
+export declare const computeGrassTrailTexel: (cell: number) => number;
+export declare const computeGrassTrailTexelIndex: (cellX: number, cellZ: number) => number;
+export declare const computeImpostorFade: (distance: number, impostorHeight: number) => number;
+export declare const IMPOSTOR_RESOLUTION = 256;
+export declare const IMPOSTOR_SWITCH_HEIGHTS = 10;
+export declare const IMPOSTOR_CROSSFADE_SHARE = .1;
+export declare const FLOWER_BEND_PER_WIND = .12;
+export declare const FLOWER_MATRIX_ATTRIBUTE_NAMES: readonly ["flowerMatrix0", "flowerMatrix1", "flowerMatrix2", "flowerMatrix3"];
+export declare const FLOWER_COLOR_ATTRIBUTE_NAME = "flowerColor";
+export declare const GRASS_TRAIL_EXTENT = 16;
+export declare const GRASS_TRAIL_TEXELS = 64;
+export declare const GRASS_TRAIL_TEXEL_SIZE: number;
+export declare const GRASS_TRAIL_STAMP_RADIUS = .6;
+export declare const GRASS_TRAIL_FADE_SECONDS = 1.5;
+export declare const GRASS_TRAIL_BEND_SHARE = .9;
+export declare const GRASS_TRAIL_FADE_START_SHARE = .8;
+export declare const GRASS_TRAIL_FADE_END_SHARE = .95;
+export declare const GRASS_BEND_PER_WIND = .9;
+export declare const GRASS_DIP_PER_BEND = .3;
+export declare const createFlowerGeometry: () => BufferGeometry;
+export declare const createFlowerMaterial: (toonMaterialOptions: Pick<ToonMaterialOptions, "lightUniforms" | "rampTexture">, windUniforms: WindUniforms) => ToonNodeMaterial;
+export declare const createFlowerTileGeometry: (matrices: Float32Array, colors: Float32Array) => InstancedBufferGeometry;
+interface GrassBladePointOptions {
+  bladeHeight: number;
+  captured: Node<"vec4">;
+  grassTrail: GrassTrail;
+  ground: Node<"vec2">;
+  offset: Node<"vec2">;
+  size: Node<"float">;
+  up: Node<"float">;
+  windUniforms: WindUniforms;
+}
+export declare const createGrassBladePoint: ({ bladeHeight, captured, grassTrail, ground, offset, size, up, windUniforms }: GrassBladePointOptions) => Node<"vec3">;
+export declare const createGrassCell: ({ cameraGround, density, groundCapture, index, ring, waterUniforms }: GrassCellOptions) => GrassCell;
+export declare const createGrassCulling: ({ bladeHeight, cameraGround, clipFromModel, density, grassTrail, groundCapture, ring, segmentCount, waterUniforms, windUniforms }: GrassCullingOptions) => InstanceCulling;
+export declare const createGrassGeometry: (segmentCount: number, bladeCount: number) => InstancedBufferGeometry;
+export declare const createGrassMaterial: ({ bladeHeight, bladeWidth, cameraGround, cellIndex, density, grassTrail, groundCapture, lightUniforms, rampTexture, ring, waterUniforms, windUniforms }: GrassOptions) => ToonNodeMaterial;
+export declare const createGrassTrail: () => GrassTrail;
+export declare const createGroundCapture: (size: number, resolution: number) => GroundCapture;
+export declare const createPlantCulling: ({ attribute, bounds: { bottom, halfWidth, height }, clipFromModel, drawDistance, eye, indexCount }: PlantCullingOptions) => InstanceCulling;
+export declare const renderGroundCapture: (renderer: Renderer, scene: Scene, { camera, center, material, renderTarget }: GroundCapture, { maxHeight }: Pick<TerrainOptions, "maxHeight">, worldCenter: Vector3Like, origin: Vector3Like) => void;
+export declare const stepGrassTrail: (trail: GrassTrail, position: Vector2, velocity: Vector2, delta: number) => void;
+export declare const RIVER_BEND_FOAM_ATTRIBUTE = "bendFoam";
+export declare const BEND_FOAM_FULL_RADIUS_WIDTHS = 2;
+export declare const createRiverGeometry: (course: readonly RiverCoursePoint[]) => BufferGeometry;
+export declare const createUnderwaterFogState: () => UnderwaterFogState;
+export declare const createWaterfallGeometry: ({ across, drop, lip, width }: WaterfallSheet) => BufferGeometry;
+export declare const createWaterFlowUniforms: () => WaterFlow;
+export declare const createWaterUniforms: () => WaterUniforms;
+export declare const updateUnderwaterFog: (eyeHeight: number, { level, underwaterFogColor, underwaterFogDensity }: Pick<WaterUniforms, "level" | "underwaterFogColor" | "underwaterFogDensity">, { color, density, heightFalloff, maxOpacity, startDistance }: FogUniforms, underwaterFogState: UnderwaterFogState) => void;
+export declare const createWindUniforms: () => WindUniforms;
+export declare const computeOriginShift: (cameraPosition: Vector3, threshold: number, step: number, shift: Vector3) => boolean;
+export declare const computeOutlineDistance: (outline: readonly GroundPoint[], x: number, z: number) => number;
+export { CliffFeature, GaussianHill, GaussianHills, GroundBand, GroundLayer, GroundLayerColors, GroundLayerField, GroundLayers, GroundPaint, GroundPathSegment, PlateauFeature, RidgeFeature, ScatterOptions, TerrainFeature, TerrainFeatureKind, TerrainOptions, TerrainResidual, TerrainResidualClearing, TerrainResidualFade, TerrainShape, TerrainTile, TerrainTileOptions, computeScatterPoints, computeTerrainTile, createGroundLayerWeights, createGroundPaintColor, createSeededRandom, createTerrainShapeHeight, getTerrainTileColumn, getTerrainTileLevel, getTerrainTileRow };