babylonjs
Version:
> We recommend using the [ES6 package `@babylonjs/core`](https://www.npmjs.com/package/@babylonjs/core) for new projects. This UMD package is provided for compatibility.
1,197 lines (1,194 loc) • 15 MB
TypeScript
declare module "babylonjs/types" {
/** Alias type for value that can be null */
export type Nullable<T> = T | null;
/**
* Alias type for number that are floats
*/
export type float = number;
/**
* Alias type for number that are doubles.
*/
export type double = number;
/**
* Alias type for number that are integer
*/
export type int = number;
/**
* Empty
*/
export type Empty = [];
/**
* Removes the first element of T and shifts
*/
export type Shift<T> = T extends unknown[] ? (((...x: T) => void) extends (h: any, ...t: infer I) => void ? I : []) : unknown;
/**
* Gets the first element of T
*/
export type First<T> = T extends unknown[] ? (((...x: T) => void) extends (h: infer I, ...t: any) => void ? I : []) : never;
/**
* Inserts A into T at the start of T
*/
export type Unshift<T, A> = T extends unknown[] ? (((h: A, ...t: T) => void) extends (...i: infer I) => void ? I : unknown) : never;
/**
* Removes the last element of T
*/
export type Pop<T> = T extends unknown[] ? (((...x: T) => void) extends (...i: [...infer I, any]) => void ? I : unknown) : never;
/**
* Gets the last element of T
*/
export type Last<T> = T extends unknown[] ? (((...x: T) => void) extends (...i: [...infer H, infer I]) => void ? I : unknown) : never;
/**
* Appends A to T
*/
export type Push<T, A> = T extends unknown[] ? (((...a: [...T, A]) => void) extends (...i: infer I) => void ? I : unknown) : never;
/**
* Concats A and B
*/
export type Concat<A, B> = {
0: A;
1: Concat<Unshift<A, 0>, Shift<B>>;
}[Empty extends B ? 0 : 1];
/**
* Extracts from A what is not B
*
* @remarks
* It does not remove duplicates (so Remove\<[0, 0, 0], [0, 0]\> yields [0]). This is intended and necessary behavior.
*/
export type Remove<A, B> = {
0: A;
1: Remove<Shift<A>, Shift<B>>;
}[Empty extends B ? 0 : 1];
/**
* The length of T
*/
export type Length<T> = T extends {
length: number;
} ? T["length"] : never;
type _FromLength<N extends number, R = Empty> = {
0: R;
1: _FromLength<N, Unshift<R, 0>>;
}[Length<R> extends N ? 0 : 1];
/**
* Creates a tuple of length N
*/
export type FromLength<N extends number> = _FromLength<N>;
/**
* Increments N
*/
export type Increment<N extends number> = Length<Unshift<_FromLength<N>, 0>>;
/**
* Decrements N
*/
export type Decrement<N extends number> = Length<Shift<_FromLength<N>>>;
/**
* Gets the sum of A and B
*/
export type Add<A extends number, B extends number> = Length<Concat<_FromLength<A>, _FromLength<B>>>;
/**
* Subtracts B from A
*/
export type Subtract<A extends number, B extends number> = Length<Remove<_FromLength<A>, _FromLength<B>>>;
/**
* Gets the type of an array's members
*/
export type Member<T, D = null> = D extends 0 ? T : T extends (infer U)[] ? Member<U, D extends number ? Decrement<D> : null> : T;
/**
* Flattens an array
*/
export type FlattenArray<A extends unknown[], D = null> = A extends (infer U)[] ? Member<Exclude<U, A>, D>[] : A extends unknown[] ? {
[K in keyof A]: Member<A[K], D>;
} : A;
/**
* Whether T is a tuple
*/
export type IsTuple<T> = T extends [] ? false : T extends [infer Head, ...infer Rest] ? true : false;
/**
* Flattens a tuple
*/
export type FlattenTuple<A extends unknown[]> = A extends [infer U, ...infer Rest] ? (U extends unknown[] ? [...U, ...FlattenTuple<Rest>] : [U, ...FlattenTuple<Rest>]) : [];
/**
* Flattens an array or tuple
*/
export type Flatten<A extends unknown[]> = IsTuple<A> extends true ? FlattenTuple<A> : FlattenArray<A>;
type _Tuple<T, N extends number, R extends unknown[] = Empty> = R["length"] extends N ? R : _Tuple<T, N, [T, ...R]>;
/**
* Creates a tuple of T with length N
*/
export type Tuple<T, N extends number> = _Tuple<T, N>;
/** Alias type for number array or Float32Array */
export type FloatArray = number[] | Float32Array;
/** Alias type for number array or Float32Array or Int32Array or Uint32Array or Uint16Array */
export type IndicesArray = number[] | Int32Array | Uint32Array | Uint16Array;
/**
* Alias type for all TypedArrays
*/
export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
/**
* Alias for types that can be used by a Buffer or VertexBuffer.
*/
export type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
/**
* Alias type for primitive types
*/
type Primitive = undefined | null | boolean | string | number | Function | Element;
/**
* Type modifier to make all the properties of an object Readonly
*/
export type Immutable<T> = T extends Primitive ? T : T extends Array<infer U> ? ReadonlyArray<U> : DeepImmutable<T>;
/**
* Type modifier to make all the properties of an object Readonly recursively
*/
export type DeepImmutable<T> = T extends Primitive ? T : T extends Array<infer U> ? DeepImmutableArray<U> : DeepImmutableObject<T>;
/**
* Type modifier to make all the properties of an object NonNullable
*/
export type NonNullableFields<T> = {
[P in keyof T]: NonNullable<T[P]>;
};
/**
* Type modifier to make all the properties of an object Writable (remove "readonly")
*/
export type WritableObject<T> = {
-readonly [P in keyof T]: T[P];
};
/**
* Type modifier to make object properties readonly.
*/
export type DeepImmutableObject<T> = {
readonly [K in keyof T]: DeepImmutable<T[K]>;
};
/** @internal */
interface DeepImmutableArray<T> extends ReadonlyArray<DeepImmutable<T>> {
}
/** @internal */
export type Constructor<C extends new (...args: any[]) => any, I extends InstanceType<C> = InstanceType<C>> = {
new (...args: ConstructorParameters<C>): I;
};
/**
* Alias type for image sources
*/
export type ImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas;
/**
* Type for typed array like objects
*/
export interface TypedArrayLike extends ArrayBufferView {
/**
* The size in bytes of the array.
*/
readonly length: number;
[n: number]: number;
}
/**
* Interface for a constructor of a TypedArray.
*/
export interface TypedArrayConstructor<T extends TypedArray = TypedArray> {
new (length: number): T;
new (elements: Iterable<number>): T;
new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): T;
/**
* The size in bytes of each element in the array.
*/
readonly BYTES_PER_ELEMENT: number;
}
export {};
}
declare module "babylonjs/sceneComponent" {
import { Scene } from "babylonjs/scene";
import { SmartArrayNoDuplicate } from "babylonjs/Misc/smartArray";
import { Nullable } from "babylonjs/types";
import { PickingInfo } from "babylonjs/Collisions/pickingInfo";
import { IPointerEvent } from "babylonjs/Events/deviceInputEvents";
import { Mesh } from "babylonjs/Meshes/mesh";
import { Effect } from "babylonjs/Materials/effect";
import { Camera } from "babylonjs/Cameras/camera";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh";
import { SubMesh } from "babylonjs/Meshes/subMesh";
import { RenderTargetTexture } from "babylonjs/Materials/Textures/renderTargetTexture";
import { IAssetContainer } from "babylonjs/IAssetContainer";
/**
* Groups all the scene component constants in one place to ease maintenance.
* @internal
*/
export class SceneComponentConstants {
static readonly NAME_EFFECTLAYER: string;
static readonly NAME_LAYER: string;
static readonly NAME_LENSFLARESYSTEM: string;
static readonly NAME_BOUNDINGBOXRENDERER: string;
static readonly NAME_PARTICLESYSTEM: string;
static readonly NAME_GAMEPAD: string;
static readonly NAME_SIMPLIFICATIONQUEUE: string;
static readonly NAME_GEOMETRYBUFFERRENDERER: string;
static readonly NAME_PREPASSRENDERER: string;
static readonly NAME_DEPTHRENDERER: string;
static readonly NAME_DEPTHPEELINGRENDERER: string;
static readonly NAME_POSTPROCESSRENDERPIPELINEMANAGER: string;
static readonly NAME_SPRITE: string;
static readonly NAME_SUBSURFACE: string;
static readonly NAME_OUTLINERENDERER: string;
static readonly NAME_PROCEDURALTEXTURE: string;
static readonly NAME_SHADOWGENERATOR: string;
static readonly NAME_OCTREE: string;
static readonly NAME_PHYSICSENGINE: string;
static readonly NAME_AUDIO: string;
static readonly NAME_FLUIDRENDERER: string;
static readonly NAME_IBLCDFGENERATOR: string;
static readonly NAME_CLUSTEREDLIGHTING: string;
static readonly STEP_ISREADYFORMESH_EFFECTLAYER: number;
static readonly STEP_ISREADYFORMESH_DEPTHRENDERER: number;
static readonly STEP_BEFOREEVALUATEACTIVEMESH_BOUNDINGBOXRENDERER: number;
static readonly STEP_EVALUATESUBMESH_BOUNDINGBOXRENDERER: number;
static readonly STEP_PREACTIVEMESH_BOUNDINGBOXRENDERER: number;
static readonly STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER: number;
static readonly STEP_BEFORECAMERADRAW_PREPASS: number;
static readonly STEP_BEFORECAMERADRAW_EFFECTLAYER: number;
static readonly STEP_BEFORECAMERADRAW_LAYER: number;
static readonly STEP_BEFORERENDERTARGETDRAW_PREPASS: number;
static readonly STEP_BEFORERENDERTARGETDRAW_LAYER: number;
static readonly STEP_BEFORERENDERINGMESH_PREPASS: number;
static readonly STEP_BEFORERENDERINGMESH_OUTLINE: number;
static readonly STEP_AFTERRENDERINGMESH_PREPASS: number;
static readonly STEP_AFTERRENDERINGMESH_OUTLINE: number;
static readonly STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW: number;
static readonly STEP_AFTERRENDERINGGROUPDRAW_BOUNDINGBOXRENDERER: number;
static readonly STEP_BEFORECAMERAUPDATE_SIMPLIFICATIONQUEUE: number;
static readonly STEP_BEFORECLEAR_PROCEDURALTEXTURE: number;
static readonly STEP_BEFORECLEAR_PREPASS: number;
static readonly STEP_BEFORERENDERTARGETCLEAR_PREPASS: number;
static readonly STEP_AFTERRENDERTARGETDRAW_PREPASS: number;
static readonly STEP_AFTERRENDERTARGETDRAW_LAYER: number;
static readonly STEP_AFTERCAMERADRAW_PREPASS: number;
static readonly STEP_AFTERCAMERADRAW_EFFECTLAYER: number;
static readonly STEP_AFTERCAMERADRAW_LENSFLARESYSTEM: number;
static readonly STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW: number;
static readonly STEP_AFTERCAMERADRAW_LAYER: number;
static readonly STEP_AFTERCAMERADRAW_FLUIDRENDERER: number;
static readonly STEP_AFTERCAMERAPOSTPROCESS_LAYER: number;
static readonly STEP_AFTERRENDERTARGETPOSTPROCESS_LAYER: number;
static readonly STEP_AFTERRENDER_AUDIO: number;
static readonly STEP_GATHERRENDERTARGETS_DEPTHRENDERER: number;
static readonly STEP_GATHERRENDERTARGETS_GEOMETRYBUFFERRENDERER: number;
static readonly STEP_GATHERRENDERTARGETS_SHADOWGENERATOR: number;
static readonly STEP_GATHERRENDERTARGETS_POSTPROCESSRENDERPIPELINEMANAGER: number;
static readonly STEP_GATHERACTIVECAMERARENDERTARGETS_DEPTHRENDERER: number;
static readonly STEP_GATHERACTIVECAMERARENDERTARGETS_FLUIDRENDERER: number;
static readonly STEP_GATHERACTIVECAMERARENDERTARGETS_CLUSTEREDLIGHTING: number;
static readonly STEP_POINTERMOVE_SPRITE: number;
static readonly STEP_POINTERDOWN_SPRITE: number;
static readonly STEP_POINTERUP_SPRITE: number;
}
/**
* This represents a scene component.
*
* This is used to decouple the dependency the scene is having on the different workloads like
* layers, post processes...
*/
export interface ISceneComponent {
/**
* The name of the component. Each component must have a unique name.
*/
name: string;
/**
* The scene the component belongs to.
*/
scene: Scene;
/**
* Register the component to one instance of a scene.
*/
register(): void;
/**
* Rebuilds the elements related to this component in case of
* context lost for instance.
*/
rebuild(): void;
/**
* Disposes the component and the associated resources.
*/
dispose(): void;
}
/**
* This represents a SERIALIZABLE scene component.
*
* This extends Scene Component to add Serialization methods on top.
*/
export interface ISceneSerializableComponent extends ISceneComponent {
/**
* Adds all the elements from the container to the scene
* @param container the container holding the elements
*/
addFromContainer(container: IAssetContainer): void;
/**
* Removes all the elements in the container from the scene
* @param container contains the elements to remove
* @param dispose if the removed element should be disposed (default: false)
*/
removeFromContainer(container: IAssetContainer, dispose?: boolean): void;
/**
* Serializes the component data to the specified json object
* @param serializationObject The object to serialize to
*/
serialize(serializationObject: any): void;
}
/**
* Strong typing of a Mesh related stage step action
*/
export type MeshStageAction = (mesh: AbstractMesh, hardwareInstancedRendering: boolean) => boolean;
/**
* Strong typing of a Evaluate Sub Mesh related stage step action
*/
export type EvaluateSubMeshStageAction = (mesh: AbstractMesh, subMesh: SubMesh) => void;
/**
* Strong typing of a pre active Mesh related stage step action
*/
export type PreActiveMeshStageAction = (mesh: AbstractMesh) => void;
/**
* Strong typing of a Camera related stage step action
*/
export type CameraStageAction = (camera: Camera) => void;
/**
* Strong typing of a Camera Frame buffer related stage step action
*/
export type CameraStageFrameBufferAction = (camera: Camera) => boolean;
/**
* Strong typing of a Render Target related stage step action
*/
export type RenderTargetStageAction = (renderTarget: RenderTargetTexture, faceIndex?: number, layer?: number) => void;
/**
* Strong typing of a RenderingGroup related stage step action
*/
export type RenderingGroupStageAction = (renderingGroupId: number) => void;
/**
* Strong typing of a Mesh Render related stage step action
*/
export type RenderingMeshStageAction = (mesh: Mesh, subMesh: SubMesh, batch: any, effect: Nullable<Effect>) => void;
/**
* Strong typing of a simple stage step action
*/
export type SimpleStageAction = () => void;
/**
* Strong typing of a render target action.
*/
export type RenderTargetsStageAction = (renderTargets: SmartArrayNoDuplicate<RenderTargetTexture>) => void;
/**
* Strong typing of a pointer move action.
*/
export type PointerMoveStageAction = (unTranslatedPointerX: number, unTranslatedPointerY: number, pickResult: Nullable<PickingInfo>, isMeshPicked: boolean, element: Nullable<HTMLElement>) => Nullable<PickingInfo>;
/**
* Strong typing of a pointer up/down action.
*/
export type PointerUpDownStageAction = (unTranslatedPointerX: number, unTranslatedPointerY: number, pickResult: Nullable<PickingInfo>, evt: IPointerEvent, doubleClick: boolean) => Nullable<PickingInfo>;
/**
* Representation of a stage in the scene (Basically a list of ordered steps)
* @internal
*/
export class Stage<T extends Function> extends Array<{
index: number;
component: ISceneComponent;
action: T;
}> {
/**
* Hide ctor from the rest of the world.
* @param items The items to add.
*/
private constructor();
/**
* Creates a new Stage.
* @returns A new instance of a Stage
*/
static Create<T extends Function>(): Stage<T>;
/**
* Registers a step in an ordered way in the targeted stage.
* @param index Defines the position to register the step in
* @param component Defines the component attached to the step
* @param action Defines the action to launch during the step
*/
registerStep(index: number, component: ISceneComponent, action: T): void;
/**
* Clears all the steps from the stage.
*/
clear(): void;
}
}
declare module "babylonjs/scene.pure" {
/** This file must only contain pure code and pure imports */
import { Nullable } from "babylonjs/types";
import { IAnimatable } from "babylonjs/Animations/animatable.interface";
import { Observable } from "babylonjs/Misc/observable.pure";
import { ISmartArrayLike, SmartArrayNoDuplicate, SmartArray } from "babylonjs/Misc/smartArray";
import { Vector2, Vector3, Vector4, Matrix } from "babylonjs/Maths/math.vector.pure";
import { IParticleSystem } from "babylonjs/Particles/IParticleSystem";
import { ImageProcessingConfiguration } from "babylonjs/Materials/imageProcessingConfiguration.pure";
import { UniformBuffer } from "babylonjs/Materials/uniformBuffer";
import { PickingInfo } from "babylonjs/Collisions/pickingInfo";
import { ICollisionCoordinator } from "babylonjs/Collisions/collisionCoordinator.pure";
import { PointerEventTypes, PointerInfoPre, PointerInfo } from "babylonjs/Events/pointerEvents";
import { KeyboardInfoPre, KeyboardInfo } from "babylonjs/Events/keyboardEvents";
import { PostProcessManager } from "babylonjs/PostProcesses/postProcessManager";
import { IOfflineProvider } from "babylonjs/Offline/IOfflineProvider";
import { RenderingGroupInfo, IRenderingManagerAutoClearSetup, RenderingManager } from "babylonjs/Rendering/renderingManager";
import { ISceneComponent, ISceneSerializableComponent, SimpleStageAction, RenderTargetsStageAction, RenderTargetStageAction, MeshStageAction, EvaluateSubMeshStageAction, PreActiveMeshStageAction, CameraStageAction, RenderingGroupStageAction, RenderingMeshStageAction, PointerMoveStageAction, PointerUpDownStageAction, CameraStageFrameBufferAction, Stage } from "babylonjs/sceneComponent";
import { AbstractActionManager } from "babylonjs/Actions/abstractActionManager";
import { WebRequest } from "babylonjs/Misc/webRequest";
import { InputManager } from "babylonjs/Inputs/scene.inputManager";
import { PerfCounter } from "babylonjs/Misc/perfCounter";
import { IFileRequest } from "babylonjs/Misc/fileRequest";
import { Color4, Color3 } from "babylonjs/Maths/math.color.pure";
import { Plane } from "babylonjs/Maths/math.plane";
import { LoadFileError, RequestFileError, ReadFileError } from "babylonjs/Misc/fileTools.pure";
import { IClipPlanesHolder } from "babylonjs/Misc/interfaces/iClipPlanesHolder";
import { IPointerEvent } from "babylonjs/Events/deviceInputEvents";
import { AnimationPropertiesOverride } from "babylonjs/Animations/animationPropertiesOverride";
import { AnimationGroup } from "babylonjs/Animations/animationGroup.pure";
import { Skeleton } from "babylonjs/Bones/skeleton";
import { Bone } from "babylonjs/Bones/bone.pure";
import { Camera } from "babylonjs/Cameras/camera.pure";
import { Collider } from "babylonjs/Collisions/collider";
import { Ray, MeshPredicate, TrianglePickingPredicate } from "babylonjs/Culling/ray.core";
import { Light } from "babylonjs/Lights/light";
import { PerformanceViewerCollector } from "babylonjs/Misc/PerformanceViewer/performanceViewerCollector";
import { MorphTarget } from "babylonjs/Morph/morphTarget";
import { MorphTargetManager } from "babylonjs/Morph/morphTargetManager";
import { PostProcess } from "babylonjs/PostProcesses/postProcess.pure";
import { Material } from "babylonjs/Materials/material.pure";
import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture.pure";
import { Geometry } from "babylonjs/Meshes/geometry";
import { TransformNode } from "babylonjs/Meshes/transformNode.pure";
import { AbstractMesh } from "babylonjs/Meshes/abstractMesh.pure";
import { MultiMaterial } from "babylonjs/Materials/multiMaterial.pure";
import { Effect } from "babylonjs/Materials/effect.pure";
import { RenderTargetTexture } from "babylonjs/Materials/Textures/renderTargetTexture.pure";
import { SubMesh } from "babylonjs/Meshes/subMesh.pure";
import { Node } from "babylonjs/node";
import { Animation } from "babylonjs/Animations/animation.pure";
import { Animatable } from "babylonjs/Animations/animatable.core";
import { AbstractEngine } from "babylonjs/Engines/abstractEngine.pure";
import { FrameGraph } from "babylonjs/FrameGraph/frameGraph";
import { IAssetContainer } from "babylonjs/IAssetContainer";
import { EffectLayer } from "babylonjs/Layers/effectLayer";
import { Sound } from "babylonjs/Audio/sound.pure";
import { Layer } from "babylonjs/Layers/layer";
import { LensFlareSystem } from "babylonjs/LensFlares/lensFlareSystem";
import { ProceduralTexture } from "babylonjs/Materials/Textures/Procedurals/proceduralTexture.pure";
import { ObjectRenderer } from "babylonjs/Rendering/objectRenderer";
/**
* Options for creating a scene uniform buffer
*/
export interface ICreateSceneUboOptions {
/** Define if the UBOs should be tracked in the frame (default: undefined - will use the value from Engine._features.trackUbosInFrame) */
trackUBOsInFrame?: boolean;
/** When true, always creates a mono (non-multiview) UBO, bypassing any multiview override */
forceMono?: boolean;
}
/**
* Define an interface for all classes that will hold resources
*/
export interface IDisposable {
/**
* Releases all held resources
*/
dispose(): void;
}
/** Interface defining initialization parameters for Scene class */
export interface SceneOptions {
/**
* Defines that scene should keep up-to-date a map of geometry to enable fast look-up by uniqueId
* It will improve performance when the number of geometries becomes important.
*/
useGeometryUniqueIdsMap?: boolean;
/**
* Defines that each material of the scene should keep up-to-date a map of referencing meshes for fast disposing
* It will improve performance when the number of mesh becomes important, but might consume a bit more memory
*/
useMaterialMeshMap?: boolean;
/**
* Defines that each mesh of the scene should keep up-to-date a map of referencing cloned meshes for fast disposing
* It will improve performance when the number of mesh becomes important, but might consume a bit more memory
*/
useClonedMeshMap?: boolean;
/**
* When enabled, the scene can handle large world coordinate rendering without jittering caused by floating point imprecision on the GPU.
* This mode offsets matrices and position-related attribute values before passing to shaders, centering camera at origin and offsetting other scene objects by camera active position.
*
* IMPORTANT: Only use this scene-level option if you intend to enable floating origin on a per-scene basis. Must use in conjunction with engine creation option 'useHighPrecisionMatrix' to fix CPU-side floating point imprecision.
* HOWEVER if you want largeWorldRendering on ALL scenes, set the useLargeWorldRendering flag on the engine instead of this scene-level flag. Doing so will automatically set useHighPrecisionMatrix on the engine as well.
*/
useFloatingOrigin?: boolean;
/** Defines if the creation of the scene should impact the engine (Eg. UtilityLayer's scene) */
virtual?: boolean;
/**
* Defines the default layerMask used when creating cameras in the scene (default: 0x0fffffff)
*/
defaultCameraLayerMask?: number;
/**
* Defines the default layerMask used when creating renderable objects in the scene (default: 0x0fffffff)
*/
defaultRenderableLayerMask?: number;
}
/**
* Define how the scene should favor performance over ease of use
*/
export enum ScenePerformancePriority {
/** Default mode. No change. Performance will be treated as less important than backward compatibility */
BackwardCompatible = 0,
/** Some performance options will be turned on trying to strike a balance between perf and ease of use */
Intermediate = 1,
/** Performance will be top priority */
Aggressive = 2
}
/**
* Represents a scene to be rendered by the engine.
* @see https://doc.babylonjs.com/features/featuresDeepDive/scene
*/
export class Scene implements IAnimatable, IClipPlanesHolder, IAssetContainer {
/** The fog is deactivated */
static readonly FOGMODE_NONE: number;
/** The fog density is following an exponential function */
static readonly FOGMODE_EXP: number;
/** The fog density is following an exponential function faster than FOGMODE_EXP */
static readonly FOGMODE_EXP2: number;
/** The fog density is following a linear function. */
static readonly FOGMODE_LINEAR: number;
/**
* Gets or sets the minimum deltatime when deterministic lock step is enabled
* @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
*/
static MinDeltaTime: number;
/**
* Gets or sets the maximum deltatime when deterministic lock step is enabled
* @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
*/
static MaxDeltaTime: number;
/**
* Factory used to create the default material.
* @param scene The scene to create the material for
* @returns The default material
*/
static DefaultMaterialFactory(scene: Scene): Material;
private static readonly _OriginalDefaultMaterialFactory;
/**
* Factory used to create the a collision coordinator.
* @returns The collision coordinator
*/
static CollisionCoordinatorFactory(): ICollisionCoordinator;
/** @internal */
_tempPickingRay: Nullable<Ray>;
/** @internal */
_cachedRayForTransform: Ray;
/** @internal */
_pickWithRayInverseMatrix: Matrix;
/** @internal */
_inputManager: InputManager;
/** Define this parameter if you are using multiple cameras and you want to specify which one should be used for pointer position */
cameraToUseForPointers: Nullable<Camera>;
/** @internal */
readonly _isScene: boolean;
/** @internal */
_blockEntityCollection: boolean;
/**
* Gets or sets a boolean that indicates if the scene must clear the render buffer before rendering a frame
*/
autoClear: boolean;
/**
* Gets or sets a boolean that indicates if the scene must clear the depth and stencil buffers before rendering a frame
*/
autoClearDepthAndStencil: boolean;
private _clearColor;
/**
* Observable triggered when the performance priority is changed
*/
onClearColorChangedObservable: Observable<Color4>;
/**
* Defines the color used to clear the render buffer (Default is (0.2, 0.2, 0.3, 1.0))
*/
get clearColor(): Color4;
set clearColor(value: Color4);
/**
* Defines the color used to simulate the ambient color (Default is (0, 0, 0))
*/
ambientColor: Color3;
/**
* This is use to store the default BRDF lookup for PBR materials in your scene.
* It should only be one of the following (if not the default embedded one):
* * For uncorrelated BRDF (pbr.brdf.useEnergyConservation = false and pbr.brdf.useSmithVisibilityHeightCorrelated = false) : https://assets.babylonjs.com/environments/uncorrelatedBRDF.dds
* * For correlated BRDF (pbr.brdf.useEnergyConservation = false and pbr.brdf.useSmithVisibilityHeightCorrelated = true) : https://assets.babylonjs.com/environments/correlatedBRDF.dds
* * For correlated multi scattering BRDF (pbr.brdf.useEnergyConservation = true and pbr.brdf.useSmithVisibilityHeightCorrelated = true) : https://assets.babylonjs.com/environments/correlatedMSBRDF.dds
* The material properties need to be setup according to the type of texture in use.
*/
environmentBRDFTexture: BaseTexture;
/**
* This stores the brdf lookup for the fuzz layer of PBR materials in your scene.
*/
environmentFuzzBRDFTexture: BaseTexture;
/**
* Intensity of the environment (i.e. all indirect lighting) in all pbr material.
* This dims or reinforces the indirect lighting overall (reflection and diffuse).
* As in the majority of the scene they are the same (exception for multi room and so on),
* this is easier to reference from here than from all the materials.
* Note that this is more of a debugging parameter and is not physically accurate.
* If you want to modify the intensity of the IBL texture, you should update iblIntensity instead.
*/
environmentIntensity: number;
/**
* Overall intensity of the IBL texture.
* This value is multiplied with the reflectionTexture.level value to calculate the final IBL intensity.
*/
iblIntensity: number;
/** @internal */
protected _imageProcessingConfiguration: ImageProcessingConfiguration;
/**
* Default image processing configuration used either in the rendering
* Forward main pass or through the imageProcessingPostProcess if present.
* As in the majority of the scene they are the same (exception for multi camera),
* this is easier to reference from here than from all the materials and post process.
*
* No setter as we it is a shared configuration, you can set the values instead.
*/
get imageProcessingConfiguration(): ImageProcessingConfiguration;
private _performancePriority;
/**
* Observable triggered when the performance priority is changed
*/
onScenePerformancePriorityChangedObservable: Observable<ScenePerformancePriority>;
/**
* Gets or sets a value indicating how to treat performance relatively to ease of use and backward compatibility
*/
get performancePriority(): ScenePerformancePriority;
set performancePriority(value: ScenePerformancePriority);
private _forceWireframe;
/**
* Gets or sets a boolean indicating if all rendering must be done in wireframe
*/
set forceWireframe(value: boolean);
get forceWireframe(): boolean;
private _skipFrustumClipping;
/**
* Gets or sets a boolean indicating if we should skip the frustum clipping part of the active meshes selection
*/
set skipFrustumClipping(value: boolean);
get skipFrustumClipping(): boolean;
private _forcePointsCloud;
/**
* Gets or sets a boolean indicating if all rendering must be done in point cloud
*/
set forcePointsCloud(value: boolean);
get forcePointsCloud(): boolean;
/**
* Gets or sets the active clipplane 1
*/
clipPlane: Nullable<Plane>;
/**
* Gets or sets the active clipplane 2
*/
clipPlane2: Nullable<Plane>;
/**
* Gets or sets the active clipplane 3
*/
clipPlane3: Nullable<Plane>;
/**
* Gets or sets the active clipplane 4
*/
clipPlane4: Nullable<Plane>;
/**
* Gets or sets the active clipplane 5
*/
clipPlane5: Nullable<Plane>;
/**
* Gets or sets the active clipplane 6
*/
clipPlane6: Nullable<Plane>;
/**
* Gets the list of root nodes (ie. nodes with no parent)
*/
rootNodes: Node[];
/** All of the cameras added to this scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/cameras
*/
cameras: Camera[];
/**
* All of the lights added to this scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction
*/
lights: Light[];
/**
* All of the (abstract) meshes added to this scene
*/
meshes: AbstractMesh[];
/**
* The list of skeletons added to the scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/bonesSkeletons
*/
skeletons: Skeleton[];
/**
* All of the particle systems added to this scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/particles/particle_system/particle_system_intro
*/
particleSystems: IParticleSystem[];
/**
* Gets the current delta time used by animation engine
*/
deltaTime: number;
/**
* Gets a list of Animations associated with the scene
*/
animations: Animation[];
/**
* All of the animation groups added to this scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/animation/groupAnimations
*/
animationGroups: AnimationGroup[];
/**
* All of the multi-materials added to this scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/multiMaterials
*/
multiMaterials: MultiMaterial[];
/**
* All of the materials added to this scene
* In the context of a Scene, it is not supposed to be modified manually.
* Any addition or removal should be done using the addMaterial and removeMaterial Scene methods.
* Note also that the order of the Material within the array is not significant and might change.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/materials_introduction
*/
materials: Material[];
/**
* The list of morph target managers added to the scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/dynamicMeshMorph
*/
morphTargetManagers: MorphTargetManager[];
/**
* The list of geometries used in the scene.
*/
geometries: Geometry[];
/**
* All of the transform nodes added to this scene
* In the context of a Scene, it is not supposed to be modified manually.
* Any addition or removal should be done using the addTransformNode and removeTransformNode Scene methods.
* Note also that the order of the TransformNode within the array is not significant and might change.
* @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/transforms/parent_pivot/transform_node
*/
transformNodes: TransformNode[];
/**
* ActionManagers available on the scene.
*/
actionManagers: AbstractActionManager[];
/**
* Object renderers available on the scene.
*/
objectRenderers: ObjectRenderer[];
/**
* Textures to keep.
*/
textures: BaseTexture[];
/** @internal */
protected _environmentTexture: Nullable<BaseTexture>;
/**
* Texture used in all pbr material as the reflection texture.
* As in the majority of the scene they are the same (exception for multi room and so on),
* this is easier to reference from here than from all the materials.
*/
get environmentTexture(): Nullable<BaseTexture>;
/**
* Texture used in all pbr material as the reflection texture.
* As in the majority of the scene they are the same (exception for multi room and so on),
* this is easier to set here than in all the materials.
*/
set environmentTexture(value: Nullable<BaseTexture>);
/**
* The list of postprocesses added to the scene
*/
postProcesses: PostProcess[];
/**
* The list of effect layers (highlights/glow) added to the scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/highlightLayer
* @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/glowLayer
*/
effectLayers: Array<EffectLayer>;
/**
* The list of sounds used in the scene.
* @deprecated please use AudioEngineV2 instead
*/
sounds: Nullable<Array<Sound>>;
/**
* The list of layers (background and foreground) of the scene
*/
layers: Array<Layer>;
/**
* The list of lens flare system added to the scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/environment/lenseFlare
*/
lensFlareSystems: Array<LensFlareSystem>;
/**
* The list of procedural textures added to the scene
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/proceduralTextures
*/
proceduralTextures: Array<ProceduralTexture>;
/**
* @returns all meshes, lights, cameras, transformNodes and bones
*/
getNodes(): Array<Node>;
/**
* Gets or sets a boolean indicating if animations are enabled
*/
animationsEnabled: boolean;
private _animationPropertiesOverride;
/**
* Gets or sets the animation properties override
*/
get animationPropertiesOverride(): Nullable<AnimationPropertiesOverride>;
set animationPropertiesOverride(value: Nullable<AnimationPropertiesOverride>);
/**
* Gets or sets a boolean indicating if a constant deltatime has to be used
* This is mostly useful for testing purposes when you do not want the animations to scale with the framerate
*/
useConstantAnimationDeltaTime: boolean;
/**
* Gets or sets a boolean indicating if the scene must keep the meshUnderPointer property updated
* Please note that it requires to run a ray cast through the scene on every frame
*/
constantlyUpdateMeshUnderPointer: boolean;
/**
* Defines the HTML cursor to use when hovering over interactive elements
*/
hoverCursor: string;
/**
* Defines the HTML default cursor to use (empty by default)
*/
defaultCursor: string;
/**
* Defines whether cursors are handled by the scene.
*/
doNotHandleCursors: boolean;
/**
* This is used to call preventDefault() on pointer down
* in order to block unwanted artifacts like system double clicks
*/
preventDefaultOnPointerDown: boolean;
/**
* This is used to call preventDefault() on pointer up
* in order to block unwanted artifacts like system double clicks
*/
preventDefaultOnPointerUp: boolean;
/**
* Gets or sets user defined metadata
*/
metadata: any;
/**
* For internal use only. Please do not use.
*/
reservedDataStore: any;
/**
* Gets the name of the plugin used to load this scene (null by default)
*/
loadingPluginName: string;
/**
* Use this array to add regular expressions used to disable offline support for specific urls
*/
disableOfflineSupportExceptionRules: RegExp[];
/**
* An event triggered when the scene is disposed.
*/
onDisposeObservable: Observable<Scene>;
private _onDisposeObserver;
/** Sets a function to be executed when this scene is disposed. */
set onDispose(callback: () => void);
/**
* An event triggered before rendering the scene (right after animations and physics)
*/
onBeforeRenderObservable: Observable<Scene>;
private _onBeforeRenderObserver;
/** Sets a function to be executed before rendering this scene */
set beforeRender(callback: Nullable<() => void>);
/**
* An event triggered after rendering the scene
*/
onAfterRenderObservable: Observable<Scene>;
/**
* An event triggered after rendering the scene for an active camera (When scene.render is called this will be called after each camera)
* This is triggered for each "sub" camera in a Camera Rig unlike onAfterCameraRenderObservable
*/
onAfterRenderCameraObservable: Observable<Camera>;
private _onAfterRenderObserver;
/** Sets a function to be executed after rendering this scene */
set afterRender(callback: Nullable<() => void>);
/**
* An event triggered before animating the scene
*/
onBeforeAnimationsObservable: Observable<Scene>;
/**
* An event triggered after animations processing
*/
onAfterAnimationsObservable: Observable<Scene>;
/**
* An event triggered before draw calls are ready to be sent
*/
onBeforeDrawPhaseObservable: Observable<Scene>;
/**
* An event triggered after draw calls have been sent
*/
onAfterDrawPhaseObservable: Observable<Scene>;
/**
* An event triggered when the scene is ready
*/
onReadyObservable: Observable<Scene>;
/**
* An event triggered before rendering a camera
*/
onBeforeCameraRenderObservable: Observable<Camera>;
private _onBeforeCameraRenderObserver;
/** Sets a function to be executed before rendering a camera*/
set beforeCameraRender(callback: () => void);
/**
* An event triggered after rendering a camera
* This is triggered for the full rig Camera only unlike onAfterRenderCameraObservable
*/
onAfterCameraRenderObservable: Observable<Camera>;
private _onAfterCameraRenderObserver;
/** Sets a function to be executed after rendering a camera*/
set afterCameraRender(callback: () => void);
/**
* An event triggered when active meshes evaluation is about to start
*/
onBeforeActiveMeshesEvaluationObservable: Observable<Scene>;
/**
* An event triggered when active meshes evaluation is done
*/
onAfterActiveMeshesEvaluationObservable: Observable<Scene>;
/**
* An event triggered when particles rendering is about to start
* Note: This event can be trigger more than once per frame (because particles can be rendered by render target textures as well)
*/
onBeforeParticlesRenderingObservable: Observable<Scene>;
/**
* An event triggered when particles rendering is done
* Note: This event can be trigger more than once per frame (because particles can be rendered by render target textures as well)
*/
onAfterParticlesRenderingObservable: Observable<Scene>;
/**
* An event triggered when SceneLoader.Append or SceneLoader.Load or SceneLoader.ImportMesh were successfully executed
*/
onDataLoadedObservable: Observable<Scene>;
/**
* An event triggered when a camera is created
*/
onNewCameraAddedObservable: Observable<Camera>;
/**
* An event triggered when a camera is removed
*/
onCameraRemovedObservable: Observable<Camera>;
/**
* An event triggered when a light is created
*/
onNewLightAddedObservable: Observable<Light>;
/**
* An event triggered when a light is removed
*/
onLightRemovedObservable: Observable<Light>;
/**
* An event triggered when a geometry is created
*/
onNewGeometryAddedObservable: Observable<Geometry>;
/**
* An event triggered when a geometry is removed
*/
onGeometryRemovedObservable: Observable<Geometry>;
/**
* An event triggered when a transform node is created
*/
onNewTransformNodeAddedObservable: Observable<TransformNode>;
/**
* An event triggered when a transform node is removed
*/
onTransformNodeRemovedObservable: Observable<TransformNode>;
/**
* An event triggered when a mesh is created
*/
onNewMeshAddedObservable: Observable<AbstractMesh>;
/**
* An event triggered when a mesh is removed
*/
onMeshRemovedObservable: Observable<AbstractMesh>;
/**
* An event triggered when a skeleton is created
*/
onNewSkeletonAddedObservable: Observable<Skeleton>;
/**
* An event triggered when a skeleton is removed
*/
onSkeletonRemovedObservable: Observable<Skeleton>;
/**
* An event triggered when a particle system is created
*/
onNewParticleSystemAddedObservable: Observable<IParticleSystem>;
/**
* An event triggered when a particle system is removed
*/
onParticleSystemRemovedObservable: Observable<IParticleSystem>;
/**
* An event triggered when an animation group is created
*/
onNewAnimationGroupAddedObservable: Observable<AnimationGroup>;
/**
* An event triggered when an animation group is removed
*/
onAnimationGroupRemovedObservable: Observable<AnimationGroup>;
/**
* An event triggered when a material is created
*/
onNewMaterialAddedObservable: Observable<Material>;
/**
* An event triggered when a multi material is created
*/
onNewMultiMaterialAddedObservable: Observable<MultiMaterial>;
/**
* An event triggered when a material is removed
*/
onMaterialRemovedObservable: Observable<Material>;
/**
* An event triggered when a multi material is removed
*/
onMultiMaterialRemovedObservable: Observable<MultiMaterial>;
/**
* An event triggered when a texture is created
*/
onNewTextureAddedObservable: Observable<BaseTexture>;
/**
* An event triggered when a texture is removed
*/
onTextureRemovedObservable: Observable<BaseTexture>;
/**
* An event triggered when a frame graph is created
*/
onNewFrameGraphAddedObservable: Observable<FrameGraph>;
/**
* An event triggered when a frame graph is removed
*/
onFrameGraphRemovedObservable: Observable<FrameGraph>;
/**
* An event triggered when an object renderer is created
*/
onNewObjectRendererAddedObservable: Observable<ObjectRenderer>;
/**
* An event triggered when an object renderer is removed
*/
onObjectRendererRemovedObservable: Observable<ObjectRenderer>;
/**
* An event triggered when a post process is created
*/
onNewPostProcessAddedObservable: Observable<PostProcess>;
/**
* An event triggered when a post process is removed
*/
onPostProcessRemovedObservable: Observable<PostProcess>;
/**
* An event triggered when an effect layer is created
*/
onNewEffectLayerAddedObservable: Observable<EffectLayer>;
/**
* An event triggered when an effect layer is removed
*/
onEffectLayerRemovedObservable: Observable<EffectLayer>;
/**
* An event triggered when render targets are about to be rendered
* Can happen multiple times per frame.
*/
onBeforeRenderTargetsRenderObservable: Observable<Scene>;
/**
* An event triggered when render targets were rendered.
* Can happen multiple times per frame.
*/
onAfterRenderTargetsRenderObservable: Observable<Scene>;
/**
* An event triggered before calculating deterministic simulation step
*/
onBeforeStepObservable: Observable<Scene>;
/**
* An event triggered after calculating deterministic simulation step
*/
onAfterStepObservable: Observable<Scene>;
/**
* An event triggered when the activeCamera property is updated
*/
onActiveCameraChanged: Observable<Scene>;
/**
* An event triggered when the activeCameras property is updated
*/
onActiveCamerasChanged: Observable<Scene>;
/**
* This Observable will be triggered before rendering each renderingGroup of each rendered camera.
* The RenderingGroupInfo class contains all the information about the context in which the observable is called
* If you wish to register an Observer only for a given set of renderingGroup, use the mask with a combination of the renderingGroup index elevated to the power of two (1 for renderingGroup 0, 2 for renderingrOup1, 4 for 2 and 8 for 3)
*/
onBeforeRenderingGroupObservable: Observable<RenderingGroupInfo>;
/**
* This Observable will be triggered after rendering each renderingGroup of each rendered camera.
* The RenderingGroupInfo class contains all the information about the context in which the observable is called
* If you wish to register an Observer only for a given set of renderingGroup, use the mask with a combination of the renderingGroup index elevated to the power of two (1 for renderingGroup 0, 2 for renderingrOup1, 4 for 2 and 8 for 3)
*/
onAfterRenderingGroupObservable: Observable<RenderingGroupInfo>;
/**
* This Observable will when a mesh has been imported into the scene.
*/
onMeshImportedObservable: Observable<AbstractMesh>;
/**
* This Observable will when an animation file has been imported into the scene.
*/
onAnimationFileImportedObservable: Observable<Scene>;
/**
* An event triggered when the environmentTexture is changed.
*/
onEnvironmentTextureChangedObservable: Observable<Nullable<BaseTexture>>;
/**
* An event triggered when the state of mesh under pointer, for a specific pointerId, changes.
*/
onMeshUnderPointerUpdatedObservable: Observable<{
mesh: Nullable<AbstractMesh>;
pointerId: number;
}>;
/**
* Gets or sets a user defined funtion to select LOD from a mesh and a camera.
* By default this function is undefined and Babylon.js will select LOD based on distance to camera
*/
customLODSelector: (mesh: AbstractMesh, camera: Camera) => Nullable<AbstractMesh>;
/** @internal */
_registeredForLateAnimationBindings: SmartArrayNoDuplicate<any>;
private _pointerPickingConfiguration;
/**
* Gets or sets a predicate used to select candidate meshes for a pointer down event
*/
get pointerDownPredicate(): (Mesh: AbstractMesh) => boolean;
set pointerDownPredicate(value: (Mesh: AbstractMesh) => boolean);
/**
* Gets or sets a predicate used to select candidate meshes for a pointer up event
*/
get pointerUpPredicate(): (Mesh: AbstractMesh) => boolean;
set pointerUpPredicate(value: (Mesh: AbstractMesh) => boolean);
/**
* Gets or sets a predicate used to select candidate meshes for a pointer move event
*/
get pointerMovePredicate(): (Mesh: AbstractMesh) => boolean;
set pointerMovePredicate(value: (Mesh: AbstractMesh) => boolean);
/**
* Gets or sets a predicate used to select candidate meshes for a pointer down event
*/
get pointerDownFastCheck(): boolean;
set pointerDownFastCheck(value: boolean);
/**
* Gets or sets a predicate used to select candidate meshes for a pointer up event
*/
get pointerUpFastCheck(): boolean;
set pointerUpFastCheck(value: boolean);
/**
* Gets or sets a predicate used to select candidate meshes for a pointer move event
*/
get pointerMoveFastCheck(): boolean;
set pointerMoveFastCheck(value: boolean);
/**
* Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer move event occurs.
*/
get skipPointerMovePicking(): boolean;
set skipPointerMovePicking(value: boolean);
/**
* Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer down event occurs.
*/
get skipPointerDownPicking(): boolean;
set skipPointerDownPicking(value: boolean);
/**
* Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a po