@babylonjs-toolkit/next 9.22.2 → 9.25.1

package/lib/scenemanager.d.ts

@@ -2,19 +2,20 @@ import { AssetContainer, InstantiatedEntries } from '@babylonjs/core/assetContai
 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 { AssetsManager, BinaryFileAssetTask, AbstractAssetTask, ContainerAssetTask, MeshAssetTask, TextFileAssetTask, ImageAssetTask } 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 { Vector3, Matrix, Quaternion, Vector2, Vector4 } 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 { Color3, Color4 } from '@babylonjs/core/Maths/math.color';
+import { SphericalPolynomial, SphericalHarmonics, PostProcess, DefaultRenderingPipeline, SSRRenderingPipeline, MotionBlurPostProcess } from '@babylonjs/core';
 import { Nullable, DeepImmutable } from '@babylonjs/core/types';
 import { Material } from '@babylonjs/core/Materials/material';
 import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
@@ -22,11 +23,11 @@ import { RecastNavigationJSPluginV2 } from '@babylonjs/addons';
 import { Animation } from '@babylonjs/core/Animations/animation';
 import { EasingFunction } from '@babylonjs/core/Animations/easing';
 import { HavokPluginParameters, HavokPlugin } from '@babylonjs/core/Physics/v2/Plugins/havokPlugin';
-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 { Observable, Observer, EventState } from '@babylonjs/core/Misc/observable';
 import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData';
 import { PBRMaterial } from '@babylonjs/core/Materials/PBR/pbrMaterial';
 import { Animatable } from '@babylonjs/core/Animations/animatable';
 import { WebGPUEngine } from '@babylonjs/core/Engines/webgpuEngine';
@@ -47,14 +48,16 @@ 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, RawTexture2DArray } from '@babylonjs/core/Materials';
+import { ShaderLanguage, ImageProcessingConfiguration, RawTexture2DArray } 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 { IInspectorOptions } from '@babylonjs/core/Debug/debugLayer';
+import { PostProcessRenderPipeline } from '@babylonjs/core/PostProcesses/RenderPipeline/postProcessRenderPipeline';
+import { SSAO2RenderingPipeline } from '@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/ssao2RenderingPipeline';
 import { ParticleSystem } from '@babylonjs/core/Particles/particleSystem';
 import { GPUParticleSystem } from '@babylonjs/core/Particles/gpuParticleSystem';
 import { AdvancedDynamicTexture } from '@babylonjs/gui/2D/advancedDynamicTexture';
