@babylonjs-toolkit/next 9.34.1 → 9.34.100

package/lib/scenemanager.d.ts

@@ -178,6 +178,7 @@ export declare class SceneManager {
     static readonly DefaultLayerMask: number;
     static readonly HiddenLayerMask: number;
     private static _HideLoadingScreen;
+    private static _FadeLoadingScreen;
     static CVTOOLS_NAME: string;
     static CVTOOLS_MESH: string;
     static CVTOOLS_HAND: string;
@@ -2182,7 +2183,7 @@ export declare class HdrpRendering {
     };
     static RegisterShaders(): void;
     static CreateSanitizePass(scene: Scene, camera: Camera, textureType: number): PostProcess;
-    private static SceneMetadata;
+    static SceneMetadata(scene: Scene): any;
     private static State;
     private static ApplyBinding;
 }
@@ -2217,6 +2218,7 @@ export declare class LightingConversions {
     static SubtractiveShadowColor(exported: any, assumeGamma: boolean): Color3;
     static MainLightColor(light: any): Color3;
     static UnityLinearLightColor(light: any): Color3;
+    static LinearizeLightColor(light: Light, scene: Scene): boolean;
     private static Warned;
     static SetShadowFade(scene: Scene, fade: any): void;
     static GetShadowFade(scene: Scene): Vector4;
@@ -2264,6 +2266,7 @@ export declare class LightingConversions {
     static readonly RelativeUnits: string;
     static EnvironmentUnits(value: any): string;
     static SpecularEnvironmentLevel(reflection: number, units: string, levelMax: number): number;
+    static EnvironmentAmbientScale(ambientIntensity: number, environmentLevel: number, units: string, isParity: boolean): number;
     static WarnBakedSkyWithoutEnvironment(skybox: any): boolean;
     static IntensityModeFor(lightType: number): number;
     static IsIntensityModeValid(lightType: number, mode: number): boolean;
@@ -2391,6 +2394,39 @@ export declare class LoadingProgress {
     private static HookSceneDispose;
     private static ForgetScene;
 }
+export interface ILoadingScreenStageView {
+    screen: HTMLElement;
+    stage: HTMLElement;
+    status: HTMLElement;
+    details: HTMLElement;
+    fill: HTMLElement;
+    slide: ReturnType<HTMLElement["animate"]>;
+}
+export declare class LoadingScreenStages {
+    static START_TEXT: string;
+    static BAR_COLOR: string;
+    static SLIDE_DURATION_MS: number;
+    private static Views;
+    private static Observer;
+    private static PreviousHostDefers;
+    private static BarState;
+    private static BarProgress;
+    static Attach(loadingScreen: any, marginTop: string): void;
+    static FindPageCover(): HTMLElement;
+    static AttachScreen(screen: HTMLElement, marginTop: string): void;
+    private static Begin;
+    static IsShowing(): boolean;
+    static SceneToReveal(engine: AbstractEngine): Scene;
+    static FadeScreen(screen: HTMLElement): void;
+    static GetBarState(): number;
+    static ShowStatus(status: string, details: string, progress: number, state: number): void;
+    static Detach(removeStages?: boolean): void;
+    private static CreateView;
+    private static StartSlide;
+    private static OnLoaderStatus;
+    private static NextBarProgress;
+    private static ToSentenceCase;
+}
 export declare class MaterialSamplerBudget {
     static BudgetOverride: number;
     private static readonly ShadowSamplerDeclaration;
@@ -2486,10 +2522,28 @@ export declare class OpaqueSceneColor {
     private static CreateTarget;
     static ShadowMapsRendered(scene: Scene, camera: Camera): boolean;
     static UseCopy: boolean;
+    private static readonly COPY_PLAIN;
+    private static readonly COPY_TO_LINEAR;
+    static CopyConversionFor(imageProcessing: {
+        isEnabled: boolean;
+        applyByPostProcess: boolean;
+    }): number;
     static QueueSamples(subMeshes: any, materials: any): boolean;
     static InstallCopy(scene: Scene, store: any): void;
     private static CopyNow;
 }
+export interface IUrpSceneBlock {
+    version: number;
+    sky?: any;
+    fog?: any;
+    clouds?: any;
+}
+export declare class PhysicalSkyBlock {
+    static readonly UrpBlockVersion: number;
+    static UrpBlock(metadata: any): IUrpSceneBlock;
+    static SkyOf(metadata: any): any;
+    static FogOf(metadata: any): any;
+}
 export declare class FixedStepClock {
     static readonly DEFAULT_FIXED_DELTA_TIME: number;
     static readonly DEFAULT_MAXIMUM_DELTA_TIME: number;
@@ -2795,6 +2849,7 @@ export declare class SceneShaderWarmup {
     static DrawHiddenMeshesOnReveal: boolean;
     static WarmEmptyThinInstancesOnReveal: boolean;
     static WarmScaleVariantsOnReveal: boolean;
+    static WarmNativeLodLevelsOnReveal: boolean;
     static OPTIONAL_UNIT_GRACE_MS: number;
     private static GIVEN_UP_NAMES_SHOWN;
     static LateCompileReporting: boolean;
@@ -2948,8 +3003,9 @@ export declare class SceneShaderWarmup {
     private static RestoreHiddenMeshes;
     private static KeepHiddenCastersInShadowMaps;
     private static RestoreShadowCasterLists;
-    private static DrawPunctualShadowMapsFully;
-    private static RestorePunctualShadowMaps;
+    private static DrawShadowMapsFully;
+    static HasCasterCullingList(shadowMap: RenderTargetTexture): boolean;
+    private static RestoreFullShadowMaps;
     private static readonly MATERIAL_VARIANT_FRAMES;
     private static readonly MaterialVariants;
     static WarmMaterialVariant(mesh: AbstractMesh, material: Material): void;
@@ -2974,6 +3030,9 @@ export declare class SceneShaderWarmup {
     private static ForgetReadyThisFrame;
     private static AlternateScaleVariants;
     private static RestoreScaleVariants;
+    static NativeLodSequence(mesh: AbstractMesh): AbstractMesh[];
+    static CycleNativeLodLevels(scene: Scene): INativeLodCycle;
+    static RestoreNativeLodLevels(scene: Scene, cycle: INativeLodCycle): void;
     private static SetScaleVariantForced;
     private static ShowHiddenEmittersForDraws;
     private static RestoreHiddenEmitters;
@@ -3244,6 +3303,14 @@ export interface IScaleVariantDraw {
     drawingOther: boolean;
     frameObserver: Observer<Scene>;
 }
+export interface INativeLodCycle {
+    sequences: Map<AbstractMesh, AbstractMesh[]>;
+    length: number;
+    frameIndex: number;
+    previousSelector: (mesh: AbstractMesh, camera: Camera) => Nullable<AbstractMesh>;
+    selector: (mesh: AbstractMesh, camera: Camera) => Nullable<AbstractMesh>;
+    frameObserver: Observer<Scene>;
+}
 export interface IHiddenEmitterDraw {
     node: BabylonNode;
     ownIsEnabled: (checkAncestors?: boolean) => boolean;
@@ -3280,12 +3347,16 @@ export interface ISubMeshDrawWrappers {
     _drawWrappers?: DrawWrapper[];
 }
 export type CustomRenderListFunction = (layerOrFace: number, renderList: readonly AbstractMesh[], renderListLength: number) => AbstractMesh[];
+export interface ICasterCullingListMarks {
+    tkCasterCulling?: boolean;
+    tkTerrainCulling?: boolean;
+}
 export interface IShadowCasterListWrap {
     shadowMap: RenderTargetTexture;
     customList: CustomRenderListFunction;
     keptList: CustomRenderListFunction;
 }
-export interface IPunctualShadowMapDraw {
+export interface IShadowMapFullDraw {
     shadowMap: RenderTargetTexture;
     customList: CustomRenderListFunction;
 }
@@ -3665,7 +3736,14 @@ export interface IShaderClock {
     smoothDeltaTime: number;
     frame: number;
 }
+export interface IShaderGlobalDriver {
+    name: string;
+    component: number;
+    rate: number;
+    wrap: number;
+}
 export declare class ShaderGlobals {
+    private static readonly DriverComponentNames;
     private static _version;
     private static _floats;
     private static _vectors;
@@ -3689,6 +3767,8 @@ export declare class ShaderGlobals {
     static DisableKeyword(name: string): void;
     static IsKeywordEnabled(name: string): boolean;
     static LoadSceneGlobals(scene: Scene, block: any): void;
+    static LoadSceneDrivers(scene: Scene, drivers: IShaderGlobalDriver[]): void;
+    private static AdvanceDriver;
     static GetClock(scene: Scene): IShaderClock;
 }
 export interface IShaderGraphPassData {
@@ -3861,6 +3941,8 @@ export declare class ShaderGraphRuntime {
     static SetThinInstanceValue(mesh: Mesh, index: number, key: string, value: any, sub?: number): boolean;
     static ApplyInstanceBlock(instance: InstancedMesh, block: any, sub?: number): boolean;
     static CloneWithBlock(material: Material, block: any, meshId: number, loadTexture?: (info: any, done: (texture: BaseTexture) => void) => void): Material;
+    static RecordExportReport(scene: Scene, entries: IExportReportEntry[]): void;
+    private static PrintExportReport;
     static FlushSceneSummary(scene: Scene): void;
 }
 export interface ShaderGraphSceneRecord {
@@ -3879,6 +3961,13 @@ export interface ShaderGraphSceneRecord {
     scheduled?: boolean;
     timer?: any;
     deadline?: number;
+    exportReport?: IExportReportEntry[];
+}
+export interface IExportReportEntry {
+    feature: string;
+    reason: string;
+    items: string[];
+    count: number;
 }
 export declare class SgShadowDepth {
     static Enabled: boolean;
@@ -4519,6 +4608,9 @@ export declare class UnityLodGroups {
     static readonly FADE_CROSSFADE: number;
     static readonly FADE_SPEEDTREE: number;
     static FADE_SECONDS: number;
+    static readonly NATIVE_TRANSFORM_TOLERANCE_METERS: number;
+    static readonly NATIVE_BASIS_TOLERANCE: number;
+    private static readonly BASIS_ELEMENTS;
     static ExportedSize(root: TransformNode, metadata: any): {
         worldSize: number;
         localPoint: Vector3;
@@ -4527,6 +4619,9 @@ export declare class UnityLodGroups {
         useDistances: boolean;
         thresholds: number[];
     };
+    static LevelsShareTransform(master: AbstractMesh, details: AbstractMesh[]): boolean;
+    private static MatricesShareTransform;
+    static RequiresSwitcher(meshLevels: AbstractMesh[][], fadeMode: number): boolean;
     static ParseFadeMode(mode: string): number;
     lodBias: number;
     private _scene;
@@ -13313,6 +13408,7 @@ export declare class HdrpFogPass {
     private static registered;
     static FogBlock(scene: Scene): any;
     static SkyOf(scene: Scene): any;
+    private static BindChain;
     static Frame(scene: Scene, fog: any): IHdrpFogFrame;
     static SkyDepth(scene: Scene): number;
     static RegisterShaders(): void;
@@ -13327,6 +13423,8 @@ export declare class HdrpFogPass {
     static AmbientDeclarations(wgsl: boolean): string;
     static AmbientGlsl(): string;
     static AmbientWgsl(): string;
+    static AerialPerspectiveGlsl(): string;
+    static AerialPerspectiveWgsl(): string;
     static GlslHelpers(prefix: string): string;
     static WgslHelpers(prefix: string): string;
     private static Glsl;
@@ -13511,6 +13609,10 @@ export declare class HdrpPhysicallyBasedSky {
         requested: boolean;
         captured: boolean;
     }, nowSeconds: number, frame: number, precomputationHash: string, lightHash: string, updateMode: number, updatePeriod: number): boolean;
+    static readonly ProbeRenderKept: number;
+    static readonly ProbeCaptureAccepted: number;
+    static readonly ProbeCaptureRetry: number;
+    static ProbeRenderOutcome(capturing: boolean, pendingFilter: boolean, drewSky: boolean): number;
     static SelectAmbientSh(skyAmbientMode: number, readback: SphericalHarmonics, exported: SphericalHarmonics): SphericalHarmonics;
     static AmbientShScale(diffuse: number, reflection: number): number;
     static EnvironmentLevel(pe: number, reflection: number): number;
@@ -13572,6 +13674,7 @@ export declare class HdrpPhysicallyBasedSky {
     private filtering;
     private pendingFilter;
     private capturing;
+    private probeDrawsSky;
     private shReading;
     private readbackHarmonics;
     private exportedHarmonics;
@@ -13584,6 +13687,8 @@ export declare class HdrpPhysicallyBasedSky {
     private apRequested;
     private apCamera;
     private readonly startTime;
+    private readonly sunIntensityScale;
+    private readonly spaceCube;
     private constructor();
     get mode(): string;
     get useBakedSky(): boolean;
@@ -13595,10 +13700,14 @@ export declare class HdrpPhysicallyBasedSky {
     private writeUniforms;
     private writeCloudUniforms;
     private cloudAmbient;
+    ambientAt(direction: Vector3): Color3;
     private cloudLayers;
+    private loadSpaceEmission;
+    private spaceEmissionUniform;
     private loadCloudMap;
     private bindEffect;
     setProbeCapture(capturing: boolean): void;
+    private encodesForDisplay;
     private applyMaterialUniforms;
     private attenuateSuns;
     private static RestoreLight;
@@ -15832,6 +15941,84 @@ export declare class LightProbeNetwork extends ScriptComponent {
     private sceneLabel;
     private onDataLoaded;
 }
+export interface IMeshWaterFollower {
+    node: string;
+    offset: number[];
+    scale: number[] | null;
+}
+export interface IMeshWaterUnderwater {
+    sealevel: number;
+    fogcolors: number[][];
+    fogcolormultiplier: number[];
+    fogdepth: number;
+    fogdensity: number;
+    fogstart: number;
+    fogend: number;
+    suncolor: number[];
+    volumenodes: string[];
+    shownodes: string[];
+    flipnodes: string[];
+    follownodes: IMeshWaterFollower[];
+}
+export interface IMeshWaterSurfaceProperties {
+    sealevel: number;
+    waveamplitude: number;
+    wavespeed: number;
+    underwater: IMeshWaterUnderwater | null;
+}
+export interface IResolvedFollower {
+    node: TransformNode;
+    offset: Vector3;
+}
+export interface IFlippedNode {
+    node: TransformNode;
+    surfaceRotation: Quaternion;
+    underwaterRotation: Quaternion;
+}
+export declare class MeshWaterSurface extends ScriptComponent {
+    private static readonly POST_PROCESSOR_CLASS;
+    private static readonly PARTICLES_CLASS;
+    private static readonly STOP_AND_CLEAR;
+    private static readonly LINEAR_FOG_END_SCALE;
+    private static Registry;
+    private waterProperties;
+    private isUnderwater;
+    private readonly fogColorChannels;
+    private readonly surfaceFogColor;
+    private surfaceFogDensity;
+    private surfaceFogStart;
+    private surfaceFogEnd;
+    private shownNodes;
+    private shownParticles;
+    private volumeNodes;
+    private flippedNodes;
+    private followers;
+    private readonly followPosition;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    static Get(scene: Scene): MeshWaterSurface;
+    protected awake(): void;
+    protected ready(): void;
+    protected start(): void;
+    protected update(): void;
+    protected destroy(): void;
+    getSeaLevel(): number;
+    getSurfaceHeight(): number;
+    getCameraHeight(camera: Camera): number;
+    isCameraUnderwater(camera: Camera): boolean;
+    ProjectPointOnWaterSurface(searchParameters: IHdrpWaterSearchParameters): IHdrpWaterSearchResult;
+    FindWaterSurfaceHeight(searchParameters: IHdrpWaterSearchParameters): IHdrpWaterSearchResult;
+    private findNodes;
+    private findParticles;
+    private prepareFlip;
+    private prepareFollowers;
+    private enterUnderwater;
+    private leaveUnderwater;
+    private writeUnderwaterFog;
+    private restoreSurfaceFog;
+    private setVolumesEnabled;
+    private updateFog;
+    private updateFollowers;
+}
 export declare class NavigationAgent extends ScriptComponent {
     static TARGET_ANGLE_FACTOR: number;
     static ANGULAR_SPEED_RATIO: number;
@@ -20694,6 +20881,7 @@ export declare class PostProcessor extends ScriptComponent {
     SetVolumeWeight(weight: number): void;
     SetVolumePriority(priority: number): void;
     private isCinemachineVolume;
+    private isSwitchedVolume;
     IsVolumeEnabled(): boolean;
     HasLocalVolumeObserver(): boolean;
     GetVolumeWeights(camera?: Camera): {
@@ -21257,6 +21445,7 @@ export interface IPostProcessCameraSelection {
 export declare class PostProcessingContract {
     static readonly VOLUME_TYPES: string[];
     static readonly CINEMACHINE_VOLUME_ROLE: string;
+    static readonly SWITCHED_VOLUME_ROLE: string;
     static readonly GRADING_MODES: string[];
     static readonly RENDERING_PATH_DEFERRED: string;
     static readonly RENDERING_PATH_FORWARD: string;
@@ -24107,6 +24296,8 @@ export declare class RigidbodyPhysics extends ScriptComponent {
     protected static CreateCompoundRootMeshShape(scene: Scene, entity: TransformNode, collision: any, layer: number, filter: number): PhysicsShape;
     static CreateCompoundChildItem(scene: Scene, root: TransformNode, childnode: TransformNode, collision: any, childmasks: IPhysicsCollisionMasks): PhyscisContainerData;
     static CreateComplexCompoundBody(scene: Scene, entity: TransformNode, childItems: PhyscisContainerData[], rootMeshShape: PhysicsShape, motionType: PhysicsMotionType, physics: any, mass: number, centerOfMass: Vector3, layermask: number, filtermask: number): PhysicsBody;
+    private static MarkCompoundChildForDisposal;
+    private static RendersItself;
     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;
@@ -25818,6 +26009,8 @@ export interface ITerrainLoadProgress {
 }
 export declare class TerrainBuilder extends ScriptComponent {
     private static _registry;
+    private static readonly ScratchInverse;
+    private static readonly ScratchLocal;
     readonly onBuiltObservable: Observable<TerrainBuilder>;
     readonly onLoadProgressObservable: Observable<ITerrainLoadProgress>;
     readonly onLoadedObservable: Observable<TerrainBuilder>;
@@ -25913,6 +26106,10 @@ export declare class TerrainBuilder extends ScriptComponent {
     protected destroy(): void;
     private disposeParts;
     private buildAsync;
+    private resolveEdgeNeighbors;
+    private edgeNeighborFor;
+    private canShareEdgeWith;
+    private isAdjacentTile;
     private applyTreesAndFoliageVisibility;
     private getShadowCasters;
     addShadowCaster(mesh: AbstractMesh, force?: boolean): void;
@@ -25952,6 +26149,7 @@ export declare class TerrainBuilder extends ScriptComponent {
     private prewarmOnce;
     private static NowMs;
     private worldToUnityUV;
+    private containsWorldPosition;
     SampleHeight(worldPosition: Vector3): number;
     GetInterpolatedHeight(u: number, v: number): number;
     GetInterpolatedNormal(u: number, v: number): Vector3;
@@ -26070,6 +26268,16 @@ export interface ITerrainDetailLayer {
         wavelength: number;
     } | null;
 }
+export interface ITerrainEdgeNeighbor {
+    heights: Uint16Array;
+    heightScale: number;
+}
+export interface ITerrainEdgeNeighbors {
+    left: ITerrainEdgeNeighbor | null;
+    right: ITerrainEdgeNeighbor | null;
+    top: ITerrainEdgeNeighbor | null;
+    bottom: ITerrainEdgeNeighbor | null;
+}
 export interface ITerrainContract {
     contract: number;
     name: string;
@@ -26286,7 +26494,6 @@ export declare class TerrainDetails {
         cast: boolean;
     }[];
     private ensureMain;
-    private static ResizePreviousMatrices;
     private static TintBuffer;
     private chunkDistance;
     private buildChunk;
@@ -26369,6 +26576,7 @@ export declare class TerrainFoliagePlugin extends MaterialPluginBase {
     constructor(material: Material);
     get isGraph(): boolean;
     static IsGraphMaterial(material: Material): boolean;
+    static GraphOwnsMotion(material: Material): boolean;
     getClassName(): string;
     isCompatible(shaderLanguage: ShaderLanguage): boolean;
     static Attach(material: Material, modes: number): TerrainFoliagePlugin;
@@ -26506,12 +26714,14 @@ export declare class TerrainHeightfield {
     private _errors;
     private _minH;
     private _maxH;
+    private edgeNeighbors;
     constructor(contract: ITerrainContract, heights: Uint16Array);
     get cellSizeX(): number;
     get cellSizeZ(): number;
     heightAt(u: number, v: number): number;
     sampleHeight(x: number, z: number): number;
     normalAt(u: number, v: number, out: number[]): void;
+    setEdgeNeighbors(neighbors: ITerrainEdgeNeighbors): void;
     setHoles(pixels: Uint8ClampedArray, width: number): void;
     private cellX;
     private cellZ;
@@ -26535,7 +26745,7 @@ export declare class TerrainHeightfield {
 export declare class TerrainMath {
     static DecodeHeight(value: number, sizeY: number): number;
     static SampleHeightBilinear(h: Uint16Array, R: number, sizeY: number, u: number, v: number): number;
-    static SampleNormal(h: Uint16Array, R: number, size: number[], u: number, v: number, out: number[]): void;
+    static SampleNormal(h: Uint16Array, R: number, size: number[], u: number, v: number, out: number[], neighbors?: ITerrainEdgeNeighbors): void;
     static UnityToLocalX(x: number, handedness: number): number;
     static UnityYawToLocal(yaw: number, handedness: number): number;
     static ControlSlot(layer: number): number[];
@@ -26687,6 +26897,8 @@ export interface ITerrainTreeCasterSlot {
     box: Float32Array;
     boxMin: Vector3;
     boxMax: Vector3;
+    capacityCeiling: number;
+    grown: boolean;
 }
 export interface ITerrainTreeHost {
     mesh: Mesh;
@@ -26702,6 +26914,8 @@ export interface ITerrainTreeHost {
     probeBuffer: Buffer;
     probeLit: boolean;
     slots: ITerrainTreeCasterSlot[];
+    capacityCeiling: number;
+    grown: boolean;
 }
 export interface ITerrainProbeSource {
     isActive(): boolean;
@@ -26722,6 +26936,9 @@ export declare class TerrainTrees {
     private static readonly SLOT_MARGIN;
     private static readonly NO_PROBE_RECORD;
     private static readonly LIGHT_TURN_DOT;
+    private static readonly HOST_DRAW_STATE;
+    private static PreparedHosts;
+    private static ProbeBuffers;
     private static _materials;
     private _owner;
     private _hf;
@@ -26734,6 +26951,7 @@ export declare class TerrainTrees {
     private _colliderShapes;
     private _distance;
     private _built;
+    private _warnedUniqueHost;
     private _n;
     private _proto;
     private _local;
@@ -26792,11 +27010,15 @@ export declare class TerrainTrees {
         drawn: number;
         visibleHosts: number;
         colliders: boolean;
+        capacity: number;
     };
+    static PreparedHostCount(scene: Scene): number;
     build(): void;
     private buildPrototype;
     static RendererUsesProbes(flags: any, index: number): boolean;
     static AttachProbeBuffer(host: Mesh, probes: Float32Array): Buffer;
+    private static CreateProbeBuffer;
+    private static ResizeProbeBuffer;
     private sampleProbes;
     pollProbes(): void;
     static NetworkLightsProbes(network: ITerrainProbeSource): boolean;
@@ -26809,6 +27031,9 @@ export declare class TerrainTrees {
     static InterleaveVertexData(mesh: Mesh): number;
     static HasGeometry(m: AbstractMesh): boolean;
     static CreateSharedHost(scene: Scene, source: Mesh, name: string): Mesh;
+    private static BakeHostGeometry;
+    private prepareHostGeometry;
+    private createUniqueHost;
     private createHost;
     private createCasterSlots;
     static HasSpeedTreeWindVertexData(mesh: AbstractMesh): boolean;
@@ -26844,9 +27069,12 @@ export declare class TerrainTrees {
     private static TieRank;
     private static KthSmallest;
     private appendInstance;
+    private static GrowTarget;
     private static LodCasts;
     private writeInstance;
     private writeCaster;
+    private static RebindGrownTarget;
+    static ResizePreviousMatrices(mesh: Mesh, matrices: Float32Array): void;
     private uploadTarget;
     private static Now;
     private buildColliders;
@@ -30686,6 +30914,225 @@ export declare class VisualEffectSpawner {
     private compileBlock;
     private static crosses;
 }
+export interface ICloudCurves {
+    density?: number[];
+    erosion?: number[];
+    ambientocclusion?: number[];
+}
+export interface ICloudNoiseFile {
+    url: string;
+    size: number;
+}
+export interface IUrpCloudsBlock {
+    state?: boolean;
+    localclouds?: boolean;
+    resolutionscale?: number;
+    densitymultiplier?: number;
+    shapefactor?: number;
+    shapescale?: number;
+    shapeoffset?: number[];
+    coveragevariation?: number;
+    coveragepatternsize?: number;
+    coveragegapamount?: number;
+    coveragepatternoffset?: number[];
+    erosionfactor?: number;
+    erosionscale?: number;
+    microerosion?: boolean;
+    microerosionfactor?: number;
+    microerosionscale?: number;
+    bottomaltitude?: number;
+    altituderange?: number;
+    earthcurvature?: number;
+    globalspeed?: number;
+    globalorientation?: number;
+    shapespeedmultiplier?: number;
+    erosionspeedmultiplier?: number;
+    altitudedistortion?: number;
+    verticalshapewindspeed?: number;
+    verticalerosionwindspeed?: number;
+    cloudmapspeedmultiplier?: number;
+    ambientlightprobedimmer?: number;
+    sunlightdimmer?: number;
+    erosionocclusion?: number;
+    scatteringtint?: number[];
+    powdereffectintensity?: number;
+    multiscattering?: number;
+    temporalaccumulationfactor?: number;
+    perceptualblending?: number;
+    numprimarysteps?: number;
+    longraysamplemultiplier?: number;
+    numlightsteps?: number;
+    fadeinmode?: number;
+    fadeinstart?: number;
+    fadeindistance?: number;
+    curves?: ICloudCurves;
+    noise?: {
+        worley?: ICloudNoiseFile;
+        erosion?: ICloudNoiseFile;
+    };
+}
+export interface ICloudSkyFields {
+    planet?: {
+        radius?: number;
+        renderingspace?: number;
+        center?: number[];
+    };
+    sunintensityscale?: number;
+}
+export type SceneWithClouds = Scene & {
+    _tkVolumetricClouds?: VolumetricClouds;
+};
+export interface ICloudTierSettings {
+    resolutionScale: number;
+    primarySteps: number;
+    longRayMultiplier: number;
+    lightSteps: number;
+}
+export declare class VolumetricCloudsMath {
+    static readonly LowestTier: number;
+    static ShellInterval(rayOrigin: number[], rayDirection: number[], innerRadius: number, outerRadius: number, planetRadius?: number): number[];
+    static StepSize(shellLength: number, steps: number, maximumStep: number): number;
+    static MaximumStep(altitudeRange: number, authoredSteps: number, tierSteps: number): number;
+    static TierSettings(tier: number, authored: IUrpCloudsBlock): ICloudTierSettings;
+    static StartTier(maximumTextureSize: number, viewportCssWidth: number): number;
+    static IsCameraCut(previousPosition: number[], currentPosition: number[]): boolean;
+    static PackCurves(density: number[], erosion: number[], ambientOcclusion: number[]): Float32Array;
+    private static IntersectSphere;
+}
+export declare class VolumetricCloudsTier {
+    tier: number;
+    isSettled: boolean;
+    private windowMilliseconds;
+    private windowFrames;
+    private meanBeforeStep;
+    private previousMean;
+    constructor(startTier: number);
+    addFrame(frameMilliseconds: number): boolean;
+}
+export declare class VolumetricClouds {
+    static readonly MeshName: string;
+    static TryCreate(scene: Scene, metadata: unknown, root: string): VolumetricClouds;
+    static Get(scene: Scene): VolumetricClouds;
+    readonly scene: Scene;
+    readonly block: IUrpCloudsBlock;
+    disposed: boolean;
+    tier: number;
+    private readonly sky;
+    private readonly root;
+    private readonly isLocal;
+    private hasAerial;
+    private placeholderAerial;
+    private readonly planetRadius;
+    private readonly planetCenter;
+    private readonly scatteringTint;
+    private settings;
+    private worleyTexture;
+    private erosionTexture;
+    private curveTexture;
+    private placeholderDepth;
+    private marchTarget;
+    private renderer;
+    private marchPass;
+    private temporalPass;
+    private readonly historyTargets;
+    private historyIndex;
+    private hasHistory;
+    private compositeMesh;
+    private compositeMaterial;
+    private isReady;
+    private isPending;
+    private preExposure;
+    private preExposureBinding;
+    private frameSeed;
+    private readonly windOffset;
+    private verticalShapeOffset;
+    private verticalErosionOffset;
+    private sceneDepth;
+    private beforeRenderObserver;
+    private afterRenderObserver;
+    private tierTracker;
+    private targetWidth;
+    private targetHeight;
+    private lastCamera;
+    private sunLight;
+    private ambientSource;
+    private ambientCaptureCount;
+    private readonly previousEye;
+    private readonly currentEye;
+    private hasPreviousEye;
+    private beforeTargetsObserver;
+    private afterTargetsObserver;
+    private disposeObserver;
+    private readonly mirror;
+    private readonly inverseViewProjection;
+    private readonly previousViewProjection;
+    private readonly previousViewProjectionUnity;
+    private readonly sunDirection;
+    private readonly cameraForward;
+    private readonly localForward;
+    private readonly ambientTop;
+    private readonly ambientBottom;
+    private constructor();
+    dispose(): void;
+    private createPasses;
+    private createCloudTarget;
+    private createCurveTexture;
+    private createCompositeMesh;
+    private loadNoise;
+    private createNoiseTexture;
+    private waitUntilReady;
+    private releasePending;
+    private render;
+    private isDisplayEncoded;
+    private trackCamera;
+    private updateTier;
+    private reportLoweredSettings;
+    private advanceWind;
+    private resizeTargets;
+    private updateTargetSize;
+    private bindMarch;
+    private bindLighting;
+    private bindAerial;
+    private resolveSun;
+    private refreshAmbient;
+    private bindTemporal;
+    private static LinearScatteringTint;
+    private static CanvasCssWidth;
+}
+export declare class VolumetricCloudsShaders {
+    static readonly MarchName: string;
+    static readonly CompositeName: string;
+    static readonly TemporalName: string;
+    static readonly TemporalUniforms: string[];
+    static readonly TemporalSamplers: string[];
+    static readonly MarchUniforms: string[];
+    static readonly MarchSamplers: string[];
+    static readonly AerialSampler: string;
+    static readonly AerialCameraUniform: string;
+    private static registered;
+    static Register(): void;
+    static AllSources(): string[];
+    private static GlslMarchUniforms;
+    private static GlslConstants;
+    private static GlslGeometry;
+    private static GlslDensity;
+    private static GlslLighting;
+    private static GlslAerial;
+    private static GlslMarch;
+    private static GlslCompositeVertex;
+    private static GlslCompositeFragment;
+    private static GlslTemporal;
+    private static WgslMarchUniforms;
+    private static WgslConstants;
+    private static WgslGeometry;
+    private static WgslDensity;
+    private static WgslLighting;
+    private static WgslAerial;
+    private static WgslMarch;
+    private static WgslCompositeVertex;
+    private static WgslCompositeFragment;
+    private static WgslTemporal;
+}
 export declare class WebVideoPlayer extends ScriptComponent implements IAssetPreloader {
     private videoLoop;
     private videoMuted;