@babylonjs-toolkit/next 9.0.1

package/lib/scenemanager.d.ts

@@ -0,0 +1,4141 @@
+import { AssetContainer, InstantiatedEntries } from '@babylonjs/core/assetContainer';
+import { AbstractEngine } from '@babylonjs/core/Engines/abstractEngine';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Scene } from '@babylonjs/core/scene';
+import { AssetsManager, BinaryFileAssetTask, ContainerAssetTask, MeshAssetTask, TextFileAssetTask, ImageAssetTask, AbstractAssetTask } from '@babylonjs/core/Misc/assetsManager';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { ShadowLight, IShadowLight } from '@babylonjs/core/Lights/shadowLight';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { ISceneLoaderProgressEvent, ISceneLoaderPluginAsync, ISceneLoaderPlugin } from '@babylonjs/core/Loading/sceneLoader';
+import { Node as BabylonNode } from '@babylonjs/core/node';
+import { Light } from '@babylonjs/core/Lights/light';
+import { Vector3, Quaternion, Vector2, Vector4, Matrix } from '@babylonjs/core/Maths/math.vector';
+import { ICrowd, IAgentParameters } from '@babylonjs/core/Navigation';
+import { FreeCamera } from '@babylonjs/core/Cameras/freeCamera';
+import { IAction } from '@babylonjs/core/Actions/action';
+import { Engine } from '@babylonjs/core/Engines/engine';
+import { SphericalPolynomial, PostProcess, DefaultRenderingPipeline, SSAORenderingPipeline, SSRRenderingPipeline } from '@babylonjs/core';
+import { Nullable, DeepImmutable } from '@babylonjs/core/types';
+import { Material } from '@babylonjs/core/Materials/material';
+import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
+import { RecastNavigationJSPluginV2 } from '@babylonjs/addons';
+import { Animation } from '@babylonjs/core/Animations/animation';
+import { EasingFunction } from '@babylonjs/core/Animations/easing';
+import { Color4, Color3 } from '@babylonjs/core/Maths/math.color';
+import { AnimationGroup, TargetedAnimation } from '@babylonjs/core/Animations/animationGroup';
+import { Space } from '@babylonjs/core/Maths/math.axis';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
+import { Animatable } from '@babylonjs/core/Animations/animatable';
+import { Observable, Observer, EventState } from '@babylonjs/core/Misc/observable';
+import { WebGPUEngine } from '@babylonjs/core/Engines/webgpuEngine';
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import { Sound } from '@babylonjs/core/Audio/sound';
+import { Skeleton } from '@babylonjs/core/Bones/skeleton';
+import { Control } from '@babylonjs/gui/2D/controls/control';
+import { Effect } from '@babylonjs/core/Materials/effect';
+import { PhysicsBody, IPhysicsEnabledObject, PhysicsShape, PhysicsShapeCapsule, PhysicsRaycastResult, PhysicsMotionType, IRaycastQuery, ShapeCastResult, PhysicsShapeSphere, PhysicsShapeMesh, PhysicsShapeConvexHull, PhysicsShapeBox, PhysicsShapeCylinder } from '@babylonjs/core/Physics';
+import { HavokPlugin } from '@babylonjs/core/Physics/v2/Plugins/havokPlugin';
+import { GLTFLoader } from '@babylonjs/loaders/glTF/2.0/glTFLoader';
+import { IScene, INode, IMaterial, IAnimation, IMesh } from '@babylonjs/loaders/glTF/2.0/glTFLoaderInterfaces';
+import { Texture } from '@babylonjs/core/Materials/Textures/texture';
+import { BaseTexture } from '@babylonjs/core/Materials/Textures/baseTexture';
+import { IGLTFLoaderExtension } from '@babylonjs/loaders/glTF/2.0/glTFLoaderExtension';
+import { CubeTexture } from '@babylonjs/core/Materials/Textures/cubeTexture';
+import { SubMesh } from '@babylonjs/core/Meshes/subMesh';
+import { MaterialDefines } from '@babylonjs/core/Materials/materialDefines';
+import { UniformBuffer } from '@babylonjs/core/Materials/uniformBuffer';
+import { MaterialPluginBase } from '@babylonjs/core/Materials/materialPluginBase';
+import { IAnimatable } from '@babylonjs/core/Animations';
+import { ShaderLanguage } from '@babylonjs/core/Materials';
+import { StaticSound, IStaticSoundOptions, AudioEngineV2, StaticSoundBuffer, StreamingSound, IWebAudioEngineOptions, AbstractSpatialAudio, IStaticSoundBufferOptions, IStreamingSoundOptions } from '@babylonjs/core/AudioV2';
+import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData';
+import { IFileRequest } from '@babylonjs/core/Misc/fileRequest';
+import { Bone } from '@babylonjs/core/Bones/bone';
+import { WebRequest } from '@babylonjs/core/Misc/webRequest';
+import { Gamepad } from '@babylonjs/core/Gamepads/gamepad';
+import { GamepadManager } from '@babylonjs/core/Gamepads/gamepadManager';
+import { ParticleSystem } from '@babylonjs/core/Particles/particleSystem';
+import { GPUParticleSystem } from '@babylonjs/core/Particles/gpuParticleSystem';
+import { AdvancedDynamicTexture } from '@babylonjs/gui/2D/advancedDynamicTexture';
+import { Vector2WithInfo } from '@babylonjs/gui/2D/math2D';
+import { VideoTexture } from '@babylonjs/core/Materials/Textures/videoTexture';
+export declare class SceneManager {
+    static get Version(): string;
+    static get Copyright(): string;
+    static GlobalOptions: any;
+    static WindowState: any;
+    static ServerEndPoint: string;
+    static EnableDebugMode: boolean;
+    static EnableUserInput: boolean;
+    static RenderLoopReady: boolean;
+    static PauseRenderLoop: boolean;
+    static LostRenderContext: boolean;
+    static AutoUpdateProgress: boolean;
+    static PhysicsCapsuleShape: number;
+    static SupportSRGBBuffers: boolean;
+    static AnimationStartMode: number;
+    static AnimationTargetFps: number;
+    static DefaultConvexHullMargin: number;
+    static DefaultHeightFieldMargin: number;
+    static AmbientLightIntensity: number;
+    static PointLightIntensity: number;
+    static SpotLightIntensity: number;
+    static DirectionalLightIntensity: number;
+    static FogExpDensityScale: number;
+    static FogExp2DensityScale: number;
+    static FogLinearDensityScale: number;
+    static TerrainColorCorrection: number;
+    static AllowCameraMovement: boolean;
+    static AllowCameraRotation: boolean;
+    static VirtualJoystickEnabled: boolean;
+    static GameTimeMilliseconds: number;
+    static ParseScriptComponents: boolean;
+    static AutoLoadScriptBundles: boolean;
+    static AutoStripNamespacePrefix: boolean;
+    static UniversalModuleDefinition: boolean;
+    static WaitForSeconds: (seconds: number) => Promise<void>;
+    static OnPreRenderLoopObservable: Observable<void>;
+    static OnPostRenderLoopObservable: Observable<void>;
+    static OnSceneReadyObservable: Observable<string>;
+    static OnEngineResizeObservable: Observable<AbstractEngine>;
+    static OnLoadCompleteObservable: Observable<AbstractEngine>;
+    static OnRebuildContextObservable: Observable<AbstractEngine>;
+    static OnAssetManagerProgress: (event: ProgressEvent) => void;
+    static readonly AllLayerMask: number;
+    static readonly DefaultLayerMask: number;
+    static readonly HiddenLayerMask: number;
+    private static _HideLoadingScreen;
+    static CVTOOLS_NAME: string;
+    static CVTOOLS_MESH: string;
+    static CVTOOLS_HAND: string;
+    static CVTOOLS_NAME_REGISTERED: boolean;
+    static CVTOOLS_MESH_REGISTERED: boolean;
+    static CVTOOLS_HAND_REGISTERED: boolean;
+    static GetEngine(scene: Scene): Engine | WebGPUEngine;
+    static GetClass(name: string): any;
+    static RegisterClass(name: string, klass: any): void;
+    static GetAuxiliaryData(scene: Scene): string;
+    static SetAuxiliaryData(scene: Scene, data: string): void;
+    private static _EventBus;
+    static get EventBus(): GlobalMessageBus;
+    static get PlaygroundCdn(): string;
+    static get PlaygroundRepo(): string;
+    static InitializePlayground(engine: Engine | WebGPUEngine | AbstractEngine, options?: IRuntimeOptions): Promise<void>;
+    static InitializeRuntime(engine: Engine | WebGPUEngine | AbstractEngine, options?: IRuntimeOptions): Promise<void>;
+    static InitializeSceneLoaderPlugin(): void;
+    static LoadRuntimeAssets(assetsManager: AssetsManager, requiredFilenames: string[], readyHandler: () => void, maxTimeout?: number, debugMode?: boolean): Promise<void>;
+    static ShowLoadingScreen(engine: Engine | WebGPUEngine | AbstractEngine, hideLoadingUIWithEngine?: boolean, defaultLoadingUIMarginTop?: string): void;
+    static HideLoadingScreen(engine: Engine | WebGPUEngine | AbstractEngine, fade?: boolean): void;
+    static ForceHideLoadingScreen(): void;
+    private static DoForceHideLoadingScreen;
+    static FocusRenderCanvas(scene: Scene): void;
+    private static SceneLoaderFileNames;
+    private static SceneLoaderPropertyBag;
+    private static SceneLoaderHandledFlag;
+    static SetOnSceneReadyHandler(filenames: string[], handler: () => void, timeout?: number, debug?: boolean): void;
+    static NavigateTo(scene: Scene, route: string, options?: any, useWindowLocation?: boolean): void;
+    static SetReactNavigationHook(scene: Scene, navigateToFunction: any): void;
+    static DeleteReactNavigationHook(scene: Scene): void;
+    private static SceneParsingEnabled;
+    static EnableSceneParsing(enabled: boolean): void;
+    static IsSceneParsingEnabled(): boolean;
+    static HasSceneBeenPreLoaded(scene: Scene): boolean;
+    static GetDefaultSkybox(scene: Scene): AbstractMesh;
+    static GetIntensityFactor(): number;
+    static GetRenderQuality(): RenderQuality;
+    static SetRenderQuality(quality: RenderQuality): void;
+    static GetEngineVersionString(scene: Scene): string;
+    static GetImageBasedLighting(scene: Scene): SphericalPolynomial;
+    static SetWindowState(name: string, data: any): void;
+    static GetWindowState<T>(name: string): T;
+    static IsDebugMode(): boolean;
+    static ConsoleLog(...data: any[]): void;
+    static ConsoleInfo(...data: any[]): void;
+    static ConsoleWarn(...data: any[]): void;
+    static ConsoleError(...data: any[]): void;
+    static LogMessage(message: string): void;
+    static LogWarning(warning: string): void;
+    static LogError(error: string): void;
+    static GetTime(): number;
+    static GetTimeMs(): number;
+    static GetGameTime(): number;
+    static GetGameTimeMs(): number;
+    static GetDeltaTime(scene: Scene, applyAnimationRatio?: boolean): number;
+    static GetDeltaSeconds(scene: Scene, applyAnimationRatio?: boolean): number;
+    static GetDeltaMilliseconds(scene: Scene, applyAnimationRatio?: boolean): number;
+    static GetTimeMilliseconds(): number;
+    static GetAnimationRatio(scene: Scene): number;
+    static RunOnce(scene: Scene, func: () => void, timeout?: number): void;
+    static DisposeScene(scene: Scene, clearColor?: Color4): void;
+    static SafeDestroy(transform: TransformNode, delay?: number, disable?: boolean): void;
+    static GetRootUrl(scene: Scene): string;
+    static SetRootUrl(scene: Scene, url: string): void;
+    static GetSceneFile(scene: Scene): string;
+    static SetSceneFile(scene: Scene, fileName: string): void;
+    static AddShadowCaster(light: ShadowLight, transform: TransformNode, children?: boolean): void;
+    static AddShadowCastersToLight(light: IShadowLight, transforms: TransformNode[], includeChildren?: boolean): void;
+    static RefreshShadowCascades(light: ShadowLight): void;
+    static RefreshAllShadowCascades(scene: Scene): void;
+    private static PhysicsViewersEnabled;
+    static IsPhysicsViewerEnabled(): boolean;
+    static TogglePhysicsViewer(scene: Scene): void;
+    static GetImportMeshes(scene: Scene, name: string): AbstractMesh[];
+    static GetImportMeshesMap(scene: Scene): Map<string, AbstractMesh[]>;
+    static ClearImportMeshes(scene: Scene): void;
+    static RegisterImportMeshes(scene: Scene, name: string, meshes: AbstractMesh[]): void;
+    static LoadImportMeshes(meshNames: string | readonly string[] | null | undefined, rootUrl: string, sceneFilename?: string, scene?: Nullable<Scene>, onSuccess?: (container: AbstractMesh[]) => void, onProgress?: (event: ISceneLoaderProgressEvent) => void, onError?: (scene: Scene, message: string, exception?: any) => void, pluginExtension?: Nullable<string>, name?: string): Nullable<ISceneLoaderPlugin | ISceneLoaderPluginAsync>;
+    static LoadImportMeshesAsync(meshNames: string | readonly string[] | null | undefined, rootUrl: string, sceneFilename?: string, scene?: Nullable<Scene>, onProgress?: (event: ISceneLoaderProgressEvent) => void, pluginExtension?: Nullable<string>, name?: string): Promise<AbstractMesh[]>;
+    static GetAssetContainer(scene: Scene, name: string): AssetContainer;
+    static GetAssetContainerMap(scene: Scene): Map<string, AssetContainer>;
+    static ClearAssetContainers(scene: Scene): void;
+    static RegisterAssetContainer(scene: Scene, name: string, container: AssetContainer): void;
+    static LoadAssetContainer(rootUrl: string, sceneFilename?: string, scene?: Scene, onSuccess?: (container: AssetContainer) => void, onProgress?: (event: ISceneLoaderProgressEvent) => void, onError?: (scene: Scene, message: string, exception?: any) => void, pluginExtension?: Nullable<string>, name?: string): void;
+    static LoadAssetContainerAsync(rootUrl: string, sceneFilename?: string, scene?: Nullable<Scene>, onProgress?: Nullable<(event: ISceneLoaderProgressEvent) => void>, pluginExtension?: Nullable<string>, name?: string): Promise<AssetContainer>;
+    static GetMesh(scene: Scene, name: string): Mesh;
+    static GetMeshByID(scene: Scene, id: string): Mesh;
+    static GetAbstractMesh(scene: Scene, name: string): AbstractMesh;
+    static GetAbstractMeshByID(scene: Scene, id: string): AbstractMesh;
+    static GetTransformNode(scene: Scene, name: string): TransformNode;
+    static GetTransformNodeByID(scene: Scene, id: string): TransformNode;
+    static GetTransformDetailMesh(transform: TransformNode): AbstractMesh;
+    static GetSkinnedMesh(transform: TransformNode): AbstractMesh;
+    static GetPrimitiveMeshes(transform: TransformNode): AbstractMesh[];
+    static GetTransformLayer(transform: TransformNode): number;
+    static GetTransformLayerMask(transform: TransformNode): number;
+    static GetTransformLayerName(transform: TransformNode): string;
+    static GetTransformTag(transform: TransformNode): string;
+    static HasTransformTags(transform: TransformNode, query: string): boolean;
+    static HasSoundManager(): boolean;
+    static IsSoundEffectPlaying(name: string): boolean;
+    static IsMusicTrackPlaying(name: string): boolean;
+    static PlayOneShot(name: string, time?: number, offset?: number, length?: number): Promise<boolean>;
+    static PlayMusicTrack(name: string, time?: number, offset?: number, length?: number): Promise<boolean>;
+    static PauseMusicTrack(name: string): boolean;
+    static MuteMusicTrack(name: string, time?: number): boolean;
+    static UnmuteMusicTrack(name: string, time?: number): boolean;
+    static StopMusicTrack(name: string, time?: number): boolean;
+    static StopAllMusicTracks(): void;
+    static PauseAllMusicTracks(): void;
+    static MuteAllMusicTracks(time?: number): void;
+    static UnmuteAllMusicTracks(time?: number): void;
+    static TextureFloatSupported(scene: Scene): boolean;
+    static RegisterClickAction(scene: Scene, mesh: AbstractMesh, func: () => void): IAction;
+    static UnregisterClickAction(mesh: AbstractMesh, action: IAction): boolean;
+    static GetMaterialWithName(scene: Scene, name: string): Material;
+    static GetAllMaterialsWithName(scene: Scene, name: string): Material[];
+    static InstantiatePrefabFromScene(scene: Scene, prefabName: string, newName: string, newParent?: Nullable<TransformNode>, newPosition?: Nullable<Vector3>, newRotation?: Nullable<Quaternion>, newScaling?: Nullable<Vector3>, cloneAnimations?: boolean): TransformNode;
+    static InstantiatePrefabFromContainer(container: AssetContainer, prefabName: string, newName: string, newParent?: Nullable<TransformNode>, newPosition?: Nullable<Vector3>, newRotation?: Nullable<Quaternion>, newScaling?: Nullable<Vector3>, cloneAnimations?: boolean, makeNewMaterials?: boolean): TransformNode;
+    static InstantiateModelsFromContainer(container: AssetContainer, nameFunction?: (sourceName: string) => string, createInstances?: boolean, cloneMaterials?: boolean, rebuildBoundingInfo?: boolean, filterPredicate?: any): TransformNode[];
+    static CreateInstancedModelsFromContainer(container: AssetContainer, newName?: string, newParent?: Nullable<TransformNode>, newPosition?: Nullable<Vector3>, newRotation?: Nullable<Quaternion>, newScaling?: Nullable<Vector3>, cloneAnimations?: boolean, makeNewMaterials?: boolean, rebuildBoundingInfo?: boolean): InstantiatedEntries;
+    static CloneTransformNode(container: AssetContainer, nodeName: string, newName: string, newParent?: Nullable<TransformNode>, newPosition?: Nullable<Vector3>, newRotation?: Nullable<Quaternion>, newScaling?: Nullable<Vector3>): TransformNode;
+    static CloneAbstractMesh(container: AssetContainer, nodeName: string, newName: string, newParent?: Nullable<TransformNode>, newPosition?: Nullable<Vector3>, newRotation?: Nullable<Quaternion>, newScaling?: Nullable<Vector3>): AbstractMesh;
+    static CreateInstancedMesh(container: AssetContainer, meshName: string, newName: string, newParent?: Nullable<TransformNode>, newPosition?: Nullable<Vector3>, newRotation?: Nullable<Quaternion>, newScaling?: Nullable<Vector3>): InstancedMesh;
+    static RebuildBoundingBoxInfo(transforms: TransformNode[]): void;
+    static AttachScriptComponent(instance: ScriptComponent, alias: string, validate?: boolean): void;
+    static DestroyScriptComponent(instance: ScriptComponent): void;
+    static DestroyGameObject(transform: TransformNode): void;
+    static GetComponent<T extends ScriptComponent>(transform: TransformNode, klass: string, recursive?: boolean): T;
+    static GetComponents<T extends ScriptComponent>(transform: TransformNode, recursive?: boolean): T[];
+    static FindGameObject(scene: Scene, path: string): TransformNode;
+    private static FindGameObjectExactPath;
+    private static FindGameObjectRecursive;
+    static DebugSceneHierarchy(scene: Scene, maxDepth?: number): void;
+    static LegacySearchForGameObject(scene: Scene, path: string): TransformNode;
+    static FindGameObjectWithTag(scene: Scene, tag: string): TransformNode;
+    static FindGameObjectsWithTag(scene: Scene, tag: string): TransformNode[];
+    static FindScriptComponents<T extends ScriptComponent>(transform: TransformNode, recursive?: boolean): T[];
+    static FindScriptComponent<T extends ScriptComponent>(transform: TransformNode, klass: string, recursive?: boolean): T;
+    static FindAllScriptComponents<T extends ScriptComponent>(transform: TransformNode, klass: string, recursive?: boolean): T[];
+    static FindSceneMetadata(transform: TransformNode): any;
+    static FindSceneCameraRig(transform: TransformNode): FreeCamera;
+    static FindSceneLightRig(transform: TransformNode): Light;
+    static FindTransformWithScript(scene: Scene, klass: string): TransformNode;
+    static FindAllTransformsWithScript(scene: Scene, klass: string): TransformNode[];
+    static FindChildTransformNode(parent: TransformNode, name: string, searchType?: SearchType, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode;
+    static FindChildTransformWithTags(parent: TransformNode, query: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode;
+    static FindAllChildTransformsWithTags(parent: TransformNode, query: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode[];
+    static FindChildTransformWithScript(parent: TransformNode, klass: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode;
+    static FindAllChildTransformsWithScript(parent: TransformNode, klass: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode[];
+    static FindComponentInParent<T extends ScriptComponent>(scene: Scene, transform: TransformNode, klass: string): T;
+    static FindComponentsInParent<T extends ScriptComponent>(scene: Scene, transform: TransformNode, klass: string): T[];
+    static FindComponentInChildren<T extends ScriptComponent>(scene: Scene, transform: TransformNode, klass: string): T;
+    static FindComponentsInChildren<T extends ScriptComponent>(scene: Scene, transform: TransformNode, klass: string): T[];
+    static SearchForScriptComponentByName<T extends ScriptComponent>(scene: Scene, klass: string): T;
+    static SearchForAllScriptComponentsByName<T extends ScriptComponent>(scene: Scene, klass: string): T[];
+    static MoveWithCollisions(entity: AbstractMesh, velocity: Vector3): void;
+    static MoveWithTranslation(entity: TransformNode, velocity: Vector3): void;
+    static TurnWithRotation(entity: TransformNode, radians: number, space?: Space): void;
+    static MAX_AGENT_COUNT: number;
+    static MAX_AGENT_RADIUS: number;
+    static OnNavMeshReadyObservable: Observable<Mesh>;
+    private static NavMeshPlugin;
+    private static NavMeshSurface;
+    private static NavMeshDebugger;
+    private static NavMeshMaterial;
+    private static CrowdInterface;
+    static HasNavigationData(): boolean;
+    static GetNavigationData(): any | null;
+    static GetNavigationMesh(): Mesh | null;
+    static GetNavigationDebug(): Mesh | null;
+    static GetNavigationPlugin(): RecastNavigationJSPluginV2 | null;
+    static GetCrowdInterface(scene: Scene): ICrowd;
+    static LoadNavigationMeshDataAsync(scene: Scene, binaryUrl: string, heightMesh?: Mesh, createDebugMesh?: boolean): Promise<void>;
+    static BuildNavigationMeshDataAsync(scene: Scene, binaryData: Uint8Array, heightMesh?: Mesh, createDebugMesh?: boolean): Promise<void>;
+    static BuildNavigationMeshTileCacheAsync(scene: Scene, tileCacheData: Uint8Array, tileCacheMeshProcess?: any, heightMesh?: Mesh, createDebugMesh?: boolean): Promise<void>;
+    static CreateNavigationMeshSceneDataAsync(scene: Scene, properties: IUnityNavigationOptions, geometry: Mesh[], heightMesh?: Mesh, createDebugMesh?: boolean): Promise<void>;
+    static DestroyNavigationMeshData(): void;
+    static ToggleFullscreenMode(scene: Scene, requestPointerLock?: boolean): void;
+    static EnterFullscreenMode(scene: Scene, requestPointerLock?: boolean): void;
+    static ExitFullscreenMode(scene: Scene): void;
+    private static GotoFullscreenBrowser;
+    private static RequestBrowserPointerLock;
+    private static ExitFromFullscreenBrowser;
+    private static CreateEasingFunction;
+    private static GetPropertyValue;
+    private static SetPropertyValue;
+    private static IsGUIControl;
+    private static IsGUIPositionProperty;
+    private static ExtractGUINumericValue;
+    private static CreateGUIAnimationProxy;
+    private static GetAnimationType;
+    private static CreateTweenAnimations;
+    static TweenTo(target: any, to: any, options?: ITweenOptions, scene?: Scene): ITweenResult;
+    static TweenToAsync(target: any, to: any, options?: ITweenOptions, scene?: Scene): Promise<void>;
+    static TweenFromTo(target: any, from: any, to: any, options?: ITweenOptions, scene?: Scene): ITweenResult;
+    static TweenFromToAsync(target: any, from: any, to: any, options?: ITweenOptions, scene?: Scene): Promise<void>;
+    static TweenGroupAsync(tweenFunctions: (() => Promise<any> | ITweenResult)[], options?: IGroupTweenOptions, scene?: Scene): Promise<void>;
+}
+export interface ITweenOptions {
+    duration?: number;
+    delay?: number;
+    ease?: string | EasingFunction;
+    autoStart?: boolean;
+    loop?: boolean;
+    repeat?: number;
+    yoyo?: boolean;
+    yoyoCount?: number;
+    speed?: number;
+    onStart?: () => void;
+    onComplete?: () => void;
+    onUpdate?: () => void;
+    onRepeat?: () => void;
+}
+export interface IGroupTweenOptions {
+    mode?: "all" | "sequence";
+    stagger?: number;
+    onComplete?: () => void;
+}
+export interface ITweenResult {
+    animations: Animatable[];
+    finished: Promise<void>;
+}
+export interface IUnityNavigationOptions {
+    cs: number;
+    ch: number;
+    tilesize: number;
+    walkableradius: number;
+    walkableheight: number;
+    walkableclimb: number;
+    walkableslopeangle: number;
+    minregionarea: number;
+    maxedgelen: number;
+    mergeregionarea: number;
+    maxsimplificationerror: number;
+    maxvertsperpoly: number;
+    detailsampledist: number;
+    detailsamplemaxerror: number;
+    buildheightmesh: boolean;
+}
+export declare abstract class ScriptComponent {
+    private _update;
+    private _late;
+    private _step;
+    private _fixed;
+    private _after;
+    private _ready;
+    private _lateUpdate;
+    private _properties;
+    private _awoken;
+    private _started;
+    private _scene;
+    private _delyed;
+    private _transform;
+    private _scriptReady;
+    private _registeredClassname;
+    private _registerComponentAlias;
+    private _lateUpdateObserver;
+    resetScriptComponent: () => void;
+    isReady(): boolean;
+    get scene(): Scene;
+    get transform(): TransformNode;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    dispose(): void;
+    getClassName(): string;
+    getProperties(): any;
+    getProperty<T>(name: string, defaultValue?: T): T;
+    setProperty(name: string, propertyValue: any): void;
+    getTime(): number;
+    getTimeMs(): number;
+    getGameTime(): number;
+    getGameTimeMs(): number;
+    getDeltaTime(): number;
+    getDeltaSeconds(): number;
+    getDeltaMilliseconds(): number;
+    getAnimationRatio(): number;
+    hasSkinnedMesh(): boolean;
+    getSkinnedMesh(): AbstractMesh;
+    getTransformMesh(): Mesh;
+    getAbstractMesh(): AbstractMesh;
+    getInstancedMesh(): InstancedMesh;
+    getPrimitiveMeshes(): AbstractMesh[];
+    getMetadata(): any;
+    getComponent<T extends ScriptComponent>(klass: string, recursive?: boolean): T;
+    getComponents<T extends ScriptComponent>(klass: string, recursive?: boolean): T[];
+    getLightRig(): Light;
+    getCameraRig(): FreeCamera;
+    getTransformTag(): string;
+    hasTransformTags(query: string): boolean;
+    getChildNode(name: string, searchType?: SearchType, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode;
+    getChildWithTags(query: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode;
+    getChildrenWithTags(query: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode[];
+    getChildWithScript(klass: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode;
+    getChildrenWithScript(klass: string, directDecendantsOnly?: boolean, predicate?: (node: BabylonNode) => boolean): TransformNode[];
+    private _bodyCollisionObserver;
+    private _bodyCollisionEndedObserver;
+    private _worldTriggerEventObserver;
+    enableCollisionEvents(): void;
+    disableCollisionEvents(): void;
+    onCollisionEnterObservable: Observable<TransformNode>;
+    onCollisionStayObservable: Observable<TransformNode>;
+    onCollisionExitObservable: Observable<TransformNode>;
+    onTriggerEnterObservable: Observable<TransformNode>;
+    onTriggerExitObservable: Observable<TransformNode>;
+    setTransformPosition(position: Vector3): void;
+    setTransformRotation(rotation: Quaternion): void;
+    registerOnClickAction(func: () => void): IAction;
+    unregisterOnClickAction(action: IAction): boolean;
+    private registerComponentInstance;
+    private delayComponentInstance;
+    private destroyComponentInstance;
+    private setupStepComponentInstance;
+    private removeStepComponentInstance;
+    private setupFixedComponentInstance;
+    private removeFixedComponentInstance;
+    private static RegisterInstance;
+    private static UpdateInstance;
+    private static LateInstance;
+    private static AfterInstance;
+    private static StepInstance;
+    private static FixedInstance;
+    private static ReadyInstance;
+    private static ResetInstance;
+    private static DestroyInstance;
+    private static ParseAutoProperties;
+    private static UnpackObjectProperty;
+}
+export declare enum System {
+    Deg2Rad,
+    Rad2Deg,
+    Epsilon = 0.000001,
+    SingleEpsilon = 1.401298e-45,
+    EpsilonNormalSqrt = 1e-15,
+    Kph2Mph = 0.621371,
+    Mph2Kph = 1.60934,
+    Mps2Kph = 3.6,
+    Mps2Mph = 2.23694,
+    Meter2Inch = 39.3701,
+    Inch2Meter = 0.0254,
+    Gravity = 9.81,
+    Gravity3G = 29.400000000000002,
+    SkidFactor = 0.25,
+    MaxInteger = 2147483647,
+    WalkingVelocity = 4.4,
+    TerminalVelocity = 55,
+    SmoothDeltaFactor = 0.2,
+    ToLinearSpace = 2.2,
+    ToGammaSpace = 0.45454545454545453
+}
+export declare enum SearchType {
+    ExactMatch = 0,
+    StartsWith = 1,
+    EndsWith = 2,
+    IndexOf = 3
+}
+export declare enum PlayerNumber {
+    Auto = 0,
+    One = 1,
+    Two = 2,
+    Three = 3,
+    Four = 4
+}
+export declare enum RenderQuality {
+    High = 0,
+    Medium = 1,
+    Low = 2
+}
+export declare enum GamepadType {
+    None = -1,
+    Generic = 0,
+    Xbox360 = 1,
+    DualShock = 2,
+    PoseController = 3
+}
+export declare enum UserInputAxis {
+    Horizontal = 0,
+    Vertical = 1,
+    ClientX = 2,
+    ClientY = 3,
+    MouseX = 4,
+    MouseY = 5,
+    Wheel = 6
+}
+export declare enum UserInputKey {
+    BackSpace = 8,
+    Tab = 9,
+    Enter = 13,
+    Shift = 16,
+    Ctrl = 17,
+    Alt = 18,
+    Pause = 19,
+    Break = 19,
+    CapsLock = 20,
+    Escape = 27,
+    SpaceBar = 32,
+    PageUp = 33,
+    PageDown = 34,
+    End = 35,
+    Home = 36,
+    LeftArrow = 37,
+    UpArrow = 38,
+    RightArrow = 39,
+    DownArrow = 40,
+    Insert = 45,
+    Delete = 46,
+    Num0 = 48,
+    Num1 = 49,
+    Num2 = 50,
+    Num3 = 51,
+    Num4 = 52,
+    Num5 = 53,
+    Num6 = 54,
+    Num7 = 55,
+    Num8 = 56,
+    Num9 = 57,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    LeftWindowKey = 91,
+    RightWindowKey = 92,
+    SelectKey = 93,
+    Numpad0 = 96,
+    Numpad1 = 97,
+    Numpad2 = 98,
+    Numpad3 = 99,
+    Numpad4 = 100,
+    Numpad5 = 101,
+    Numpad6 = 102,
+    Numpad7 = 103,
+    Numpad8 = 104,
+    Numpad9 = 105,
+    Multiply = 106,
+    Add = 107,
+    Subtract = 109,
+    DecimalPoint = 110,
+    Divide = 111,
+    F1 = 112,
+    F2 = 113,
+    F3 = 114,
+    F4 = 115,
+    F5 = 116,
+    F6 = 117,
+    F7 = 118,
+    F8 = 119,
+    F9 = 120,
+    F10 = 121,
+    F11 = 122,
+    F12 = 123,
+    NumLock = 144,
+    ScrollLock = 145,
+    SemiColon = 186,
+    EqualSign = 187,
+    Comma = 188,
+    Dash = 189,
+    Period = 190,
+    ForwardSlash = 191,
+    GraveAccent = 192,
+    OpenBracket = 219,
+    BackSlash = 220,
+    CloseBraket = 221,
+    SingleQuote = 222
+}
+export interface UserInputPress {
+    index: number;
+    action: () => void;
+}
+export type UserInputAction = (index: number) => void;
+export declare class UserInputOptions {
+    static KeyboardSmoothing: boolean;
+    static KeyboardMoveSensibility: number;
+    static KeyboardArrowSensibility: number;
+    static KeyboardMoveDeadZone: number;
+    static GamepadDeadStickValue: number;
+    static GamepadLStickXInverted: boolean;
+    static GamepadLStickYInverted: boolean;
+    static GamepadRStickXInverted: boolean;
+    static GamepadRStickYInverted: boolean;
+    static GamepadLStickSensibility: number;
+    static GamepadRStickSensibility: number;
+    static SupportedInputDevices: any[];
+    static BabylonAngularSensibility: number;
+    static DefaultAngularSensibility: number;
+    static PointerWheelDeadZone: number;
+    static PointerMouseDeadZone: number;
+    static PointerMouseInverted: boolean;
+    static UseCanvasElement: boolean;
+    static UseArrowKeyRotation: boolean;
+    static EnableBabylonRotation: boolean;
+}
+export interface IRuntimeOptions {
+    hardwareScalingLevel?: number;
+    initSceneFileLoaders?: boolean;
+    loadAsyncRuntimeLibs?: boolean;
+    loadProjectScriptBundle?: boolean;
+    projectScriptBundleUrl?: string;
+    showDefaultLoadingScreen?: boolean;
+    hideLoadingUIWithEngine?: boolean;
+    defaultLoadingUIMarginTop?: string;
+}
+export interface IAssetPreloader {
+    addPreloaderTasks(assetsManager: PreloadAssetsManager): void;
+}
+export interface IWindowMessage {
+    source: string;
+    command: string;
+    [key: string]: any;
+}
+export interface IUnityTransform {
+    type: string;
+    id: string;
+    tag: string;
+    name: string;
+    layer: number;
+}
+export interface IUnityCurve {
+    type: string;
+    length: number;
+    prewrapmode: string;
+    postwrapmode: string;
+    animation: any;
+}
+export interface IUnityMaterial {
+    type: string;
+    id: string;
+    name: string;
+    shader: string;
+    gltf: number;
+}
+export interface IUnityTexture {
+    type: string;
+    name: string;
+    width: number;
+    height: number;
+    filename: string;
+    wrapmode: string;
+    filtermode: string;
+    anisolevel: number;
+}
+export interface IUnityCubemap {
+    type: string;
+    name: string;
+    info: any;
+    width: number;
+    height: number;
+    filename: string;
+    extension: string;
+    wrapmode: string;
+    filtermode: string;
+    anisolevel: number;
+    texelsizex: number;
+    texelsizey: number;
+    dimension: number;
+    format: number;
+    mipmapbias: number;
+    mipmapcount: number;
+}
+export interface IUnityAudioClip {
+    type: string;
+    name: string;
+    filename: string;
+    length: number;
+    channels: number;
+    frequency: number;
+    samples: number;
+}
+export interface IUnityVideoClip {
+    type: string;
+    name: string;
+    filename: string;
+    length: number;
+    width: number;
+    height: number;
+    framerate: number;
+    framecount: number;
+    audiotracks: number;
+}
+export interface IUnityFontAsset {
+    type: string;
+    filename: string;
+    format: string;
+}
+export interface IUnityTextAsset {
+    type: string;
+    filename: string;
+    base64: string;
+    json: boolean;
+}
+export interface IUnityDefaultAsset {
+    type: string;
+    filename: string;
+    base64: string;
+    json: boolean;
+}
+export interface IUnityVector2 {
+    x: number;
+    y: number;
+}
+export interface IUnityVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface IUnityVector4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface IUnityColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare class RequestHeader {
+    name: string;
+    value: string;
+}
+export declare class GlobalMessageBus {
+    constructor();
+    OnMessage<T>(message: string, handler: (data: T) => void): void;
+    PostMessage(message: string, data?: any, target?: string, transfer?: Transferable[] | undefined): void;
+    RemoveHandler(message: string, handler: (data: any) => void): void;
+    ResetHandlers(): void;
+    Dispose(): void;
+    private HandleWindowMessage;
+    private OnDispatchMessage;
+    private ListenerDictionary;
+}
+export declare class PreloadAssetsManager extends AssetsManager {
+    addContainerTask(taskName: string, meshesNames: any, rootUrl: string, sceneFilename: string): ContainerAssetTask;
+    addMeshTask(taskName: string, meshesNames: any, rootUrl: string, sceneFilename: string): MeshAssetTask;
+    addTextFileTask(taskName: string, url: string): TextFileAssetTask;
+    addBinaryFileTask(taskName: string, url: string): BinaryFileAssetTask;
+    addImageTask(taskName: string, url: string): ImageAssetTask;
+    private handlePreloadingProgress;
+}
+export declare enum MaterialAlphaMode {
+    OPAQUE = "OPAQUE",
+    MASK = "MASK",
+    BLEND = "BLEND"
+}
+export declare class CubeTextureLoader {
+    name: string;
+    size: number;
+    mapkey: string;
+    material: Material;
+    extension: string;
+    prefiltered: boolean;
+    boundingBoxSize: Vector3;
+    boundingBoxPosition: Vector3;
+    reflectionProbePower: number;
+}
+export declare class CVTOOLS_unity_metadata implements IGLTFLoaderExtension {
+    readonly name: string;
+    static readonly IBL_TINY_VALUE: number;
+    static readonly IBL_SPEC_FACTOR: number;
+    static readonly IBL_PROBE_FACTOR: number;
+    enabled: boolean;
+    private _webgpu;
+    private _loader;
+    private _babylonScene;
+    private _metadataParser;
+    private _loaderScene;
+    private _assetsManager;
+    private _parserList;
+    private _masterList;
+    private _detailList;
+    private _shaderList;
+    private _readyList;
+    private _preloadList;
+    private _animationGroups;
+    private _materialMap;
+    private _lightmapMap;
+    private _reflectionMap;
+    private _reflectionCache;
+    private _assetContainer;
+    private _activeMeshes;
+    private _parseScene;
+    private _leftHanded;
+    private _disposeRoot;
+    private _sceneParsed;
+    private _preWarmTime;
+    private _hideLoader;
+    private _rootUrl;
+    private _fileName;
+    private _licenseName;
+    private _licenseType;
+    private _pendingReflectionTextures;
+    private static ScriptBundleCache;
+    constructor(loader: GLTFLoader);
+    dispose(): void;
+    onLoading(): void;
+    onReady(): void;
+    onComplete(): void;
+    getScriptBundleTag(): string;
+    getScriptBundleUrl(): string;
+    finishComplete(): void;
+    onValidate(): void;
+    onCleanup(): void;
+    setupLoader(): void;
+    startParsing(): void;
+    private _processActiveMeshes;
+    private _processUnityMeshes;
+    private _processPreloadTimeout;
+    loadSceneAsync(context: string, scene: IScene): Promise<void> | null;
+    private _loadSceneInternalAsync;
+    private _loadSceneExAsync;
+    loadNodeAsync(context: string, node: INode, assign: (babylonMesh: TransformNode) => void): Promise<TransformNode> | null;
+    loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
+    private _getCachedMaterialByIndex;
+    private _getCachedLightmapByIndex;
+    createMaterial(context: string, material: IMaterial, babylonDrawMode: number): Nullable<Material>;
+    loadAnimationAsync(context: string, animation: IAnimation): Promise<AnimationGroup>;
+    _loadMeshPrimitiveAsync(context: string, name: string, node: INode, mesh: IMesh, primitive: any, assign: (babylonMesh: AbstractMesh) => void): Promise<AbstractMesh>;
+    private _setupBabylonMesh;
+    private _setupBabylonMultiMaterials;
+    private _processLevelOfDetail;
+    private _processShaderMaterials;
+    private preProcessSceneProperties;
+    private postProcessSceneProperties;
+    private updateSkyboxEnvironment;
+    private generateSphericalHarmonics;
+    private lateProcessSceneProperties;
+    private _preloadRawMaterialsAsync;
+    private _parseMultiMaterialAsync;
+    private _parseCommonConstantProperties;
+    private _parseUniformAndSamplerProperties;
+}
+export declare class CVTOOLS_babylon_mesh implements IGLTFLoaderExtension {
+    readonly name: string;
+    enabled: boolean;
+    private _loader;
+    constructor(loader: GLTFLoader);
+    dispose(): void;
+}
+export declare class CVTOOLS_left_handed implements IGLTFLoaderExtension {
+    readonly name: string;
+    enabled: boolean;
+    private _loader;
+    constructor(loader: GLTFLoader);
+    dispose(): void;
+}
+export declare class CustomShaderMaterial extends PBRMaterial {
+    universalMaterial: boolean;
+    private _defines;
+    private _uniforms;
+    private _samplers;
+    private _attributes;
+    private _textures;
+    private _vectors4;
+    private _vectors3;
+    private _vectors2;
+    private _floats;
+    private _bools;
+    private _ubos;
+    private _wgslSamplers;
+    private _noMatrixTextures;
+    protected shader: string;
+    protected plugin: MaterialPluginBase;
+    private _unityLightingPlugin;
+    getPlugin(): MaterialPluginBase;
+    getClassName(): string;
+    constructor(name: string, scene: Scene);
+    initMaterial(): void;
+    addAttribute(attributeName: string): void;
+    checkUniform(uniformName: string, type: string, value?: any): void;
+    checkSampler(samplerName: string, texture?: any): void;
+    splitLighting(diffuseIbl: number, specularIbl: number): void;
+    addTextureUniform(name: string, texture: Texture): CustomShaderMaterial;
+    setTextureValue(name: string, texture: Texture): CustomShaderMaterial;
+    markTextureAsRaw(name: string): void;
+    getTextureValue(name: string): Texture;
+    addVector4Uniform(name: string, value: Vector4): CustomShaderMaterial;
+    setVector4Value(name: string, value: Vector4): CustomShaderMaterial;
+    getVector4Value(name: string): Vector4;
+    addVector3Uniform(name: string, value: Vector3): CustomShaderMaterial;
+    setVector3Value(name: string, value: Vector3): CustomShaderMaterial;
+    getVector3Value(name: string): Vector3;
+    addVector2Uniform(name: string, value: Vector2): CustomShaderMaterial;
+    setVector2Value(name: string, value: Vector2): CustomShaderMaterial;
+    getVector2Value(name: string): Vector2;
+    addFloatUniform(name: string, value: number): CustomShaderMaterial;
+    setFloatValue(name: string, value: number): CustomShaderMaterial;
+    getFloatValue(name: string): number;
+    addBoolUniform(name: string, value: boolean): CustomShaderMaterial;
+    setBoolValue(name: string, value: boolean): CustomShaderMaterial;
+    getBoolValue(name: string): boolean;
+    getAnimatables(): IAnimatable[];
+    getActiveTextures(): BaseTexture[];
+    hasTexture(texture: BaseTexture): boolean;
+    getCustomUniforms(wgsl: boolean): any;
+    getCustomSamplers(): string[];
+    getCustomAttributes(): string[];
+    getCustomVertexCode(wgsl: boolean): string;
+    getCustomFragmentCode(wgsl: boolean): string;
+    prepareCustomDefines(defines: MaterialDefines): void;
+    updateCustomBindings(effectOrUniformBuffer: UniformBuffer | Effect): void;
+    legacyUpdateCustomBindings(effect: UniformBuffer): void;
+    protected buildUniformProperty(uniformName: string, uniformType: string, uniformValue: any): void;
+}
+export declare class CustomShaderMaterialPlugin extends MaterialPluginBase {
+    private _isEnabled;
+    getClassName(): string;
+    constructor(material: Material, name: string, priority: number, defines?: {}, addToPluginList?: boolean, enable?: boolean, resolveIncludes?: boolean);
+    getIsEnabled(): boolean;
+    setIsEnabled(enabled: boolean): void;
+    vertexDefinitions: string;
+    fragmentDefinitions: string;
+    getCustomShaderMaterial(): CustomShaderMaterial;
+}
+export declare class UnityStyleLightingPlugin extends CustomShaderMaterialPlugin {
+    constructor(material: CustomShaderMaterial, shaderName: string);
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    getClassName(): string;
+    getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
+    getUniforms(shaderLanguage: ShaderLanguage): any;
+    prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
+}
+export type CustomUniformProperty = {
+    name: string;
+    size: number;
+    type: string;
+    arraySize?: number;
+};
+export declare class UniversalShaderMaterial extends CustomShaderMaterial {
+    constructor(name: string, scene: Scene);
+    getShaderName(): string;
+}
+export declare class MetadataParser {
+    private _physicList;
+    private _shadowList;
+    private _freezeList;
+    private _scriptList;
+    private _babylonScene;
+    constructor(scene: Scene);
+    parseSceneComponents(entity: TransformNode): void;
+    postProcessSceneComponents(preloadList: Array<ScriptComponent>, readyList: Array<ScriptComponent>): void;
+    private static DoParseSceneComponents;
+    private static DoProcessPendingScripts;
+    private static DoProcessPendingShadows;
+    private static DoProcessPendingPhysics;
+    private static DoProcessPendingFreezes;
+    private static SetupCameraComponent;
+    private static SetupLightComponent;
+}
+export declare class StandardShaderMaterial extends StandardMaterial {
+    universalMaterial: boolean;
+    private _defines;
+    private _uniforms;
+    private _samplers;
+    private _attributes;
+    private _textures;
+    private _vectors4;
+    private _vectors3;
+    private _vectors2;
+    private _floats;
+    private _bools;
+    private _ubos;
+    private _wgslSamplers;
+    protected shader: string;
+    protected plugin: MaterialPluginBase;
+    getClassName(): string;
+    constructor(name: string, scene: Scene);
+    initMaterial(): void;
+    addAttribute(attributeName: string): void;
+    checkUniform(uniformName: string, type: string, value?: any): void;
+    checkSampler(samplerName: string, texture?: any): void;
+    addTextureUniform(name: string, texture: Texture): StandardShaderMaterial;
+    setTextureValue(name: string, texture: Texture): StandardShaderMaterial;
+    getTextureValue(name: string): Texture;
+    addVector4Uniform(name: string, value: Vector4): StandardShaderMaterial;
+    setVector4Value(name: string, value: Vector4): StandardShaderMaterial;
+    getVector4Value(name: string): Vector4;
+    addVector3Uniform(name: string, value: Vector3): StandardShaderMaterial;
+    setVector3Value(name: string, value: Vector3): StandardShaderMaterial;
+    getVector3Value(name: string): Vector3;
+    addVector2Uniform(name: string, value: Vector2): StandardShaderMaterial;
+    setVector2Value(name: string, value: Vector2): StandardShaderMaterial;
+    getVector2Value(name: string): Vector2;
+    addFloatUniform(name: string, value: number): StandardShaderMaterial;
+    setFloatValue(name: string, value: number): StandardShaderMaterial;
+    getFloatValue(name: string): number;
+    addBoolUniform(name: string, value: boolean): StandardShaderMaterial;
+    setBoolValue(name: string, value: boolean): StandardShaderMaterial;
+    getBoolValue(name: string): boolean;
+    getAnimatables(): IAnimatable[];
+    getActiveTextures(): BaseTexture[];
+    hasTexture(texture: BaseTexture): boolean;
+    getCustomUniforms(wgsl: boolean): any;
+    getCustomSamplers(): string[];
+    getCustomAttributes(): string[];
+    getCustomVertexCode(wgsl: boolean): string;
+    getCustomFragmentCode(wgsl: boolean): string;
+    prepareCustomDefines(defines: MaterialDefines): void;
+    updateCustomBindings(effectOrUniformBuffer: UniformBuffer | Effect): void;
+    legacyUpdateCustomBindings(effect: UniformBuffer): void;
+    protected buildUniformProperty(uniformName: string, uniformType: string, uniformValue: any): void;
+}
+export declare class StandardShaderMaterialPlugin extends MaterialPluginBase {
+    private _isEnabled;
+    getClassName(): string;
+    constructor(material: Material, name: string, priority: number, defines?: {}, addToPluginList?: boolean, enable?: boolean, resolveIncludes?: boolean);
+    getIsEnabled(): boolean;
+    setIsEnabled(enabled: boolean): void;
+    vertexDefinitions: string;
+    fragmentDefinitions: string;
+    getCustomShaderMaterial(): StandardShaderMaterial;
+}
+export declare class Utilities {
+    private static UpVector;
+    private static AuxVector;
+    private static ZeroVector;
+    private static TempMatrix;
+    private static TempMatrix2;
+    private static TempVector2;
+    private static TempVector3;
+    private static TempQuaternion;
+    private static TempQuaternion2;
+    private static TempQuaternion3;
+    private static TempDirectionBuffer;
+    private static LoadingState;
+    static ZeroPad(num: number, places: number): string;
+    static ShiftArray(arr: any[], reverse: boolean): any[];
+    static OnPreloaderProgress: (remainingCount: number, totalCount: number, lastFinishedTask: AbstractAssetTask) => void;
+    static OnPreloaderComplete: (tasks: AbstractAssetTask[]) => void;
+    static GetLayerMask(layer: number): number;
+    static IsLayerMasked(mask: number, layer: number): boolean;
+    static GetHavokPlugin(): HavokPlugin;
+    static GetLoadingState(): number;
+    static GetRandomRange(min: number, max: number, last?: Nullable<number>, retries?: Nullable<number>): number;
+    static GetRandomFloat(min: number, max: number, last?: Nullable<number>, retries?: Nullable<number>): number;
+    static GetRandomInteger(min: number, max: number, last?: Nullable<number>, retries?: Nullable<number>): number;
+    static Approximately(a: number, b: number): boolean;
+    static GetVertexDataFromMesh(mesh: Mesh): VertexData;
+    static CalculateDestinationPoint(origin: Vector3, direction: Vector3, length: number): Vector3;
+    static CalculateDestinationPointToRef(origin: Vector3, direction: Vector3, length: number, result: Vector3): void;
+    static UpdateAbstractMeshMaterial(mesh: AbstractMesh, material: Material, materialIndex: number): void;
+    static HermiteVector3(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, amount: number): Vector3;
+    static HermiteVector3ToRef(value1: DeepImmutable<Vector3>, tangent1: DeepImmutable<Vector3>, value2: DeepImmutable<Vector3>, tangent2: DeepImmutable<Vector3>, amount: number, result: Vector3): void;
+    static ExpSmoothing(dt: number, timeConstant: number): number;
+    static LerpLog(a: number, b: number, t: number): number;
+    static LerpExp(a: number, b: number, t: number): number;
+    static LerpUnclamped(a: number, b: number, t: number): number;
+    static LerpUnclampedColor3(a: Color3, b: Color3, t: number): Color3;
+    static LerpUnclampedColor3ToRef(a: Color3, b: Color3, t: number, result: Color3): void;
+    static LerpUnclampedColor4(a: Color4, b: Color4, t: number): Color4;
+    static LerpUnclampedColor4ToRef(a: Color4, b: Color4, t: number, result: Color4): void;
+    static LerpUnclampedVector2(a: Vector2, b: Vector2, t: number): Vector2;
+    static LerpUnclampedVector2ToRef(a: Vector2, b: Vector2, t: number, result: Vector2): void;
+    static LerpUnclampedVector3(a: Vector3, b: Vector3, t: number): Vector3;
+    static LerpUnclampedVector3ToRef(a: Vector3, b: Vector3, t: number, result: Vector3): void;
+    static LerpUnclampedVector4(a: Vector4, b: Vector4, t: number): Vector4;
+    static LerpUnclampedVector4ToRef(a: Vector4, b: Vector4, t: number, result: Vector4): void;
+    static IsEqualUsingDot(dot: number): boolean;
+    static QuaternionAngle(a: Quaternion, b: Quaternion): number;
+    static QuaternionLengthSquared(quat: Quaternion): number;
+    static QuaternionRotateTowards(from: Quaternion, to: Quaternion, maxDegreesDelta: number): Quaternion;
+    static QuaternionRotateTowardsToRef(from: Quaternion, to: Quaternion, maxDegreesDelta: number, result: Quaternion): void;
+    static QuaternionSlerpUnclamped(from: Quaternion, to: Quaternion, t: number): Quaternion;
+    static QuaternionSlerpUnclampedToRef(a: Quaternion, b: Quaternion, t: number, result: Quaternion): void;
+    static MoveTowards(current: number, target: number, maxDelta: number): number;
+    static MoveTowardsVector2(current: Vector2, target: Vector2, maxDistanceDelta: number): Vector2;
+    static MoveTowardsVector2ToRef(current: Vector2, target: Vector2, maxDistanceDelta: number, result: Vector2): void;
+    static MoveTowardsVector3(current: Vector3, target: Vector3, maxDistanceDelta: number): Vector3;
+    static MoveTowardsVector3ToRef(current: Vector3, target: Vector3, maxDistanceDelta: number, result: Vector3): void;
+    static MoveTowardsVector4(current: Vector4, target: Vector4, maxDistanceDelta: number): Vector4;
+    static MoveTowardsVector4ToRef(current: Vector4, target: Vector4, maxDistanceDelta: number, result: Vector4): void;
+    static ClampMagnitudeVector2(vector: Vector2, length: number): Vector2;
+    static ClampMagnitudeVector2ToRef(vector: Vector2, length: number, result: Vector2): void;
+    static ClampMagnitudeVector3(vector: Vector3, length: number): Vector3;
+    static ClampMagnitudeVector3ToRef(vector: Vector3, length: number, result: Vector3): void;
+    static GetAngle(from: Vector3, to: Vector3): number;
+    static GetAngleRadians(from: Vector3, to: Vector3): number;
+    static ClampAngle(angle: number, min: number, max: number): number;
+    static ClampAngle180(angle: number, min: number, max: number): number;
+    static ClampAngle360(angle: number, min: number, max: number): number;
+    static SmoothDamp(current: number, target: number, smoothTime: number, maxSpeed: number, deltaTime: number, currentVelocity: Vector2): number;
+    static SmoothDampAngle(current: number, target: number, smoothTime: number, maxSpeed: number, deltaTime: number, currentVelocity: Vector2): number;
+    static SmoothDampVector2(current: Vector2, target: Vector2, smoothTime: number, maxSpeed: number, deltaTime: number, currentVelocity: Vector2): Vector2;
+    static SmoothDampVector2ToRef(current: Vector2, target: Vector2, smoothTime: number, maxSpeed: number, deltaTime: number, currentVelocity: Vector2, result: Vector2): void;
+    static SmoothDampVector3(current: Vector3, target: Vector3, smoothTime: number, maxSpeed: number, deltaTime: number, currentVelocity: Vector3): Vector3;
+    static SmoothDampVector3ToRef(current: Vector3, target: Vector3, smoothTime: number, maxSpeed: number, deltaTime: number, currentVelocity: Vector3, result: Vector3): void;
+    static ToMatrix(x: number, y: number, z: number): Matrix;
+    static ToMatrixToRef(x: number, y: number, z: number, result: Matrix): void;
+    static FastMatrixLerp(startValue: Matrix, endValue: Matrix, gradient: number, result: Matrix): void;
+    static FastMatrixSlerp(startValue: Matrix, endValue: Matrix, gradient: number, result: Matrix): void;
+    static ToEuler(quaternion: Quaternion): Vector3;
+    static ToEulerToRef(quaternion: Quaternion, result: Vector3): void;
+    static FromEuler(x: number, y: number, z: number): Quaternion;
+    static FromEulerToRef(x: number, y: number, z: number, result: Quaternion): void;
+    static QuaternionDiff(a: Quaternion, b: Quaternion): Quaternion;
+    static QuaternionDiffToRef(a: Quaternion, b: Quaternion, result: Quaternion): void;
+    static QuaternionSubtractToRef(source: Quaternion, other: Quaternion, result: Quaternion): void;
+    static RotateVector(vec: Vector3, quat: Quaternion): Vector3;
+    static RotateVectorToRef(vec: Vector3, quat: Quaternion, result: Vector3): void;
+    static LookRotation(direction: Vector3): Quaternion;
+    static LookRotationToRef(direction: Vector3, result: Quaternion): void;
+    static Vector3Rad2Deg(vector: Vector3): Vector3;
+    static Vector3Rad2DegToRef(vector: Vector3, result: Vector3): void;
+    static MultiplyQuaternionByVector(rotation: Quaternion, point: Vector3): Vector3;
+    static MultiplyQuaternionByVectorToRef(rotation: Quaternion, point: Vector3, result: Vector3): void;
+    static ValidateTransformRotation(transform: TransformNode): void;
+    static ValidateTransformQuaternion(transform: TransformNode): void;
+    static GetKeyboardInputValue(scene: Scene, currentValue: number, targetValue: number): number;
+    static GenerateRandonNumber(min: number, max: number, decimals?: number): number;
+    static ProjectVector(vector: Vector3, onnormal: Vector3): Vector3;
+    static ProjectVectorToRef(vector: Vector3, onnormal: Vector3, result: Vector3): void;
+    static ProjectVectorOnPlane(vector: Vector3, planenormal: Vector3): Vector3;
+    static ProjectVectorOnPlaneToRef(vector: Vector3, planenormal: Vector3, result: Vector3): void;
+    static AreVectorsEqual(v1: Vector3, v2: Vector3, p: number): boolean;
+    static GetVerticalSlopeAngle(v: Vector3, max?: number): number;
+    static DownloadEnvironment(cubemap: CubeTexture, success?: () => void, failure?: () => void): void;
+    static HasOwnProperty(object: any, property: string): boolean;
+    static FindMeshCollider(scene: Scene, object: IPhysicsEnabledObject): IPhysicsEnabledObject;
+    static ColliderInstances(): boolean;
+    static ReparentColliders(): boolean;
+    static UseTriangleNormals(): boolean;
+    static UseConvexTriangles(): boolean;
+    static DefaultRenderGroup(): number;
+    static ShowDebugColliders(): boolean;
+    static ColliderVisibility(): number;
+    static ColliderRenderGroup(): number;
+    static CollisionWireframe(): boolean;
+    static GetColliderMaterial(scene: Scene): Material;
+    static CalculateCombinedFriction(friction0: number, friction1: number): number;
+    static CalculateCombinedRestitution(restitution0: number, restitution1: number): number;
+    private static LoaderItemsMarkedForDisposal;
+    static AddLoaderItemMarkedForDisposal(node: TransformNode): void;
+    static ResetLoaderItemsMarkedForDisposal(): void;
+    static RemoveLoaderItemsMarkedForDisposal(): void;
+    static GetDirectTargetAngle(transform: TransformNode, worldSpaceTarget: Vector3): number;
+    static GetSmoothTargetAngle(transform: TransformNode, worldSpaceTarget: Vector3): number;
+    static CalculatCatmullRom(p0: Vector3, p1: Vector3, p2: Vector3, p3: Vector3, i: number): Vector3;
+    static CalculatCatmullRomToRef(p0: Vector3, p1: Vector3, p2: Vector3, p3: Vector3, i: number, result: Vector3): void;
+    static MakeProper(name: string): string;
+    static StartsWith(source: string, word: string): boolean;
+    static EndsWith(source: string, word: string): boolean;
+    static ReplaceAll(source: string, word: string, replace: string): string;
+    static IsNullOrEmpty(source: string): boolean;
+    static SafeStringPush(array: string[], value: string): void;
+    static ParseColor3(source: IUnityColor, defaultValue?: Color3, toLinearSpace?: boolean): Color3;
+    static ParseColor4(source: IUnityColor, defaultValue?: Color4, toLinearSpace?: boolean): Color4;
+    static ParseVector2(source: IUnityVector2, defaultValue?: Vector2): Vector2;
+    static ParseVector3(source: IUnityVector3, defaultValue?: Vector3): Vector3;
+    static ParseVector4(source: IUnityVector4, defaultValue?: Vector4): Vector4;
+    static ParseSound(source: IUnityAudioClip, scene: Scene, name: string, callback?: Nullable<() => void>, options?: IStaticSoundOptions): Promise<StaticSound>;
+    static ParseTexture(source: IUnityTexture, scene: Scene, noMipmap?: boolean, invertY?: boolean, samplingMode?: number, onLoad?: Nullable<() => void>, onError?: Nullable<(message?: string, exception?: any) => void>, buffer?: Nullable<any>, deleteBuffer?: boolean, format?: number): Texture;
+    static ParseCubemap(source: IUnityCubemap, scene: Scene): CubeTexture;
+    static ParseTextAsset(source: IUnityTextAsset, defaultValue?: string): string;
+    static ParseJsonAsset<T>(source: IUnityTextAsset, defaultValue?: string, reviver?: (this: any, key: string, value: any) => any): T;
+    static ParseTransformByID(source: IUnityTransform, scene: Scene, defaultValue?: TransformNode): TransformNode;
+    static ParseTransformByName(source: IUnityTransform, scene: Scene, defaultValue?: TransformNode): TransformNode;
+    static ParseChildTransform(parent: TransformNode, source: IUnityTransform, defaultValue?: TransformNode): TransformNode;
+    static SetAbsolutePosition(transform: TransformNode, position: Vector3): void;
+    static GetAbsolutePosition(transform: TransformNode, offsetPosition?: Vector3, computeMatrix?: boolean): Vector3;
+    static GetAbsolutePositionToRef(transform: TransformNode, result: Vector3, offsetPosition?: Vector3, computeMatrix?: boolean): void;
+    static SetAbsoluteRotation(transform: TransformNode, rotation: Quaternion): void;
+    static GetAbsoluteRotation(transform: TransformNode): Quaternion;
+    static GetAbsoluteRotationToRef(transform: TransformNode, result: Quaternion): void;
+    static TransformPoint(owner: TransformNode | Camera, position: Vector3, computeMatrix?: boolean): Vector3;
+    static InverseTransformPoint(owner: TransformNode | Camera, position: Vector3, computeMatrix?: boolean): Vector3;
+    static TransformPointToRef(owner: TransformNode | Camera, position: Vector3, result: Vector3, computeMatrix?: boolean): void;
+    static InverseTransformPointToRef(owner: TransformNode | Camera, position: Vector3, result: Vector3, computeMatrix?: boolean): void;
+    static TransformDirection(owner: TransformNode | Camera, direction: Vector3, computeMatrix?: boolean): Vector3;
+    static InverseTransformDirection(owner: TransformNode | Camera, direction: Vector3, computeMatrix?: boolean): Vector3;
+    static TransformDirectionToRef(owner: TransformNode | Camera, direction: Vector3, result: Vector3, computeMatrix?: boolean): void;
+    static InverseTransformDirectionToRef(owner: TransformNode | Camera, direction: Vector3, result: Vector3, computeMatrix?: boolean): void;
+    static RecomputeCenterPivotPoint(owner: AbstractMesh): void;
+    static GetDirectionVector(owner: TransformNode | Camera, vector: Vector3): Vector3;
+    static GetDirectionVectorToRef(owner: TransformNode | Camera, vector: Vector3, result: Vector3): void;
+    static GetForwardVector(owner: TransformNode | Camera): Vector3;
+    static GetForwardVectorToRef(owner: TransformNode | Camera, result: Vector3): void;
+    static GetRightVector(owner: TransformNode | Camera): Vector3;
+    static GetRightVectorToRef(owner: TransformNode | Camera, result: Vector3): void;
+    static GetUpVector(owner: TransformNode | Camera): Vector3;
+    static GetUpVectorToRef(owner: TransformNode | Camera, result: Vector3): void;
+    static BlendFloatValue(source: number, value: number, weight: number): number;
+    static BlendVector2Value(source: Vector2, value: Vector2, weight: number): void;
+    static BlendVector3Value(source: Vector3, value: Vector3, weight: number): void;
+    static BlendQuaternionValue(source: Quaternion, value: Quaternion, weight: number): void;
+    static SetAnimationTargetProperty(animation: Animation, property: string): void;
+    static SampleAnimationFloat(animation: Animation, time: number, loopMode?: number, gltfAnimation?: boolean): number;
+    static SampleAnimationVector2(animation: Animation, time: number, loopMode?: number, gltfAnimation?: boolean): Vector2;
+    static SampleAnimationVector3(animation: Animation, time: number, loopMode?: number, gltfAnimation?: boolean): Vector3;
+    static SampleAnimationQuaternion(animation: Animation, time: number, loopMode?: number, gltfAnimation?: boolean): Quaternion;
+    static SampleAnimationMatrix(animation: Animation, time: number, loopMode?: number, gltfAnimation?: boolean): Matrix;
+    static GetLastKeyFrameIndex(animation: Animation): number;
+    private static InterpolateAnimation;
+    static UpdateLoopBlendPositionSettings(animationTrack: AnimationGroup, loopBlendPositionY: boolean, loopBlendPositionXZ: boolean): void;
+    static TakeScreenSnapshot(scene: Scene, engine: AbstractEngine, size?: {
+        width?: number;
+        height?: number;
+        precision?: number;
+    }, bitmapOptions?: ImageBitmapOptions, onComplete?: (bmd: ImageBitmap | null) => void): void;
+    static DownloadImageBitmap(bmp: ImageBitmap | null, filename?: string, type?: "image/png" | "image/jpeg", quality?: number): HTMLCanvasElement | OffscreenCanvas;
+    static MarkLinear(t?: BaseTexture | null): void;
+    static MarkGamma(t?: BaseTexture | null): void;
+    static WorldToScreenPoint(scene: Scene, position: Vector3, camera?: Camera): Vector3;
+    static ScreenToWorldPoint(scene: Scene, position: Vector3): Vector3;
+    static LoadTextFile(url: string, onSuccess: (data: string | ArrayBuffer) => void, onProgress?: (data: any) => void, onError?: (request?: WebRequest, exception?: any) => void): IFileRequest;
+    static LoadTextFileAsync(url: string): Promise<string>;
+    static GetHttpRequest(url: string, headers?: RequestHeader[], onSuccess?: (xhr: XMLHttpRequest) => void, onFailure?: (reason: any) => void, onProgress?: (evt: ProgressEvent) => void, useArrayBuffer?: boolean, overrideMimeType?: string): XMLHttpRequest;
+    static GetHttpRequestAsync(url: string, headers?: RequestHeader[], onProgress?: (evt: ProgressEvent) => void, useArrayBuffer?: boolean, overrideMimeType?: string): Promise<XMLHttpRequest>;
+    static PostHttpRequest(url: string, data: any, headers?: RequestHeader[], contentType?: string, onSuccess?: (xhr: XMLHttpRequest) => void, onFailure?: (reason: any) => void, onProgress?: (evt: ProgressEvent) => void, useArrayBuffer?: boolean, overrideMimeType?: string): XMLHttpRequest;
+    static PostHttpRequestAsync(url: string, data: any, headers?: RequestHeader[], contentType?: string, onProgress?: (evt: ProgressEvent) => void, useArrayBuffer?: boolean, overrideMimeType?: string): Promise<XMLHttpRequest>;
+    static RemapValueToRange(value: number, a1: number, a2: number, b1: number, b2: number): number;
+    static CloneSkeletonPrefab(scene: Scene, skeleton: Skeleton, name: string, id?: string, root?: TransformNode): Skeleton;
+    static GetSceneTransforms(scene: Scene): TransformNode[];
+    static PostParseSceneComponents(scene: Scene, transforms: TransformNode[], preloadList: Array<ScriptComponent>, readyList: Array<ScriptComponent>): MetadataParser;
+    static GetDefaultReflectionTexture(scene: Scene): CubeTexture;
+    static GetNeutralReflectionTexture(scene: Scene, grayValue?: number, level?: number): CubeTexture;
+    static GetAssetContainerMesh(container: AssetContainer, meshName: string): Mesh;
+    static GetAssetContainerNode(container: AssetContainer, nodeName: string): TransformNode;
+    static CloneAssetContainerItem(container: AssetContainer, assetName: string, nameFunction?: (sourceName: string) => string, newParent?: Nullable<TransformNode>, makeNewMaterials?: boolean, cloneAnimations?: boolean): TransformNode;
+    static AssignAnimationGroupsToInstance(root: TransformNode, groups: AnimationGroup[]): void;
+    static AssignAnimationGroupsToNode(transform: TransformNode, groups: AnimationGroup[]): void;
+    static UnitySlopeAngleToCosine(unitySlopeAngleDegrees: number): number;
+    static InstantiateHierarchy(node: TransformNode, newParent?: Nullable<TransformNode>, onNewNodeCreated?: (source: TransformNode, clone: TransformNode) => void): Nullable<TransformNode>;
+    static InstantiateNodeHierarchy(node: TransformNode, newParent?: Nullable<TransformNode>, onNewNodeCreated?: (source: TransformNode, clone: TransformNode) => void): Nullable<TransformNode>;
+    static InstantiateMeshHierarchy(mesh: Mesh, newParent: Nullable<TransformNode>, createInstance: boolean, onNewNodeCreated?: (source: TransformNode, clone: TransformNode) => void): Nullable<TransformNode>;
+    static PrepareSkeletonForRendering(skeleton: Skeleton, dontCheckFrameId?: boolean): void;
+    static RetargetAnimationGroupSkeleton(animationGroup: AnimationGroup, targetSkeleton: Skeleton, targetArmatureNode?: TransformNode): void;
+    static RetargetAnimationGroupBlendShapes(animationGroup: AnimationGroup, targetMesh: Mesh): void;
+    static LinkSkeletonMeshes(master: Skeleton, slave: Skeleton): void;
+    static FindBoneByName(skeleton: Skeleton, name: string): Bone;
+    static SwitchHandednessVector3(input: Vector3): Vector3;
+    static SwitchHandednessVector4(input: Vector4): Vector4;
+    static SwitchHandednessQuaternion(input: Quaternion): Quaternion;
+    static ComputeBlendingSpeed(rate: number, duration: number, dampen?: boolean): number;
+    static CalculateCameraDistance(farClipPlane: number, lodPercent: number, clipPlaneScale?: number): number;
+    static EvalSphericalPolynomialRGB(poly: SphericalPolynomial, n: Vector3): Color3;
+    static BestFitScale(unityRGB: number[], babRGB: number[]): number;
+    static ComputeSHEval6Fit(sp: SphericalPolynomial, unityEval6: number[]): {
+        scale: number;
+        rmse: number;
+        perChannelRMSE: number[];
+        perDir: Array<any>;
+    };
+    static InstantiateClass(className: string): any;
+    static GetSimpleClassName(obj: any): string;
+    static DisposeEntity(entity: AbstractMesh): void;
+    static SearchTransformNodes(name: string, nodes: BabylonNode[], searchType?: SearchType): BabylonNode;
+    static SearchTransformNodeForTags(query: string, nodes: BabylonNode[]): BabylonNode;
+    static SearchAllTransformNodesForTags(query: string, nodes: BabylonNode[]): BabylonNode[];
+    static SearchTransformNodeForScript(klass: string, nodes: BabylonNode[]): BabylonNode;
+    static SearchAllTransformNodesForScript(klass: string, nodes: BabylonNode[]): BabylonNode[];
+    static CreateGuid(suffix?: string): string;
+    static ValidateTransformGuid(node: TransformNode): void;
+    static RegisterInstancedMeshBuffers(mesh: Mesh): void;
+    static CloneValue(source: any, destinationObject: any): any;
+    static CloneEntityMetadata(source: any): any;
+    static FastJsonCopy(val: any): any;
+    static DeepCopyProperties(source: any, destination: any, doNotCopyList?: string[], mustCopyList?: string[]): void;
+    static ValidateTransformMetadata(transform: TransformNode): void;
+}
+export declare class GrassStandardMaterial extends StandardShaderMaterial {
+    private _windTimeAccum;
+    private _lastUpdateFrame;
+    constructor(name: string, scene: Scene);
+    awake(): void;
+    update(): void;
+    getShaderName(): string;
+    getMaxDistance(): number;
+    setMaxDistance(distance: number): void;
+    getFadeStart(): number;
+    setFadeStart(distance: number): void;
+    getWaveSpeed(): number;
+    setWaveSpeed(speed: number): void;
+    getWaveSize(): number;
+    setWaveSize(size: number): void;
+    getWindAmount(): number;
+    setWindAmount(amount: number): void;
+    getWindTint(): Vector4;
+    setWindTint(tint: Vector4): void;
+    getShadowIntensity(): number;
+    setShadowIntensity(intensity: number): void;
+}
+export declare class GrassStandardMaterialPlugin extends StandardShaderMaterialPlugin {
+    constructor(customMaterial: StandardShaderMaterial, shaderName: string);
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
+    private getWGSLVertexMainEnd;
+    private getWGSLVaryingDefinitions;
+    private getWGSLVertexWorldPos;
+    private getGLSLVertexDefinitions;
+    private getGLSLVertexMainEnd;
+    private getGLSLVertexWorldPos;
+    private getWGSLFragmentCode;
+    private getGLSLFragmentCode;
+    private getGLSLFragmentDefinitions;
+    getUniforms(shaderLanguage: ShaderLanguage): any;
+    getSamplers(samplers: string[]): void;
+    getAttributes(attributes: string[], scene: Scene, mesh: AbstractMesh): void;
+    prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
+}
+export declare class GrassBillboardMaterial extends StandardShaderMaterial {
+    private _windTimeAccum;
+    private _lastUpdateFrame;
+    constructor(name: string, scene: Scene);
+    awake(): void;
+    update(): void;
+    getShaderName(): string;
+    getMaxDistance(): number;
+    setMaxDistance(distance: number): void;
+    getFadeStart(): number;
+    setFadeStart(distance: number): void;
+    getWaveSpeed(): number;
+    setWaveSpeed(speed: number): void;
+    getWaveSize(): number;
+    setWaveSize(size: number): void;
+    getWindAmount(): number;
+    setWindAmount(amount: number): void;
+    getWindTint(): Vector4;
+    setWindTint(tint: Vector4): void;
+    getShadowIntensity(): number;
+    setShadowIntensity(intensity: number): void;
+    getSphericalBillboardEnabled(): boolean;
+    setSphericalBillboardEnabled(enabled: boolean): void;
+}
+export declare class GrassBillboardMaterialPlugin extends StandardShaderMaterialPlugin {
+    constructor(customMaterial: StandardShaderMaterial, shaderName: string);
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
+    private getWGSLVertexMainEnd;
+    private getWGSLVaryingDefinitions;
+    private getWGSLVertexWorldPos;
+    private getGLSLVertexDefinitions;
+    private getGLSLVertexMainEnd;
+    private getGLSLVertexWorldPos;
+    private getWGSLFragmentCode;
+    private getGLSLFragmentCode;
+    private getGLSLFragmentDefinitions;
+    getUniforms(shaderLanguage: ShaderLanguage): any;
+    getSamplers(samplers: string[]): void;
+    getAttributes(attributes: string[], scene: Scene, mesh: AbstractMesh): void;
+    prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
+}
+export declare class VertexAnimationMaterial extends CustomShaderMaterial {
+    controller: VertexAnimationController;
+    runtimeAlbedoSkins: BaseTexture;
+    runtimeNormalSkins: BaseTexture;
+    constructor(name: string, scene: Scene);
+    awake(): void;
+    update(): void;
+    getShaderName(): string;
+    getController(): VertexAnimationController;
+    cloneForInstance(instanceName: string): VertexAnimationMaterial;
+    setRuntimeSkinArrays(albedoArray: BaseTexture, normalArray: BaseTexture, nullOutDefaults?: boolean): void;
+    clearRuntimeSkinArrays(): void;
+    installSkinsFromUrlsAsync(layers: {
+        albedo: string;
+        normal: string;
+    }[], width: number, height: number, options?: {
+        nullOutDefaults?: boolean;
+        rootUrl?: string;
+        generateMipMaps?: boolean;
+        samplingMode?: number;
+    }): Promise<void>;
+    private _notifyPluginOfRuntimeSkinChange;
+}
+export interface IVertexAnimationRendererReference {
+    name?: string;
+    vertexrenderer?: string;
+    vertexindex?: number;
+    vertexcontroller?: string;
+    vertextransform: string;
+    vertexguid: string;
+    vertexpath?: string;
+    vertexmesh?: string;
+    vertexsubmeshes?: number;
+}
+export interface IVertexAnimationSettings extends IVertexAnimationRendererReference {
+    name: string;
+    vertex: string;
+    vertexnormal: string;
+    vertextextureformat: "png" | "exr";
+    vertexpacking: "separate" | "none";
+    vertexframes: number;
+    vertexfps: number;
+    vertexwidth: number;
+    vertexheight: number;
+    vertexcount: number;
+    vertexrowsperframe: number;
+    vertexposmin: [number, number, number];
+    vertexposmax: [number, number, number];
+    vertexmethod: "soft";
+    vertexlooptime: boolean;
+    vertexloopblend: boolean;
+    vertexcombined?: boolean;
+    vertexfromrow?: number;
+    vertextorow?: number;
+}
+export interface IVertexAnimationRendererClip {
+    guid: string;
+    settings: IVertexAnimationSettings;
+    positionTexture: Texture | null;
+    normalTexture: Texture | null;
+    posMinV3: Vector3;
+    posMaxV3: Vector3;
+    fromRow: number;
+}
+export interface IVertexAnimationClip {
+    name: string;
+    renderers: {
+        [guid: string]: IVertexAnimationRendererClip;
+    };
+    firstRendererGuid: string;
+    duration: number;
+    loop: boolean;
+    loopBlend: boolean;
+}
+export declare class VertexAnimationController {
+    private static _registry;
+    private static _globalTextureCache;
+    static Find(guid: string): VertexAnimationController;
+    static GetOrCreate(guid: string, scene: Scene, rootUrl?: string, lazyLoadTextures?: boolean): VertexAnimationController;
+    static CollectRendererTargets(settings: IVertexAnimationSettings[]): IVertexAnimationRendererReference[];
+    static SetSkinIndex(mesh: AbstractMesh, skinIndex: number): void;
+    static GetSkinIndex(mesh: AbstractMesh): number;
+    static DisposeAll(scene?: Scene): void;
+    readonly guid: string;
+    readonly scene: Scene;
+    rootUrl: string;
+    private _plugins;
+    private _clips;
+    private _currentClip;
+    private _previousClip;
+    private _time;
+    private _previousTime;
+    private _speed;
+    private _loop;
+    private _loopBlend;
+    private _manualLoopOverride;
+    private _playing;
+    private _blendDuration;
+    private _blendElapsed;
+    private _blendWeight;
+    private _mode;
+    private _normalMode;
+    private _lazyLoad;
+    private _tickObserver;
+    private _disposeObserver;
+    private _lastFrameId;
+    private _textureCache;
+    private _textureCacheKeys;
+    private _instanceMeshes;
+    setInstanceMesh(rendererGuid: string, mesh: AbstractMesh): void;
+    private constructor();
+    dispose(): void;
+    get currentClip(): IVertexAnimationClip;
+    get previousClip(): IVertexAnimationClip;
+    get currentTime(): number;
+    get previousTime(): number;
+    get blendWeight(): number;
+    get isPlaying(): boolean;
+    get normalMode(): "separate" | "none";
+    get loopBlend(): boolean;
+    get mode(): "auto" | "drive";
+    get speed(): number;
+    get loopOverride(): boolean | null;
+    getClip(name: string): IVertexAnimationClip | null;
+    setSpeed(speed: number): void;
+    setLoop(loop: boolean): void;
+    setRuntimeSkinArrays(albedoArray: BaseTexture, normalArray: BaseTexture, nullOutDefaults?: boolean): void;
+    clearRuntimeSkinArrays(): void;
+    installSkinsFromUrlsAsync(layers: {
+        albedo: string;
+        normal: string;
+    }[], width: number, height: number, options?: {
+        nullOutDefaults?: boolean;
+        rootUrl?: string;
+        generateMipMaps?: boolean;
+        samplingMode?: number;
+    }): Promise<void>;
+    setCurrentTime(time: number): void;
+    getCurrentTime(): number;
+    addPlugin(plugin: VertexAnimationMaterialPlugin): void;
+    removePlugin(plugin: VertexAnimationMaterialPlugin): void;
+    loadAnimations(settings: IVertexAnimationSettings[]): void;
+    play(clipName: string, blendDuration?: number): boolean;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    driveBlend(primaryName: string, primaryTimeSec: number, secondaryName: string | null, secondaryTimeSec: number, blendWeight: number): boolean;
+    getCurrentRendererClip(rendererGuid: string): IVertexAnimationRendererClip;
+    getPreviousRendererClip(rendererGuid: string): IVertexAnimationRendererClip;
+    private _tick;
+    private _getOrCreateVATBuffer;
+    private _isRendererPositionReady;
+    private _areBlendTargetsReady;
+    private _wrapTime;
+    private _ensureClipTexturesLoaded;
+    private _getOrAcquireTexture;
+    private static _acquireVATTexture;
+    private static _releaseVATTexture;
+    private static _makeVATTextureCacheKey;
+    private static _createVATTexture;
+    private _resolveUrl;
+    private _getRendererClip;
+}
+export declare class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
+    vertexAnimations: IVertexAnimationSettings[];
+    controller: VertexAnimationController;
+    private _rendererTargets;
+    private _targetRendererGuid;
+    private _placeholderTexture;
+    private _placeholderAlbedoArray;
+    private _placeholderNormalArray;
+    private _cc_posTex;
+    private _cc_normTex;
+    private _cc_prevPosTex;
+    private _cc_prevNormTex;
+    private _cc_texW;
+    private _cc_texH;
+    private _cc_rowsPF;
+    private _cc_vCount;
+    private _cc_posMin;
+    private _cc_posMax;
+    private _cc_prevTexW;
+    private _cc_prevTexH;
+    private _cc_prevRowsPF;
+    private _cc_prevPosMin;
+    private _cc_prevPosMax;
+    private static readonly _zeroV3;
+    private static readonly _oneV3;
+    constructor(customMaterial: CustomShaderMaterial, shaderName: string);
+    dispose(): void;
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
+    getUniforms(shaderLanguage: ShaderLanguage): any;
+    getSamplers(samplers: string[]): void;
+    getAttributes(attributes: string[], scene: Scene, mesh: AbstractMesh): void;
+    prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    onRuntimeSkinArraysChanged(): void;
+    bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
+    private _pushRuntimeSkinSamplers;
+    setupAnimations(settings: IVertexAnimationSettings[], controllerId: string, rootUrl?: string, lazyLoadTextures?: boolean): VertexAnimationController;
+    private _captureRendererTarget;
+    private _resolveRendererTarget;
+    private _matchRendererByGuid;
+    private _matchRendererByPath;
+    private _matchRendererByName;
+    private _readMetadataString;
+    private _buildNodePath;
+    private _pathEndsWith;
+    syncFromController(material: VertexAnimationMaterial, controller?: VertexAnimationController): void;
+    bindVATToEffect(effect: Effect): void;
+    private _pushVATUniforms;
+    private getGLSLVertexDefinitions;
+    private getGLSLVertexPositionCode;
+    private getGLSLVertexNormalCode;
+    private getWGSLVertexDefinitions;
+    private getWGSLVertexPositionCode;
+    private getWGSLVertexNormalCode;
+    private getGLSLVertexMainEnd;
+    private getWGSLVertexMainEnd;
+    private getGLSLFragmentDefinitions;
+    private getGLSLFragmentAlbedoCode;
+    private getGLSLFragmentNormalCode;
+    private getWGSLFragmentDefinitions;
+    private getWGSLFragmentAlbedoCode;
+    private getWGSLFragmentNormalCode;
+}
+export interface KeymapState {
+    result: boolean | number;
+    pressTime: number;
+    releaseTime: number;
+}
+export declare enum DragDirection {
+    None = 0,
+    Up = 1,
+    Down = 2,
+    Right = 3,
+    Left = 4
+}
+export declare enum PinchZoomState {
+    None = 0,
+    ZoomIn = 1,
+    ZoomOut = 2
+}
+export declare class InputController {
+    static MOUSE_DAMPENER: number;
+    static TAP_THRESHOLD_MS: number;
+    static GamepadManager: GamepadManager;
+    static GamepadConnected: (pad: Gamepad, state: EventState) => void;
+    static GamepadDisconnected: (pad: Gamepad, state: EventState) => void;
+    static GetMouseButtonsDown(): number;
+    static GetLeftButtonDown(): boolean;
+    static GetMiddleButtonDown(): boolean;
+    static GetRightButtonDown(): boolean;
+    static GetMouseDownTarget(): any;
+    static GetMouseDragTarget(): any;
+    static GetPinchZoomState(): PinchZoomState;
+    static AllowMobileControls: boolean;
+    static MobileControlsActive: boolean;
+    static EnablePinchZoomTracking: boolean;
+    static EnableUserInput(engine: AbstractEngine, scene: Scene, options?: {
+        contextMenu?: boolean;
+        pointerLock?: boolean;
+        preventDefault?: boolean;
+        useCapture?: boolean;
+    }): void;
+    static ConfigureUserInput(engine: AbstractEngine, scene: Scene, options?: {
+        contextMenu?: boolean;
+        pointerLock?: boolean;
+        preventDefault?: boolean;
+        useCapture?: boolean;
+    }): void;
+    static SetLeftJoystickBuffer(leftStickX: number, leftStickY: number, invertY?: boolean): void;
+    static SetRightJoystickBuffer(rightStickX: number, rightStickY: number, invertY?: boolean): void;
+    static DisableUserInput(scene: Scene, useCapture?: boolean): void;
+    static LockMousePointer(scene: Scene, lock: boolean): void;
+    private static LastMousePosition;
+    private static PointerLockedFlag;
+    static IsPointerLocked(): boolean;
+    private static LockMousePointerObserver;
+    static IsPointerLockHandled(): boolean;
+    static GetUserInput(input: UserInputAxis, player?: PlayerNumber): number;
+    static OnKeyboardUp(callback: (keycode: number) => void): void;
+    static OnKeyboardDown(callback: (keycode: number) => void): void;
+    static OnKeyboardPress(keycode: number, callback: () => void): void;
+    static GetKeyboardInput(keycode: number): boolean;
+    static IsKeyboardButtonHeld(keycode: number): boolean;
+    static WasKeyboardButtonTapped(keycode: number, reset?: boolean): boolean;
+    static ResetKeyboardButtonTapped(keycode: number): void;
+    static OnPointerUp(callback: (button: number) => void): void;
+    static OnPointerDown(callback: (button: number) => void): void;
+    static OnPointerPress(button: number, callback: () => void): void;
+    static GetPointerInput(button: number): boolean;
+    static IsPointerButtonHeld(button: number): boolean;
+    static WasPointerButtonTapped(number: number, reset?: boolean): boolean;
+    static ResetPointerButtonTapped(button: number): void;
+    static GetPointerDragDirection(mousex: number, mousey: number, buttondown: boolean): DragDirection;
+    static ResetPinchZoomTracking(): void;
+    static GetMousePosition(scene: Scene, bottomUp?: boolean): Vector3;
+    static IsWheelScrolling(): boolean;
+    static OnGamepadButtonUp(callback: (button: number) => void, player?: PlayerNumber): void;
+    static OnGamepadButtonDown(callback: (button: number) => void, player?: PlayerNumber): void;
+    static OnGamepadButtonPress(button: number, callback: () => void, player?: PlayerNumber): void;
+    static GetGamepadButtonInput(button: number, player?: PlayerNumber): boolean;
+    static IsGamepadButtonHeld(button: number, player?: PlayerNumber): boolean;
+    static IsGamepadButtonTapped(button: number, player?: PlayerNumber): boolean;
+    static ResetGamepadButtonTapped(button: number, player?: PlayerNumber): void;
+    static OnGamepadDirectionUp(callback: (direction: number) => void, player?: PlayerNumber): void;
+    static OnGamepadDirectionDown(callback: (direction: number) => void, player?: PlayerNumber): void;
+    static OnGamepadDirectionPress(direction: number, callback: () => void, player?: PlayerNumber): void;
+    static GetGamepadDirectionInput(direction: number, player?: PlayerNumber): boolean;
+    static IsGamepadDirectionHeld(direction: number, player?: PlayerNumber): boolean;
+    static IsGamepadDirectionTapped(direction: number, player?: PlayerNumber): boolean;
+    static ResetGamepadDirectionTapped(direction: number, player?: PlayerNumber): void;
+    static OnGamepadTriggerLeft(callback: (value: number) => void, player?: PlayerNumber): void;
+    static OnGamepadTriggerRight(callback: (value: number) => void, player?: PlayerNumber): void;
+    static GetGamepadTriggerInput(trigger: number, player?: PlayerNumber): number;
+    static IsGamepadTriggerHeld(trigger: number, player?: PlayerNumber): boolean;
+    static IsGamepadTriggerTapped(trigger: number, player?: PlayerNumber): boolean;
+    static ResetGamepadTriggerTapped(trigger: number, player?: PlayerNumber): void;
+    static GetGamepadType(player?: PlayerNumber): GamepadType;
+    static GetGamepad(player?: PlayerNumber): Gamepad;
+    static InputKeyDownHandler(keyCode: number, event?: MouseEvent | TouchEvent | PointerEvent | KeyboardEvent): any;
+    static InputKeyUpHandler(keyCode: number, event?: MouseEvent | TouchEvent | PointerEvent | KeyboardEvent): any;
+    private static input;
+    private static keymap;
+    private static scroll;
+    private static wheel;
+    private static mousex;
+    private static mousey;
+    private static vertical;
+    private static horizontal;
+    private static mousex2;
+    private static mousey2;
+    private static vertical2;
+    private static horizontal2;
+    private static mousex3;
+    private static mousey3;
+    private static vertical3;
+    private static horizontal3;
+    private static mousex4;
+    private static mousey4;
+    private static vertical4;
+    private static horizontal4;
+    private static a_mousex;
+    private static x_scroll;
+    private static x_wheel;
+    private static x_mousex;
+    private static x_mousey;
+    private static x_vertical;
+    private static x_horizontal;
+    private static k_mousex;
+    private static k_mousey;
+    private static k_vertical;
+    private static k_horizontal;
+    private static j_mousex;
+    private static j_mousey;
+    private static j_vertical;
+    private static j_horizontal;
+    private static g_mousex1;
+    private static g_mousey1;
+    private static g_vertical1;
+    private static g_horizontal1;
+    private static g_mousex2;
+    private static g_mousey2;
+    private static g_vertical2;
+    private static g_horizontal2;
+    private static g_mousex3;
+    private static g_mousey3;
+    private static g_vertical3;
+    private static g_horizontal3;
+    private static g_mousex4;
+    private static g_mousey4;
+    private static g_vertical4;
+    private static g_horizontal4;
+    private static dragDirection;
+    private static pinchZoomState;
+    private static pinchZoomEvents;
+    private static pinchZoomDistance;
+    private static mouseDownTarget;
+    private static mouseDragTarget;
+    private static leftButtonDown;
+    private static middleButtonDown;
+    private static rightButtonDown;
+    private static mouseButtonsDown;
+    private static mouseButtonPress;
+    private static mouseButtonDown;
+    private static mouseButtonUp;
+    private static keyButtonPress;
+    private static keyButtonDown;
+    private static keyButtonUp;
+    private static previousPosition;
+    private static preventDefault;
+    private static lastClientX;
+    private static lastClientY;
+    private static virtualClientX;
+    private static virtualClientY;
+    private static rightHanded;
+    private static gamepad1;
+    private static gamepad1Type;
+    private static gamepad1ButtonPress;
+    private static gamepad1ButtonDown;
+    private static gamepad1ButtonUp;
+    private static gamepad1DpadPress;
+    private static gamepad1DpadDown;
+    private static gamepad1DpadUp;
+    private static gamepad1LeftTrigger;
+    private static gamepad1RightTrigger;
+    private static gamepad2;
+    private static gamepad2Type;
+    private static gamepad2ButtonPress;
+    private static gamepad2ButtonDown;
+    private static gamepad2ButtonUp;
+    private static gamepad2DpadPress;
+    private static gamepad2DpadDown;
+    private static gamepad2DpadUp;
+    private static gamepad2LeftTrigger;
+    private static gamepad2RightTrigger;
+    private static gamepad3;
+    private static gamepad3Type;
+    private static gamepad3ButtonPress;
+    private static gamepad3ButtonDown;
+    private static gamepad3ButtonUp;
+    private static gamepad3DpadPress;
+    private static gamepad3DpadDown;
+    private static gamepad3DpadUp;
+    private static gamepad3LeftTrigger;
+    private static gamepad3RightTrigger;
+    private static gamepad4;
+    private static gamepad4Type;
+    private static gamepad4ButtonPress;
+    private static gamepad4ButtonDown;
+    private static gamepad4ButtonUp;
+    private static gamepad4DpadPress;
+    private static gamepad4DpadDown;
+    private static gamepad4DpadUp;
+    private static gamepad4LeftTrigger;
+    private static gamepad4RightTrigger;
+    private static tickKeyboardInput;
+    private static updateUserInput;
+    private static resetUserInput;
+    private static resetKeyMapHandler;
+    private static getPinchZoomDistance;
+    private static cachePinchZoomPointer;
+    private static removePinchZoomPointer;
+    private static processPinchZoomTracking;
+    private static inputKeyDownHandler;
+    private static inputKeyUpHandler;
+    private static inputPointerWheelHandler;
+    private static inputPointerDownHandler;
+    private static inputPointerUpHandler;
+    private static inputPointerMoveHandler;
+    private static inputOneButtonDownHandler;
+    private static inputOneButtonUpHandler;
+    private static inputOneXboxDPadDownHandler;
+    private static inputOneShockDPadDownHandler;
+    private static inputOneXboxDPadUpHandler;
+    private static inputOneShockDPadUpHandler;
+    private static inputOneXboxLeftTriggerHandler;
+    private static inputOneXboxRightTriggerHandler;
+    private static inputOneLeftStickHandler;
+    private static inputOneRightStickHandler;
+    private static inputTwoButtonDownHandler;
+    private static inputTwoButtonUpHandler;
+    private static inputTwoXboxDPadDownHandler;
+    private static inputTwoShockDPadDownHandler;
+    private static inputTwoXboxDPadUpHandler;
+    private static inputTwoShockDPadUpHandler;
+    private static inputTwoXboxLeftTriggerHandler;
+    private static inputTwoXboxRightTriggerHandler;
+    private static inputTwoLeftStickHandler;
+    private static inputTwoRightStickHandler;
+    private static inputThreeButtonDownHandler;
+    private static inputThreeButtonUpHandler;
+    private static inputThreeXboxDPadDownHandler;
+    private static inputThreeShockDPadDownHandler;
+    private static inputThreeXboxDPadUpHandler;
+    private static inputThreeShockDPadUpHandler;
+    private static inputThreeXboxLeftTriggerHandler;
+    private static inputThreeXboxRightTriggerHandler;
+    private static inputThreeLeftStickHandler;
+    private static inputThreeRightStickHandler;
+    private static inputFourButtonDownHandler;
+    private static inputFourButtonUpHandler;
+    private static inputFourXboxDPadDownHandler;
+    private static inputFourShockDPadDownHandler;
+    private static inputFourXboxDPadUpHandler;
+    private static inputFourShockDPadUpHandler;
+    private static inputFourXboxLeftTriggerHandler;
+    private static inputFourXboxRightTriggerHandler;
+    private static inputFourLeftStickHandler;
+    private static inputFourRightStickHandler;
+    private static inputManagerGamepadConnected;
+    private static inputManagerGamepadDisconnected;
+}
+export declare class WindowManager {
+    static IsWindows(): boolean;
+    static IsCordova(): boolean;
+    static IsWebAssembly(): boolean;
+    static IsOculusBrowser(): boolean;
+    static IsSamsungBrowser(): boolean;
+    static IsWindowsPhone(): boolean;
+    static IsBlackBerry(): boolean;
+    static IsOperaMini(): boolean;
+    static IsAndroid(): boolean;
+    static IsWebOS(): boolean;
+    static IsIOS(): boolean;
+    static IsIPHONE(): boolean;
+    static IsIPAD(): boolean;
+    static IsIPOD(): boolean;
+    static IsIE11(): boolean;
+    static IsMobile(): boolean;
+    static IsHighEndMobile(): boolean;
+    static IsHighEndMobileAsync(): Promise<boolean>;
+    static IsDesktop(): boolean;
+    static IsPlaystation(): boolean;
+    static IsXboxConsole(): boolean;
+    static IsXboxLive(): boolean;
+    static IsFrameWindow(): boolean;
+    static IsPortraitWindow(): boolean;
+    static IsLandscapeWindow(): boolean;
+    static IsStandaloneWindow(): boolean;
+    static IsFullscreenWindow(): boolean;
+    static IsProgressiveWindow(): boolean;
+    static GetDisplayMode(): string;
+    static GetOrientation(): string;
+    static AlertMessage(text: string, title?: string): any;
+    static GetQueryStringParam(name: string, url: string): string;
+    static PostWindowMessage(msg: IWindowMessage, targetOrigin?: string, localWindow?: boolean): void;
+    static ShowSceneLoader(): void;
+    static HideSceneLoader(): void;
+    static UpdateLoaderStatus(status: string, details: string, state: number): void;
+    static UpdateLoaderDetails(details: string, state: number): void;
+    static UpdateLoaderProgress(progress: string, state: number): void;
+    static ShowPageErrorMessage(message: string, title?: string, timeout?: number): void;
+    static SetTimeout(timeout: number, func: () => void): number;
+    static ClearTimeout(handle: number): void;
+    static SetInterval(interval: number, func: () => void): number;
+    static ClearInterval(handle: number): void;
+    static Atob(data: string): string;
+    static Btoa(data: string): string;
+    static PopupDebug(scene: Scene): void;
+    static ToggleDebug(scene: Scene, embed?: boolean, parent?: HTMLElement): void;
+    private static debugLayerVisible;
+    static GetLocalStorageItem(key: string): string;
+    static SetLocalStorageItem(key: string, value: string): void;
+    static GetSessionStorageItem(key: string): string;
+    static SetSessionStorageItem(key: string, value: string): void;
+    static GetFilenameFromUrl(url: string): string;
+    static GetUrlParameter(key: string): string;
+    static GetVirtualRealityEnabled(): boolean;
+    static SetVirtualRealityEnabled(enabled: boolean): void;
+    static SetWindowsLaunchMode(mode?: number): void;
+    static GetHardwareScalingLevel(): number;
+    static QuitWindowsApplication(): void;
+    static PrintToScreen(text: string, color?: string): void;
+    private static PrintElement;
+}
+export declare class AnimationState extends ScriptComponent {
+    static FPS: number;
+    static EXIT: string;
+    static TIME: number;
+    private _looptime;
+    private _loopblend;
+    private _frametime;
+    private _layercount;
+    private _updatemode;
+    private _hasrootmotion;
+    private _animationplaying;
+    private _initialtargetblending;
+    private _hastransformhierarchy;
+    private _leftfeetbottomheight;
+    private _rightfeetbottomheight;
+    private _runtimecontroller;
+    private _executed;
+    private _awakened;
+    private _initialized;
+    private _checkers;
+    private _source;
+    private _machine;
+    private _animationmode;
+    private _animationrig;
+    private _deltaPosition;
+    private _deltaRotation;
+    private _angularVelocity;
+    private _rootMotionSpeed;
+    private _lastMotionSpeed;
+    private _loopMotionSpeed;
+    private _lastRotateSpeed;
+    private _loopRotateSpeed;
+    private _lastMotionRotation;
+    private _lastMotionPosition;
+    private _positionWeight;
+    private _rootBoneWeight;
+    private _rotationWeight;
+    private _rootQuatWeight;
+    private _rootBoneTransform;
+    private _positionHolder;
+    private _rootBoneHolder;
+    private _rotationHolder;
+    private _rootQuatHolder;
+    private _rootMotionMatrix;
+    private _rootMotionScaling;
+    private _rootMotionRotation;
+    private _rootMotionPosition;
+    private _dirtyMotionMatrix;
+    private _dirtyBlenderMatrix;
+    private _targetPosition;
+    private _targetRotation;
+    private _targetScaling;
+    private _updateMatrix;
+    private _blenderMatrix;
+    private _blendWeights;
+    private _emptyScaling;
+    private _emptyPosition;
+    private _emptyRotation;
+    private _ikFrameEanbled;
+    private _data;
+    private _anims;
+    private _clips;
+    private _numbers;
+    private _booleans;
+    private _triggers;
+    private _parameters;
+    private _smoothTargets;
+    delayStart: number;
+    speedRatio: number;
+    delayUpdateUntilReady: boolean;
+    enableAnimations: boolean;
+    applyRootMotion: boolean;
+    awakened(): boolean;
+    initialized(): boolean;
+    hasRootMotion(): boolean;
+    isFirstFrame(): boolean;
+    isLastFrame(): boolean;
+    ikFrameEnabled(): boolean;
+    getAnimationTime(): number;
+    getFrameLoopTime(): boolean;
+    getFrameLoopBlend(): boolean;
+    getAnimationPlaying(): boolean;
+    getRuntimeController(): string;
+    getRootBoneTransform(): TransformNode;
+    getDeltaRootMotionAngle(): number;
+    getDeltaRootMotionSpeed(): number;
+    getDeltaRootMotionPosition(): Vector3;
+    getDeltaRootMotionRotation(): Quaternion;
+    getFixedRootMotionPosition(): Vector3;
+    getFixedRootMotionRotation(): Quaternion;
+    getVertexAnimationController(): VertexAnimationController;
+    isVertexAnimationModeEnabled(): boolean;
+    getVertexAnimationMaterial(rendererIndex?: number, subMeshIndex?: number): VertexAnimationMaterial;
+    onAnimationAwakeObservable: Observable<TransformNode>;
+    onAnimationInitObservable: Observable<TransformNode>;
+    onAnimationIKObservable: Observable<number>;
+    onAnimationEndObservable: Observable<number>;
+    onAnimationLoopObservable: Observable<number>;
+    onAnimationEventObservable: Observable<IAnimatorEvent>;
+    onAnimationUpdateObservable: Observable<TransformNode>;
+    onAnimationTransitionObservable: Observable<TransformNode>;
+    protected m_zeroVector: Vector3;
+    protected m_defaultGroup: AnimationGroup;
+    protected m_animationTargets: TargetedAnimation[];
+    protected m_rotationIdentity: Quaternion;
+    protected m_timelineScrubbing: boolean;
+    protected m_vertexAnimationMode: boolean;
+    protected m_vertexAnimationRenderers: Mesh[];
+    protected m_vertexAnimationController: VertexAnimationController;
+    protected m_vertexAnimationDefaultClip: string;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected update(): void;
+    protected destroy(): void;
+    playDefault(transitionDuration?: number, animationLayer?: number, frameRate?: number): boolean;
+    playAnimation(state: string, transitionDuration?: number, animationLayer?: number, frameRate?: number): boolean;
+    stopAnimation(animationLayer?: number): boolean;
+    killAnimations(): boolean;
+    setTimelineScrubbing(isScrubbing: boolean): void;
+    getIsTimelineScrubbing(): boolean;
+    setAnimationTime(seconds: number): boolean;
+    setAnimationSpeed(speed: number): boolean;
+    setAnimationLoop(loop: boolean): boolean;
+    hasBool(name: string): boolean;
+    getBool(name: string): boolean;
+    setBool(name: string, value: boolean): void;
+    hasFloat(name: string): boolean;
+    getFloat(name: string): number;
+    setFloat(name: string, value: number): void;
+    hasInteger(name: string): boolean;
+    getInteger(name: string): number;
+    setInteger(name: string, value: number): void;
+    hasTrigger(name: string): boolean;
+    getTrigger(name: string): boolean;
+    setTrigger(name: string): void;
+    resetTrigger(name: string): void;
+    setSmoothFloat(name: string, targetValue: number, dampTime?: number, _deltaTime?: number): void;
+    setSmoothInteger(name: string, targetValue: number, dampTime?: number, _deltaTime?: number): void;
+    private updateSmoothParameters;
+    private getMachineState;
+    private setMachineState;
+    getCurrentState(layer: number): MachineState;
+    getDefaultClips(): any[];
+    getDefaultSource(): string;
+    setLayerWeight(layer: number, weight: number): void;
+    private sourceAnimationGroups;
+    fixAnimationGroup(group: AnimationGroup): string;
+    getAnimationGroup(name: string): AnimationGroup;
+    getAnimationGroups(): AnimationGroup[];
+    setAnimationGroups(groups: AnimationGroup[]): void;
+    private updateAnimationGroups;
+    private setupSourceAnimationGroups;
+    private awakeStateMachine;
+    private updateStateMachine;
+    private destroyStateMachine;
+    private updateAnimationState;
+    private updateVertexAnimationLayer;
+    private updateAnimationTargets;
+    private updateBlendableTargets;
+    private finalizeAnimationTargets;
+    private checkStateMachine;
+    private checkStateTransitions;
+    private playCurrentAnimationState;
+    private stopCurrentAnimationState;
+    private checkAvatarTransformPath;
+    private filterTargetAvatarMask;
+    private sortWeightedBlendingList;
+    private computeWeightedFrameRatio;
+    private getFirstMotion;
+    private getLastMotion;
+    private setupTreeBranches;
+    private parseTreeBranches;
+    private parse1DSimpleTreeBranches;
+    private parse2DSimpleDirectionalTreeBranches;
+    private parse2DFreeformDirectionalTreeBranches;
+    private parse2DFreeformCartesianTreeBranches;
+}
+export declare class BlendTreeValue {
+    source: IBlendTreeChild;
+    motion: string;
+    posX: number;
+    posY: number;
+    weight: number;
+    constructor(config: {
+        source: IBlendTreeChild;
+        motion: string;
+        posX?: number;
+        posY?: number;
+        weight?: number;
+    });
+}
+export declare class BlendTreeUtils {
+    static ClampValue(num: number, min: number, max: number): number;
+    static GetSignedAngle(a: Vector2, b: Vector2): number;
+    static GetLinearInterpolation(x0: number, y0: number, x1: number, y1: number, x: number): number;
+    static GetRightNeighbourIndex(inputX: number, blendTreeArray: BlendTreeValue[]): number;
+}
+export declare class BlendTreeSystem {
+    static Calculate1DSimpleBlendTree(inputX: number, blendTreeArray: BlendTreeValue[]): void;
+    static Calculate2DFreeformDirectional(inputX: number, inputY: number, blendTreeArray: BlendTreeValue[]): void;
+    static Calculate2DFreeformCartesian(inputX: number, inputY: number, blendTreeArray: BlendTreeValue[]): void;
+    private static TempVector2_IP;
+    private static TempVector2_POSI;
+    private static TempVector2_POSJ;
+    private static TempVector2_POSIP;
+    private static TempVector2_POSIJ;
+}
+export declare class MachineState {
+    hash: number;
+    name: string;
+    tag: string;
+    time: number;
+    type: MotionType;
+    rate: number;
+    length: number;
+    layer: string;
+    layerIndex: number;
+    played: number;
+    machine: string;
+    motionid: number;
+    interrupted: boolean;
+    apparentSpeed: number;
+    averageAngularSpeed: number;
+    averageDuration: number;
+    averageSpeed: number[];
+    cycleOffset: number;
+    cycleOffsetParameter: string;
+    cycleOffsetParameterActive: boolean;
+    iKOnFeet: boolean;
+    mirror: boolean;
+    mirrorParameter: string;
+    mirrorParameterActive: boolean;
+    speed: number;
+    speedParameter: string;
+    speedParameterActive: boolean;
+    blendtree: IBlendTree;
+    transitions: ITransition[];
+    behaviours: IBehaviour[];
+    events: IAnimatorEvent[];
+    ccurves: IUnityCurve[];
+    tcurves: Animation[];
+    constructor();
+}
+export declare class TransitionCheck {
+    result: string;
+    offest: number;
+    blending: number;
+    duration: number;
+    triggered: string[];
+}
+export declare class AnimationMixer {
+    influenceBuffer: number;
+    positionBuffer: Vector3;
+    rotationBuffer: Quaternion;
+    scalingBuffer: Vector3;
+    originalMatrix: Matrix;
+    blendingFactor: number;
+    blendingSpeed: number;
+    rootPosition: Vector3;
+    rootRotation: Quaternion;
+}
+export declare class BlendingWeights {
+    primary: IBlendTreeChild;
+    secondary: IBlendTreeChild;
+}
+export declare enum MotionType {
+    Clip = 0,
+    Tree = 1
+}
+export declare enum ConditionMode {
+    If = 1,
+    IfNot = 2,
+    Greater = 3,
+    Less = 4,
+    Equals = 6,
+    NotEqual = 7
+}
+export declare enum InterruptionSource {
+    None = 0,
+    Source = 1,
+    Destination = 2,
+    SourceThenDestination = 3,
+    DestinationThenSource = 4
+}
+export declare enum BlendTreeType {
+    Simple1D = 0,
+    SimpleDirectional2D = 1,
+    FreeformDirectional2D = 2,
+    FreeformCartesian2D = 3,
+    Direct = 4,
+    Clip = 5
+}
+export declare enum AnimatorParameterType {
+    Float = 1,
+    Int = 3,
+    Bool = 4,
+    Trigger = 9
+}
+export interface IAnimatorEvent {
+    id: number;
+    clip: string;
+    time: number;
+    function: string;
+    intParameter: number;
+    floatParameter: number;
+    stringParameter: string;
+    objectIdParameter: string;
+    objectNameParameter: string;
+}
+export interface IAvatarMask {
+    hash: number;
+    maskName: string;
+    maskType: string;
+    transformCount: number;
+    transformPaths: string[];
+}
+export interface IAnimationLayer {
+    owner: string;
+    hash: number;
+    name: string;
+    index: number;
+    entry: string;
+    machine: string;
+    iKPass: boolean;
+    avatarMask: IAvatarMask;
+    blendingMode: number;
+    defaultWeight: number;
+    syncedLayerIndex: number;
+    syncedLayerAffectsTiming: boolean;
+    animationTime: number;
+    animationNormal: number;
+    animationMaskMap: Map<string, number>;
+    animationFirstRun: boolean;
+    animationEndFrame: boolean;
+    animationLoopFrame: boolean;
+    animationLoopCount: number;
+    animationLoopEvents: any;
+    animationStateMachine: MachineState;
+    vatTransitionActive?: boolean;
+    vatTransitionElapsed?: number;
+    vatTransitionDuration?: number;
+    vatSourceClipName?: string;
+    vatSourceTimeSec?: number;
+}
+export interface IBehaviour {
+    hash: number;
+    name: string;
+    layerIndex: number;
+    properties: any;
+}
+export interface ITransition {
+    hash: number;
+    anyState: boolean;
+    layerIndex: number;
+    machineLayer: string;
+    machineName: string;
+    canTransitionToSelf: boolean;
+    destination: string;
+    duration: number;
+    exitTime: number;
+    hasExitTime: boolean;
+    fixedDuration: boolean;
+    intSource: InterruptionSource;
+    isExit: boolean;
+    mute: boolean;
+    name: string;
+    offset: number;
+    orderedInt: boolean;
+    solo: boolean;
+    conditions: ICondition[];
+}
+export interface ICondition {
+    hash: number;
+    mode: ConditionMode;
+    parameter: string;
+    threshold: number;
+}
+export interface IBlendTree {
+    hash: number;
+    name: string;
+    state: string;
+    children: IBlendTreeChild[];
+    layerIndex: number;
+    apparentSpeed: number;
+    averageAngularSpeed: number;
+    averageDuration: number;
+    averageSpeed: number[];
+    blendParameterX: string;
+    blendParameterY: string;
+    blendType: BlendTreeType;
+    isAnimatorMotion: boolean;
+    isHumanMotion: boolean;
+    isLooping: boolean;
+    minThreshold: number;
+    maxThreshold: number;
+    useAutomaticThresholds: boolean;
+    valueParameterX: number;
+    valueParameterY: number;
+}
+export interface IBlendTreeChild {
+    hash: number;
+    layerIndex: number;
+    cycleOffset: number;
+    directBlendParameter: string;
+    apparentSpeed: number;
+    averageAngularSpeed: number;
+    averageDuration: number;
+    averageSpeed: number[];
+    mirror: boolean;
+    type: MotionType;
+    motion: string;
+    positionX: number;
+    positionY: number;
+    threshold: number;
+    timescale: number;
+    subtree: IBlendTree;
+    weight: number;
+    ratio: number;
+    track: AnimationGroup;
+}
+export declare class AudioSource extends ScriptComponent implements IAssetPreloader {
+    static MAX_VOLUME: number;
+    static DEFAULT_LEVEL: number;
+    static DEFAULT_ROLLOFF: number;
+    private static AUDIO_ENGINE_V2;
+    private static AUDIO_ENGINE_V2_OPTIONS;
+    private _audio;
+    private _name;
+    private _loop;
+    private _mute;
+    private _pitch;
+    private _volume;
+    private _preload;
+    private _playonawake;
+    private _spatialblend;
+    private _preloaderUrl;
+    private _lastmutedvolume;
+    private _priority;
+    private _panstereo;
+    private _mindistance;
+    private _maxdistance;
+    private _reverbzonemix;
+    private _bypasseffects;
+    private _bypassreverbzones;
+    private _bypasslistenereffects;
+    private _initializedReadyInstance;
+    private _isAudioPlaying;
+    private _isAudioPaused;
+    private _isAudioSpatial;
+    getSoundClip(): StaticSound | Sound;
+    onReadyObservable: Observable<StaticSound | Sound>;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected start(): void;
+    protected after(): void;
+    protected destroy(): void;
+    protected awakeAudioSource(): Promise<void>;
+    protected startAudioSource(): void;
+    protected updateAudioSource(): Promise<void>;
+    protected destroyAudioSource(): void;
+    isLegacy(): boolean;
+    isReady(): boolean;
+    isPlaying(): boolean;
+    isPaused(): boolean;
+    play(time?: number, offset?: number, length?: number): Promise<boolean>;
+    private internalPlay;
+    pause(): boolean;
+    stop(time?: number): boolean;
+    mute(time?: number): boolean;
+    unmute(time?: number): boolean;
+    getPitch(): number;
+    setPitch(value: number): void;
+    getVolume(): number;
+    setVolume(volume: number, time?: number): boolean;
+    setPosition(location: Vector3): void;
+    getPlaybackSpeed(): number;
+    setPlaybackSpeed(rate: number): void;
+    setRolloffMode(mode: string): void;
+    setMinDistance(distance: number): void;
+    setMaxDistance(distance: number): void;
+    setSpatialBlend(blend: number): void;
+    hasSpatialSound(): boolean;
+    getSpatialSound(): AbstractSpatialAudio;
+    attachToSpatialNode(transform: TransformNode): void;
+    getCurrentTrackTime(): number;
+    setAudioDataSource(source: string | ArrayBuffer): Promise<void>;
+    setLegacyDataSource(source: string | ArrayBuffer | MediaStream): void;
+    addPreloaderTasks(assetsManager: PreloadAssetsManager): void;
+    static IsLegacyEngine(): boolean;
+    static GetAudioOptions(): IWebAudioEngineOptions;
+    static SetAudioOptions(options: IWebAudioEngineOptions): void;
+    static GetAudioEngine(): Promise<AudioEngineV2>;
+    static UnlockLegacyAudio(): void;
+    static UnlockAudioEngine(): Promise<void>;
+    static AttachSpatialCamera(node: BabylonNode): Promise<void>;
+    static DetachSpatialCamera(): Promise<void>;
+    static CreateSoundBuffer(source: ArrayBuffer | AudioBuffer | StaticSoundBuffer | string | string[], options?: Partial<IStaticSoundBufferOptions>): Promise<StaticSoundBuffer>;
+    static CreateStaticSound(name: string, source: ArrayBuffer | AudioBuffer | StaticSoundBuffer | string | string[], options: Partial<IStaticSoundOptions>): Promise<StaticSound>;
+    static CreateStreamingSound(name: string, source: HTMLMediaElement | string | string[], options?: Partial<IStreamingSoundOptions>): Promise<StreamingSound>;
+}
+export declare class CharacterController extends ScriptComponent {
+    static TERMINAL_VELOCITY: number;
+    static DEFAULT_CHARACTER_MASS: number;
+    private _avatarRadius;
+    private _avatarHeight;
+    private _centerOffset;
+    private _slopeLimit;
+    private _skinWidth;
+    private _stepHeight;
+    private _minMoveDistance;
+    private _verticalVelocity;
+    private _currentSlopeAngle;
+    private _collisionEvents;
+    private _targetRotation;
+    private _targetVelocity;
+    private _currentVelocity;
+    private _inputVelocity;
+    private _stepUpVelocity;
+    private _gravityFactor;
+    private _minJumpTimer;
+    private _isGrounded;
+    private _groundContacts;
+    private _groundContactInfo;
+    private _groundedEnterTimer;
+    private _groundedExitTimer;
+    private _raycastResult;
+    private _rayOrigin;
+    private _rayTarget;
+    private _previousGroundHeight;
+    private _stepDetectionDistance;
+    protected m_moveDeltaX: number;
+    protected m_moveDeltaY: number;
+    protected m_moveDeltaZ: number;
+    protected m_havokplugin: any;
+    getAvatarRadius(): number;
+    getAvatarHeight(): number;
+    getCenterOffset(): Vector3;
+    getSkinWidth(): number;
+    getStepHeight(): number;
+    getGravityFactor(): number;
+    setGravityFactor(factor: number): void;
+    getInputVelocity(): Vector3;
+    setInputVelocity(velocity: Vector3): void;
+    getStepUpVelocity(): number;
+    getCurrentSlopeAngle(): number;
+    getVerticalVelocity(): number;
+    getMinMoveDistance(): number;
+    setMinMoveDistance(distance: number): void;
+    getGroundContactInfo(): IGroundContactInfo | null;
+    getMinJumpTimer(): number;
+    getSlopeLimit(): number;
+    setSlopeLimit(slopeRadians: number): void;
+    isGrounded(): boolean;
+    canJump(): boolean;
+    onUpdatePositionObservable: Observable<TransformNode>;
+    onUpdateVelocityObservable: Observable<TransformNode>;
+    enableUpdate: boolean;
+    enableGravity: boolean;
+    enableStepOffset: boolean;
+    useMultiRaycast: boolean;
+    multiRaycastCount: number;
+    groundCheckDistance: number;
+    stepUpVelocityFactor: number;
+    defaultJumpingTimer: number;
+    onlyApplyGravityWhenNotGrounded: boolean;
+    downwardVelocityClamp: number;
+    contactHysteresisTime: number;
+    groundedEnterTime: number;
+    groundedExitTime: number;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected update(): void;
+    protected fixed(): void;
+    set(px: number, py: number, pz: number, rx?: number, ry?: number, rz?: number, rw?: number): void;
+    move(velocity: Vector3, aux?: boolean): void;
+    jump(speed: number): void;
+    turn(angle: number): void;
+    rotate(x: number, y: number, z: number, w: number): void;
+    setRigidBodyMass(mass: number): void;
+    setCollisionState(collision: boolean): void;
+    setCollisionFilters(membershipMask: number, collideMask: number): void;
+    private registerGroundContact;
+    private updateGroundContactAges;
+    private isContactAtFeet;
+    private isValidGroundNormal;
+    private performSingleRayGroundCheck;
+    private performMultiRayGroundCheck;
+    private performGroundRaycast;
+    private detectAndHandleStepOffset;
+    private updateGroundedState;
+    private createPhysicsBodyAndShape;
+    private createPhysicsShapeCapsule;
+}
+export interface IGroundContactInfo {
+    hasGround: boolean;
+    groundNormal: Vector3;
+    groundHeight: number;
+    groundBody: PhysicsBody | null;
+}
+export declare class SimpleCharacterController extends ScriptComponent {
+    private _eulerAngles;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected start(): void;
+    set(px: number, py: number, pz: number, rx?: number, ry?: number, rz?: number, rw?: number, aux?: boolean): void;
+    move(velocity: Vector3, aux?: boolean): void;
+    jump(speed: number): void;
+    turn(angle: number): void;
+    rotate(x: number, y: number, z: number, w: number): void;
+}
+export declare class RecastCharacterController extends ScriptComponent {
+    private _eulerAngles;
+    private _teleportVector;
+    private _navigationAgent;
+    getNavigationAgent(): NavigationAgent;
+    setNavigationAgent(agent: NavigationAgent): void;
+    setDestinationPoint(destination: Vector3, closetPoint?: boolean): void;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected start(): void;
+    set(px: number, py: number, pz: number, rx?: number, ry?: number, rz?: number, rw?: number, aux?: boolean): void;
+    move(velocity: Vector3, aux?: boolean): void;
+    jump(speed: number): void;
+    turn(angle: number): void;
+    rotate(x: number, y: number, z: number, w: number): void;
+}
+export declare class ColorFilterPlugin {
+    static CreatePostProcess(scene: Scene, camera: Camera, options?: {
+        color?: number[] | Color3 | Color4;
+    }): PostProcess;
+}
+export declare class ColoredBloomPlugin {
+    static CreateColoredBloom(scene: Scene, camera: Camera, options?: {
+        threshold?: number;
+        color?: number[] | Color3 | Color4;
+        weight?: number;
+        kernel?: number;
+        ratio?: number;
+        passes?: number;
+        saturation?: number;
+        downsampleRatio?: number;
+    }): any;
+}
+export declare class btVehicleTuning {
+    suspensionStiffness: number;
+    suspensionCompression: number;
+    suspensionDamping: number;
+    maxSuspensionTravelCm: number;
+    frictionSlip: number;
+    maxSuspensionForce: number;
+}
+export declare class btVehicleRaycasterResult {
+    hitPointInWorld: Vector3;
+    hitNormalInWorld: Vector3;
+    distFraction: number;
+    hitBody: any;
+    filterCollideMask: number;
+    filterMembershipMask: number;
+}
+export interface IbtVehicleRaycaster {
+    castRay(from: Vector3, to: Vector3, result: btVehicleRaycasterResult): any;
+}
+export declare class btDefaultVehicleRaycaster implements IbtVehicleRaycaster {
+    private _raycastResult;
+    private _query;
+    constructor(query?: IRaycastQuery);
+    castRay(from: Vector3, to: Vector3, result: btVehicleRaycasterResult): any;
+}
+export declare class btWheelRaycastInfo {
+    contactNormalWS: Vector3;
+    contactPointWS: Vector3;
+    suspensionLength: number;
+    hardPointWS: Vector3;
+    wheelDirectionWS: Vector3;
+    wheelAxleWS: Vector3;
+    isInContact: boolean;
+    groundObject: any;
+}
+export declare class btWheelInfo {
+    raycastInfo: btWheelRaycastInfo;
+    worldTransformPosition: Vector3;
+    worldTransformRotation: Quaternion;
+    chassisConnectionPointCS: Vector3;
+    wheelDirectionCS: Vector3;
+    wheelAxleCS: Vector3;
+    suspensionRestLength: number;
+    maxSuspensionTravelCm: number;
+    wheelRadius: number;
+    suspensionStiffness: number;
+    dampingCompression: number;
+    dampingRelaxation: number;
+    frictionSlip: number;
+    maxSuspensionForce: number;
+    isFrontWheel: boolean;
+    steering: number;
+    rotation: number;
+    deltaRotation: number;
+    rollInfluence: number;
+    engineForce: number;
+    brake: number;
+    clippedInvContactDotSuspension: number;
+    suspensionRelativeVelocity: number;
+    suspensionForce: number;
+    skidInfo: number;
+    clientInfo: any;
+    steeringAngle: number;
+    rotationBoost: number;
+    defaultFriction: number;
+    invertWheelDirection: boolean;
+    maxVisualTravelRange: number;
+    contactCollideMask: number;
+    contactMembershipMask: number;
+    _prevContactNormalWS: Vector3;
+    _prevSuspensionLength: number;
+    _prevSuspensionForce: number;
+    _hasPrevSuspState: boolean;
+    _rayHistoryLengths: number[];
+    _rayHistoryNormalsX: number[];
+    _rayHistoryNormalsY: number[];
+    _rayHistoryNormalsZ: number[];
+    _rayHistoryIndex: number;
+    _rayHistoryCount: number;
+    _smoothedSuspensionLength: number;
+    _smoothedContactNormal: Vector3;
+    _smoothedContactNormalValid: boolean;
+    _contactLossFrames: number;
+    transform: TransformNode;
+    spinner: TransformNode;
+    constructor(ci: {
+        chassisConnectionCS: Vector3;
+        wheelDirectionCS: Vector3;
+        wheelAxleCS: Vector3;
+        suspensionRestLength: number;
+        maxSuspensionTravelCm: number;
+        wheelRadius: number;
+        suspensionStiffness: number;
+        dampingCompression: number;
+        dampingRelaxation: number;
+        frictionSlip: number;
+        maxSuspensionForce: number;
+        isFrontWheel: boolean;
+    });
+    getSuspensionRestLength(): number;
+}
+export declare class btRaycastVehicle {
+    static FILTER_GROUP_ALL_COLLIDERS: number;
+    static FILTER_GROUP_VEHICLE_COLLIDERS: number;
+    static FILTER_GROUP_BRIDGE_COLLIDERS: number;
+    static FILTER_GROUP_ROAD_COLLIDERS: number;
+    static FILTER_GROUP_GRASS_COLLIDERS: number;
+    static FILTER_GROUP_CURB_COLLIDERS: number;
+    static FILTER_GROUP_FENCE_COLLIDERS: number;
+    static FILTER_GROUP_ALL_VEHICLE_COLLIDERS: number;
+    static VEHICLE_MESH_TAG: string;
+    static BRIDGE_MESH_TAG: string;
+    static ROAD_MESH_TAG: string;
+    static GRASS_MESH_TAG: string;
+    static CURB_MESH_TAG: string;
+    static FENCE_MESH_TAG: string;
+    private _chassisBody;
+    private _vehicleRaycaster;
+    private _wheelInfo;
+    private _indexRightAxis;
+    private _indexUpAxis;
+    private _indexForwardAxis;
+    private _currentVehicleSpeedKmHour;
+    enableMultiRaycast: boolean;
+    minimumWheelContacts: number;
+    trackConnectionAccel: number;
+    smoothFlyingImpulse: number;
+    arcadeSteeringAssist: number;
+    smoothedGradientSpeed: number;
+    maximumYawRateLow: number;
+    maximumYawRateHigh: number;
+    angularDamping: Vector3;
+    wheelSkidFadeInSpeed: number;
+    wheelSkidFadeOutSpeed: number;
+    minContactDotSuspension: number;
+    suspensionForceSmoothing: number;
+    suspensionDampingOverdrive: number;
+    raycastSmoothingEnabled: boolean;
+    raycastHistoryBufferSize: number;
+    raycastLengthCompressionAlpha: number;
+    raycastLengthRelaxationAlpha: number;
+    raycastNormalSmoothingAlpha: number;
+    raycastOutlierRejectionEnabled: boolean;
+    raycastOutlierThresholdMeters: number;
+    raycastMaxLengthChangePerSecond: number;
+    raycastContactLossGraceFrames: number;
+    raycastDebugLogEnabled: boolean;
+    raycastDebugLogIntervalFrames: number;
+    raycastDebugLogSpikeThresholdMeters: number;
+    raycastDebugLogWheelMask: number;
+    private _raycastDebugFrameCounter;
+    private _raycastMedianScratch;
+    sideToSideStabilityEnabled: boolean;
+    sideToSideStabilityStartKmh: number;
+    sideToSideStabilityFullKmh: number;
+    stabilizationDebug: boolean;
+    stabilizationDebugInterval: number;
+    downforceCoefficient: number;
+    constantDownforce: number;
+    stabilizationNormalSmoothing: number;
+    airborneGroundNormalHoldTime: number;
+    groundedAutoLevelEnabled: boolean;
+    groundedAutoLevelStrength: number;
+    groundedAutoLevelDeadzoneDeg: number;
+    groundedAutoLevelSettleDeg: number;
+    groundedAutoLevelSettleScale: number;
+    groundedAutoLevelHysteresisDeg: number;
+    groundedAutoLevelStartKmh: number;
+    groundedAutoLevelFullKmh: number;
+    groundedAutoLevelMaxRate: number;
+    groundedAutoLevelPartialContactBoost: number;
+    groundedAutoLevelSlideScale: number;
+    groundedAutoLevelTrackNormalMinDot: number;
+    airborneTrackConnectionStartKmh: number;
+    airborneTrackConnectionFullKmh: number;
+    airborneTrackConnectionMaxAccel: number;
+    airborneRiseDamping: number;
+    airborneMaxRiseSpeed: number;
+    private _groundedAutoLevelWasActive;
+    private _stabilizationGroundNormal;
+    private _stabilizationHasGroundNormal;
+    private _stabilizationAirborneTime;
+    isArcadeBurnoutModeActive: boolean;
+    isArcadeDonutModeActive: boolean;
+    isArcadeFootBrakeActive: boolean;
+    isArcadeHandBrakeActive: boolean;
+    isArcadeWheelSkidActive: boolean;
+    isArcadeYawAssistActive: boolean;
+    arcadeYawAssistDebugLogEnabled: boolean;
+    arcadeYawAssistDebugLogIntervalFrames: number;
+    arcadeYawAssistDebugLogEdgeEvents: boolean;
+    arcadeHandbrakeKickStrengthDegPerSec: number;
+    arcadeHandbrakeKickFrames: number;
+    arcadeHandbrakeYawAuthority: number;
+    arcadeHandbrakeMaxYawRateDegPerSec: number;
+    arcadeHandbrakeReferenceSpeedKmh: number;
+    arcadeHandbrakeSpeedGateEnabled: boolean;
+    arcadeHandbrakeLowSpeedShape: number;
+    arcadeHandbrakeDirectYawEnabled: boolean;
+    arcadeHandbrakeDirectYawDegPerSec: number;
+    arcadeHandbrakeDirectYawDurationMs: number;
+    arcadeHandbrakeDirectYawFadeMs: number;
+    arcadeDonutDirectYawEnabled: boolean;
+    arcadeDonutDirectYawDegPerSec: number;
+    arcadeDonutDirectYawDurationMs: number;
+    arcadeDonutDirectYawFadeMs: number;
+    arcadeHandbrakeMaxSlideAngleDeg: number;
+    arcadeHandbrakeCounterSteerClampEnabled: boolean;
+    arcadeHandbrakeCounterSteerYawThresholdDegPerSec: number;
+    arcadeHandbrakeClampReleaseFadeMs: number;
+    arcadeHandbrakeSteerSlewLimitEnabled: boolean;
+    arcadeHandbrakeSteerSlewLimitDegPerSec: number;
+    private _wasArcadeHandBrakeActive;
+    private _wasArcadeYawAssistApplyingForce;
+    private _handbrakeKickJzRemaining;
+    private _handbrakeKickFramesRemaining;
+    private _arcadeHandbrakeLatchedDriveSign;
+    private _arcadeHandbrakeHoldElapsedSec;
+    private _arcadeHandbrakeSlewedSteerRad;
+    private _arcadeHandbrakeClampReleaseFadeSec;
+    private _arcadeDonutHoldElapsedSec;
+    private _arcadeYawAssistDebugFrameCounter;
+    private _arcadeYawAssistLastKickRad;
+    private _arcadeYawAssistLastIaddPerWheel;
+    private _arcadeYawAssistLastClampScalar;
+    private _arcadeYawAssistLastLeverSum;
+    burnoutFrictionFloor: number;
+    frictionRestoreSpeed: number;
+    arcadeBurnoutWheelSpinGain: number;
+    arcadeDonutWheelSpinGain: number;
+    arcadeBurnoutDirectionChangeSpeedKmh: number;
+    arcadeBurnoutDirectionChangeGripScale: number;
+    arcadeWheelSpinBuildSpeed: number;
+    arcadeWheelSpinRecoverySpeed: number;
+    arcadeWheelSpinAirDamping: number;
+    arcadeWheelSpinMaxAngularVelocity: number;
+    arcadeStationaryBurnoutWheelSpinGain: number;
+    arcadeStationaryBurnoutMinAngularVelocity: number;
+    arcadeSkidFadeInSpeed: number;
+    arcadeSkidFadeOutSpeed: number;
+    arcadeYawCapMultiplier: number;
+    wheelAtRestSpeedThresholdKmh: number;
+    wheelSpinDebugLogEnabled: boolean;
+    wheelSpinDebugLogIntervalFrames: number;
+    private _wheelSpinDebugLogCounter;
+    private _postHandbrakeLogFrames;
+    private _postHandbrakeLogCounter;
+    private _wasAnyArcadeModeActive;
+    private _forwardWS;
+    private _axle;
+    private _forwardImpulse;
+    private _sideImpulse;
+    private _arcadeSkidInfo;
+    private _arcadePreviousWheelSpin;
+    sideFrictionStiffness: number;
+    private _chassisMass;
+    private _chassisInvMass;
+    private _chassisTransform;
+    private _rayResults;
+    private _sv1;
+    private _sv2;
+    private _sv3;
+    private _sv4;
+    private _sv5;
+    private _sv6;
+    private _sv7;
+    private _sv8;
+    private _sv9;
+    private _sv10;
+    private _sq1;
+    private _sq2;
+    private _sm1;
+    private _sm2;
+    private _sm3;
+    private _sm4;
+    private _vapLinVel;
+    private _vapAngVel;
+    private _vapRelPos;
+    private _vapCenter;
+    private _vapCross;
+    private _rsbVel1;
+    private _crfVel1;
+    private _basisCols;
+    private _stb1;
+    private _stb2;
+    private _stb3;
+    private _stb4;
+    private _stb5;
+    constructor(tuning: btVehicleTuning, chassisBody: PhysicsBody, raycaster: IbtVehicleRaycaster);
+    addWheel(connectionPointCS: Vector3, wheelDirectionCS: Vector3, wheelAxleCS: Vector3, suspensionRestLength: number, wheelRadius: number, tuning: btVehicleTuning, isFrontWheel: boolean): btWheelInfo;
+    getNumWheels(): number;
+    getWheelInfo(index: number): btWheelInfo;
+    setSteeringValue(steering: number, wheelIndex: number): void;
+    getSteeringValue(wheelIndex: number): number;
+    applyEngineForce(force: number, wheelIndex: number): void;
+    setBrake(brake: number, wheelIndex: number): void;
+    getCurrentSpeedKmHour(): number;
+    getRigidBody(): PhysicsBody;
+    getRightAxis(): number;
+    getUpAxis(): number;
+    getForwardAxis(): number;
+    setCoordinateSystem(rightIndex: number, upIndex: number, forwardIndex: number): void;
+    getForwardVector(): Vector3;
+    getForwardVectorToRef(result: Vector3): void;
+    cacheMassProperties(): void;
+    setIsArcadeBurnoutActive(active: boolean): void;
+    getIsArcadeBurnoutActive(): boolean;
+    setIsArcadeDonutActive(active: boolean): void;
+    getIsArcadeDonutActive(): boolean;
+    setIsArcadeFootBrakeActive(active: boolean): void;
+    getIsArcadeFootBrakeActive(): boolean;
+    setIsArcadeHandBrakeActive(active: boolean): void;
+    getIsArcadeHandBrakeActive(): boolean;
+    setIsArcadeWheelSkidActive(active: boolean): void;
+    getIsArcadeWheelSkidActive(): boolean;
+    private setWheelContactFilters;
+    resetSuspension(): void;
+    getChassisWorldTransform(): Matrix;
+    private updateWheelTransformsWS;
+    updateWheelTransform(wheelIndex: number, interpolatedTransform?: boolean): void;
+    private rayCast;
+    private smoothRaycastHit;
+    private getGravityUpToRef;
+    private computeStabilizationUpVector;
+    private applyFlyingStabilization;
+    private applyGroundedAutoLevel;
+    private applyTrackConnectionAndDownforce;
+    updateVehicle(step: number): void;
+    private updateSuspension;
+    private applyEasyDonutYawAssist;
+    private applyHandbrakeYawAssist;
+    private resolveWheelSpinDirection;
+    private updateArcadeWheelRotationBoost;
+    private getWheelAngularVelocity;
+    private getArcadeBurnoutDirectionChangeFactor;
+    private updateArcadeSkidInfo;
+    private updateFriction;
+    private velocityAtWorldPoint;
+    private resolveSingleBilateral;
+    private calcRollingFriction;
+    private clampChassisYawRate;
+    getNaturalWheelSlip(wheelIndex: number): boolean;
+    getSignedFrontSteeringAngleRad(): number;
+    getApproxWheelbaseMeters(): number;
+    dispose(): void;
+}
+export declare class LensDistortionPlugin {
+    private _distortionIntensity;
+    private _distortionIntensityX;
+    private _distortionIntensityY;
+    private _distortionCenterX;
+    private _distortionCenterY;
+    private _distortionScale;
+    private _isEnabled;
+    get distortionIntensity(): number;
+    set distortionIntensity(value: number);
+    get distortionIntensityX(): number;
+    set distortionIntensityX(value: number);
+    get distortionIntensityY(): number;
+    set distortionIntensityY(value: number);
+    get distortionCenterX(): number;
+    set distortionCenterX(value: number);
+    get distortionCenterY(): number;
+    set distortionCenterY(value: number);
+    get distortionScale(): number;
+    set distortionScale(value: number);
+    get isEnabled(): boolean;
+    private _updateEnabledState;
+    constructor(options?: {
+        distortionIntensity?: number;
+        distortionIntensityX?: number;
+        distortionIntensityY?: number;
+        distortionCenterX?: number;
+        distortionCenterY?: number;
+        distortionScale?: number;
+    });
+    getUniforms(): {
+        [key: string]: {
+            type: string;
+            value: any;
+        };
+    };
+    getFragmentShaderCode(): string;
+    getWGSLShaderCode(): string;
+    static CreatePostProcess(scene: any, camera: any, options?: {
+        distortionIntensity?: number;
+        distortionIntensityX?: number;
+        distortionIntensityY?: number;
+        distortionCenterX?: number;
+        distortionCenterY?: number;
+        distortionScale?: number;
+    }): any;
+}
+export declare class NavigationAgent extends ScriptComponent {
+    static TARGET_ANGLE_FACTOR: number;
+    static ANGULAR_SPEED_RATIO: number;
+    static GLOBAL_CROWD_INSTANCE: boolean;
+    private crowd;
+    private type;
+    private speed;
+    private baseOffset;
+    private avoidRadius;
+    private avoidHeight;
+    private acceleration;
+    private areaMask;
+    private autoRepath;
+    private autoBraking;
+    private autoTraverseOffMeshLink;
+    private avoidancePriority;
+    private obstacleAvoidanceType;
+    private distanceToTarget;
+    private teleporting;
+    private moveDirection;
+    private resetPosition;
+    private lastPosition;
+    private distancePosition;
+    private currentPosition;
+    private currentRotation;
+    private currentVelocity;
+    private currentWaypoint;
+    heightOffset: number;
+    angularSpeed: number;
+    updatePosition: boolean;
+    updateRotation: boolean;
+    distanceEpsilon: number;
+    velocityEpsilon: number;
+    offMeshVelocity: number;
+    stoppingDistance: number;
+    isReady(): boolean;
+    isNavigating(): boolean;
+    isTeleporting(): boolean;
+    isOnOffMeshLink(): boolean;
+    getAgentType(): number;
+    getAgentState(): number;
+    getAgentIndex(): number;
+    getAgentOffset(): number;
+    getTargetDistance(): number;
+    getCurrentPosition(): Vector3;
+    getCurrentRotation(): Quaternion;
+    getCurrentVelocity(): Vector3;
+    getAgentParameters(): IAgentParameters;
+    setAgentParameters(parameters: IAgentParameters): void;
+    onReadyObservable: Observable<TransformNode>;
+    onPreUpdateObservable: Observable<TransformNode>;
+    onPostUpdateObservable: Observable<TransformNode>;
+    onNavCompleteObservable: Observable<TransformNode>;
+    protected m_agentState: number;
+    protected m_agentIndex: number;
+    protected m_agentReady: boolean;
+    protected m_agentGhost: TransformNode;
+    protected m_agentParams: IAgentParameters;
+    protected m_agentMovement: Vector3;
+    protected m_agentDirection: Vector3;
+    protected m_agentQuaternion: Quaternion;
+    protected m_agentDestination: Vector3;
+    protected m_debugDestinationSphere: Mesh;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected update(): void;
+    protected destroy(): void;
+    private awakeNavigationAgent;
+    private updateNavigationAgent;
+    private updateAgentParameters;
+    private destroyNavigationAgent;
+    move(offset: Vector3, closetPoint?: boolean): void;
+    teleport(destination: Vector3, closetPoint?: boolean): void;
+    setDestination(destination: Vector3, closetPoint?: boolean): void;
+    setAcceleration(speed: number): void;
+    setMovementSpeed(speed: number): void;
+    setSeparationWeight(weight: number): void;
+    setOptimizationRange(range: number): void;
+    setCollisionQueryRange(range: number): void;
+    setAgentRadius(radius: number): void;
+    setAgentHeight(height: number): void;
+    getAgentVelocity(): Vector3;
+    getAgentVelocityToRef(result: Vector3): void;
+    getAgentPosition(): Vector3;
+    getAgentPositionToRef(result: Vector3): void;
+    getAgentWaypoint(): Vector3;
+    getAgentWaypointToRef(result: Vector3): void;
+    cancelNavigation(): void;
+    getDebugDestinationMesh(): Mesh;
+    showDebugDestination(show: boolean): void;
+}
+export declare enum CrowdAgentState {
+    DT_CROWDAGENT_STATE_INVALID = 0,
+    DT_CROWDAGENT_STATE_WALKING = 1,
+    DT_CROWDAGENT_STATE_OFFMESH = 2
+}
+export declare class PostProcessor extends ScriptComponent {
+    private static GlobalInstance;
+    static get Instance(): PostProcessor;
+    private highDynamicRange;
+    private neutralToneMapping;
+    private toneMappingMode;
+    private defaultContrast;
+    private defaultExposure;
+    private defaultLookupTable;
+    private colorGradingSettings;
+    private bloomSettings;
+    private vignetteSettings;
+    private sharpenSettings;
+    private grainSettings;
+    private chromaticAberrationSettings;
+    private depthOfFieldSettings;
+    private motionBlurSettings;
+    private lensDistortionSettings;
+    private autoExposureSettings;
+    private colorFilterPP;
+    private coloredBloomPP;
+    private motionBlurPP;
+    private roundedVignettePP;
+    private lensDistortionPP;
+    private defaultRenderPipeline;
+    private screenSpaceAOPipeline;
+    private screenSpaceRPipeline;
+    GetDefaultRenderPipeline(): DefaultRenderingPipeline;
+    GetSSAORRenderPipeline(): SSAORenderingPipeline;
+    GetSSRRenderPipeline(): SSRRenderingPipeline;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected ready(): void;
+    protected parseColorGradingSettings(settings: any): any;
+    protected applyColorGradingSettings(): void;
+    protected mapToneMapper(tonemapperParam: any): {
+        enabled: boolean;
+        type: number | null;
+    };
+    protected parseBloomSettings(settings: any): any;
+    protected applyBloomSettings(): void;
+    protected parseSharpenSettings(settings: any): any;
+    protected applySharpenSettings(): void;
+    protected parseGrainSettings(settings: any): any;
+    protected applyGrainSettings(): void;
+    protected parseVignetteSettings(settings: any): any;
+    protected applyVignetteSettings(): void;
+    protected parseDepthOfFieldSettings(settings: any): any;
+    protected applyDepthOfFieldSettings(): void;
+    protected parseMotionBlurSettings(settings: any): any;
+    protected applyMotionBlurSettings(): void;
+    protected parseAutoExposure(settings: any): any;
+    protected applyAutoExposureSettings(): void;
+    protected parseLensDistortionSettings(settings: any): any;
+    protected applyLensDistortionSettings(): void;
+    protected parseChromaticAberrationSettings(settings: any): any;
+    protected applyChromaticAberrationSettings(): void;
+    protected parseAmbientOcclusionSettings(settings: any): any;
+    protected parseScreenSpaceReflectionsSettings(settings: any): any;
+    static unwrapParam(param: any): any;
+    static extractParam(param: any): {
+        value: any;
+        overrideState: boolean | null;
+    };
+}
+export declare class RaycastVehicle {
+    private static TempVector;
+    private static AutoSuspensionForceReserve;
+    private _centerMass;
+    private _chassisMesh;
+    private _tempVectorPos;
+    lockedWheelIndexes: number[];
+    getCenterMassOffset(): Vector3;
+    getInternalVehicle(): btRaycastVehicle;
+    getUpAxis(): number;
+    getRightAxis(): number;
+    getForwardAxis(): number;
+    getForwardVector(): Vector3;
+    getNumWheels(): number;
+    getWheelInfo(wheel: number): btWheelInfo;
+    resetSuspension(): void;
+    setEngineForce(power: number, wheel: number): void;
+    setBrakingForce(brake: number, wheel: number): void;
+    updateWheelTransform(wheel: number, interpolate: boolean): void;
+    getWheelTransformPosition(wheel: number): Vector3;
+    getWheelTransformRotation(wheel: number): Quaternion;
+    getRawCurrentSpeedKph(): number;
+    getRawCurrentSpeedMph(): number;
+    getAbsCurrentSpeedKph(): number;
+    getAbsCurrentSpeedMph(): number;
+    getVehicleTuningSystem(): btVehicleTuning;
+    getChassisWorldTransform(): Matrix;
+    protected m_scene: Scene;
+    protected m_vehicle: btRaycastVehicle;
+    protected m_vehicleTuning: btVehicleTuning;
+    protected m_vehicleRaycaster: btDefaultVehicleRaycaster;
+    protected m_vehicleColliders: any[];
+    protected m_tempPosition: Vector3;
+    protected m_wheelDirectionCS0: Vector3;
+    protected m_wheelAxleCS: Vector3;
+    constructor(scene: Scene, entity: AbstractMesh, center: Vector3);
+    dispose(): void;
+    static GetInstance(scene: Scene, rigidbody: RigidbodyPhysics): RaycastVehicle;
+    tickVehicleController(step: number): void;
+    getEnableMultiRaycast(): boolean;
+    setEnableMultiRaycast(flag: boolean): void;
+    getSmoothedGradientSpeed(): number;
+    setSmoothedGradientSpeed(impulse: number): void;
+    getMaximumYawRateLow(): number;
+    setMaximumYawRateLow(impulse: number): void;
+    getMaximumYawRateHigh(): number;
+    setMaximumYawRateHigh(impulse: number): void;
+    getAngularDampingControl(): Vector3;
+    setAngularDampingControl(damping: Vector3): void;
+    getSmoothFlyingImpulse(): number;
+    setSmoothFlyingImpulse(impulse: number): void;
+    setGroundedAutoLevelEnabled(flag: boolean): void;
+    setGroundedAutoLevelStrength(strength: number): void;
+    setGroundedAutoLevelDeadzone(degrees: number): void;
+    setGroundedAutoLevelSettleDeg(degrees: number): void;
+    setGroundedAutoLevelSettleScale(scale: number): void;
+    setGroundedAutoLevelHysteresis(degrees: number): void;
+    setGroundedAutoLevelSpeedRange(startKmh: number, fullKmh: number): void;
+    setGroundedAutoLevelMaxRate(rate: number): void;
+    getTrackConnectionAccel(): number;
+    setTrackConnectionAccel(force: number): void;
+    setAirborneTrackConnectionMaxAccel(accel: number): void;
+    setAirborneTrackConnectionSpeedRange(startKmh: number, fullKmh: number): void;
+    setAirborneRiseDamping(rate: number): void;
+    setAirborneMaxRiseSpeed(speed: number): void;
+    getMinimumWheelContacts(): number;
+    setMinimumWheelContacts(contacts: number): void;
+    getDownforceCoefficient(): number;
+    setDownforceCoefficient(value: number): void;
+    getConstantDownforce(): number;
+    setConstantDownforce(value: number): void;
+    getWheelIndexByID(id: string): number;
+    getWheelIndexByName(name: string): number;
+    getWheelColliderInfo(wheel: number): number;
+    setWheelTransformMesh(wheel: number, transform: TransformNode): void;
+    protected ensureNodeRotationQuaternion(node: TransformNode): Quaternion;
+    protected normalizeWheelRotation(angle: number): number;
+    protected syncWheelSpinnerRotation(wheelinfo: any): void;
+    protected rebaseWheelSpinnerRotation(wheelinfo: any): void;
+    getWheelSkidFadeInSpeed(): number;
+    setWheelSkidFadeInSpeed(value: number): void;
+    getWheelSkidFadeOutSpeed(): number;
+    setWheelSkidFadeOutSpeed(value: number): void;
+    isArcadeYawAssistActive(): boolean;
+    getArcadeSteeringAssist(): number;
+    setArcadeSteeringAssist(value: number): void;
+    getArcadeDonutDirectYawDegPerSec(): number;
+    setArcadeDonutDirectYawDegPerSec(value: number): void;
+    getArcadeHandbrakeDirectYawDegPerSec(): number;
+    setArcadeHandbrakeDirectYawDegPerSec(value: number): void;
+    getArcadeHandbrakeMaxSlideAngleDeg(): number;
+    setArcadeHandbrakeMaxSlideAngleDeg(value: number): void;
+    getArcadeHandbrakeBicycleYawAuthority(): number;
+    setArcadeHandbrakeBicycleYawAuthority(value: number): void;
+    getArcadeHandbrakeMaxYawRateDegPerSec(): number;
+    setArcadeHandbrakeMaxYawRateDegPerSec(value: number): void;
+    getArcadeHandbrakeReferenceSpeedKmh(): number;
+    setArcadeHandbrakeReferenceSpeedKmh(value: number): void;
+    getArcadeHandbrakeKickStrengthDegPerSec(): number;
+    setArcadeHandbrakeKickStrengthDegPerSec(value: number): void;
+    getArcadeBurnoutActive(): boolean;
+    setArcadeBurnoutActive(active: boolean): void;
+    getArcadeDonutActive(): boolean;
+    setArcadeDonutActive(active: boolean): void;
+    getArcadeFootBrakeActive(): boolean;
+    setArcadeFootBrakeActive(active: boolean): void;
+    getArcadeHandBrakeActive(): boolean;
+    setArcadeHandBrakeActive(active: boolean): void;
+    setArcadeBurnoutDirectionChangeSpeed(mph: number): void;
+    getApproxWheelbaseMeters(): number;
+    getSignedFrontSteeringAngleRad(): number;
+    getVisualSteeringAngle(wheel: number): number;
+    setVisualSteeringAngle(angle: number, wheel: number): void;
+    getPhysicsSteeringAngle(wheel: number): number;
+    setPhysicsSteeringAngle(angle: number, wheel: number): void;
+    protected setupWheelInformation(): void;
+    private applyAutoSuspensionForce;
+    private getWheelForwardPosition;
+    getNaturalWheelSlip(wheelIndex: number): boolean;
+    getWheelAtRestSpeedThresholdKmh(): number;
+    setWheelAtRestSpeedThresholdKmh(value: number): void;
+    setWheelSpinDebugLogEnabled(enabled: boolean): void;
+    getWheelSpinDebugLogEnabled(): boolean;
+    setWheelSpinDebugLogIntervalFrames(frames: number): void;
+    updateWheelInformation(): void;
+    protected lockedWheelInformation(wheel: number): boolean;
+    protected deleteWheelInformation(): void;
+}
+export declare class RigidbodyPhysics extends ScriptComponent {
+    static PHYSICS_STEP_TIME: number;
+    private static RaycastResult;
+    private static LocalShapeResult;
+    private static WorldShapeResult;
+    private static RaycastDestination;
+    private _isKinematic;
+    private _centerOfMass;
+    protected m_raycastVehicle: RaycastVehicle;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected update(): void;
+    protected fixed(): void;
+    protected destroy(): void;
+    protected awakeRigidbodyState(): void;
+    protected updateRigidbodyState(): void;
+    protected fixedRigidbodyState(): void;
+    protected destroyRigidbodyState(): void;
+    isKinematic(): boolean;
+    hasWheelColliders(): boolean;
+    getRaycastVehicle(): any;
+    static GetHavokInstance(): any;
+    static Raycast(origin: Vector3, direction: Vector3, length: number, query?: IRaycastQuery): PhysicsRaycastResult;
+    static Shapecast(query: IPhysicsShapeCastQuery): IPhysicsShapeCastResult;
+    static RaycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult, query?: IRaycastQuery): void;
+    static ShapecastToRef(query: IPhysicsShapeCastQuery, localShapeResult: ShapeCastResult, worldShapeResult: ShapeCastResult): void;
+    static SetMaxVelocities(maxLinVel: number, maxAngVel: number): void;
+    static PhysicsShapeCache: any;
+    static NewPhysicsShapeCount: number;
+    static CachedPhysicsShapeCount: number;
+    static DebugPhysicsViewer: any;
+    static OnSetupPhysicsPlugin: (scene: Scene) => void;
+    static ConfigurePhysicsEngine(scene: Scene, fixedTimeStep?: boolean, subTimeStep?: number, maxWorldSweep?: number, ccdEnabled?: boolean, ccdPenetration?: number, gravityLevel?: Vector3): Promise<void>;
+    static SetupPhysicsComponent(scene: Scene, entity: TransformNode): void;
+    protected static GetPhysicsMaterialCombine(unity: number): number;
+    protected static GetCachedPhysicsMeshShape(scene: Scene, entity: TransformNode, meshkey: string, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, layer: number, filter: number): PhysicsShapeMesh;
+    protected static GetCachedPhysicsConvexHullShape(scene: Scene, entity: TransformNode, meshkey: string, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, layer: number, filter: number): PhysicsShapeConvexHull;
+    protected static GetCachedPhysicsBoxShape(scene: Scene, trigger: boolean, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, layer: number, filter: number): PhysicsShapeBox;
+    protected static GetCachedPhysicsSphereShape(scene: Scene, trigger: boolean, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, layer: number, filter: number): PhysicsShapeSphere;
+    protected static GetCachedPhysicsCapsuleShape(scene: Scene, trigger: boolean, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, layer: number, filter: number): PhysicsShapeCapsule;
+    protected static GetCachedPhysicsCylinderShape(scene: Scene, trigger: boolean, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, layer: number, filter: number): PhysicsShapeCylinder;
+    protected static CreateStandardPhysicsShapeAndBody(scene: Scene, entity: TransformNode, metadata: any, impostortype: number, istrigger: boolean, istruestatic: boolean, motiontype: PhysicsMotionType, mass: number, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, terraindata: any, com: any, persist: boolean, layer: number, filter: number): void;
+    protected static CreateCompoundPhysicsShapeAndBody(scene: Scene, root: TransformNode, entity: TransformNode, element: any, impostortype: number, staticfriction: number, dynamicfriction: number, restitution: number, fcombine: number, rcombine: number, sitems: PhyscisContainerData[], item: PhyscisContainerData, center: any, complex: boolean, trigger: boolean, persist: boolean, layer: number, filter: number): void;
+    protected static CreateHeightFieldTerrainShapeFromMesh(terrainMesh: Mesh, scaleX: number, scaleZ: number): any;
+    static GetPhysicsHeapSize(): number;
+    static ConfigRigidbodyPhysics(scene: Scene, entity: TransformNode, child: boolean, trigger: boolean, physics: any, mass: number, com: Vector3): void;
+    static CreatePhysicsMetadata(mass: number, drag?: number, angularDrag?: number, centerMass?: Vector3): any;
+    static CreateCollisionMetadata(type: string, trigger?: boolean, convexmesh?: boolean, restitution?: number, dynamicfriction?: number, staticfriction?: number): any;
+    static CreatePhysicsProperties(mass: number, drag?: number, angularDrag?: number, useGravity?: boolean, isKinematic?: boolean): any;
+    protected static AddChildShapeFromParent(containerShape: PhysicsShape, parentTransform: TransformNode, newChild: PhysicsShape, childTransform: TransformNode): void;
+    static NoImpostor: number;
+    static SphereImpostor: number;
+    static BoxImpostor: number;
+    static PlaneImpostor: number;
+    static MeshImpostor: number;
+    static CapsuleImpostor: number;
+    static CylinderImpostor: number;
+    static ParticleImpostor: number;
+    static HeightmapImpostor: number;
+    static ConvexHullImpostor: number;
+    static CustomImpostor: number;
+    static RopeImpostor: number;
+    static ClothImpostor: number;
+    static SoftbodyImpostor: number;
+    private static _factorAngVel;
+    private static _factorLinVel;
+    private static _factorLocalVel;
+    private static _dampingAngVel;
+    private static _dampingLinVel;
+    private static _dampingLocalVel;
+    private static _tempMatrix;
+    static SetDamping: (body: PhysicsBody, linearDamping: number, angularDamping: number) => void;
+    static GetDamping: (body: PhysicsBody) => {
+        linearDamping: number;
+        angularDamping: number;
+    };
+    static ApplyDamping: (body: PhysicsBody, linearDamping: number, angularDamping: number, timeStep: number) => void;
+    static ApplyPerAxisAngularDamping: (body: PhysicsBody, angularDampingX: number, angularDampingY: number, angularDampingZ: number, timeStep: number) => void;
+    static SetAngularFactor: (body: PhysicsBody, factorX: number, factorY: number, factorZ: number) => void;
+    static SetLinearFactor: (body: PhysicsBody, factorX: number, factorY: number, factorZ: number) => void;
+    static SetFactors: (body: PhysicsBody, linearFactor: Vector3, angularFactor: Vector3) => void;
+}
+export declare class PhyscisContainerData {
+    shape: PhysicsShape;
+    translation: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export interface IPhysicsShapeCastResult {
+    local: ShapeCastResult;
+    world: ShapeCastResult;
+}
+export interface IPhysicsShapeCastQuery {
+    shape: PhysicsShape;
+    rotation: Quaternion;
+    startPosition: Vector3;
+    endPosition: Vector3;
+    shouldHitTriggers: boolean;
+    ignoreBody?: PhysicsBody;
+}
+export declare class RoundedVignettePlugin {
+    static CreatePostProcess(scene: Scene, camera: Camera, options?: {
+        color?: number[] | Color3 | Color4;
+        center?: number[];
+        intensity?: number;
+        smoothness?: number;
+        rounded?: boolean;
+        blendMode?: string | number;
+    }): PostProcess;
+}
+export declare class ShurikenParticles extends ScriptComponent {
+    private static DefaultParticleTexture;
+    private static readonly DEFAULT_PARTICLE_PROPERTIES;
+    private m_particleSystem;
+    private m_emitterMesh;
+    private m_systemProperties;
+    private m_isInitialized;
+    private m_playOnAwake;
+    private m_autoStart;
+    private m_systemTime;
+    private m_isLooping;
+    private m_duration;
+    private m_emissionTimer;
+    private m_burstTimers;
+    private m_prewarm;
+    private m_startDelay;
+    private m_simulationSpeed;
+    private m_scalingMode;
+    private m_emitterVelocityMode;
+    private m_customSimulationSpace;
+    private m_emitterVelocity;
+    private m_gravitySource;
+    private m_useUnscaledTime;
+    private m_reportedDeltaTime;
+    private m_isSystemRunning;
+    private m_cullingMode;
+    private m_isVisible;
+    private m_pausedTime;
+    private m_lastVisibilityCheck;
+    private static readonly UNITY_TO_BABYLON_SIZE_RATIO;
+    private static readonly UNITY_TO_BABYLON_GRAVITY_RATIO;
+    private static readonly UNITY_TO_BABYLON_EMIT_RATE_RATIO;
+    private static readonly UNITY_TO_BABYLON_EMIT_POWER_RATIO;
+    private static readonly UNITY_TO_BABYLON_CONE_SCALE_RATIO;
+    private static readonly UNITY_TO_BABYLON_LIFETIME_RATIO;
+    private static readonly UNITY_TO_BABYLON_DEATH_FADE_ALPHA;
+    static EMITTER_POSITION_OFFSET: Vector3;
+    static EMITTER_ROTATION_OFFSET: Vector3;
+    private m_animationCurves;
+    private m_gradients;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    getParticleSystem(): ParticleSystem | GPUParticleSystem;
+    getEmitterMesh(): AbstractMesh;
+    private internalPlay;
+    play(): void;
+    stop(): void;
+    pause(): void;
+    reset(): void;
+    isPlaying(): boolean;
+    getParticleCount(): number;
+    getCustomSimulationSpace(): number;
+    getEmitterVelocity(): Vector3;
+    getGravitySource(): number;
+    getUseUnscaledTime(): boolean;
+    getCustomDeltaTime(): number;
+    getReportedDeltaTime(): number;
+    getEffectiveDeltaTime(): number;
+    private calculateStartDelay;
+    protected awake(): void;
+    protected start(): void;
+    protected ready(): void;
+    protected update(): void;
+    private shouldSimulateThisFrame;
+    protected late(): void;
+    protected step(): void;
+    protected fixed(): void;
+    protected after(): void;
+    protected destroy(): void;
+    private static mergeWithDefaults;
+    private static deepMerge;
+    private static getPropertyWithDefault;
+    static getMinimalSerializationData(fullProperties: any): any;
+    private static extractDifferences;
+    private static arraysEqual;
+    static getDefaultProperties(): IParticleSystemProperties;
+    private initializeParticleSystem;
+    private shouldUseGPUParticles;
+    private createEmitterMesh;
+    private createDefaultParticleTexture;
+    private createCPUParticleSystem;
+    private createGPUParticleSystem;
+    private configureMainModule;
+    private configureEmissionModule;
+    private configureShapeModule;
+    private configureRendererModule;
+    private implementStretchRendering;
+    private implementConstrainedBillboarding;
+    private implementMeshRendering;
+    private implementParticleSorting;
+    private implementParticleAlignment;
+    private implementParticleFlipping;
+    private implementParticlePivot;
+    private implementParticleRoll;
+    private implementVelocityScaling;
+    private implementNormalDirection;
+    private implementFreeformStretching;
+    private implementMaskInteraction;
+    private implementStretchRotation;
+    private implementShadowBias;
+    private implementMultiMeshRendering;
+    private implementCustomVertexStreams;
+    private implementTrailMaterial;
+    private implementMaterialConfiguration;
+    private implementShadowConfiguration;
+    private implementProbeConfiguration;
+    private implementGPUInstancing;
+    private implementSortingLayer;
+    private configureVelocityOverLifetimeModule;
+    private configureLimitVelocityOverLifetimeModule;
+    private configureColorOverLifetimeModule;
+    private configureSizeOverLifetimeModule;
+    private configureRotationOverLifetimeModule;
+    private configureTextureSheetAnimationModule;
+    private ensureBasicConfiguration;
+    private convertMinMaxCurve;
+    private convertMinMaxGradient;
+    private convertColor;
+    private colorsEqual;
+    private applyUnityGradientToBabylon;
+    private convertVector3;
+    private evaluateCurveAtTime;
+    private setupBursts;
+    private resetBurstTimers;
+    private updateSystem;
+    private updateEmission;
+    private updateAnimationProperties;
+    private updateBursts;
+    private triggerBurst;
+    private configureEmissionShape;
+    private setupVelocityOverLifetime;
+    private setupLimitVelocity;
+    private createColorGradient;
+    private setupSpriteAnimation;
+    private createBoxShapeEmitter;
+    private createSphereShapeEmitter;
+    private createConeShapeEmitter;
+    private configureNoiseModule;
+    private configureCollisionModule;
+    private configureTrailsModule;
+    private configureSubEmittersModule;
+    private updateEmitterVelocityInheritance;
+    private updateCustomSimulationSpace;
+    private updateRingBufferMode;
+    private handleStopAction;
+    private setupCullingVisibilityCheck;
+    private isEmitterVisible;
+    private handleVisibilityChange;
+    private disposeParticleSystem;
+}
+export interface IParticleSystemMinMaxCurve {
+    mode: number;
+    constant: number;
+    constantMin: number;
+    constantMax: number;
+    multiplier: number;
+    curve?: IParticleSystemAnimationCurve;
+    curveMin?: IParticleSystemAnimationCurve;
+    curveMax?: IParticleSystemAnimationCurve;
+}
+export interface IParticleSystemMinMaxGradient {
+    mode: number;
+    color: IParticleSystemColor;
+    colorMin: IParticleSystemColor;
+    colorMax: IParticleSystemColor;
+    gradient?: IParticleSystemGradient;
+    gradientMin?: IParticleSystemGradient;
+    gradientMax?: IParticleSystemGradient;
+}
+export interface IParticleSystemAnimationCurve {
+    length: number;
+    preWrapMode: number;
+    postWrapMode: number;
+    keys: IParticleSystemKeyframe[];
+}
+export interface IParticleSystemKeyframe {
+    time: number;
+    value: number;
+    inTangent: number;
+    outTangent: number;
+    inWeight: number;
+    outWeight: number;
+    weightedMode: number;
+}
+export interface IParticleSystemGradient {
+    mode: number;
+    colorKeys: IParticleSystemColorKey[];
+    alphaKeys: IParticleSystemAlphaKey[];
+}
+export interface IParticleSystemColorKey {
+    color: IParticleSystemColor;
+    time: number;
+}
+export interface IParticleSystemAlphaKey {
+    alpha: number;
+    time: number;
+}
+export interface IParticleSystemColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export interface IParticleSystemVector2 {
+    x: number;
+    y: number;
+}
+export interface IParticleSystemVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface IParticleSystemBurst {
+    time: number;
+    count: IParticleSystemMinMaxCurve;
+    cycleCount: number;
+    repeatInterval: number;
+    probability: number;
+}
+export interface IParticleSystemMainModule {
+    duration: number;
+    loop: boolean;
+    prewarm: boolean;
+    startDelay: IParticleSystemMinMaxCurve;
+    startDelayMultiplier: number;
+    startLifetime: IParticleSystemMinMaxCurve;
+    startLifetimeMultiplier: number;
+    startSpeed: IParticleSystemMinMaxCurve;
+    startSpeedMultiplier: number;
+    startSize3D: boolean;
+    startSize: IParticleSystemMinMaxCurve;
+    startSizeMultiplier: number;
+    startSizeX: IParticleSystemMinMaxCurve;
+    startSizeXMultiplier: number;
+    startSizeY: IParticleSystemMinMaxCurve;
+    startSizeYMultiplier: number;
+    startSizeZ: IParticleSystemMinMaxCurve;
+    startSizeZMultiplier: number;
+    startRotation3D: boolean;
+    startRotation: IParticleSystemMinMaxCurve;
+    startRotationMultiplier: number;
+    startRotationX: IParticleSystemMinMaxCurve;
+    startRotationXMultiplier: number;
+    startRotationY: IParticleSystemMinMaxCurve;
+    startRotationYMultiplier: number;
+    startRotationZ: IParticleSystemMinMaxCurve;
+    startRotationZMultiplier: number;
+    flipRotation: number;
+    startColor: IParticleSystemMinMaxGradient;
+    gravityModifier: IParticleSystemMinMaxCurve;
+    gravityModifierMultiplier: number;
+    simulationSpace: number;
+    simulationSpeed: number;
+    deltaTime: number;
+    scalingMode: number;
+    playOnAwake: boolean;
+    emitterVelocityMode: number;
+    maxParticles: number;
+    stopAction: number;
+    cullingMode: number;
+    ringBufferMode: number;
+    ringBufferLoopRange: IParticleSystemVector2;
+    customSimulationSpace?: number;
+    emitterVelocity?: IParticleSystemVector3;
+    gravitySource?: number;
+    useUnscaledTime?: boolean;
+}
+export interface IParticleSystemEmissionModule {
+    enabled: boolean;
+    rateOverTime: IParticleSystemMinMaxCurve;
+    rateOverTimeMultiplier: number;
+    rateOverDistance: IParticleSystemMinMaxCurve;
+    rateOverDistanceMultiplier: number;
+    burstCount: number;
+    bursts: IParticleSystemBurst[];
+}
+export interface IParticleSystemShapeModule {
+    enabled: boolean;
+    shapeType: number;
+    angle: number;
+    radius: number;
+    radiusMode: number;
+    radiusSpread: number;
+    radiusSpeed: IParticleSystemMinMaxCurve;
+    radiusSpeedMultiplier: number;
+    donutRadius: number;
+    position: IParticleSystemVector3;
+    rotation: IParticleSystemVector3;
+    scale: IParticleSystemVector3;
+    alignToDirection: boolean;
+    randomDirectionAmount: number;
+    sphericalDirectionAmount: number;
+    randomPositionAmount: number;
+    biasOnTriangles: boolean;
+    useMeshMaterialIndex: boolean;
+    meshMaterialIndex: number;
+    useMeshColors: boolean;
+    normalOffset: number;
+    meshSpawnMode: number;
+    meshSpawnSpread: number;
+    meshSpawnSpeed: IParticleSystemMinMaxCurve;
+    meshSpawnSpeedMultiplier: number;
+    arc: number;
+    arcMode: number;
+    arcSpread: number;
+    arcSpeed: IParticleSystemMinMaxCurve;
+    arcSpeedMultiplier: number;
+    length: number;
+    boxThickness: IParticleSystemVector3;
+}
+export interface IParticleSystemRendererModule {
+    enabled: boolean;
+    materials: any[];
+    renderMode: number;
+    cameraVelocityScale: number;
+    velocityScale: number;
+    lengthScale: number;
+    normalDirection: number;
+    sortMode: number;
+    sortingFudge: number;
+    minParticleSize: number;
+    maxParticleSize: number;
+    alignment: number;
+    flip: IParticleSystemVector2;
+    allowRoll: boolean;
+    pivot: IParticleSystemVector3;
+    shadowCastingMode: number;
+    receiveShadows: boolean;
+    motionVectorGenerationMode: number;
+    lightProbeUsage: number;
+    reflectionProbeUsage: number;
+    enableGPUInstancing: boolean;
+    mesh?: any;
+    sortingLayerID: number;
+    sortingOrder: number;
+    freeformStretching?: boolean;
+    maskInteraction?: number;
+    meshCount?: number;
+    meshDistribution?: number;
+    rotateWithStretchDirection?: boolean;
+    shadowBias?: number;
+    supportsMeshInstancing?: boolean;
+    activeVertexStreamsCount?: number;
+    activeTrailVertexStreamsCount?: number;
+    meshes?: any[];
+    trailMaterial?: any;
+}
+export interface IParticleSystemVelocityOverLifetimeModule {
+    enabled: boolean;
+    space: number;
+    x: IParticleSystemMinMaxCurve;
+    y: IParticleSystemMinMaxCurve;
+    z: IParticleSystemMinMaxCurve;
+    xMultiplier: number;
+    yMultiplier: number;
+    zMultiplier: number;
+    orbitalX: IParticleSystemMinMaxCurve;
+    orbitalY: IParticleSystemMinMaxCurve;
+    orbitalZ: IParticleSystemMinMaxCurve;
+    orbitalXMultiplier: number;
+    orbitalYMultiplier: number;
+    orbitalZMultiplier: number;
+    orbitalOffsetX: IParticleSystemMinMaxCurve;
+    orbitalOffsetY: IParticleSystemMinMaxCurve;
+    orbitalOffsetZ: IParticleSystemMinMaxCurve;
+    orbitalOffsetXMultiplier: number;
+    orbitalOffsetYMultiplier: number;
+    orbitalOffsetZMultiplier: number;
+    radial: IParticleSystemMinMaxCurve;
+    radialMultiplier: number;
+    speedModifier: IParticleSystemMinMaxCurve;
+    speedModifierMultiplier: number;
+}
+export interface IParticleSystemLimitVelocityOverLifetimeModule {
+    enabled: boolean;
+    limitX: IParticleSystemMinMaxCurve;
+    limitY: IParticleSystemMinMaxCurve;
+    limitZ: IParticleSystemMinMaxCurve;
+    limitXMultiplier: number;
+    limitYMultiplier: number;
+    limitZMultiplier: number;
+    limit: IParticleSystemMinMaxCurve;
+    limitMultiplier: number;
+    dampen: number;
+    separateAxes: boolean;
+    space: number;
+    drag: IParticleSystemMinMaxCurve;
+    dragMultiplier: number;
+    multiplyDragByParticleSize: boolean;
+    multiplyDragByParticleVelocity: boolean;
+}
+export interface IParticleSystemColorOverLifetimeModule {
+    enabled: boolean;
+    color: IParticleSystemMinMaxGradient;
+}
+export interface IParticleSystemSizeOverLifetimeModule {
+    enabled: boolean;
+    size: IParticleSystemMinMaxCurve;
+    sizeMultiplier: number;
+    x: IParticleSystemMinMaxCurve;
+    xMultiplier: number;
+    y: IParticleSystemMinMaxCurve;
+    yMultiplier: number;
+    z: IParticleSystemMinMaxCurve;
+    zMultiplier: number;
+    separateAxes: boolean;
+}
+export interface IParticleSystemRotationOverLifetimeModule {
+    enabled: boolean;
+    x: IParticleSystemMinMaxCurve;
+    xMultiplier: number;
+    y: IParticleSystemMinMaxCurve;
+    yMultiplier: number;
+    z: IParticleSystemMinMaxCurve;
+    zMultiplier: number;
+    separateAxes: boolean;
+}
+export interface IParticleSystemTextureSheetAnimationModule {
+    enabled: boolean;
+    mode: number;
+    timeMode: number;
+    fps: number;
+    numTilesX: number;
+    numTilesY: number;
+    animation: number;
+    useRandomRow: boolean;
+    frameOverTime: IParticleSystemMinMaxCurve;
+    frameOverTimeMultiplier: number;
+    startFrame: IParticleSystemMinMaxCurve;
+    startFrameMultiplier: number;
+    cycleCount: number;
+    rowIndex: number;
+    rowMode: number;
+    uvChannelMask: number;
+    flipU: number;
+    flipV: number;
+    speedRange: IParticleSystemVector2;
+}
+export interface IParticleSystemProperties {
+    isPlaying: boolean;
+    isPaused: boolean;
+    isStopped: boolean;
+    isEmitting: boolean;
+    particleCount: number;
+    time: number;
+    randomSeed: number;
+    useAutoRandomSeed: boolean;
+    name: string;
+    instanceId: number;
+    enabled: boolean;
+    transformPosition: IParticleSystemVector3;
+    transformRotation: IParticleSystemVector3;
+    transformScale: IParticleSystemVector3;
+    materialName?: string;
+    materialId?: number;
+    mainTextureName?: string;
+    mainTextureId?: number;
+    main: IParticleSystemMainModule;
+    emission: IParticleSystemEmissionModule;
+    shape: IParticleSystemShapeModule;
+    renderer: IParticleSystemRendererModule;
+    velocityOverLifetime: IParticleSystemVelocityOverLifetimeModule;
+    limitVelocityOverLifetime: IParticleSystemLimitVelocityOverLifetimeModule;
+    colorOverLifetime: IParticleSystemColorOverLifetimeModule;
+    sizeOverLifetime: IParticleSystemSizeOverLifetimeModule;
+    rotationOverLifetime: IParticleSystemRotationOverLifetimeModule;
+    textureSheetAnimation: IParticleSystemTextureSheetAnimationModule;
+    inheritVelocity?: any;
+    forceOverLifetime?: any;
+    colorBySpeed?: any;
+    sizeBySpeed?: any;
+    rotationBySpeed?: any;
+    externalForces?: any;
+    noise?: any;
+    collision?: any;
+    triggers?: any;
+    subEmitters?: any;
+    lights?: any;
+    trails?: any;
+    customData?: any;
+}
+export declare class MeshNormalProxy {
+    blendWithPhysicsNormal: number;
+    maxLookupDistance: number;
+    searchRadius: number;
+    useProjectionTest: boolean;
+    private _v0x;
+    private _v0y;
+    private _v0z;
+    private _v1x;
+    private _v1y;
+    private _v1z;
+    private _v2x;
+    private _v2y;
+    private _v2z;
+    private _n0x;
+    private _n0y;
+    private _n0z;
+    private _n1x;
+    private _n1y;
+    private _n1z;
+    private _n2x;
+    private _n2y;
+    private _n2z;
+    private _fnx;
+    private _fny;
+    private _fnz;
+    private _cx;
+    private _cy;
+    private _cz;
+    private _triangleCount;
+    private _cellTriangles;
+    private _htKeys;
+    private _htStarts;
+    private _htCounts;
+    private _cellSize;
+    private _hashOriginX;
+    private _hashOriginZ;
+    private _sourceMesh;
+    private _worldMatrix;
+    private _invWorldMatrix;
+    private _matrixDirty;
+    private _scratchV0;
+    private _scratchLocal;
+    private _candidatesBuf;
+    private _uniqueBuf;
+    private _seenSet;
+    get triangleCount(): number;
+    get cellSize(): number;
+    get sourceMesh(): AbstractMesh;
+    buildFromMesh(mesh: AbstractMesh, cellSize?: number): boolean;
+    invalidateTransform(): void;
+    getNormalAtPointToRef(worldHitPoint: Vector3, resultNormal: Vector3, rawHavokNormal?: Vector3): boolean;
+    dispose(): void;
+    private _makeHashKey;
+    private _bsearchCell;
+    private _barycentricScratch;
+    private _computeBarycentricInline;
+}
+export declare class SmoothMeshNormalSystem {
+    private static _instance;
+    static get instance(): SmoothMeshNormalSystem;
+    private _registry;
+    register(body: PhysicsBody, proxy: MeshNormalProxy): void;
+    unregister(body: PhysicsBody, disposeProxy?: boolean): void;
+    lookup(body: PhysicsBody): MeshNormalProxy;
+    has(body: PhysicsBody): boolean;
+    get count(): number;
+    disposeAll(): void;
+    static buildAndRegister(mesh: AbstractMesh, body: PhysicsBody, cellSize?: number, blendWithPhysics?: number): MeshNormalProxy;
+}
+export interface IDetailLayerData {
+    layerindex?: number;
+    densitymap?: number[];
+    densitywidth?: number;
+    densityheight?: number;
+    minwidth?: number;
+    maxwidth?: number;
+    minheight?: number;
+    maxheight?: number;
+    noisespread?: number;
+    bendfactor?: number;
+    healthycolor?: number[];
+    drycolor?: number[];
+    colorvariationmap?: number[];
+    rendermode?: string;
+    useprototypemesh?: boolean;
+    useinstancing?: boolean;
+    prototypemeshnodeid?: string;
+    prototypemeshname?: string;
+    prototypetexturefile?: string;
+    prototypetexture?: any;
+    isvalid?: boolean;
+    maxdistance?: number;
+    noiseseed?: number;
+    positionjitter?: number;
+    positionsjitter?: number;
+    aligntoground?: number;
+    holeedgepadding?: number;
+    prototypelocalscale?: number[];
+    detailinstancepatches?: Array<{
+        patchX: number;
+        patchY: number;
+        bounds: number[];
+        transforms: number[];
+    }>;
+    densityparam?: number;
+    usedensityscaling?: boolean;
+    density?: number;
+    targetcoverage?: number;
+    detailscattermode?: string;
+}
+export interface ITerrainProperties {
+    name?: string;
+    terrainsize?: number[];
+    basemapdistance?: number;
+    treebillboarddistance?: number;
+    treecrossfadelength?: number;
+    treedistance?: number;
+    treeinstancecount?: number;
+    detailwidth?: number;
+    detailheight?: number;
+    detailpatchcount?: number;
+    detailresolution?: number;
+    detailresolutionperpatch?: number;
+    detailbillboardingmode?: number;
+    detailgrassshadowlevel?: number;
+    detailgrassreceiveshadows?: boolean;
+    detailobjectdensity?: number;
+    detailobjectdistance?: number;
+    wavinggrassamount?: number;
+    wavinggrassspeed?: number;
+    wavinggrasssize?: number;
+    wavinggrasstint?: number[];
+    detaillayers?: IDetailLayerData[];
+    detailscattermode?: string;
+}
+export interface IDetailInstance {
+    position: Vector3;
+    rotation: number;
+    scale: Vector3;
+    color: Color4;
+}
+export declare enum ColorCorrectionMode {
+    None = 0,
+    ToGamma = 1,
+    ToLinear = 2
+}
+export declare class TerrainBuilder extends ScriptComponent {
+    private detailLayerContainers;
+    private detailMeshSources;
+    static grassHeightScale: number;
+    static grassRandomFlip: boolean;
+    static grassCastShadows: boolean;
+    static grassReceiveFog: boolean;
+    static grassColorCorrectionMode: ColorCorrectionMode;
+    static detailChunkMode: number;
+    static detailChunkTargetInstances: number;
+    static detailChunkWorldSize: number;
+    static detailChunkMaxChunksPerAxis: number;
+    static detailChunkMaxTotalChunks: number;
+    static meshDetailChunkMode: number;
+    static meshDetailChunkTargetInstances: number;
+    static meshDetailChunkWorldSize: number;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected destroy(): void;
+    private disposeDetailLayers;
+    static BuildDetailPrototypes(properties: ITerrainProperties, terrainTransform: TransformNode, scene: Scene, builderInstance?: TerrainBuilder): void;
+    private static BuildMeshDetailLayer;
+    private static BuildGrassDetailLayer;
+    private static GenerateMeshInstancesFromUnityPatches;
+    private static CreateGrassThinInstancesFromDensityMap;
+    private static CreateDetailThinInstancesFromDensityMap;
+    private static CreateGrassPrototype;
+    private static CreateSingleQuadBillboard;
+    private static CreateCrossQuadGrass;
+    private static ApplyUpNormals;
+    private static HashToUnitFloat;
+    private static NormalizeRotation;
+    private static DoColorCorrection;
+    private static GammaToLinear;
+    private static LinearToGamma;
+}
+export declare class UserInterface extends ScriptComponent {
+    private static readonly PHYSICAL_SIZE_SLICE_FACTOR;
+    private static readonly PHYSICAL_SIZE_POINT_FACTOR;
+    private static readonly CHARACTER_WORD_SPACE_FACTOR;
+    static OnParseNodeObject: Observable<any>;
+    static OnInterfaceLoaded: Observable<string>;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected start(): Promise<void>;
+    protected parseNodeObject(rootNode: any, hostPrefix: string): void;
+    private processNodeSources;
+    private extractRequiredFonts;
+    private loadRequiredFonts;
+    private loadFontManifest;
+    private loadSingleFont;
+    private loadUnityFont;
+    private loadGoogleFont;
+    private isGoogleFont;
+    private isSystemFontAvailable;
+    private static CreateInternalUserInterface;
+    private static LoadForegroundInterfaceData;
+    private static LoadBackgroundInterfaceData;
+    private static ParseUserInterfaceObject;
+    private static FixUserInterfacePrototypes;
+    private static ProcessControlEvents;
+    private static processUnityUIEvents;
+    private static processUIToolkitEvents;
+    private static isUnityUIEvent;
+    private static wireUnityUIButtonEvents;
+    private static wireUnityUIToggleEvents;
+    private static wireUnityUISliderEvents;
+    private static wireUnityUIDropdownEvents;
+    private static wireUnityUIScrollRectEvents;
+    private static wireUnityUIInputFieldEvents;
+    private static wireUIToolkitButtonEvents;
+    private static wireUIToolkitToggleEvents;
+    private static wireUIToolkitSliderEvents;
+    private static wireUIToolkitDropdownEvents;
+    private static executeUnityUIEvent;
+    private static executeUIToolkitEvent;
+    private static findTargetObject;
+    private static extractParameters;
+    private static resolveObjectReference;
+    private static executeUIToolkitCallback;
+    private static ProcessHdrColors;
+    private static emulateUnityHDR;
+    private static applyUnityHDRToneMapping;
+    private static applyHdrEffects;
+    private static applyGlowEffects;
+    private static applyLightingEffects;
+    private static applyAdvancedLightingEffects;
+    private static parseRgbaColor;
+    private static ApplyHdrVisualEnhancements;
+    private static ProcessPreserveAspectRatio;
+    private static applyPreserveAspectRatio;
+    private static ProcessTextSpacingProperties;
+    private static applyCharacterSpacing;
+    private static applyWordSpacing;
+    static IsForegroundReady(scene: Scene): boolean;
+    static SetForegroundTexture(scene: Scene, adt: AdvancedDynamicTexture): void;
+    static GetForegroundTexture(scene: Scene, createOptions?: any): AdvancedDynamicTexture;
+    static IsBackgroundReady(scene: Scene): boolean;
+    static SetBackgroundTexture(scene: Scene, adt: AdvancedDynamicTexture): void;
+    static GetBackgroundTexture(scene: Scene, createOptions?: any): AdvancedDynamicTexture;
+    static GetCanvasElement(name: string, scene?: Scene): Control;
+    static ShowCanvasElement(element: Control, fadeDuration?: number, fadeSpeedRatio?: number): Promise<void>;
+    static HideCanvasElement(element: Control, fadeDuration?: number, fadeSpeedRatio?: number): Promise<void>;
+    static AttachClickHandler(element: Control, func: (eventData?: Vector2WithInfo, eventState?: EventState) => any): Observer<Vector2WithInfo> | null;
+}
+export declare class WebVideoPlayer extends ScriptComponent implements IAssetPreloader {
+    private videoLoop;
+    private videoMuted;
+    private videoAlpha;
+    private videoFaded;
+    private videoPoster;
+    private videoInvert;
+    private videoSample;
+    private videoVolume;
+    private videoMipmaps;
+    private videoPlayback;
+    private videoPlayOnAwake;
+    private videoPreloaderUrl;
+    private videoBlobUrl;
+    private videoPreload;
+    private _initializedReadyInstance;
+    getVideoMaterial(): StandardMaterial;
+    getVideoTexture(): VideoTexture;
+    getVideoElement(): HTMLVideoElement;
+    getVideoScreen(): AbstractMesh;
+    getVideoBlobUrl(): string;
+    onReadyObservable: Observable<VideoTexture>;
+    protected m_abstractMesh: AbstractMesh;
+    protected m_videoTexture: VideoTexture;
+    protected m_videoMaterial: StandardMaterial;
+    protected m_diffuseIntensity: number;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected destroy(): void;
+    protected awakeWebVideoPlayer(): void;
+    protected destroyWebVideoPlayer(): void;
+    isReady(): boolean;
+    isPlaying(): boolean;
+    isPaused(): boolean;
+    play(): Promise<boolean>;
+    private internalPlay;
+    private checkedPlay;
+    private checkedRePlay;
+    pause(): boolean;
+    mute(): boolean;
+    unmute(): boolean;
+    getVolume(): number;
+    setVolume(volume: number): boolean;
+    setDataSource(source: string | string[] | HTMLVideoElement): void;
+    revokeVideoBlobUrl(): void;
+    addPreloaderTasks(assetsManager: PreloadAssetsManager): void;
+}
+//# sourceMappingURL=scenemanager.d.ts.map