@babylonjs/core 7.34.0 → 7.34.2

package/Materials/Textures/renderTargetTexture.d.ts

@@ -11,11 +11,11 @@ import type { SubMesh } from "../../Meshes/subMesh";
 import type { InternalTexture } from "../../Materials/Textures/internalTexture";
 import { Texture } from "../../Materials/Textures/texture";
 import type { PostProcess } from "../../PostProcesses/postProcess";
-import { RenderingManager } from "../../Rendering/renderingManager";
 import type { IRenderTargetTexture, RenderTargetWrapper } from "../../Engines/renderTargetWrapper";
 import type { Material } from "../material";
 import type { AbstractEngine } from "../../Engines/abstractEngine";
 import type { IParticleSystem } from "../../Particles/IParticleSystem.js";
+import { ObjectRenderer } from "../../Rendering/objectRenderer.js";
 declare module "../effect" {
     interface Effect {
         /**
@@ -74,7 +74,7 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
      */
     static readonly REFRESHRATE_RENDER_ONCE: number;
     /**
-     * The texture will only be rendered rendered every frame and is recommended for dynamic contents.
+     * The texture will be rendered every frame and is recommended for dynamic contents.
      */
     static readonly REFRESHRATE_RENDER_ONEVERYFRAME: number;
     /**
@@ -86,20 +86,19 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
      * Use this predicate to dynamically define the list of mesh you want to render.
      * If set, the renderList property will be overwritten.
      */
-    renderListPredicate: (AbstractMesh: AbstractMesh) => boolean;
-    private _renderList;
-    private _unObserveRenderList;
+    get renderListPredicate(): (AbstractMesh: AbstractMesh) => boolean;
+    set renderListPredicate(value: (AbstractMesh: AbstractMesh) => boolean);
     /**
      * Use this list to define the list of mesh you want to render.
      */
     get renderList(): Nullable<Array<AbstractMesh>>;
     set renderList(value: Nullable<Array<AbstractMesh>>);
-    private _renderListHasChanged;
     /**
      * Define the list of particle systems to render in the texture. If not provided, will render all the particle systems of the scene.
      * Note that the particle systems are rendered only if renderParticles is set to true.
      */
-    particleSystemList: Nullable<Array<IParticleSystem>>;
+    get particleSystemList(): Nullable<Array<IParticleSystem>>;
+    set particleSystemList(value: Nullable<Array<IParticleSystem>>);
     /**
      * Use this function to overload the renderList array at rendering time.
      * Return null to render with the current renderList, else return the list of meshes to use for rendering.
@@ -109,31 +108,38 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
      * The length of this list is passed through renderListLength: don't use renderList.length directly because the array can
      * hold dummy elements!
      */
-    getCustomRenderList: (layerOrFace: number, renderList: Nullable<Immutable<Array<AbstractMesh>>>, renderListLength: number) => Nullable<Array<AbstractMesh>>;
+    get getCustomRenderList(): Nullable<(layerOrFace: number, renderList: Nullable<Immutable<Array<AbstractMesh>>>, renderListLength: number) => Nullable<Array<AbstractMesh>>>;
+    set getCustomRenderList(value: Nullable<(layerOrFace: number, renderList: Nullable<Immutable<Array<AbstractMesh>>>, renderListLength: number) => Nullable<Array<AbstractMesh>>>);
     /**
-     * Define if particles should be rendered in your texture.
+     * Define if particles should be rendered in your texture (default: true).
      */
-    renderParticles: boolean;
+    get renderParticles(): boolean;
+    set renderParticles(value: boolean);
     /**
-     * Define if sprites should be rendered in your texture.
+     * Define if sprites should be rendered in your texture (default: false).
      */
-    renderSprites: boolean;
+    get renderSprites(): boolean;
+    set renderSprites(value: boolean);
     /**
-     * Force checking the layerMask property even if a custom list of meshes is provided (ie. if renderList is not undefined)
+     * Force checking the layerMask property even if a custom list of meshes is provided (ie. if renderList is not undefined) (default: false).
      */
-    forceLayerMaskCheck: boolean;
+    get forceLayerMaskCheck(): boolean;
+    set forceLayerMaskCheck(value: boolean);
     /**
      * Define the camera used to render the texture.
      */
-    activeCamera: Nullable<Camera>;
+    get activeCamera(): Nullable<Camera>;
+    set activeCamera(value: Nullable<Camera>);
     /**
      * Override the mesh isReady function with your own one.
      */
-    customIsReadyFunction: (mesh: AbstractMesh, refreshRate: number, preWarm?: boolean) => boolean;
+    get customIsReadyFunction(): (mesh: AbstractMesh, refreshRate: number, preWarm?: boolean) => boolean;
+    set customIsReadyFunction(value: (mesh: AbstractMesh, refreshRate: number, preWarm?: boolean) => boolean);
     /**
      * Override the render function of the texture with your own one.
      */
-    customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>, beforeTransparents?: () => void) => void;
+    get customRenderFunction(): (opaqueSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>, beforeTransparents?: () => void) => void;
+    set customRenderFunction(value: (opaqueSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>, beforeTransparents?: () => void) => void);
     /**
      * Define if camera post processes should be use while rendering the texture.
      */
@@ -167,7 +173,7 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
     /**
      * An event triggered before rendering the texture
      */
-    onBeforeRenderObservable: Observable<number>;
+    get onBeforeRenderObservable(): Observable<number>;
     private _onBeforeRenderObserver;
     /**
      * Set a before render callback in the texture.
@@ -177,7 +183,7 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
     /**
      * An event triggered after rendering the texture
      */
-    onAfterRenderObservable: Observable<number>;
+    get onAfterRenderObservable(): Observable<number>;
     private _onAfterRenderObserver;
     /**
      * Set a after render callback in the texture.
@@ -216,22 +222,25 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
      * Skip the initial clear of the rtt at the beginning of the frame render loop
      */
     skipInitialClear: boolean;
-    protected _renderingManager: RenderingManager;
     /** @internal */
-    _waitingRenderList?: string[];
+    get _waitingRenderList(): string[] | undefined;
+    /** @internal */
+    set _waitingRenderList(value: string[] | undefined);
+    protected _objectRenderer: ObjectRenderer;
     protected _doNotChangeAspectRatio: boolean;
-    protected _currentRefreshId: number;
-    protected _refreshRate: number;
     protected _textureMatrix: Matrix;
     protected _samples: number;
     protected _renderTargetOptions: RenderTargetCreationOptions;
     private _canRescale;
     protected _renderTarget: Nullable<RenderTargetWrapper>;
+    private _currentFaceIndex;
+    private _currentLayer;
+    private _currentUseCameraPostProcess;
+    private _currentDumpForDebug;
     /**
      * Current render pass id of the render target texture. Note it can change over the rendering as there's a separate id for each face of a cube / each layer of an array layer!
      */
-    renderPassId: number;
-    private _renderPassIds;
+    get renderPassId(): number;
     /**
      * Gets the render pass ids used by the render target texture. For a single render target the array length will be 1, for a cube texture it will be 6 and for
      * a 2D texture array it will return an array of ids the size of the 2D texture array
@@ -247,7 +256,6 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
      * @param material material or array of materials to use for this render pass. If undefined is passed, no specific material will be used but the regular material instead (mesh.material). It's possible to provide an array of materials to use a different material for each rendering in the case of a cube texture (6 rendering) and a 2D texture array (as many rendering as the length of the array)
      */
     setMaterialForRendering(mesh: AbstractMesh | AbstractMesh[], material?: Material | Material[]): void;
-    private _isCubeData;
     /**
      * Define if the texture has multiple draw buffers or if false a single draw buffer.
      */
@@ -327,28 +335,15 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
      * @param label defines the label of the texture (for debugging purpose)
      */
     createDepthStencilTexture(comparisonFunction?: number, bilinearFiltering?: boolean, generateStencil?: boolean, samples?: number, format?: number, label?: string): void;
-    private _releaseRenderPassId;
-    private _createRenderPassId;
     protected _processSizeParameter(size: TextureSize | {
         ratio: number;
-    }, createRenderPassIds?: boolean): void;
+    }): void;
     /**
      * Define the number of samples to use in case of MSAA.
      * It defaults to one meaning no MSAA has been enabled.
      */
     get samples(): number;
     set samples(value: number);