@@ -71,6 +74,7 @@ export declare class SceneManager {
     static RenderLoopReady: boolean;
     static PauseRenderLoop: boolean;
     static ScenePlaying: boolean;
+    static DeinstanceProbeLitNodes: boolean;
     private static PhysicsTimeStep;
     static LostRenderContext: boolean;
     static AutoUpdateProgress: boolean;
@@ -83,6 +87,7 @@ export declare class SceneManager {
     static PointLightIntensity: number;
     static SpotLightIntensity: number;
     static DirectionalLightIntensity: number;
+    static ShadowDarknessScale: number;
     static FogExpDensityScale: number;
     static FogExp2DensityScale: number;
     static FogLinearDensityScale: number;
@@ -141,6 +146,7 @@ export declare class SceneManager {
     static HideLoadingScreen(engine: Engine | WebGPUEngine | AbstractEngine, fade?: boolean): void;
     static ForceHideLoadingScreen(): void;
     private static DoForceHideLoadingScreen;
+    static ShowRenderCanvas(scene: Scene): void;
     static FocusRenderCanvas(scene: Scene): void;
     static ShowSplashScreen(): void;
     static HideSplashScreen(scene?: Scene, delayMs?: number): void;
@@ -155,6 +161,10 @@ export declare class SceneManager {
     static HasSceneBeenPreLoaded(scene: Scene): boolean;
     static GetDefaultSkybox(scene: Scene): AbstractMesh;
     static GetIntensityFactor(): number;
+    static GetLightmapBakeMode(): string;
+    static GetShadowmaskMode(): string;
+    static GetSubtractiveShadowColor(): Color3;
+    static GetRenderPipeline(): string;
     static GetRenderQuality(): RenderQuality;
     static SetRenderQuality(quality: RenderQuality): void;
     static GetEngineVersionString(scene: Scene): string;
@@ -238,7 +248,7 @@ export declare class SceneManager {
     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 InstantiatePrefabFromContainer(container: AssetContainer, prefabName: string, newName: string, newParent?: Nullable<TransformNode>, newPosition?: Nullable<Vector3>, newRotation?: Nullable<Quaternion>, newScaling?: Nullable<Vector3>, cloneAnimations?: boolean, makeNewMaterials?: boolean, createInstancedMesh?: Nullable<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;
@@ -299,6 +309,50 @@ export declare class SceneManager {
     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(scene?: Scene): void;
+    static MAX_NAVIGATION_AREAS: number;
+    static NAVIGATION_AREA_WALKABLE: number;
+    static NAVIGATION_AREA_NOT_WALKABLE: number;
+    static NAVIGATION_AREA_JUMP: number;
+    static NAVIGATION_AREA_HEIGHT_TOLERANCE: number;
+    static OnNavigationAreasChangedObservable: Observable<number>;
+    private static NavAreaNames;
+    private static NavAreaCosts;
+    private static NavAreaVolumes;
+    private static NavAreaMeshes;
+    private static NavAreaHandle;
+    private static NavAreaBaseline;
+    private static NavAreaDebugger;
+    private static NavAreaDebugMaterial;
+    private static NavAreaShowDebug;
+    private static NavAreaScene;
+    private static NavAreaWarnings;
+    static RegisterNavigationArea(id: number, name: string, cost?: number): void;
+    static SetNavigationAreaCost(id: number, cost: number): void;
+    static GetNavigationAreaCost(id: number): number;
+    static GetNavigationAreaByName(name: string): number;
+    static GetNavigationAreaNames(): string[];
+    static NavigationAreaToFlags(area: number): number;
+    static AreaMaskToIncludeFlags(areaMask: number): number;
+    static ConfigureNavigationQueryFilter(filter: any, includeFlags?: number, areaCosts?: Map<number, number>): void;
+    static AddNavigationAreaVolume(area: number, minimum: Vector3, maximum: Vector3): number;
+    static RemoveNavigationAreaVolume(handle: number): void;
+    static ClearNavigationAreaVolumes(): void;
+    static AddNavigationAreaMesh(mesh: AbstractMesh, area: number, heightTolerance?: number): void;
+    static RemoveNavigationAreaMesh(mesh: AbstractMesh): void;
+    static ClearNavigationAreaMeshes(): void;
+    static ApplyNavigationAreas(): number;
+    static GetNavigationAreaAtPosition(position: Vector3): number;
+    static RefreshNavigationAreaDebugMesh(scene: Scene): Mesh;
+    static GetNavigationAreaDebug(): Mesh | null;
+    private static PrepareNavigationAreas;
+    private static RefreshNavigationAreaCosts;
+    private static IsValidNavigationArea;
+    private static ClampNavigationAreaCost;
+    private static ResolveNavigationArea;
+    private static GetNavigationAreaColor;
+    private static ForEachNavigationPolygon;
+    private static CreateNavigationAreaSurface;
+    private static IsOverNavigationAreaSurface;
     static ToggleFullscreenMode(scene: Scene, requestPointerLock?: boolean): void;
     static EnterFullscreenMode(scene: Scene, requestPointerLock?: boolean): void;
     static ExitFullscreenMode(scene: Scene): void;
@@ -361,6 +415,17 @@ export interface IUnityNavigationOptions {
     detailsamplemaxerror: number;
     buildheightmesh: boolean;
 }
+export interface INavigationAreaVolume {
+    handle: number;
+    area: number;
+    minimum: Vector3;
+    maximum: Vector3;
+}
+export interface INavigationAreaMesh {
+    mesh: AbstractMesh;
+    area: number;
+    heightTolerance: number;
+}
 export declare abstract class ScriptComponent {
     private _update;
     private _late;
@@ -645,6 +710,7 @@ export declare class UserInputOptions {
 export interface IRuntimeOptions {
     enableUserInput?: boolean;
     hardwareScalingLevel?: number;
+    trackDevicePixelRatio?: boolean;
     initSceneFileLoaders?: boolean;
     loadAsyncRuntimeLibs?: boolean;
     loadProjectScriptBundle?: boolean;
@@ -783,12 +849,22 @@ export declare class GlobalMessageBus {
     private OnDispatchMessage;
     private ListenerDictionary;
 }
+export declare class PreloadPromiseTask extends AbstractAssetTask {
+    promiseFactory: () => Promise<any>;
+    timeoutMs: number;
+    result: any;
+    constructor(name: string, promiseFactory: () => Promise<any>, timeoutMs?: number);
+    runTask(scene: Scene, onSuccess: () => void, onError: (message?: string, exception?: any) => void): void;
+}
 export declare class PreloadAssetsManager extends AssetsManager {
+    static PreloadContainerSkins: boolean;
+    static PreloadContainerAssetsAsync(scene: Scene, container: AssetContainer, rootUrl?: string): Promise<void>;
     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;
+    addPromiseTask(taskName: string, promiseFactory: () => Promise<any>, timeoutMs?: number): PreloadPromiseTask;
     private handlePreloadingProgress;
 }
 export declare enum MaterialAlphaMode {
@@ -833,6 +909,7 @@ export declare class CVTOOLS_unity_metadata implements IGLTFLoaderExtension {
     private _animationGroups;
     private _materialMap;
     private _lightmapMap;
+    private _shadowmaskMap;
     private _reflectionMap;
     private _reflectionCache;
     private _assetContainer;
@@ -849,6 +926,8 @@ export declare class CVTOOLS_unity_metadata implements IGLTFLoaderExtension {
     private _licenseType;
     private _pendingReflectionTextures;
     private static ScriptBundleCache;
+    private static _bundleWarned;
+    private _missingMaterialClasses;
     constructor(loader: GLTFLoader);
     dispose(): void;
     static CreateExtensionAsync(loader: GLTFLoader): Promise<CVTOOLS_unity_metadata>;
@@ -873,6 +952,8 @@ export declare class CVTOOLS_unity_metadata implements IGLTFLoaderExtension {
     loadMaterialPropertiesAsync(context: string, material: IMaterial, babylonMaterial: Material): Nullable<Promise<void>>;
     private _getCachedMaterialByIndex;
     private _getCachedLightmapByIndex;
+    private _registerShadowmaskSampler;
+    private _getCachedShadowmaskByIndex;
     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>;
@@ -914,12 +995,12 @@ export declare class CustomShaderMaterial extends PBRMaterial {
     private _attributes;
     private _textures;
     private _vectors4;
+    private _matrices;
     private _vectors3;
     private _vectors2;
     private _floats;
     private _bools;
     private _ubos;
-    private _wgslSamplers;
     private _noMatrixTextures;
     protected shader: string;
     protected plugin: MaterialPluginBase;
@@ -930,6 +1011,7 @@ export declare class CustomShaderMaterial extends PBRMaterial {
     private _skinArrayEmissive;
     private _skinLayerUniform;
     private _skinArraySwitchingPlugin;
+    private _shadowmaskPlugin;
     getPlugin(): MaterialPluginBase;
     getClassName(): string;
     constructor(name: string, scene: Scene);
@@ -957,9 +1039,13 @@ export declare class CustomShaderMaterial extends PBRMaterial {
     setTextureValue(name: string, texture: Texture): CustomShaderMaterial;
     markTextureAsRaw(name: string): void;
     getTextureValue(name: string): Texture;
+    getShadowmaskTexture(): BaseTexture;
     addVector4Uniform(name: string, value: Vector4): CustomShaderMaterial;
     setVector4Value(name: string, value: Vector4): CustomShaderMaterial;
     getVector4Value(name: string): Vector4;
+    addMatrixUniform(name: string, value: Matrix): CustomShaderMaterial;
+    setMatrixValue(name: string, value: Matrix): CustomShaderMaterial;
+    getMatrixValue(name: string): Matrix;
     addVector3Uniform(name: string, value: Vector3): CustomShaderMaterial;
     setVector3Value(name: string, value: Vector3): CustomShaderMaterial;
     getVector3Value(name: string): Vector3;
@@ -981,6 +1067,7 @@ export declare class CustomShaderMaterial extends PBRMaterial {
     getCustomVertexCode(wgsl: boolean): string;
     getCustomFragmentCode(wgsl: boolean): string;
     prepareCustomDefines(defines: MaterialDefines): void;
+    updateShadowmaskBindings(subMesh: SubMesh): void;
     updateCustomBindings(effectOrUniformBuffer: UniformBuffer | Effect): void;
     legacyUpdateCustomBindings(effect: UniformBuffer): void;
     protected buildUniformProperty(uniformName: string, uniformType: string, uniformValue: any): void;
@@ -1002,7 +1089,9 @@ export declare class UnityStyleLightingPlugin extends CustomShaderMaterialPlugin
     getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
     getUniforms(shaderLanguage: ShaderLanguage): any;
     prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    hardBindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
     bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
+    static WriteProbeHarmonics(uniformBuffer: UniformBuffer, subMesh: SubMesh): boolean;
 }
 export declare class SkinArraySwitchingPlugin extends CustomShaderMaterialPlugin {
     constructor(material: CustomShaderMaterial);
@@ -1029,6 +1118,26 @@ export declare class SkinArraySwitchingPlugin extends CustomShaderMaterialPlugin
     private getWGSLMetalRoughApplyCode;
     private getWGSLEmissiveCode;
 }
+export declare class ShadowmaskPlugin extends CustomShaderMaterialPlugin {
+    constructor(material: CustomShaderMaterial);
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    getClassName(): string;
+    getSamplers(samplers: string[]): void;
+    getAttributes(attributes: string[], scene: Scene, mesh: AbstractMesh): void;
+    prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    updateShadowmaskBindings(mesh: AbstractMesh): void;
+    static IsBakedIntoLightmap(light: any): boolean;
+    private updateSubtractiveBindings;
+    getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
+    private getSubtractiveCode;
+    private getCombineCode;
+    private getGLSLDefinitions;
+    private getGLSLSample;
+    private getGLSLLightCode;
+    private getWGSLDefinitions;
+    private getWGSLSample;
+    private getWGSLLightCode;
+}
 export type CustomUniformProperty = {
     name: string;
     size: number;
@@ -1039,6 +1148,27 @@ export declare class UniversalShaderMaterial extends CustomShaderMaterial {
     constructor(name: string, scene: Scene);
     getShaderName(): string;
 }
+export declare class LightingConversions {
+    static ProbeRiderEpoch: number;
+    static readonly MaxShadowmaskLights: number;
+    static OcclusionSelector(channel: number): Vector4;
+    static BakedShadowStrength(maskValue: number, shadowStrength: number): number;
+    static SrgbToLinear(c: number): number;
+    static SubtractiveShadowColor(exported: any, assumeGamma: boolean): Color3;
+    static MainLightColor(light: any): Color3;
+    private static Warned;
+    static WarnOnce(key: string, message: string): void;
+    static hasWarned(key: string): boolean;
+    static resetWarnings(): void;
+    static IntensityModeFor(lightType: number): number;
+    static IsIntensityModeValid(lightType: number, mode: number): boolean;
+    static readonly UnitySHPreScaled: boolean;
+    static readonly UnitySHStride: number;
+    static SphericalHarmonicsFromUnity(coeffs: ArrayLike<number>, offset: number, scale: number): SphericalHarmonics;
+    static ProbeUniformsFromUnity(coeffs: ArrayLike<number>, offset: number, scale: number, out: Float32Array, outOffset: number): Float32Array;
+    static EvaluateShUniforms(u: ArrayLike<number>, offset: number, nx: number, ny: number, nz: number, out: number[]): number[];
+    static TetrahedronBarycentric(px: number, py: number, pz: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number, dx: number, dy: number, dz: number, out: Float32Array | number[]): boolean;
+}
 export declare class MetadataParser {
     private _physicList;
     private _shadowList;
@@ -1046,6 +1176,7 @@ export declare class MetadataParser {
     private _scriptList;
     private _babylonScene;
     constructor(scene: Scene);
+    static GetShadowDarkness(shadowstrength: number): number;
     parseSceneComponents(entity: TransformNode): void;
     postProcessSceneComponents(preloadList: Array<ScriptComponent>, readyList: Array<ScriptComponent>): void;
     private static DoParseSceneComponents;
@@ -1069,7 +1200,6 @@ export declare class StandardShaderMaterial extends StandardMaterial {
     private _floats;
     private _bools;
     private _ubos;
-    private _wgslSamplers;
     protected shader: string;
     protected plugin: MaterialPluginBase;
     getClassName(): string;
@@ -1324,13 +1454,13 @@ export declare class Utilities {
     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 CloneAssetContainerItem(container: AssetContainer, assetName: string, nameFunction?: (sourceName: string) => string, newParent?: Nullable<TransformNode>, makeNewMaterials?: boolean, cloneAnimations?: boolean, createInstancedMesh?: Nullable<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 InstantiateHierarchy(node: TransformNode, newParent?: Nullable<TransformNode>, onNewNodeCreated?: (source: TransformNode, clone: TransformNode) => void, createInstancedMesh?: Nullable<boolean>): Nullable<TransformNode>;
+    static InstantiateNodeHierarchy(node: TransformNode, newParent?: Nullable<TransformNode>, onNewNodeCreated?: (source: TransformNode, clone: TransformNode) => void, createInstancedMesh?: Nullable<boolean>): Nullable<TransformNode>;
+    static InstantiateMeshHierarchy(mesh: Mesh, newParent: Nullable<TransformNode>, createInstance: boolean, onNewNodeCreated?: (source: TransformNode, clone: TransformNode) => void, createInstancedMesh?: Nullable<boolean>): 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;
@@ -1515,6 +1645,8 @@ export declare class VertexAnimationMaterial extends CustomShaderMaterial {
     private _vatSkinArrayNormal;
     private _vatSkinArrayMetalRough;
     private _vatSkinArrayEmissive;
+    private _vatSkinSlot;
+    private _vatSkinLayerUniform;
     constructor(name: string, scene: Scene);
     awake(): void;
     update(): void;
@@ -1529,6 +1661,12 @@ export declare class VertexAnimationMaterial extends CustomShaderMaterial {
     disableVatSkinArrayMetalRough(): void;
     enableVatSkinArrayEmissive(): VertexAnimationMaterial;
     disableVatSkinArrayEmissive(): void;
+    setVatSkinSlot(slot: number): VertexAnimationMaterial;
+    get vatSkinSlot(): number;
+    enableVatSkinLayerUniform(): VertexAnimationMaterial;
+    setVatSkinLayerUniform(layer: number): VertexAnimationMaterial;
+    disableVatSkinLayerUniform(): VertexAnimationMaterial;
+    get vatSkinLayerUniform(): boolean;
     get vatSkinArray(): boolean;
     get vatSkinArrayNormal(): boolean;
     get vatSkinArrayMetalRough(): boolean;
@@ -1592,8 +1730,11 @@ export declare class VertexAnimationController {
     static Find(guid: string): VertexAnimationController;
     static GetOrCreate(guid: string, scene: Scene, rootUrl?: string, lazyLoadTextures?: boolean): VertexAnimationController;
     static CollectRendererTargets(settings: IVertexAnimationSettings[]): IVertexAnimationRendererReference[];
-    static SetAtlasCellIndex(mesh: AbstractMesh, cellIndex: number): void;
-    static GetAtlasCellIndex(mesh: AbstractMesh): number;
+    static readonly MAX_ATLAS_CELL_SLOTS: number;
+    static readonly MAX_ATLAS_CELL_INDEX: number;
+    static SetAtlasCellIndex(mesh: AbstractMesh, cellIndex: number, slot?: number): void;
+    static GetAtlasCellIndex(mesh: AbstractMesh, slot?: number): number;
+    static PackAtlasCells(mesh: AbstractMesh): number;
     static DisposeAll(scene?: Scene): void;
     readonly guid: string;
     readonly scene: Scene;
@@ -2048,6 +2189,12 @@ export declare class WindowManager {
     static PopupDebug(scene: Scene): void;
     static ToggleDebug(scene: Scene, embed?: boolean, parent?: HTMLElement): void;
     private static debugLayerVisible;
+    private static inspectorTokens;
+    static ShowInspector(scene: Scene, options: IInspectorOptions): void;
+    static HideInspector(scene: Scene): void;
+    private static DisposeInspectorToken;
+    static GetInspectorGlobal(): any;
+    static GetInspectorToken(scene: Scene): any;
     static GetLocalStorageItem(key: string): string;
     static SetLocalStorageItem(key: string, value: string): void;
     static GetSessionStorageItem(key: string): string;
@@ -2058,6 +2205,9 @@ export declare class WindowManager {
     static SetVirtualRealityEnabled(enabled: boolean): void;
     static SetWindowsLaunchMode(mode?: number): void;
     static GetHardwareScalingLevel(): number;
+    private static devicePixelRatioWatches;
+    static IsDevicePixelRatioWatched(engine: any): boolean;
+    static WatchDevicePixelRatio(engine: any, onChange?: (ratio: number, level: number) => void): () => void;
     static QuitWindowsApplication(): void;
     static PrintToScreen(text: string, color?: string, duration?: number): void;
     private static PrintElement;
@@ -2066,6 +2216,8 @@ export declare class AnimationState extends ScriptComponent {
     static FPS: number;
     static EXIT: string;
     static TIME: number;
+    static KEEP_PHASE: number;
+    static MAX_LOOP_EVENTS_PER_ADVANCE: number;
     private _looptime;
     private _loopblend;
     private _frametime;
@@ -2134,6 +2286,7 @@ export declare class AnimationState extends ScriptComponent {
     delayUpdateUntilReady: boolean;
     enableAnimations: boolean;
     applyRootMotion: boolean;
+    externalClock: boolean;
     awakened(): boolean;
     initialized(): boolean;
     hasRootMotion(): boolean;
@@ -2172,17 +2325,26 @@ export declare class AnimationState extends ScriptComponent {
     protected m_vertexAnimationRenderers: Mesh[];
     protected m_vertexAnimationController: VertexAnimationController;
     protected m_vertexAnimationDefaultClip: string;
+    protected m_vertexAnimationSearchNodes: AbstractMesh[];
+    protected m_animationPaused: boolean;
+    protected m_warnedInvalidDelta: boolean;
     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;
+    playDefault(transitionDuration?: number, animationLayer?: number, frameRate?: number, normalizedTimeOffset?: number): boolean;
+    playAnimation(state: string, transitionDuration?: number, animationLayer?: number, frameRate?: number, normalizedTimeOffset?: number): boolean;
     stopAnimation(animationLayer?: number): boolean;
     killAnimations(): boolean;
+    updateAnimation(deltaSeconds: number): void;
+    pauseAnimation(): void;
+    resumeAnimation(): void;
+    getAnimationPaused(): boolean;
     setTimelineScrubbing(isScrubbing: boolean): void;
     getIsTimelineScrubbing(): boolean;
-    setAnimationTime(seconds: number): boolean;
+    setAnimationNormalizedTime(normal: number, animationLayer?: number): boolean;
+    setAnimationTime(seconds: number, animationLayer?: number): boolean;
+    getCurrentAnimationLength(animationLayer?: number): number;
     setAnimationSpeed(speed: number): boolean;
     setAnimationLoop(loop: boolean): boolean;
     hasBool(name: string): boolean;
@@ -2204,6 +2366,7 @@ export declare class AnimationState extends ScriptComponent {
     private getMachineState;
     private setMachineState;
     getCurrentState(layer: number): MachineState;
+    getCurrentAnimationName(animationLayer?: number): string;
     getDefaultClips(): any[];
     getDefaultSource(): string;
     setLayerWeight(layer: number, weight: number): void;
@@ -2215,9 +2378,19 @@ export declare class AnimationState extends ScriptComponent {
     private updateAnimationGroups;
     private setupSourceAnimationGroups;
     private awakeStateMachine;
+    private resolveVertexAnimationRenderer;
+    private getRelativeTransformPath;
     private updateStateMachine;
     private destroyStateMachine;
     private updateAnimationState;
+    private getPublicLayer;
+    private isLayerLooping;
+    private getLayerClipLength;
+    private computeLayerSpeed;
+    private advanceLayerPhase;
+    private static WrapNormal;
+    private countEventCrossings;
+    private resolveVertexAnimationClips;
     private updateVertexAnimationLayer;
     private updateAnimationTargets;
     private updateBlendableTargets;
@@ -2378,6 +2551,14 @@ export interface IAvatarMask {
     transformCount: number;
     transformPaths: string[];
 }
+export interface IVertexAnimationClipSelection {
+    primaryName: string;
+    secondaryName: string | null;
+    primaryWeight: number;
+    primaryDuration: number;
+    secondaryDuration: number;
+    primaryLooping: boolean;
+}
 export interface IAnimationLayer {
     owner: string;
     hash: number;
@@ -2686,13 +2867,172 @@ export declare class RecastCharacterController extends ScriptComponent {
     turn(angle: number): void;
     rotate(x: number, y: number, z: number, w: number): void;
 }
+export interface IChromaticAberrationUnitySettings {
+    intensity: number;
+    fastMode: boolean;
+}
+export declare class ChromaticAberrationPlugin {
+    static readonly AmountScale: number;
+    static readonly MinSamples: number;
+    static readonly MaxSamples: number;
+    static readonly ShaderName: string;
+    static readonly ShaderKey: string;
+    private static DefaultSpectralLuts;
+    static PackAmount(intensity: number): number;
+    static SampleCount(diffX: number, diffY: number, width: number, height: number): number;
+    static CornerDisplacement(amount: number): number;
+    static GetFragmentShader(): string;
+    static GetDefaultSpectralLut(scene: Scene): Texture;
+    static ReleaseDefaultSpectralLut(scene: Scene): boolean;
+    static DefaultSpectralLutCount(scene: Scene): number;
+    static CreatePostProcess(scene: Scene, camera: Camera, options?: {
+        textureType?: number;
+        intensity?: number;
+        fastMode?: boolean;
+        spectralLutTexture?: Texture;
+        samplingMode?: number;
+    }): PostProcess;
+}
+export interface IColorFilterUnitySettings {
+    color: number[];
+}
 export declare class ColorFilterPlugin {
+    private static channel;
     static CreatePostProcess(scene: Scene, camera: Camera, options?: {
         color?: number[] | Color3 | Color4;
+        colorSrgb?: number[] | Color3 | Color4;
+        textureType?: number;
     }): PostProcess;
 }
+export interface IColorGradingHdrUnitySettings {
+    postExposure: number;
+}
+export declare class ColorGradingHdrPlugin {
+    static readonly LogC: {
+        cut: number;
+        a: number;
+        b: number;
+        c: number;
+        d: number;
+        e: number;
+        f: number;
+    };
+    static readonly DefaultLutSize: number;
+    static readonly ShaderName: string;
+    static readonly ShaderKey: string;
+    static PackPostExposure(ev: number): number;
+    static LinearToLogC(x: number): number;
+    static LogCToLinear(x: number): number;
+    static SrgbToLinear(v: number): number;
+    static PackLutParams(lutSize: number, use3D: boolean): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    static GetFragmentShader(): string;
+    static CreatePostProcess(scene: Scene, camera: Camera, options: {
+        textureType?: number;
+        lut: BaseTexture;
+        lutSize?: number;
+        use3D?: boolean;
+        postExposure?: number;
+        decodeSrgb?: boolean;
+        samplingMode?: number;
+    }): PostProcess;
+    private static inferLutSize;
+}
+export interface IBloomUnitySettings {
+    intensity: number;
+    threshold: number;
+    softKnee: number;
+    diffusion: number;
+    scatter?: number;
+    color: number[];
+    volumetype?: string;
+    clamp?: number;
+    highQualityFiltering?: boolean;
+    downscale?: number;
+    maxIterations?: number;
+}
+export interface IBloomPyramidState {
+    iterations: number;
+    sampleScale: number;
+    threshold: number[];
+    intensity: number;
+    tint: number[];
+    width: number;
+    height: number;
+    tw: number;
+    th: number;
+}
+export interface IBloomUrpPyramidState {
+    mipCount: number;
+    downres: number;
+    threshold: number;
+    knee: number;
+    clampMax: number;
+    scatter: number;
+    intensity: number;
+    tint: number[];
+    hq: number;
+    width: number;
+    height: number;
+    tw: number;
+    th: number;
+}
 export declare class ColoredBloomPlugin {
+    static readonly PrefilterShaderName: string;
+    static readonly DownsampleShaderName: string;
+    static readonly UpsampleShaderName: string;
+    static readonly CompositeShaderName: string;
+    static IntensityMultiplier(): number;
+    static readonly PrefilterShaderKey: string;
+    static readonly DownsampleShaderKey: string;
+    static readonly UpsampleShaderKey: string;
+    static readonly CompositeShaderKey: string;
+    static readonly MaxIterations: number;
+    static readonly HalfMax: number;
+    static readonly Epsilon: number;
+    static readonly DownsampleTaps: number[][];
+    static readonly DownsampleWeights: number[];
+    static readonly TentWeights: number[];
+    static readonly TentDivisor: number;
+    static readonly UrpPrefilterShaderName: string;
+    static readonly UrpBlurHShaderName: string;
+    static readonly UrpBlurVShaderName: string;
+    static readonly UrpUpsampleShaderName: string;
+    static readonly UrpCompositeShaderName: string;
+    static readonly UrpPrefilterShaderKey: string;
+    static readonly UrpBlurHShaderKey: string;
+    static readonly UrpBlurVShaderKey: string;
+    static readonly UrpUpsampleShaderKey: string;
+    static readonly UrpCompositeShaderKey: string;
+    static readonly UrpBlurHWeights: number[];
+    static readonly UrpBlurVOffsets: number[];
+    static readonly UrpBlurVWeights: number[];
+    static UrpLevelRatio(level: number, downres: number): number;
+    static UrpPyramidPassNames(mipCount: number): string[];
+    private static num;
+    private static channel;
+    static LevelRatio(level: number): number;
+    static PyramidPassNames(iterations: number): string[];
+    static GetPyramidShaders(): {
+        prefilter: string;
+        downsample: string;
+        upsample: string;
+        composite: string;
+    };
+    private static registerPyramidShaders;
+    static GetUrpPyramidShaders(): {
+        prefilter: string;
+        blurH: string;
+        blurV: string;
+        upsample: string;
+        composite: string;
+    };
+    private static registerUrpPyramidShaders;
     static CreateColoredBloom(scene: Scene, camera: Camera, options?: {
+        textureType?: number;
         threshold?: number;
         color?: number[] | Color3 | Color4;
         weight?: number;
@@ -2701,7 +3041,128 @@ export declare class ColoredBloomPlugin {
         passes?: number;
         saturation?: number;
         downsampleRatio?: number;
+        unity?: IBloomUnitySettings;
+        pyramid?: boolean;
+        urp?: boolean;
+        diffusion?: number;
+        softKnee?: number;
+        iterations?: number;
+        sampleScale?: number;
+        onRebuild?: (chain: any, removed: PostProcess[], added: PostProcess[]) => void;
     }): any;
+    private static createPyramid;
+    private static createBlurChain;
+    private static createUrpPyramid;
+}
+export interface IFxaaUnitySettings {
+    fastMode: boolean;
+}
+export declare class FxaaPlugin {
+    static readonly ShaderName: string;
+    static readonly ShaderKey: string;
+    static readonly LumaShaderName: string;
+    static readonly LumaShaderKey: string;
+    static readonly QualityPreset: number;
+    static readonly FastPreset: number;
+    static readonly QualityPresetSteps: number[];
+    static readonly FastPresetSteps: number[];
+    static readonly QualitySettings: {
+        subpix: number;
+        edgeThreshold: number;
+        edgeThresholdMin: number;
+    };
+    static readonly FastSettings: {
+        subpix: number;
+        edgeThreshold: number;
+        edgeThresholdMin: number;
+    };
+    static readonly LumaCoefficients: number[];
+    static readonly GammaPower: number;
+    static PresetNumber(fast: boolean): number;
+    static PresetSteps(fast: boolean): number[];
+    static PackQuality(fast: boolean): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    static PackRcpFrame(width: number, height: number): {
+        x: number;
+        y: number;
+    };
+    static IsLinearTextureType(textureType: number): boolean;
+    static LinearFromGamma(value: number): number;
+    static GammaFromLinear(value: number): number;
+    static Luminance(r: number, g: number, b: number): number;
+    private static glslFloat;
+    static GetSearchCode(steps: number[], indent?: string): string;
+    static GetLumaShader(): string;
+    static GetFragmentShader(): string;
+    static CreatePostProcess(scene: Scene, camera: Camera, options?: {
+        textureType?: number;
+        fastMode?: boolean;
+        samplingMode?: number;
+    }): PostProcess;
+    private static num;
+}
+export interface IGrainUnitySettings {
+    intensity: number;
+    size: number;
+    lumContrib: number;
+    colored: boolean;
+}
+export declare class GrainPlugin {
+    static readonly IntensityScale: number;
+    static readonly IntensityScaleURP: number;
+    static readonly UrpGrainTextureStd: number;
+    static readonly UrpBakeRawStd: number;
+    static readonly UrpGrainSeed: number;
+    static readonly NoiseSize: number;
+    static readonly UrpNoiseSize: number;
+    static readonly SampleCount: number;
+    static readonly NoiseParameters: number[];
+    static readonly ColoredPhaseOffsets: number[];
+    static readonly PhasePeriod: number;
+    static readonly ShaderName: string;
+    static readonly ShaderKey: string;
+    static readonly BakerName: string;
+    static readonly BakerKey: string;
+    static Halton(index: number, radix: number): number;
+    static IntensityMultiplier(): number;
+    static PackParams1(intensity: number, lumContrib: number, typeMultiplier?: number, intensityScale?: number): {
+        x: number;
+        y: number;
+    };
+    static PackParams2(width: number, height: number, size: number, index: number, noiseSize?: number): {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    static Phase(seconds?: number): number;
+    static LuminanceResponse(r: number, g: number, b: number, lumContrib: number): number;
+    static GetBakerShader(): string;
+    static GetFragmentShader(): string;
+    static Mulberry32(seed: number): () => number;
+    static BuildUrpGrainTexels(size: number, seed?: number, targetStd?: number): Float32Array;
+    static ToHalfFloat(value: number): number;
+    static CreateUrpGrainTexture(scene: Scene, size?: number, seed?: number): Texture;
+    static CreateNoiseTexture(scene: Scene, colored: boolean, film?: boolean): BaseTexture;
+    static CreatePostProcess(scene: Scene, camera: Camera, options?: {
+        textureType?: number;
+        intensity?: number;
+        size?: number;
+        lumContrib?: number;
+        colored?: boolean;
+        film?: boolean;
+        typeMultiplier?: number;
+        intensityScale?: number;
+        samplingMode?: number;
+    }): PostProcess;
+    private static halfBuffer;
+    private static halfBits;
+    private static now;
+    private static clamp01;
+    private static num;
 }
 export declare class btVehicleTuning {
     suspensionStiffness: number;
@@ -3022,7 +3483,23 @@ export declare class btRaycastVehicle {
     getApproxWheelbaseMeters(): number;
     dispose(): void;
 }
+export interface ILensDistortionUnitySettings {
+    intensity: number;
+    intensityX: number;
+    intensityY: number;
+    center: number[];
+    scale: number;
+    volumetype?: string;
+}
 export declare class LensDistortionPlugin {
+    static DeriveModel(unity: ILensDistortionUnitySettings): {
+        distortionIntensity: number;
+        distortionIntensityX: number;
+        distortionIntensityY: number;
+        distortionCenterX: number;
+        distortionCenterY: number;
+        distortionScale: number;
+    };
     private _distortionIntensity;
     private _distortionIntensityX;
     private _distortionIntensityY;
@@ -3059,7 +3536,6 @@ export declare class LensDistortionPlugin {
         };
     };
     getFragmentShaderCode(): string;
-    getWGSLShaderCode(): string;
     static CreatePostProcess(scene: any, camera: any, options?: {
         distortionIntensity?: number;
         distortionIntensityX?: number;
@@ -3067,8 +3543,91 @@ export declare class LensDistortionPlugin {
         distortionCenterX?: number;
         distortionCenterY?: number;
         distortionScale?: number;
+        textureType?: number;
+        unity?: ILensDistortionUnitySettings;
     }): any;
 }
+export declare class LightProbeTetraWalker {
+    readonly probeCount: number;
+    readonly tetraCount: number;
+    readonly positions: Float32Array;
+    readonly probeSh: Float32Array;
+    readonly indices: Int32Array;
+    readonly adjacency: Int32Array;
+    maxWalkSteps: number;
+    lastSteps: number;
+    lastClamped: boolean;
+    readonly weights: Float32Array;
+    private readonly _probeTetra;
+    constructor(positions: Float32Array, probeSh: Float32Array, indices: Int32Array, adjacency: Int32Array);
+    nearestProbe(px: number, py: number, pz: number): number;
+    locate(px: number, py: number, pz: number, startTet: number): number;
+    private _clampWeights;
+    blend(tet: number, scale: number, out: Float32Array, outOffset: number): void;
+    sample(px: number, py: number, pz: number, startTet: number, scale: number, out: Float32Array, outOffset: number): number;
+}
+export declare class LightProbeNetwork extends ScriptComponent {
+    static MoveThreshold: number;
+    static MaxWalkSteps: number;
+    private static readonly Sections;
+    private _url;
+    private _probeCount;
+    private _tetraCount;
+    private _rendererCount;
+    private _scale;
+    private _walker;
+    private _rendererSh;
+    private _rendererOcclusion;
+    private _rendererAnchor;
+    private _networkActive;
+    private _networkReason;
+    private _networkAwake;
+    private _networkLoaded;
+    private _networkAttached;
+    private _networkLoadRequested;
+    private _dynMeshes;
+    private _dynCount;
+    private _dynTet;
+    private _dynLast;
+    private _dynAnchor;
+    private _dynHasAnchor;
+    private _staticCount;
+    private _pending;
+    private _newMeshObserver;
+    private _bakedLights;
+    private _lastWalkSteps;
+    private _tmp;
+    private _nearestWarned;
+    private static SetRider;
+    static Get(scene: Scene): LightProbeNetwork;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    private readProperties;
+    addPreloaderTasks(assetsManager: PreloadAssetsManager): void;
+    protected awake(): void;
+    private selfLoad;
+    protected late(): void;
+    protected destroy(): void;
+    isActive(): boolean;
+    getDisabledReason(): string;
+    getProbeCount(): number;
+    getTetraCount(): number;
+    getRendererCount(): number;
+    getStaticCount(): number;
+    getDynamicCount(): number;
+    getLastWalkSteps(): number;
+    getWalker(): LightProbeTetraWalker;
+    attach(mesh: AbstractMesh, dynamic: boolean): boolean;
+    detach(mesh: AbstractMesh): void;
+    sampleMeshNow(mesh: AbstractMesh): number;
+    private sampleDynamic;
+    private ensureCapacity;
+    private probeKeyOf;
+    evaluateAt(px: number, py: number, pz: number, out: Float32Array): number;
+    private tryAttachAll;
+    private disable;
+    private sceneLabel;
+    private onDataLoaded;
+}
 export declare class NavigationAgent extends ScriptComponent {
     static TARGET_ANGLE_FACTOR: number;
     static ANGULAR_SPEED_RATIO: number;
@@ -3100,6 +3659,11 @@ export declare class NavigationAgent extends ScriptComponent {
     private m_stuckCounter;
     private m_reachObserver;
     private m_navMeshDestroyObserver;
+    private m_navAreasObserver;
+    private m_areaCosts;
+    private m_filterSlot;
+    private static CROWD_FILTER_SLOTS;
+    private static CROWD_FILTER_WARNED;
     speed: number;
     reachRadius: number;
     heightOffset: number;
@@ -3154,6 +3718,9 @@ export declare class NavigationAgent extends ScriptComponent {
     private getLookAtStopDistance;
     private updateAgentParameters;
     private applyAgentUpdateFlags;
+    private applyAgentFilter;
+    private refreshAgentPolicy;
+    private getFilteredClosestPoint;
     private destroyNavigationAgent;
     move(offset: Vector3, closetPoint?: boolean): void;
     teleport(destination: Vector3, closetPoint?: boolean, initialRotation?: Quaternion): void;
@@ -3174,6 +3741,12 @@ export declare class NavigationAgent extends ScriptComponent {
     getAgentWaypointToRef(result: Vector3): void;
     cancelNavigation(): void;
     releaseNavigationCrowd(): void;
+    setAreaMask(areaMask: number): void;
+    getAreaMask(): number;
+    setAreaCost(area: number, cost: number): void;
+    getAreaCost(area: number): number;
+    resetAreaCosts(): void;
+    getQueryFilter(): any;
     getDebugDestinationMesh(): Mesh;
     showDebugDestination(show: boolean): void;
 }
@@ -3189,69 +3762,882 @@ export declare enum NavMoveStatus {
     Stuck = "stuck",
     Cancelled = "cancelled"
 }
+export interface IPostProcessColorGradingState {
+    camera: string;
+    configuration: ImageProcessingConfiguration;
+    expected: {
+        exposure?: number;
+        contrast?: number;
+        globalSaturation?: number;
+        colorCurvesEnabled?: boolean;
+        toneMappingEnabled?: boolean;
+        toneMappingType?: number;
+        colorGradingEnabled?: boolean;
+        ditheringEnabled?: boolean;
+        ditheringIntensity?: number;
+    };
+    lutUrl: string;
+    colorFilter: number[];
+    hdr?: boolean;
+    dropped?: boolean;
+}
+export interface IPostProcessImagingSnapshot {
+    configuration: ImageProcessingConfiguration;
+    key: string;
+    curve: boolean;
+    value: any;
+    camera: string;
+}
+export interface IPostProcessStackFlags {
+    vignetteActive: boolean;
+    hdrGrading: boolean;
+    hdrReason: string;
+}
+export interface IPostProcessInspectorField {
+    key: string;
+    label: string;
+    kind: "number" | "switch" | "text";
+    unit?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    readOnly?: boolean;
+    description?: string;
+    get(): any;
+    set?(value: any): void;
+}
+export interface IPostProcessInspectorEffect {
+    camera: Camera;
+    family: string;
+    unityEffect: string;
+    order: number;
+    applied: boolean;
+    target: string;
+    reason?: string;
+    enabled: boolean;
+    fields: IPostProcessInspectorField[];
+}
+export interface IPostProcessLutEntry {
+    strip: Texture;
+    ready: BaseTexture;
+    waiting: ((texture: BaseTexture) => void)[];
+}
+export interface IPostProcessPluginTextureEntry {
+    texture: Texture;
+    ready: boolean;
+    failed: boolean;
+    waiting: ((texture: Texture) => void)[];
+}
+export interface IPostProcessBloomRecord {
+    camera: Camera;
+    chain: any;
+    color: number[];
+    weight: number;
+    threshold: number;
+    kernel: number;
+    iterations: number;
+    sampleScale: number;
+    mipCount?: number;
+    scatter?: number;
+}
 export declare class PostProcessor extends ScriptComponent {
     private static GlobalInstance;
+    private static Registry;
+    private static Warned;
+    private static Scheduled;
     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;
+    static get Volumes(): PostProcessor[];
+    static readonly PipelinePrefix: string;
+    static LutInvertY: boolean;
+    static LutSamplingMode: number;
+    static LutUse3D: boolean;
+    static ForceScreenSpaceReflections: boolean;
+    static Dithering: boolean;
+    static HalfFloatChain: boolean;
+    static InspectorSection: boolean;
+    static InspectorState: {
+        available: boolean;
+        registered: boolean;
+    };
+    static readonly HeadSlots: {
+        motionBlur: number;
+        lensDistortion: number;
+        chromaticAberration: number;
+        bloom: number;
+        vignette: number;
+        grain: number;
+        grading: number;
+        grainAfterGrading: number;
+    };
+    static readonly TailSlotBase: number;
+    static readonly TailSlots: {
+        fxaa: number;
+    };
+    static IsTailSlot(slot: number): boolean;
+    static readonly BuiltInPipeline: string;
+    static readonly SrpPipelines: string[];
+    static VolumeTypeOf(model: any): string;
+    static IsSrpVolume(model: any): boolean;
+    static warnOnce(key: string, message: string): void;
+    static hasWarned(key: string): boolean;
+    private volumeProperties;
+    private volumeLayer;
+    private orchestrator;
+    private applied;
+    private readyCalled;
+    private stacks;
     private defaultRenderPipeline;
     private screenSpaceAOPipeline;
     private screenSpaceRPipeline;
+    private ownedPipelines;
+    private reusedPipelines;
+    private ownedRenderPipelines;
+    private ownedPostProcesses;
+    private ownedTextures;
+    private lutTextures;
+    private pendingPlugins;
+    private buildObservers;
+    private reordering;
+    private frontPostProcesses;
+    private frontSlots;
+    private tailPostProcesses;
+    private tailSlots;
+    private fxaas;
+    private coloredBloom;
+    private vignettes;
+    private chromaticAberrations;
+    private grains;
+    private hdrGradings;
+    private pluginTextures;
+    private depthOfFields;
+    private motionBlurs;
+    private lensDistortions;
+    private lensUnitySettings;
+    private antialiasings;
+    private ambientOcclusions;
+    private ditherings;
+    private screenSpaceReflections;
+    private ssrGates;
+    private gradingStates;
+    private gradingDrift;
+    private effectListings;
+    private effectEnabled;
+    private toggleOrders;
+    private detachedPasses;
+    private toggleSaved;
+    private imagingSnapshots;
+    private imagingWrites;
+    private droppedGradingStates;
+    private gradingReadBackScheduled;
+    private disposed;
     GetDefaultRenderPipeline(): DefaultRenderingPipeline;
-    GetSSAORRenderPipeline(): SSAORenderingPipeline;
+    GetSSAORRenderPipeline(): SSAO2RenderingPipeline;
     GetSSRRenderPipeline(): SSRRenderingPipeline;
-    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    GetVolumeProperties(): IPostProcessVolumeProperties;
+    GetVolumeLayer(): number;
+    IsOrchestrator(): boolean;
+    GetCameraStacks(): {
+        camera: Camera;
+        stack: IPostProcessStack;
+        pipeline: DefaultRenderingPipeline;
+    }[];
+    protected awake(): void;
     protected ready(): void;
-    protected parseColorGradingSettings(settings: any): any;
-    protected applyColorGradingSettings(): void;
-    protected mapToneMapper(tonemapperParam: any): {
+    private tryOrchestrate;
+    protected destroy(): void;
+    applyVolumes(): void;
+    getOrCreatePipeline(camera: Camera, hdr: boolean): DefaultRenderingPipeline;
+    protected watchPipelineBuilds(pipeline: DefaultRenderingPipeline): void;
+    protected registerPass(camera: Camera, passes: PostProcess[], slot: number): void;
+    static CompactChain(camera: Camera): void;
+    protected screenSpacePasses(camera: Camera): PostProcess[];
+    reorderPluginPasses(pipeline: DefaultRenderingPipeline): number;
+    protected placeTailPasses(camera: Camera): number;
+    static FindDefaultPipeline(scene: Scene, camera: Camera): DefaultRenderingPipeline;
+    static readonly Consumes: {
+        [family: string]: string[];
+    };
+    static readonly ConsumesUrp: {
+        [family: string]: string[];
+    };
+    private applyStack;
+    static ChainTextureType(scene: Scene, metadata: IPostProcessCameraMetadata, pipeline?: DefaultRenderingPipeline): number;
+    static DeriveStackFlags(model: IPostProcessModel, metadata: IPostProcessCameraMetadata): IPostProcessStackFlags;
+    protected applyAntialiasing(camera: Camera, pipeline: DefaultRenderingPipeline, metadata: IPostProcessCameraMetadata, textureType?: number): void;
+    protected applySamplesToFirstPass(camera: Camera): void;
+    static StripLacksToneMapper(lut: IPostProcessLutReference): boolean;
+    GetAntialiasings(): {
+        pipeline: DefaultRenderingPipeline;
+        camera: Camera;
+        mode: number;
+        fxaa: boolean;
+        samples: number;
+        firstPass: PostProcess;
+        prePassSamples?: number;
+        fxaaPass?: PostProcess;
+        lumaPass?: PostProcess;
+        fast?: boolean;
+    }[];
+    protected applyColorGrading(camera: Camera, pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number, flags?: IPostProcessStackFlags): void;
+    protected applyHdrColorGrading(camera: Camera, pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel, model: IPostProcessModel, imaging: ImageProcessingConfiguration, textureType: number): void;
+    protected applyDithering(camera: Camera, pipeline: DefaultRenderingPipeline): void;
+    GetDitherings(): {
+        camera: Camera;
+        configuration: ImageProcessingConfiguration;
         enabled: boolean;
-        type: number | null;
+        intensity: number;
+    }[];
+    protected writeImaging(configuration: ImageProcessingConfiguration, key: string, value: any, camera?: string): void;
+    protected restoreImagingFor(camera: string, configuration: ImageProcessingConfiguration): string[];
+    protected assertGradingState(state: IPostProcessColorGradingState): void;
+    protected restoreImaging(): void;
+    GetImagingSnapshots(): IPostProcessImagingSnapshot[];
+    static GetImageProcessing(scene: Scene, pipeline: DefaultRenderingPipeline): ImageProcessingConfiguration;
+    static ToColorArray(value: any): number[];
+    protected requestLutTexture(lut: IPostProcessLutReference, apply: (texture: BaseTexture) => void): void;
+    protected requestPluginTexture(url: string, purpose: string, apply: (texture: Texture) => void): void;
+    private finalizeLutTexture;
+    static RepackLutStrip(pixels: Uint8Array, width: number, height: number): Uint8Array;
+    static ResolveSceneUrl(scene: Scene, url: string): string;
+    private scheduleGradingReadBack;
+    verifyColorGrading(reassert?: boolean): string[];
+    GetColorGradingDrift(): {
+        camera: string;
+        keys: string[];
+    }[];
+    private pushGradingState;
+    GetColorGradingStates(): IPostProcessColorGradingState[];
+    protected applyBloom(camera: Camera, pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number, flags?: IPostProcessStackFlags): void;
+    static ChainPasses(chain: any): PostProcess[];
+    protected rechainBloom(camera: Camera, chain: any, removed: PostProcess[], added: PostProcess[]): void;
+    private forgetPostProcesses;
+    protected applyVignette(camera: Camera, pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number): void;
+    protected applyChromaticAberration(camera: Camera, pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number): void;
+    protected applyGrain(camera: Camera, pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number): void;
+    protected applySharpen(pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel): void;
+    protected fieldValue(family: IPostProcessEffectModel, name: string): any;
+    protected fieldOverridden(family: IPostProcessEffectModel, name: string): boolean;
+    protected warnUnconsumedFields(family: IPostProcessEffectModel, extra?: string[]): void;
+    protected warnUnsupportedFields(family: IPostProcessEffectModel, names: string[]): void;
+    static ToVector2Array(value: any, fallback: number[]): number[];
+    GetColoredBloomChains(): IPostProcessBloomRecord[];
+    GetVignettes(): {
+        camera: Camera;
+        postProcess: PostProcess;
+        center: number[];
+        intensity: number;
+        smoothness: number;
+        roundness: number;
+        rounded: boolean;
+        color: number[];
+        distortion: IVignetteDistortion;
+    }[];
+    GetChromaticAberrations(): {
+        camera: Camera;
+        postProcess: PostProcess;
+        intensity: number;
+        fastMode: boolean;
+        spectralLutUrl: string;
+        spectralLut: BaseTexture;
+    }[];
+    GetGrains(): {
+        camera: Camera;
+        postProcess: PostProcess;
+        intensity: number;
+        size: number;
+        lumContrib: number;
+        colored: boolean;
+        typeMultiplier: number;
+        noise: BaseTexture;
+    }[];
+    GetHdrGradings(): {
+        camera: Camera;
+        postProcess: PostProcess;
+        lutUrl: string;
+        postExposure: number;
+        decodeSrgb: boolean;
+        use3D: boolean;
+        lutSize: number;
+    }[];
+    GetHeadPasses(): {
+        postProcess: PostProcess;
+        slot: number;
+    }[];
+    GetTailPasses(): {
+        postProcess: PostProcess;
+        slot: number;
+    }[];
+    GetFxaaPasses(): {
+        camera: Camera;
+        postProcess: PostProcess;
+        lumaPass: PostProcess;
+        fastMode: boolean;
+    }[];
+    protected applyDepthOfField(pipeline: DefaultRenderingPipeline, family: IPostProcessEffectModel, model: IPostProcessModel, metadata?: IPostProcessCameraMetadata): void;
+    protected applyMotionBlur(camera: Camera, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number): void;
+    static FindMotionBlur(camera: Camera): MotionBlurPostProcess;
+    protected applyLensDistortion(camera: Camera, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number): void;
+    protected deriveLensDistortionOptions(family: IPostProcessEffectModel, model: IPostProcessModel): any;
+    protected deriveLensUnitySettings(family: IPostProcessEffectModel, model: IPostProcessModel): ILensDistortionUnitySettings;
+    protected getLensUnitySettings(camera: Camera, model: IPostProcessModel): ILensDistortionUnitySettings;
+    GetLensUnitySettings(): {
+        camera: Camera;
+        settings: ILensDistortionUnitySettings;
+    }[];
+    GetDepthOfFields(): {
+        pipeline: DefaultRenderingPipeline;
+        focusDistance: number;
+        fStop: number;
+        focalLength: number;
+        blurLevel: number;
+    }[];
+    GetMotionBlurs(): {
+        camera: Camera;
+        postProcess: MotionBlurPostProcess;
+        reused: boolean;
+        motionStrength: number;
+        motionBlurSamples: number;
+        isObjectBased: boolean;
+    }[];
+    GetLensDistortions(): {
+        camera: Camera;
+        postProcess: PostProcess;
+        options: any;
+    }[];
+    protected applyAmbientOcclusion(camera: Camera, family: IPostProcessEffectModel, model: IPostProcessModel, textureType: number): void;
+    protected applyScreenSpaceReflections(camera: Camera, family: IPostProcessEffectModel, model: IPostProcessModel, metadata: IPostProcessCameraMetadata, textureType: number): void;
+    protected releaseScreenSpaceReflections(camera: Camera): void;
+    protected applyHdrpExposure(family: IPostProcessEffectModel): void;
+    static FindRenderPipeline(scene: Scene, camera: Camera, ctor: any): PostProcessRenderPipeline;
+    protected detachLegacyPipeline(camera: Camera, legacyCtor: any, replacementCtor: any, label: string): void;
+    GetAmbientOcclusions(): {
+        camera: Camera;
+        pipeline: SSAO2RenderingPipeline;
+        reused: boolean;
+        settings: IPostProcessSsao;
+    }[];
+    GetScreenSpaceReflections(): {
+        camera: Camera;
+        pipeline: SSRRenderingPipeline;
+        reused: boolean;
+        settings: IPostProcessSsr;
+    }[];
+    GetSsrGates(): IPostProcessSsrGate[];
+    static readonly EffectOrders: {
+        [family: string]: number;
+    };
+    static readonly AntialiasingEffectName: string;
+    onEffectListingChangedObservable: Observable<PostProcessor>;
+    GetEffectListings(): {
+        camera: Camera;
+        effects: IPostProcessInspectorEffect[];
+    }[];
+    GetEffectListing(camera: Camera): IPostProcessInspectorEffect[];
+    IsEffectEnabled(camera: Camera, family: string): boolean;
+    protected setEffectEnabledFlag(camera: Camera, family: string, enabled: boolean): void;
+    protected rebuildEffectListing(camera: Camera): void;
+    protected notifyEffectListing(): void;
+    private buildEffectListing;
+    private listingRow;
+    private numberField;
+    private switchField;
+    private textField;
+    private colorFields;
+    private enumLabel;
+    private listingValues;
+    private static fmt;
+    private listGrain;
+    private listVignette;
+    private listChromaticAberration;
+    private listBloom;
+    private listColorGrading;
+    private listDepthOfField;
+    private listMotionBlur;
+    private listLensDistortion;
+    private listAmbientOcclusion;
+    private listScreenSpaceReflections;
+    private listSharpen;
+    private listAntialiasing;
+    static readonly ToggleFamilies: string[];
+    SetEffectEnabled(camera: Camera, family: string, enabled: boolean): boolean;
+    GetToggleOrder(camera: Camera): PostProcess[];
+    private pipelineOf;
+    private pluginNameOf;
+    private spliceIntoToggleOrder;
+    private recordToggleOrder;
+    private toggleOwnedPasses;
+    private togglePasses;
+    private togglePipelineFlag;
+    private toggleImagingGrade;
+    private toggleRenderPipeline;
+    protected trackPostProcess(postProcess: PostProcess, camera: Camera): void;
+    protected trackTexture(texture: BaseTexture): void;
+    protected trackRenderPipeline(pipeline: PostProcessRenderPipeline): void;
+    protected releaseStacks(): void;
+    static GlslangWatchdog: boolean;
+    static GlslangStallDelay: number;
+    static GlslangRetryTimeout: number;
+    static GlslangRetryBackoff: number[];
+    static readonly GlslangWarningKey: string;
+    static GlslangClock: () => number;
+    static GlslangSchedule: (callback: () => void, ms: number) => any;
+    private glslangObserver;
+    private glslangObserverScene;
+    private glslangToken;
+    private glslangStuckSince;
+    private glslangState;
+    static GlslangEngine(scene: Scene): any;
+    GetGlslangWatchdogState(): {
+        armed: boolean;
+        attempts: number;
+        running: boolean;
+        failed: boolean;
+        recovered: boolean;
+        reason: string;
+        rebuilt: string[];
+        stuckPasses: string[];
+    };
+    GetGlslangStuckPasses(): PostProcess[];
+    protected armGlslangWatchdog(): void;
+    protected checkGlslangWatchdog(): void;
+    private startGlslangRetry;
+    static ResetGlslangScriptCaches(engine: any): string[];
+    private recoverGlslang;
+    private failGlslang;
+    static RebuildGlslangPasses(engine: any, passes: PostProcess[]): string[];
+    private annotateGlslangReasons;
+    private removeGlslangObserver;
+    protected disarmGlslangWatchdog(): void;
+}
+export interface IPostProcessEnumValue {
+    value?: number;
+    name?: string;
+}
+export interface IPostProcessTextureReference {
+    url?: string;
+    type?: string;
+    width?: number;
+    height?: number;
+    exported?: boolean;
+}
+export interface IPostProcessLutReference extends IPostProcessTextureReference {
+    lutsize?: number;
+    lutlayout?: string;
+    identity?: boolean;
+    lutspace?: string;
+    lutencoding?: string;
+    operators?: string[];
+}
+export interface IPostProcessEffect {
+    effecttype?: string;
+    effectnamespace?: string;
+    enabled?: boolean;
+    active?: boolean;
+    parameters?: {
+        [key: string]: any;
+    };
+}
+export interface IPostProcessVolumeBounds {
+    shape: "box" | "sphere";
+    center: number[];
+    size?: number[];
+    radius?: number;
+}
+export interface IPostProcessVolumeProperties {
+    volumetype?: string;
+    isglobal?: boolean;
+    bounds?: IPostProcessVolumeBounds;
+    pipelinedefault?: boolean;
+    weight?: number;
+    priority?: number;
+    blenddistance?: number;
+    profilename?: string;
+    colorspace?: string;
+    effectcount?: number;
+    effects?: IPostProcessEffect[];
+}
+export interface IPostProcessCameraMetadata {
+    postprocessing?: boolean;
+    volumelayermask?: number;
+    antialiasing?: IPostProcessEnumValue;
+    msaasamples?: number;
+    allowhdr?: boolean;
+    renderingpath?: string;
+    physicalaperture?: number;
+    physicalfocallength?: number;
+}
+export interface IPostProcessSsrGate {
+    camera: string;
+    volumetype: string;
+    renderingpath: string;
+    forced: boolean;
+    applied: boolean;
+    reused: boolean;
+    reason: string;
+    flags: {
+        inputTextureColorIsInGammaSpace: boolean;
+        generateOutputInGammaSpace: boolean;
+        enableSmoothReflections: boolean;
+        blurDispersionStrength: number;
+        roughnessFactor: number;
+    };
+}
+export interface IPostProcessField {
+    value: any;
+    overridden: boolean;
+    unsupported?: string;
+}
+export interface IPostProcessEffectModel {
+    family: string;
+    source: string;
+    active: boolean;
+    fields: {
+        [name: string]: IPostProcessField;
+    };
+}
+export interface IPostProcessUnsupportedEffect {
+    effecttype: string;
+    effectnamespace: string;
+}
+export interface IPostProcessModel {
+    volumetype: string;
+    volumetypes: string[];
+    families: {
+        [family: string]: IPostProcessEffectModel;
+    };
+    lut: IPostProcessLutReference;
+    unsupported: IPostProcessUnsupportedEffect[];
+    warnings: string[];
+}
+export interface IPostProcessVolumeEntry {
+    name: string;
+    layer: number;
+    properties: IPostProcessVolumeProperties;
+    cameraLocal?: number[];
+}
+export interface IPostProcessIgnoredVolume {
+    name: string;
+    reason: string;
+}
+export interface IPostProcessStack {
+    model: IPostProcessModel;
+    applied: string[];
+    ignored: IPostProcessIgnoredVolume[];
+    warnings: string[];
+}
+export interface IPostProcessCameraCandidate {
+    name: string;
+    main?: boolean;
+    metadata?: IPostProcessCameraMetadata;
+    camera?: any;
+}
+export interface IPostProcessCameraSelection {
+    cameras: IPostProcessCameraCandidate[];
+    mode: string;
+    warning?: string;
+}
+export declare class PostProcessingContract {
+    static readonly VOLUME_TYPES: string[];
+    static readonly GRADING_MODES: string[];
+    static readonly RENDERING_PATH_DEFERRED: string;
+    static readonly RENDERING_PATH_FORWARD: string;
+    static readonly Defaults: {
+        [family: string]: {
+            [field: string]: any;
+        };
+    };
+    static readonly KnownFields: {
+        [family: string]: {
+            BuiltIn?: string[];
+            URP?: string[];
+            HDRP?: string[];
+        };
+    };
+    static readonly ModeOnlyFields: {
+        [family: string]: string[];
     };
-    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;
+    static unconsumedFields(family: IPostProcessEffectModel, consumes: string[]): string[];
+    static readonly Vocabulary: {
+        [effecttype: string]: {
+            family: string | null;
+            rename?: {
+                [from: string]: string;
+            };
+            consumedElsewhere?: boolean;
+        };
+    };
+    static readonly HDRP_NAMESPACE: string;
+    static parseVolume(props: any): IPostProcessVolumeProperties;
+    static parseVolumeBounds(raw: any): IPostProcessVolumeBounds;
+    static parseEffect(raw: any): IPostProcessEffect;
+    static readField(param: any): IPostProcessField;
+    static enumIndex(value: any, fallback?: number): number;
+    static enumName(value: any): string;
+    static normalise(volume: IPostProcessVolumeProperties): IPostProcessModel;
+    private static createFamily;
+    private static parseLut;
+    static parseTexture(raw: any): IPostProcessTextureReference;
+    static readonly TextureFields: {
+        [family: string]: string[];
     };
+    static gradingMode(model: IPostProcessModel): IPostProcessEnumValue;
+    static isHdrGrading(model: IPostProcessModel): boolean;
+    static tonemapper(model: IPostProcessModel): IPostProcessEnumValue;
+    static renderingPath(metadata: IPostProcessCameraMetadata): string;
+    static volumeType(volume: IPostProcessVolumeProperties): string;
+    static localVolumeWeight(bounds: IPostProcessVolumeBounds, cameraLocal: number[], blendDistance: number): number;
+    static blendStack(volumes: IPostProcessVolumeEntry[], layerMask?: number): IPostProcessStack;
+    static layerInMask(layer: number, mask: number): boolean;
+    private static scaleModel;
+    private static blendInto;
+    static interpolate(from: any, to: any, t: number): any;
+    static selectCameras(cameras: IPostProcessCameraCandidate[]): IPostProcessCameraSelection;
+    static isNumber(v: any): boolean;
+    static clone(v: any): any;
+    static fieldOf(model: IPostProcessModel, family: string, name: string): IPostProcessField;
+}
+export interface IPostProcessToneMapper {
+    enabled: boolean;
+    type: number;
+    warning?: string;
+}
+export interface IPostProcessVignetteCenter {
+    centerX: number;
+    centerY: number;
+}
+export interface IPostProcessGaussianDof {
+    focusDistanceMm: number;
+    blurLevel: number;
+    warning: string;
+}
+export interface IPostProcessSsao {
+    totalStrength: number;
+    radius: number;
+    samples: number;
+    expensiveBlur: boolean;
+    ssaoRatio: number;
+    blurRatio: number;
+    epsilon: number;
+    base: number;
+    maxZ: number;
+    minZAspect: number;
+    bilateralSamples: number;
+    bilateralSoften: number;
+    bilateralTolerance: number;
+}
+export interface IPostProcessSsr {
+    maxSteps: number;
+    thickness: number;
+    strength: number;
+    ssrDownsample: number;
+    maxDistance?: number;
+    attenuateScreenBorders?: boolean;
+    roughnessFactor?: number;
+    blurDispersionStrength?: number;
+    enableSmoothReflections?: boolean;
+}
+export interface IPostProcessAntialiasing {
+    fxaa: boolean;
+    fast: boolean;
+    samples: number;
+    mode: number;
+}
+export declare class PostProcessingConversions {
+    static ContrastMin: number;
+    static ContrastMax: number;
+    static NeutralToneMapperType: number;
+    static ExposureMaxStops: number;
+    static exposureFromEV(ev: number): number;
+    static contrastFromUnity(contrast: number): number;
+    static saturationFromUnity(saturation: number): number;
+    static toneMapperFromPPv2(tonemapper: number): IPostProcessToneMapper;
+    static toneMapperFromSRP(mode: number): IPostProcessToneMapper;
+    private static toneMapperFromMode;
+    static srgbToLinearColor(color: number[]): number[];
+    static srgbToLinear(c: number): number;
+    static linearToSrgb(c: number): number;
+    static linearToSrgbColor(color: number[]): number[];
+    static isWhite(color: number[], tolerance?: number): boolean;
+    static BloomWeightScaleURP: number;
+    static BloomThresholdGamma: number;
+    static BloomKernelMin: number;
+    static BloomKernelMax: number;
+    static BloomScale: number;
+    static BloomMaxIterations: number;
+    static BloomWeightScaleHDRP: number;
+    static bloomWeightFromIntensity(intensity: number, volumetype?: string): number;
+    static bloomThresholdFromUnity(threshold: number, volumetype?: string, softKnee?: number): number;
+    static BloomHardKneeSRP: number;
+    static BloomKneeWeight: number;
+    static gammaToLinearSpace(value: number): number;
+    static bloomPyramidFromDiffusion(diffusion: number, width: number, height: number): {
+        iterations: number;
+        sampleScale: number;
+        logs: number;
+        tw: number;
+        th: number;
+    };
+    static bloomThresholdVectorFromPPv2(threshold: number, softKnee?: number): number[];
+    static bloomKernelFromScatter(scatter: number): number;
+    private static kernelFromUnit;
+    static bloomUrpPrefilterParams(threshold: number, clamp?: number): {
+        threshold: number;
+        knee: number;
+        clamp: number;
+    };
+    static bloomUrpScatter(scatter: number): number;
+    static bloomUrpLadder(width: number, height: number, downscale?: number, maxIterations?: number): {
+        tw: number;
+        th: number;
+        mipCount: number;
+        downres: number;
+    };
+    static bloomUrpTint(color: number[]): number[];
+    static dofBlurLevelFromUrpBokeh(highQualitySampling: boolean): number;
+    static vignetteCenter(uv: number[]): IPostProcessVignetteCenter;
+    static vignetteColorLinear(rgba: number[]): number[];
+    static gradingModeIsHdr(gradingMode: number, volumetype: string): boolean;
+    static gradingModeBakesToneMapper(gradingMode: number, volumetype: string): boolean;
+    static GrainIntensityMultiplier: number;
+    static BloomIntensityMultiplier: number;
+    static FilmGrainTypeMultipliers: number[];
+    static FilmGrainAmplitudeScaleURP: number;
+    static SharpenEdgeScale: number;
+    static filmGrainTypeMultiplier(type: number): number;
+    static sharpenEdgeAmount(intensity: number): number;
+    static dofFocusDistanceMm(metres: number): number;
+    static dofFocusDistanceFromHdrpRanges(nearFocusEnd: number, farFocusStart: number): number;
+    static dofBlurLevelFromKernelSize(kernelSize: number): number;
+    static dofFromGaussian(start: number, end: number, maxRadius: number): IPostProcessGaussianDof;
+    static MotionStrengthK: number;
+    static MotionBlurQualitySamples: number[];
+    static motionStrengthFromShutterAngle(shutterAngle: number): number;
+    static motionStrengthFromIntensity(intensity: number): number;
+    static motionSamplesFromQuality(quality: number): number;
+    static LensDistortionK: number;
+    static LensDistortionDegreesPerUnit: number;
+    static LensDistortionMaxDegrees: number;
+    static lensDistortionTheta(normalised: number): number;
+    static lensDistortionIntensity(normalised: number): number;
+    static lensDistortionModelScale(normalised: number): number;
+    static lensDistortionAxisIntensity(intensity: number, multiplier: number): number;
+    static lensDistortionCenterUv(center: number): number;
+    static lensDistortionScale(scale: number): number;
+    static lensDistortionNormalised(value: number, volumetype?: string): number;
+    static SsaoQualitySamples: number[];
+    static SsaoExpensiveBlurFromQuality: number;
+    static SsaoStrengthScale: number;
+    static SsaoRadiusScale: number;
+    static SsaoRatio: number;
+    static SsaoBlurRatio: number;
+    static SsaoEpsilon: number;
+    static SsaoBase: number;
+    static SsaoMaxZ: number;
+    static SsaoMinZAspect: number;
+    static SsaoExpensiveBlur: boolean;
+    static SsaoBilateralSamples: number;
+    static SsaoBilateralSoften: number;
+    static SsaoBilateralTolerance: number;
+    private static SsaoDeclared;
+    static frozen(name: string): number;
+    static ssaoFromUnity(intensity: number, radius: number, quality?: number, stepCount?: number): IPostProcessSsao;
+    static DitheringIntensity: number;
+    static SsrPresets: IPostProcessSsr[];
+    static SsrBlurDispersionStrength: number;
+    static SsrRoughnessFactor: number;
+    static ssrRoughnessBlur(minSmoothness?: number): {
+        roughnessFactor: number;
+        blurDispersionStrength: number;
+        enableSmoothReflections: boolean;
+    };
+    static ssrPresetTable(preset: number): IPostProcessSsr;
+    static ssrCustomFromUnity(maximumIterationCount: number, thickness: number, resolution: number, maximumMarchDistance: number, distanceFade: number, vignette: number): IPostProcessSsr;
+    static ssrFromHdrp(rayMaxIterations: number, minSmoothness: number, screenFadeDistance: number): IPostProcessSsr;
+    static antialiasingFromMetadata(mode: number, msaaSamples: number): IPostProcessAntialiasing;
+    static num(value: any, fallback: number): number;
+    static clamp(value: number, min: number, max: number): number;
+}
+export interface IInspectorDisposable {
+    dispose(): void;
+}
+export interface IInspectorSectionRow {
+    section: string;
+    order?: number;
+    component: (props: {
+        context: any;
+    }) => any;
+}
+export interface IInspectorPropertiesService {
+    addSection(section: {
+        identity: string;
+        order?: number;
+        collapseByDefault?: boolean;
+    }): IInspectorDisposable;
+    addSectionContent(content: {
+        key: string;
+        predicate: (entity: unknown) => boolean;
+        content: readonly IInspectorSectionRow[];
+    }): IInspectorDisposable;
+}
+export interface IInspectorServiceDefinition {
+    friendlyName: string;
+    consumes?: any[];
+    produces?: any[];
+    factory: (...args: any[]) => any;
+}
+export interface IPostProcessInspectorRow {
+    family: string;
+    field: string;
+    order: number;
+}
+export interface IPostProcessInspectorRegistration extends IPostProcessInspectorRow {
+    kind: string;
+    key: string;
+}
+export declare class PostProcessingInspector {
+    static readonly SectionIdentity: string;
+    static readonly SectionOrder: number;
+    static readonly RequiredExports: string[];
+    static readonly StockSections: {
+        [family: string]: string;
+    };
+    static readonly PassFamilies: {
+        [plugin: string]: string;
+    };
+    static readonly FamilyFields: {
+        [family: string]: string[];
+    };
+    static readonly HeaderFields: string[];
+    static readonly EmptyRowKey: string;
+    static get RowCatalogue(): IPostProcessInspectorRow[];
+    private static catalogue;
+    static readonly RowKinds: string[];
+    static get RowRegistrations(): IPostProcessInspectorRegistration[];
+    static IsRowPresent(entity: any, reg: IPostProcessInspectorRegistration): boolean;
+    static IsEmptyRowPresent(entity: any): boolean;
+    static EmptyRowMessage(entity: any): string;
+    static ResolveNoteTarget(entity: any, family: string): string;
+    static GetInspectorGlobal(): any;
+    static IsAvailable(inspector?: any): boolean;
+    static GetServiceDefinitions(inspector?: any): IInspectorServiceDefinition[];
+    static IsInspectable(entity: any): boolean;
+    static IsOwnedPipeline(entity: any): boolean;
+    static IsToolkitPass(entity: any): boolean;
+    static ResolveContext(entity: any): {
+        camera: any;
+        family: string;
+        effects: IPostProcessInspectorEffect[];
+        unmapped?: boolean;
+    };
+    static ResolveEffect(entity: any, family: string): IPostProcessInspectorEffect;
+    static ResolveField(entity: any, family: string, field: string): IPostProcessInspectorField;
+    static CreateServiceDefinition(inspector: any): IInspectorServiceDefinition;
+    static Register(inspector: any, properties: IInspectorPropertiesService): {
+        dispose: () => void;
+    };
+    static RenderRow(inspector: any, context: any, reg: IPostProcessInspectorRegistration, observable: any, notify: () => void): any;
+    private static state;
+    private static setRegistered;
 }
 export declare class RaycastVehicle {
     private static TempVector;
@@ -3474,16 +4860,6 @@ export interface IPhysicsShapeCastQuery {
     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;
@@ -3972,6 +5348,14 @@ export declare class SkinTextureArray {
         invertY?: boolean;
         mipmaps?: boolean;
     }): Promise<RawTexture2DArray>;
+    static IsCached(scene: Scene, urls: string[], options?: {
+        samplingMode?: number;
+        aniso?: number;
+        invertY?: boolean;
+        mipmaps?: boolean;
+    }): boolean;
+    private static _clampLayers;
+    private static _cacheKey;
     private static _uploadMipChain;
     private static _downsampleLayers;
     private static _maxArrayLayers;
@@ -4165,7 +5549,7 @@ export declare class TerrainBuilder extends ScriptComponent {
     private static GammaToLinear;
     private static LinearToGamma;
 }
-export declare class TextureAtlasSkin extends ScriptComponent {
+export declare class TextureAtlasSkin extends ScriptComponent implements IAssetPreloader {
     private abtractMesh;
     private textureData;
     private defaultIndex;
@@ -4178,11 +5562,18 @@ export declare class TextureAtlasSkin extends ScriptComponent {
     private _applied;
     private _manifest;
     private _currentIndex;
+    private _pendingIndex;
     private _targets;
     private _clonedMultiMaterial;
+    onSkinsReadyObservable: Observable<TextureAtlasSkin>;
+    private _outstandingBuilds;
+    private _skinsReady;
     constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
     protected awake(): void;
     protected start(): void;
+    private readSliceProperties;
+    addPreloaderTasks(assetsManager: PreloadAssetsManager): void;
+    protected destroy(): void;
     getAbstractSkinnedMesh(): AbstractMesh;
     applySkins(): void;
     setSkinIndex(index: number): number;
@@ -4190,15 +5581,51 @@ export declare class TextureAtlasSkin extends ScriptComponent {
     skinCount(): number;
     private maxChannelSliceCount;
     getSkinIndex(): number;
+    static OnAllSkinsReadyObservable: Observable<Scene>;
+    private static readonly SKIN_READY_TIMEOUT_MS;
+    private static readonly SKIN_READY_SETTLE_MS;
+    private static readonly SKIN_SHADER_WAIT_MS;
+    private static readonly SKIN_PRELOAD_TIMEOUT_MS;
+    private static readonly SKIN_READY_POLL_MS;
+    private static _pendingBuilds;
+    private static _buildActivity;
+    private static _buildsSinceNotify;
+    private static _batchWatch;
+    private static _batchScene;
+    static GetPendingSkinBuilds(): number;
+    static AreAllSkinsReady(): boolean;
+    static WhenAllSkinsReady(scene: Scene, timeoutMs?: number, settleMs?: number): Promise<boolean>;
+    private static NoteBuildStarted;
+    private static NoteBuildFinished;
+    private static TrackSkinBuild;
+    private beginSkinBuild;
+    private endSkinBuild;
+    isSkinsReady(): boolean;
+    private markSkinsReady;
+    private static startBatchWatch;
+    private static stopBatchWatch;
+    private static whenSceneReady;
+    private static nowMs;
+    private resolveVatSlot;
     private configureMaterial;
+    private skinChannels;
+    private channelUrlsFor;
+    private static readonly CHANNEL_SPECS;
+    private static ChannelOptions;
+    static PreloadContainerSkinsAsync(scene: Scene, container: AssetContainer, rootUrl?: string, timeoutMs?: number): Promise<boolean>;
+    private static ScanContainerSkinChannels;
+    private static SlicePropertyUrls;
+    private assignChannelArray;
     private albedoChannelUrls;
     private normalChannelUrls;
     private metalRoughChannelUrls;
     private emissiveChannelUrls;
     private sliceUrls;
     private resolveLayerUrl;
+    private setVatUniformMode;
     private applyIndexToTargets;
     private applyLayerToMaterial;
+    private refreshMaterialDefines;
     private isInstancedSetup;
     private ensureSkinLayerBuffer;
     private getMeshSlots;
@@ -4280,6 +5707,65 @@ export declare class UserInterface extends ScriptComponent {
     static HideCanvasElement(element: Control, fadeDuration?: number, fadeSpeedRatio?: number): Promise<void>;
     static AttachClickHandler(element: Control, func: (eventData?: Vector2WithInfo, eventState?: EventState) => any): Observer<Vector2WithInfo> | null;
 }
+export interface IVignetteDistortion {
+    intensity: number;
+    intensityX: number;
+    intensityY: number;
+    center: number[];
+    scale: number;
+}
+export interface IVignetteUnitySettings {
+    intensity: number;
+    smoothness: number;
+    roundness: number;
+    rounded: boolean;
+    center: number[];
+    color: number[];
+}
+export declare class VignettePlugin {
+    static readonly IntensityScale: number;
+    static readonly SmoothnessScale: number;
+    static readonly RoundnessScale: number;
+    static readonly DefaultRoundness: number;
+    static readonly ShaderName: string;
+    static readonly ShaderKey: string;
+    static PackSettings(intensity: number, smoothness: number, roundness: number, rounded: boolean): {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    static Factor(uvX: number, uvY: number, centerX: number, centerY: number, settings: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    }, width: number, height: number, distortion?: IVignetteDistortion): number;
+    private static clamp01;
+    static GetFragmentShader(): string;
+    static CreatePostProcess(scene: Scene, camera: Camera, options?: {
+        textureType?: number;
+        intensity?: number;
+        smoothness?: number;
+        roundness?: number;
+        rounded?: boolean;
+        center?: {
+            x: number;
+            y: number;
+        } | number[];
+        color?: number[] | Color3 | Color4;
+        colorSrgb?: number[] | Color3 | Color4;
+        samplingMode?: number;
+        distortion?: IVignetteDistortion;
+        distortionSettings?: ILensDistortionUnitySettings;
+    }): PostProcess;
+    static toDistortion(distortion: any): IVignetteDistortion;
+    static DistortUv(uvX: number, uvY: number, distortion: IVignetteDistortion): number[];
+    private static toCenter;
+    private static linearOf;
+    private static toColor;
+    private static num;
+}
 export declare class WebVideoPlayer extends ScriptComponent implements IAssetPreloader {
     private videoLoop;
     private videoMuted;