import { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture"; import { Vector3 } from "../Maths/math.vector"; import type { AbstractMesh } from "../Meshes/abstractMesh"; import type { Nullable } from "../types"; import { AbstractScene } from "../abstractScene"; import type { Scene } from "../scene"; declare module "../abstractScene" { interface AbstractScene { /** * The list of reflection probes added to the scene * @see https://doc.babylonjs.com/features/featuresDeepDive/environment/reflectionProbes */ reflectionProbes: Array; /** * Removes the given reflection probe from this scene. * @param toRemove The reflection probe to remove * @returns The index of the removed reflection probe */ removeReflectionProbe(toRemove: ReflectionProbe): number; /** * Adds the given reflection probe to this scene. * @param newReflectionProbe The reflection probe to add */ addReflectionProbe(newReflectionProbe: ReflectionProbe): void; } } /** * Class used to generate realtime reflection / refraction cube textures * @see https://doc.babylonjs.com/features/featuresDeepDive/environment/reflectionProbes */ export declare class ReflectionProbe { /** defines the name of the probe */ name: string; private _scene; private _renderTargetTexture; private _projectionMatrix; private _viewMatrix; private _target; private _add; private _attachedMesh; private _invertYAxis; private _sceneUBOs; private _currentSceneUBO; /** Gets or sets probe position (center of the cube map) */ position: Vector3; /** * Gets or sets an object used to store user defined information for the reflection probe. */ metadata: any; /** @internal */ _parentContainer: Nullable; /** * Creates a new reflection probe * @param name defines the name of the probe * @param size defines the texture resolution (for each face) * @param scene defines the hosting scene * @param generateMipMaps defines if mip maps should be generated automatically (true by default) * @param useFloat defines if HDR data (float data) should be used to store colors (false by default) * @param linearSpace defines if the probe should be generated in linear space or not (false by default) */ constructor( /** defines the name of the probe */ name: string, size: number, scene: Scene, generateMipMaps?: boolean, useFloat?: boolean, linearSpace?: boolean); /** Gets or sets the number of samples to use for multi-sampling (0 by default). Required WebGL2 */ get samples(): number; set samples(value: number); /** Gets or sets the refresh rate to use (on every frame by default) */ get refreshRate(): number; set refreshRate(value: number); /** * Gets the hosting scene * @returns a Scene */ getScene(): Scene; /** Gets the internal CubeTexture used to render to */ get cubeTexture(): RenderTargetTexture; /** Gets or sets the list of meshes to render */ get renderList(): Nullable; set renderList(value: Nullable); /** * Attach the probe to a specific mesh (Rendering will be done from attached mesh's position) * @param mesh defines the mesh to attach to */ attachToMesh(mesh: Nullable): void; /** * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups * @param renderingGroupId The rendering group id corresponding to its index * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true. */ setRenderingAutoClearDepthStencil(renderingGroupId: number, autoClearDepthStencil: boolean): void; /** * Clean all associated resources */ dispose(): void; /** * Converts the reflection probe information to a readable string for debug purpose. * @param fullDetails Supports for multiple levels of logging within scene loading * @returns the human readable reflection probe info */ toString(fullDetails?: boolean): string; /** * Get the class name of the refection probe. * @returns "ReflectionProbe" */ getClassName(): string; /** * Serialize the reflection probe to a JSON representation we can easily use in the respective Parse function. * @returns The JSON representation of the texture */ serialize(): any; /** * Parse the JSON representation of a reflection probe in order to recreate the reflection probe in the given scene. * @param parsedReflectionProbe Define the JSON representation of the reflection probe * @param scene Define the scene the parsed reflection probe should be instantiated in * @param rootUrl Define the root url of the parsing sequence in the case of relative dependencies * @returns The parsed reflection probe if successful */ static Parse(parsedReflectionProbe: any, scene: Scene, rootUrl: string): Nullable; }