-    /**
-     * Resets the refresh counter of the texture and start bak from scratch.
-     * Could be useful to regenerate the texture if it is setup to render only once.
-     */
-    resetRefreshCounter(): void;
-    /**
-     * Define the refresh rate of the texture or the rendering frequency.
-     * Use 0 to render just once, 1 to render on every frame, 2 to render every two frames and so on...
-     */
-    get refreshRate(): number;
-    set refreshRate(value: number);
     /**
      * Adds a post process to the render target rendering passes.
      * @param postProcess define the post process to add
@@ -364,6 +359,17 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
      * @param postProcess define the post process to remove from the list
      */
     removePostProcess(postProcess: PostProcess): void;
+    /**
+     * Resets the refresh counter of the texture and start bak from scratch.
+     * Could be useful to regenerate the texture if it is setup to render only once.
+     */
+    resetRefreshCounter(): void;
+    /**
+     * Define the refresh rate of the texture or the rendering frequency.
+     * Use 0 to render just once, 1 to render on every frame, 2 to render every two frames and so on...
+     */
+    get refreshRate(): number;
+    set refreshRate(value: number);
     /** @internal */
     _shouldRender(): boolean;
     /**
@@ -415,7 +421,6 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
     resize(size: TextureSize | {
         ratio: number;
     }): void;
-    private _defaultRenderListPrepared;
     /**
      * Renders all the objects from the render list into the texture.
      * @param useCameraPostProcess Define if camera post processes should be used during the rendering
@@ -431,7 +436,6 @@ export declare class RenderTargetTexture extends Texture implements IRenderTarge
     isReadyForRendering(): boolean;
     private _render;
     private _bestReflectionRenderTargetDimension;
-    private _prepareRenderingManager;
     /**
      * @internal
      * @param faceIndex face index to bind to if this is a cubetexture