@babylonjs/core 7.34.1 → 7.34.3

package/Materials/Textures/renderTargetTexture.js

@@ -2,12 +2,11 @@ import { Observable } from "../../Misc/observable.js";
 import { Matrix, Vector3 } from "../../Maths/math.vector.js";
 import { Texture } from "../../Materials/Textures/texture.js";
 import { PostProcessManager } from "../../PostProcesses/postProcessManager.js";
-import { RenderingManager } from "../../Rendering/renderingManager.js";
 
-import { _ObserveArray } from "../../Misc/arrayTools.js";
 import { FloorPOT, NearestPOT } from "../../Misc/tools.functions.js";
 import { Effect } from "../effect.js";
 import { Logger } from "../../Misc/logger.js";
+import { ObjectRenderer } from "../../Rendering/objectRenderer.js";
 /**
  * Sets a depth stencil texture from a render target on the engine to be used in the shader.
  * @param channel Name of the sampler variable.
@@ -22,24 +21,103 @@ Effect.prototype.setDepthStencilTexture = function (channel, texture) {
  * Actually, It is the base of lot of effects in the framework like post process, shadows, effect layers and rendering pipelines...
  */
 export class RenderTargetTexture extends Texture {
+    /**
+     * Use this predicate to dynamically define the list of mesh you want to render.
+     * If set, the renderList property will be overwritten.
+     */
+    get renderListPredicate() {
+        return this._objectRenderer.renderListPredicate;
+    }
+    set renderListPredicate(value) {
+        this._objectRenderer.renderListPredicate = value;
+    }
     /**
      * Use this list to define the list of mesh you want to render.
      */
     get renderList() {
-        return this._renderList;
+        return this._objectRenderer.renderList;
     }
     set renderList(value) {
-        if (this._renderList === value) {
-            return;
-        }
-        if (this._unObserveRenderList) {
-            this._unObserveRenderList();
-            this._unObserveRenderList = null;
-        }
-        if (value) {
-            this._unObserveRenderList = _ObserveArray(value, this._renderListHasChanged);
-        }
-        this._renderList = value;
+        this._objectRenderer.renderList = value;
+    }
+    /**
+     * 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.
+     */
+    get particleSystemList() {
+        return this._objectRenderer.particleSystemList;
+    }
+    set particleSystemList(value) {
+        this._objectRenderer.particleSystemList = value;
+    }
+    /**
+     * 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.
+     * For 2DArray RTT, layerOrFace is the index of the layer that is going to be rendered, else it is the faceIndex of
+     * the cube (if the RTT is a cube, else layerOrFace=0).
+     * The renderList passed to the function is the current render list (the one that will be used if the function returns null).
+     * The length of this list is passed through renderListLength: don't use renderList.length directly because the array can
+     * hold dummy elements!
+     */
+    get getCustomRenderList() {
+        return this._objectRenderer.getCustomRenderList;
+    }
+    set getCustomRenderList(value) {
+        this._objectRenderer.getCustomRenderList = value;
+    }
+    /**
+     * Define if particles should be rendered in your texture (default: true).
+     */
+    get renderParticles() {
+        return this._objectRenderer.renderParticles;
+    }
+    set renderParticles(value) {
+        this._objectRenderer.renderParticles = value;
+    }
+    /**
+     * Define if sprites should be rendered in your texture (default: false).
+     */
+    get renderSprites() {
+        return this._objectRenderer.renderSprites;
+    }
+    set renderSprites(value) {
+        this._objectRenderer.renderSprites = value;
+    }
+    /**
+     * Force checking the layerMask property even if a custom list of meshes is provided (ie. if renderList is not undefined) (default: false).
+     */
+    get forceLayerMaskCheck() {
+        return this._objectRenderer.forceLayerMaskCheck;
+    }
+    set forceLayerMaskCheck(value) {
+        this._objectRenderer.forceLayerMaskCheck = value;
+    }
+    /**
+     * Define the camera used to render the texture.
+     */
+    get activeCamera() {
+        return this._objectRenderer.activeCamera;
+    }
+    set activeCamera(value) {
+        this._objectRenderer.activeCamera = value;
+    }
+    /**
+     * Override the mesh isReady function with your own one.
+     */
+    get customIsReadyFunction() {
+        return this._objectRenderer.customIsReadyFunction;
+    }
+    set customIsReadyFunction(value) {
+        this._objectRenderer.customIsReadyFunction = value;
+    }
+    /**
+     * Override the render function of the texture with your own one.
+     */
+    get customRenderFunction() {
+        return this._objectRenderer.customRenderFunction;
+    }
+    set customRenderFunction(value) {
+        this._objectRenderer.customRenderFunction = value;
     }
     /**
      * Post-processes for this render target
@@ -60,6 +138,12 @@ export class RenderTargetTexture extends Texture {
         }
         this._onAfterUnbindObserver = this.onAfterUnbindObservable.add(callback);
     }
+    /**
+     * An event triggered before rendering the texture
+     */
+    get onBeforeRenderObservable() {
+        return this._objectRenderer.onBeforeRenderObservable;
+    }
     /**
      * Set a before render callback in the texture.
      * This has been kept for backward compatibility and use of onBeforeRenderObservable is recommended.
@@ -70,6 +154,12 @@ export class RenderTargetTexture extends Texture {
         }
         this._onBeforeRenderObserver = this.onBeforeRenderObservable.add(callback);
     }
+    /**
+     * An event triggered after rendering the texture
+     */
+    get onAfterRenderObservable() {
+        return this._objectRenderer.onAfterRenderObservable;
+    }
     /**
      * Set a after render callback in the texture.
      * This has been kept for backward compatibility and use of onAfterRenderObservable is recommended.
@@ -90,18 +180,32 @@ export class RenderTargetTexture extends Texture {
         }
         this._onClearObserver = this.onClearObservable.add(callback);
     }
+    /** @internal */
+    get _waitingRenderList() {
+        return this._objectRenderer._waitingRenderList;
+    }
+    /** @internal */
+    set _waitingRenderList(value) {
+        this._objectRenderer._waitingRenderList = value;
+    }
+    /**
+     * 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!
+     */
+    get renderPassId() {
+        return this._objectRenderer.renderPassId;
+    }
     /**
      * 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
      */
     get renderPassIds() {
-        return this._renderPassIds;
+        return this._objectRenderer.renderPassIds;
     }
     /**
      * Gets the current value of the refreshId counter
      */
     get currentRefreshId() {
-        return this._currentRefreshId;
+        return this._objectRenderer.currentRefreshId;
     }
     /**
      * Sets a specific material to be used to render a mesh/a list of meshes in this render target texture
@@ -109,18 +213,7 @@ export class RenderTargetTexture extends Texture {
      * @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, material) {
-        let meshes;
-        if (!Array.isArray(mesh)) {
-            meshes = [mesh];
-        }
-        else {
-            meshes = mesh;
-        }
-        for (let j = 0; j < meshes.length; ++j) {
-            for (let i = 0; i < this._renderPassIds.length; ++i) {
-                meshes[j].setMaterialForRenderPass(this._renderPassIds[i], material !== undefined ? (Array.isArray(material) ? material[i] : material) : undefined);
-            }
-        }
+        this._objectRenderer.setMaterialForRendering(mesh, material);
     }
     /**
      * Define if the texture has multiple draw buffers or if false a single draw buffer.
@@ -196,32 +289,6 @@ export class RenderTargetTexture extends Texture {
             gammaSpace = options.gammaSpace ?? gammaSpace;
         }
         super(null, scene, !generateMipMaps, undefined, samplingMode, undefined, undefined, undefined, undefined, format);
-        this._unObserveRenderList = null;
-        this._renderListHasChanged = (_functionName, previousLength) => {
-            const newLength = this._renderList ? this._renderList.length : 0;
-            if ((previousLength === 0 && newLength > 0) || newLength === 0) {
-                this.getScene()?.meshes.forEach((mesh) => {
-                    mesh._markSubMeshesAsLightDirty();
-                });
-            }
-        };
-        /**
-         * 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.
-         */
-        this.particleSystemList = null;
-        /**
-         * Define if particles should be rendered in your texture.
-         */
-        this.renderParticles = true;
-        /**
-         * Define if sprites should be rendered in your texture.
-         */
-        this.renderSprites = false;
-        /**
-         * Force checking the layerMask property even if a custom list of meshes is provided (ie. if renderList is not undefined)
-         */
-        this.forceLayerMaskCheck = false;
         /**
          * Define if the camera viewport should be respected while rendering the texture or if the render should be done to the entire texture.
          */
@@ -234,14 +301,6 @@ export class RenderTargetTexture extends Texture {
          * An event triggered when the texture is unbind.
          */
         this.onAfterUnbindObservable = new Observable();
-        /**
-         * An event triggered before rendering the texture
-         */
-        this.onBeforeRenderObservable = new Observable();
-        /**
-         * An event triggered after rendering the texture
-         */
-        this.onAfterRenderObservable = new Observable();
         /**
          * An event triggered after the texture clear
          */
@@ -256,8 +315,6 @@ export class RenderTargetTexture extends Texture {
          * Skip the initial clear of the rtt at the beginning of the frame render loop
          */
         this.skipInitialClear = false;
-        this._currentRefreshId = -1;
-        this._refreshRate = 1;
         this._samples = 1;
         this._canRescale = true;
         this._renderTarget = null;
@@ -274,20 +331,83 @@ export class RenderTargetTexture extends Texture {
         const engine = this.getScene().getEngine();
         this._gammaSpace = gammaSpace;
         this._coordinatesMode = Texture.PROJECTION_MODE;
-        this.renderList = [];
         this.name = name;
         this.isRenderTarget = true;
         this._initialSizeParameter = size;
-        this._renderPassIds = [];
-        this._isCubeData = isCube;
         this._processSizeParameter(size);
-        this.renderPassId = this._renderPassIds[0];
+        this._objectRenderer = new ObjectRenderer(name, scene, {
+            numPasses: isCube ? 6 : this.getRenderLayers() || 1,
+            doNotChangeAspectRatio,
+        });
+        this._objectRenderer.onBeforeRenderingManagerRenderObservable.add(() => {
+            // Before clear
+            for (const step of this._scene._beforeRenderTargetClearStage) {
+                step.action(this, this._currentFaceIndex, this._currentLayer);
+            }
+            // Clear
+            if (this.onClearObservable.hasObservers()) {
+                this.onClearObservable.notifyObservers(engine);
+            }
+            else if (!this.skipInitialClear) {
+                engine.clear(this.clearColor || this._scene.clearColor, true, true, true);
+            }
+            if (!this._doNotChangeAspectRatio) {
+                this._scene.updateTransformMatrix(true);
+            }
+            // Before Camera Draw
+            for (const step of this._scene._beforeRenderTargetDrawStage) {
+                step.action(this, this._currentFaceIndex, this._currentLayer);
+            }
+        });
+        this._objectRenderer.onAfterRenderingManagerRenderObservable.add(() => {
+            // After Camera Draw
+            for (const step of this._scene._afterRenderTargetDrawStage) {
+                step.action(this, this._currentFaceIndex, this._currentLayer);
+            }
+            const saveGenerateMipMaps = this._texture?.generateMipMaps ?? false;
+            if (this._texture) {
+                this._texture.generateMipMaps = false; // if left true, the mipmaps will be generated (if this._texture.generateMipMaps = true) when the first post process binds its own RTT: by doing so it will unbind the current RTT,
+                // which will trigger a mipmap generation. We don't want this because it's a wasted work, we will do an unbind of the current RTT at the end of the process (see unbindFrameBuffer) which will
+                // trigger the generation of the final mipmaps
+            }
+            if (this._postProcessManager) {
+                this._postProcessManager._finalizeFrame(false, this._renderTarget ?? undefined, this._currentFaceIndex, this._postProcesses, this.ignoreCameraViewport);
+            }
+            else if (this._currentUseCameraPostProcess) {
+                this._scene.postProcessManager._finalizeFrame(false, this._renderTarget ?? undefined, this._currentFaceIndex);
+            }
+            for (const step of this._scene._afterRenderTargetPostProcessStage) {
+                step.action(this, this._currentFaceIndex, this._currentLayer);
+            }
+            if (this._texture) {
+                this._texture.generateMipMaps = saveGenerateMipMaps;
+            }
+            if (!this._doNotChangeAspectRatio) {
+                this._scene.updateTransformMatrix(true);
+            }
+            // Dump ?
+            if (this._currentDumpForDebug) {
+                if (!this._dumpTools) {
+                    Logger.Error("dumpTools module is still being loaded. To speed up the process import dump tools directly in your project");
+                }
+                else {
+                    this._dumpTools.DumpFramebuffer(this.getRenderWidth(), this.getRenderHeight(), engine);
+                }
+            }
+        });
+        this._objectRenderer.onFastPathRenderObservable.add(() => {
+            if (this.onClearObservable.hasObservers()) {
+                this.onClearObservable.notifyObservers(engine);
+            }
+            else {
+                if (!this.skipInitialClear) {
+                    engine.clear(this.clearColor || this._scene.clearColor, true, true, true);
+                }
+            }
+        });
         this._resizeObserver = engine.onResizeObservable.add(() => { });
         this._generateMipMaps = generateMipMaps ? true : false;
         this._doNotChangeAspectRatio = doNotChangeAspectRatio;
-        // Rendering groups
-        this._renderingManager = new RenderingManager(scene);
-        this._renderingManager._useSceneAutoClearSetup = true;
         if (isMulti) {
             return;
         }
@@ -337,24 +457,7 @@ export class RenderTargetTexture extends Texture {
     createDepthStencilTexture(comparisonFunction = 0, bilinearFiltering = true, generateStencil = false, samples = 1, format = 14, label) {
         this._renderTarget?.createDepthStencilTexture(comparisonFunction, bilinearFiltering, generateStencil, samples, format, label);
     }
-    _releaseRenderPassId() {
-        if (this._scene) {
-            const engine = this._scene.getEngine();
-            for (let i = 0; i < this._renderPassIds.length; ++i) {
-                engine.releaseRenderPassId(this._renderPassIds[i]);
-            }
-        }
-        this._renderPassIds = [];
-    }
-    _createRenderPassId() {
-        this._releaseRenderPassId();
-        const engine = this._scene.getEngine(); // scene can't be null in a RenderTargetTexture, see constructor
-        const numPasses = this._isCubeData ? 6 : this.getRenderLayers() || 1;
-        for (let i = 0; i < numPasses; ++i) {
-            this._renderPassIds[i] = engine.createRenderPassId(`RenderTargetTexture - ${this.name}#${i}`);
-        }
-    }
-    _processSizeParameter(size, createRenderPassIds = true) {
+    _processSizeParameter(size) {
         if (size.ratio) {
             this._sizeRatio = size.ratio;
             const engine = this._getEngine();
@@ -366,9 +469,6 @@ export class RenderTargetTexture extends Texture {
         else {
             this._size = size;
         }
-        if (createRenderPassIds) {
-            this._createRenderPassId();
-        }
     }
     /**
      * Define the number of samples to use in case of MSAA.
@@ -382,24 +482,6 @@ export class RenderTargetTexture extends Texture {
             this._samples = this._renderTarget.setSamples(value);
         }
     }
-    /**
-     * 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() {
-        this._currentRefreshId = -1;
-    }
-    /**
-     * 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() {
-        return this._refreshRate;
-    }
-    set refreshRate(value) {
-        this._refreshRate = value;
-        this.resetRefreshCounter();
-    }
     /**
      * Adds a post process to the render target rendering passes.
      * @param postProcess define the post process to add
@@ -448,19 +530,26 @@ export class RenderTargetTexture extends Texture {
             this._postProcesses[0].autoClear = false;
         }
     }
+    /**
+     * 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() {
+        this._objectRenderer.resetRefreshCounter();
+    }
+    /**
+     * 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() {
+        return this._objectRenderer.refreshRate;
+    }
+    set refreshRate(value) {
+        this._objectRenderer.refreshRate = value;
+    }
     /** @internal */
     _shouldRender() {
-        if (this._currentRefreshId === -1) {
-            // At least render once
-            this._currentRefreshId = 1;
-            return true;
-        }
-        if (this.refreshRate === this._currentRefreshId) {
-            this._currentRefreshId = 1;
-            return true;
-        }
-        this._currentRefreshId++;
-        return false;
+        return this._objectRenderer.shouldRender();
     }
     /**
      * Gets the actual render size of the texture.
@@ -550,7 +639,7 @@ export class RenderTargetTexture extends Texture {
         if (!scene) {
             return;
         }
-        this._processSizeParameter(size, false);
+        this._processSizeParameter(size);
         if (wasCube) {
             this._renderTarget = scene.getEngine().createRenderTargetCubeTexture(this.getRenderSize(), this._renderTargetOptions);
         }
@@ -583,145 +672,44 @@ export class RenderTargetTexture extends Texture {
             // avoid a static import to allow ignoring the import in some cases
             import("../../Misc/dumpTools.js").then((module) => (this._dumpTools = module));
         }
-        return this._render(false, false, true);
+        this._objectRenderer.prepareRenderList();
+        this.onBeforeBindObservable.notifyObservers(this);
+        this._objectRenderer.initRender(this.getRenderWidth(), this.getRenderHeight());
+        const isReady = this._objectRenderer._checkReadiness();
+        this.onAfterUnbindObservable.notifyObservers(this);
+        this._objectRenderer.finishRender();
+        return isReady;
     }
-    _render(useCameraPostProcess = false, dumpForDebug = false, checkReadiness = false) {
+    _render(useCameraPostProcess = false, dumpForDebug = false) {
         const scene = this.getScene();
         if (!scene) {
-            return checkReadiness;
+            return;
         }
-        const engine = scene.getEngine();
         if (this.useCameraPostProcesses !== undefined) {
             useCameraPostProcess = this.useCameraPostProcesses;
         }
-        if (this._waitingRenderList) {
-            if (!this.renderListPredicate) {
-                this.renderList = [];
-                for (let index = 0; index < this._waitingRenderList.length; index++) {
-                    const id = this._waitingRenderList[index];
-                    const mesh = scene.getMeshById(id);
-                    if (mesh) {
-                        this.renderList.push(mesh);
-                    }
-                }
-            }
-            this._waitingRenderList = undefined;
-        }
-        // Is predicate defined?
-        if (this.renderListPredicate) {
-            if (this.renderList) {
-                this.renderList.length = 0; // Clear previous renderList
-            }
-            else {
-                this.renderList = [];
-            }
-            const scene = this.getScene();
-            if (!scene) {
-                return checkReadiness;
-            }
-            const sceneMeshes = scene.meshes;
-            for (let index = 0; index < sceneMeshes.length; index++) {
-                const mesh = sceneMeshes[index];
-                if (this.renderListPredicate(mesh)) {
-                    this.renderList.push(mesh);
-                }
-            }
-        }
-        const currentRenderPassId = engine.currentRenderPassId;
+        this._objectRenderer.prepareRenderList();
         this.onBeforeBindObservable.notifyObservers(this);
-        // Set custom projection.
-        // Needs to be before binding to prevent changing the aspect ratio.
-        const camera = this.activeCamera ?? scene.activeCamera;
-        const sceneCamera = scene.activeCamera;
-        if (camera) {
-            if (camera !== scene.activeCamera) {
-                scene.setTransformMatrix(camera.getViewMatrix(), camera.getProjectionMatrix(true));
-                scene.activeCamera = camera;
+        this._objectRenderer.initRender(this.getRenderWidth(), this.getRenderHeight());
+        if ((this.is2DArray || this.is3D) && !this.isMulti) {
+            for (let layer = 0; layer < this.getRenderLayers(); layer++) {
+                this._renderToTarget(0, useCameraPostProcess, dumpForDebug, layer);
+                scene.incrementRenderId();
+                scene.resetCachedMaterial();
             }
-            engine.setViewport(camera.rigParent ? camera.rigParent.viewport : camera.viewport, this.getRenderWidth(), this.getRenderHeight());
         }
-        this._defaultRenderListPrepared = false;
-        let returnValue = checkReadiness;
-        if (!checkReadiness) {
-            if ((this.is2DArray || this.is3D) && !this.isMulti) {
-                for (let layer = 0; layer < this.getRenderLayers(); layer++) {
-                    this._renderToTarget(0, useCameraPostProcess, dumpForDebug, layer, camera);
-                    scene.incrementRenderId();
-                    scene.resetCachedMaterial();
-                }
-            }
-            else if (this.isCube && !this.isMulti) {
-                for (let face = 0; face < 6; face++) {
-                    this._renderToTarget(face, useCameraPostProcess, dumpForDebug, undefined, camera);
-                    scene.incrementRenderId();
-                    scene.resetCachedMaterial();
-                }
-            }
-            else {
-                this._renderToTarget(0, useCameraPostProcess, dumpForDebug, undefined, camera);
+        else if (this.isCube && !this.isMulti) {
+            for (let face = 0; face < 6; face++) {
+                this._renderToTarget(face, useCameraPostProcess, dumpForDebug);
+                scene.incrementRenderId();
+                scene.resetCachedMaterial();
             }
         }
         else {
-            if (!scene.getViewMatrix()) {
-                // We probably didn't execute scene.render() yet, so make sure we have a view/projection matrix setup for the scene
-                scene.updateTransformMatrix();
-            }
-            const numLayers = this.is2DArray || this.is3D ? this.getRenderLayers() : this.isCube ? 6 : 1;
-            for (let layer = 0; layer < numLayers && returnValue; layer++) {
-                let currentRenderList = null;
-                const defaultRenderList = this.renderList ? this.renderList : scene.getActiveMeshes().data;
-                const defaultRenderListLength = this.renderList ? this.renderList.length : scene.getActiveMeshes().length;
-                engine.currentRenderPassId = this._renderPassIds[layer];
-                this.onBeforeRenderObservable.notifyObservers(layer);
-                if (this.getCustomRenderList) {
-                    currentRenderList = this.getCustomRenderList(layer, defaultRenderList, defaultRenderListLength);
-                }
-                if (!currentRenderList) {
-                    currentRenderList = defaultRenderList;
-                }
-                if (!this._doNotChangeAspectRatio) {
-                    scene.updateTransformMatrix(true);
-                }
-                for (let i = 0; i < currentRenderList.length && returnValue; ++i) {
-                    const mesh = currentRenderList[i];
-                    if (!mesh.isEnabled() || mesh.isBlocked || !mesh.isVisible || !mesh.subMeshes) {
-                        continue;
-                    }
-                    if (this.customIsReadyFunction) {
-                        if (!this.customIsReadyFunction(mesh, this.refreshRate, checkReadiness)) {
-                            returnValue = false;
-                            continue;
-                        }
-                    }
-                    else if (!mesh.isReady(true)) {
-                        returnValue = false;
-                        continue;
-                    }
-                }
-                this.onAfterRenderObservable.notifyObservers(layer);
-                if (this.is2DArray || this.is3D || this.isCube) {
-                    scene.incrementRenderId();
-                    scene.resetCachedMaterial();
-                }
-            }
-            const particleSystems = this.particleSystemList || scene.particleSystems;
-            for (const particleSystem of particleSystems) {
-                if (!particleSystem.isReady()) {
-                    returnValue = false;
-                }
-            }
+            this._renderToTarget(0, useCameraPostProcess, dumpForDebug);
         }
         this.onAfterUnbindObservable.notifyObservers(this);
-        engine.currentRenderPassId = currentRenderPassId;
-        scene.activeCamera = sceneCamera;
-        if (sceneCamera) {
-            if (this.activeCamera && this.activeCamera !== scene.activeCamera) {
-                scene.setTransformMatrix(sceneCamera.getViewMatrix(), sceneCamera.getProjectionMatrix(true));
-            }
-            engine.setViewport(sceneCamera.viewport);
-        }
-        scene.resetCachedMaterial();
-        return returnValue;
+        this._objectRenderer.finishRender();
     }
     _bestReflectionRenderTargetDimension(renderDimension, scale) {
         const minimum = 128;
@@ -730,79 +718,6 @@ export class RenderTargetTexture extends Texture {
         // Ensure we don't exceed the render dimension (while staying POT)
         return Math.min(FloorPOT(renderDimension), curved);
     }
-    _prepareRenderingManager(currentRenderList, currentRenderListLength, camera, checkLayerMask) {
-        const scene = this.getScene();
-        if (!scene) {
-            return;
-        }
-        this._renderingManager.reset();
-        const sceneRenderId = scene.getRenderId();
-        for (let meshIndex = 0; meshIndex < currentRenderListLength; meshIndex++) {
-            const mesh = currentRenderList[meshIndex];
-            if (mesh && !mesh.isBlocked) {
-                if (this.customIsReadyFunction) {
-                    if (!this.customIsReadyFunction(mesh, this.refreshRate, false)) {
-                        this.resetRefreshCounter();
-                        continue;
-                    }
-                }
-                else if (!mesh.isReady(this.refreshRate === 0)) {
-                    this.resetRefreshCounter();
-                    continue;
-                }
-                if (!mesh._internalAbstractMeshDataInfo._currentLODIsUpToDate && camera) {
-                    mesh._internalAbstractMeshDataInfo._currentLOD = scene.customLODSelector ? scene.customLODSelector(mesh, camera) : mesh.getLOD(camera);
-                    mesh._internalAbstractMeshDataInfo._currentLODIsUpToDate = true;
-                }
-                if (!mesh._internalAbstractMeshDataInfo._currentLOD) {
-                    continue;
-                }
-                let meshToRender = mesh._internalAbstractMeshDataInfo._currentLOD;
-                if (meshToRender !== mesh && meshToRender.billboardMode !== 0) {
-                    meshToRender.computeWorldMatrix(); // Compute world matrix if LOD is billboard
-                }
-                meshToRender._preActivateForIntermediateRendering(sceneRenderId);
-                let isMasked;
-                if (checkLayerMask && camera) {
-                    isMasked = (mesh.layerMask & camera.layerMask) === 0;
-                }
-                else {
-                    isMasked = false;
-                }
-                if (mesh.isEnabled() && mesh.isVisible && mesh.subMeshes && !isMasked) {
-                    if (meshToRender !== mesh) {
-                        meshToRender._activate(sceneRenderId, true);
-                    }
-                    if (mesh._activate(sceneRenderId, true) && mesh.subMeshes.length) {
-                        if (!mesh.isAnInstance) {
-                            meshToRender._internalAbstractMeshDataInfo._onlyForInstancesIntermediate = false;
-                        }
-                        else {
-                            if (mesh._internalAbstractMeshDataInfo._actAsRegularMesh) {
-                                meshToRender = mesh;
-                            }
-                        }
-                        meshToRender._internalAbstractMeshDataInfo._isActiveIntermediate = true;
-                        scene._prepareSkeleton(meshToRender);
-                        for (let subIndex = 0; subIndex < meshToRender.subMeshes.length; subIndex++) {
-                            const subMesh = meshToRender.subMeshes[subIndex];
-                            this._renderingManager.dispatch(subMesh, meshToRender);
-                        }
-                    }
-                    mesh._postActivate();
-                }
-            }
-        }
-        const particleSystems = this.particleSystemList || scene.particleSystems;
-        for (let particleIndex = 0; particleIndex < particleSystems.length; particleIndex++) {
-            const particleSystem = particleSystems[particleIndex];
-            const emitter = particleSystem.emitter;
-            if (!particleSystem.isStarted() || !emitter || (emitter.position && !emitter.isEnabled())) {
-                continue;
-            }
-            this._renderingManager.dispatchParticles(particleSystem);
-        }
-    }
     /**
      * @internal
      * @param faceIndex face index to bind to if this is a cubetexture
@@ -839,113 +754,20 @@ export class RenderTargetTexture extends Texture {
             this._bindFrameBuffer(faceIndex, layer);
         }
     }
-    _renderToTarget(faceIndex, useCameraPostProcess, dumpForDebug, layer = 0, camera = null) {
+    _renderToTarget(faceIndex, useCameraPostProcess, dumpForDebug, layer = 0) {
         const scene = this.getScene();
         if (!scene) {
             return;
         }
         const engine = scene.getEngine();
-        // Bind
+        this._currentFaceIndex = faceIndex;
+        this._currentLayer = layer;
+        this._currentUseCameraPostProcess = useCameraPostProcess;
+        this._currentDumpForDebug = dumpForDebug;
         this._prepareFrame(scene, faceIndex, layer, useCameraPostProcess);
         engine._debugPushGroup?.(`render to face #${faceIndex} layer #${layer}`, 2);
-        if (this.is2DArray || this.is3D) {
-            engine.currentRenderPassId = this._renderPassIds[layer];
-            this.onBeforeRenderObservable.notifyObservers(layer);
-        }
-        else {
-            engine.currentRenderPassId = this._renderPassIds[faceIndex];
-            this.onBeforeRenderObservable.notifyObservers(faceIndex);
-        }
-        const fastPath = engine.snapshotRendering && engine.snapshotRenderingMode === 1;
-        if (!fastPath) {
-            // Get the list of meshes to render
-            let currentRenderList = null;
-            const defaultRenderList = this.renderList ? this.renderList : scene.getActiveMeshes().data;
-            const defaultRenderListLength = this.renderList ? this.renderList.length : scene.getActiveMeshes().length;
-            if (this.getCustomRenderList) {
-                currentRenderList = this.getCustomRenderList(this.is2DArray || this.is3D ? layer : faceIndex, defaultRenderList, defaultRenderListLength);
-            }
-            if (!currentRenderList) {
-                // No custom render list provided, we prepare the rendering for the default list, but check
-                // first if we did not already performed the preparation before so as to avoid re-doing it several times
-                if (!this._defaultRenderListPrepared) {
-                    this._prepareRenderingManager(defaultRenderList, defaultRenderListLength, camera, !this.renderList || this.forceLayerMaskCheck);
-                    this._defaultRenderListPrepared = true;
-                }
-                currentRenderList = defaultRenderList;
-            }
-            else {
-                // Prepare the rendering for the custom render list provided
-                this._prepareRenderingManager(currentRenderList, currentRenderList.length, camera, this.forceLayerMaskCheck);
-            }
-            // Before clear
-            for (const step of scene._beforeRenderTargetClearStage) {
-                step.action(this, faceIndex, layer);
-            }
-            // Clear
-            if (this.onClearObservable.hasObservers()) {
-                this.onClearObservable.notifyObservers(engine);
-            }
-            else if (!this.skipInitialClear) {
-                engine.clear(this.clearColor || scene.clearColor, true, true, true);
-            }
-            if (!this._doNotChangeAspectRatio) {
-                scene.updateTransformMatrix(true);
-            }
-            // Before Camera Draw
-            for (const step of scene._beforeRenderTargetDrawStage) {
-                step.action(this, faceIndex, layer);
-            }
-            // Render
-            this._renderingManager.render(this.customRenderFunction, currentRenderList, this.renderParticles, this.renderSprites);
-            // After Camera Draw
-            for (const step of scene._afterRenderTargetDrawStage) {
-                step.action(this, faceIndex, layer);
-            }
-            const saveGenerateMipMaps = this._texture?.generateMipMaps ?? false;
-            if (this._texture) {
-                this._texture.generateMipMaps = false; // if left true, the mipmaps will be generated (if this._texture.generateMipMaps = true) when the first post process binds its own RTT: by doing so it will unbind the current RTT,
-                // which will trigger a mipmap generation. We don't want this because it's a wasted work, we will do an unbind of the current RTT at the end of the process (see unbindFrameBuffer) which will
-                // trigger the generation of the final mipmaps
-            }
-            if (this._postProcessManager) {
-                this._postProcessManager._finalizeFrame(false, this._renderTarget ?? undefined, faceIndex, this._postProcesses, this.ignoreCameraViewport);
-            }
-            else if (useCameraPostProcess) {
-                scene.postProcessManager._finalizeFrame(false, this._renderTarget ?? undefined, faceIndex);
-            }
-            for (const step of scene._afterRenderTargetPostProcessStage) {
-                step.action(this, faceIndex, layer);
-            }
-            if (this._texture) {
-                this._texture.generateMipMaps = saveGenerateMipMaps;
-            }
-            if (!this._doNotChangeAspectRatio) {
-                scene.updateTransformMatrix(true);
-            }
-            // Dump ?
-            if (dumpForDebug) {
-                if (!this._dumpTools) {
-                    Logger.Error("dumpTools module is still being loaded. To speed up the process import dump tools directly in your project");
-                }
-                else {
-                    this._dumpTools.DumpFramebuffer(this.getRenderWidth(), this.getRenderHeight(), engine);
-                }
-            }
-        }
-        else {
-            // Clear
-            if (this.onClearObservable.hasObservers()) {
-                this.onClearObservable.notifyObservers(engine);
-            }
-            else {
-                if (!this.skipInitialClear) {
-                    engine.clear(this.clearColor || scene.clearColor, true, true, true);
-                }
-            }
-        }
+        this._objectRenderer.render(faceIndex + layer, true); // only faceIndex or layer (if any) will be different from 0 (we don't support array of cubes), so it's safe to add them to get the pass index
         engine._debugPopGroup?.(2);
-        // Unbind
         this._unbindFrameBuffer(engine, faceIndex);
         if (this._texture && this.isCube && faceIndex === 5) {
             engine.generateMipMapsForCubemap(this._texture, true);
@@ -961,7 +783,7 @@ export class RenderTargetTexture extends Texture {
      * @param transparentSortCompareFn The transparent queue comparison function use to sort.
      */
     setRenderingOrder(renderingGroupId, opaqueSortCompareFn = null, alphaTestSortCompareFn = null, transparentSortCompareFn = null) {
-        this._renderingManager.setRenderingOrder(renderingGroupId, opaqueSortCompareFn, alphaTestSortCompareFn, transparentSortCompareFn);
+        this._objectRenderer.setRenderingOrder(renderingGroupId, opaqueSortCompareFn, alphaTestSortCompareFn, transparentSortCompareFn);
     }
     /**
      * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
@@ -970,8 +792,7 @@ export class RenderTargetTexture extends Texture {
      * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
      */
     setRenderingAutoClearDepthStencil(renderingGroupId, autoClearDepthStencil) {
-        this._renderingManager.setRenderingAutoClearDepthStencil(renderingGroupId, autoClearDepthStencil);
-        this._renderingManager._useSceneAutoClearSetup = false;
+        this._objectRenderer.setRenderingAutoClearDepthStencil(renderingGroupId, autoClearDepthStencil);
     }
     /**
      * Clones the texture.
@@ -1027,10 +848,8 @@ export class RenderTargetTexture extends Texture {
     dispose() {
         this.onResizeObservable.clear();
         this.onClearObservable.clear();
-        this.onAfterRenderObservable.clear();
         this.onAfterUnbindObservable.clear();
         this.onBeforeBindObservable.clear();
-        this.onBeforeRenderObservable.clear();
         if (this._postProcessManager) {
             this._postProcessManager.dispose();
             this._postProcessManager = null;
@@ -1038,13 +857,12 @@ export class RenderTargetTexture extends Texture {
         if (this._prePassRenderTarget) {
             this._prePassRenderTarget.dispose();
         }
-        this._releaseRenderPassId();
+        this._objectRenderer.dispose();
         this.clearPostProcesses(true);
         if (this._resizeObserver) {
             this.getScene().getEngine().onResizeObservable.remove(this._resizeObserver);
             this._resizeObserver = null;
         }
-        this.renderList = null;
         // Remove from custom render targets
         const scene = this.getScene();
         if (!scene) {
@@ -1067,9 +885,7 @@ export class RenderTargetTexture extends Texture {
     }
     /** @internal */
     _rebuild() {
-        if (this.refreshRate === RenderTargetTexture.REFRESHRATE_RENDER_ONCE) {
-            this.refreshRate = RenderTargetTexture.REFRESHRATE_RENDER_ONCE;
-        }
+        this._objectRenderer._rebuild();
         if (this._postProcessManager) {
             this._postProcessManager._rebuild();
         }
@@ -1078,9 +894,7 @@ export class RenderTargetTexture extends Texture {
      * Clear the info related to rendering groups preventing retention point in material dispose.
      */
     freeRenderingGroups() {
-        if (this._renderingManager) {
-            this._renderingManager.freeRenderingGroups();
-        }
+        this._objectRenderer.freeRenderingGroups();
     }
     /**
      * Gets the number of views the corresponding to the texture (eg. a MultiviewRenderTarget will have > 1)
@@ -1093,16 +907,16 @@ export class RenderTargetTexture extends Texture {
 /**
  * The texture will only be rendered once which can be useful to improve performance if everything in your render is static for instance.
  */
-RenderTargetTexture.REFRESHRATE_RENDER_ONCE = 0;
+RenderTargetTexture.REFRESHRATE_RENDER_ONCE = ObjectRenderer.REFRESHRATE_RENDER_ONCE;
 /**
- * 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.
  */
-RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYFRAME = 1;
+RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYFRAME = ObjectRenderer.REFRESHRATE_RENDER_ONEVERYFRAME;
 /**
  * The texture will be rendered every 2 frames which could be enough if your dynamic objects are not
  * the central point of your effect and can save a lot of performances.
  */
-RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYTWOFRAMES = 2;
+RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYTWOFRAMES = ObjectRenderer.REFRESHRATE_RENDER_ONEVERYTWOFRAMES;
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 Texture._CreateRenderTargetTexture = (name, renderTargetSize, scene, generateMipMaps, creationFlags) => {
     return new RenderTargetTexture(name, renderTargetSize, scene, generateMipMaps);