.

src/Materials/Textures/prePassRenderTarget.ts

@@ -76,8 +76,17 @@ export class PrePassRenderTarget extends MultiRenderTarget {
      * Checks that the size of this RT is still adapted to the desired render size.
      */
     public _checkSize() {
-        var requiredWidth = this._engine.getRenderWidth(true);
-        var requiredHeight = this._engine.getRenderHeight(true);
+        var requiredWidth;
+        var requiredHeight;
+
+        if (this.renderTargetTexture) {
+        	requiredWidth = this.renderTargetTexture.getRenderWidth();
+        	requiredHeight = this.renderTargetTexture.getRenderHeight();
+        } else {
+        	requiredWidth = this._engine.getRenderWidth(true);
+        	requiredHeight = this._engine.getRenderHeight(true);
+        }
+        
         var width = this.getRenderWidth();
         var height = this.getRenderHeight();
 

src/Materials/Textures/renderTargetTexture.ts

@@ -849,7 +849,9 @@ export class RenderTargetTexture extends Texture {
 
     public _prepareFrame(scene: Scene, faceIndex?: number, layer?: number, useCameraPostProcess?: boolean) {
         if (this._postProcessManager) {
-            this._postProcessManager._prepareFrame(this._texture, this._postProcesses);
+            if (!this._prePass) {
+                this._postProcessManager._prepareFrame(this._texture, this._postProcesses);
+            }
         }
         else if (!useCameraPostProcess || !scene.postProcessManager._prepareFrame(this._texture)) {
             this._bindFrameBuffer(faceIndex, layer);
@@ -870,9 +872,7 @@ export class RenderTargetTexture extends Texture {
         }
 
         // Bind
-        if (!this._prePass) {
-            this._prepareFrame(scene, faceIndex, layer, useCameraPostProcess);
-        }
+        this._prepareFrame(scene, faceIndex, layer, useCameraPostProcess);
 
         if (this.is2DArray) {
             this.onBeforeRenderObservable.notifyObservers(layer);
@@ -903,13 +903,16 @@ export class RenderTargetTexture extends Texture {
             this._prepareRenderingManager(currentRenderList, currentRenderList.length, camera, false);
         }
 
+        // Before clear
+        for (let step of scene._beforeRenderTargetClearStage) {
+            step.action(this, faceIndex, layer);
+        }
+
         // Clear
         if (this.onClearObservable.hasObservers()) {
             this.onClearObservable.notifyObservers(engine);
         } else {
-            if (!this._prePass) {
-                engine.clear(this.clearColor || scene.clearColor, true, true, true);
-            }
+            engine.clear(this.clearColor || scene.clearColor, true, true, true);
         }
 
         if (!this._doNotChangeAspectRatio) {

src/Rendering/prePassRenderer.ts

@@ -47,13 +47,13 @@ export class PrePassRenderer {
      */
     public mrtCount: number = 0;
 
-    public _mrtFormats: number[] = [];
-    public _mrtLayout: number[];
-    public _textureIndices: number[] = [];
+    private _mrtFormats: number[] = [];
+    private _mrtLayout: number[];
+    private _textureIndices: number[] = [];
 
-    public _multiRenderAttachments: number[];
-    public _defaultAttachments: number[];
-    public _clearAttachments: number[];
+    private _multiRenderAttachments: number[];
+    private _defaultAttachments: number[];
+    private _clearAttachments: number[];
 
     /**
      * Returns the index of a texture in the multi render target texture array.
@@ -103,7 +103,6 @@ export class PrePassRenderer {
     public defaultRT: PrePassRenderTarget;
 
     /**
-     * TODO : public ?
      * Configuration for prepass effects
      */
     private _effectConfigurations: PrePassEffectConfiguration[] = [];
@@ -133,8 +132,9 @@ export class PrePassRenderer {
         return this._currentTarget === this.defaultRT;
     }
 
-    public _geometryBuffer: Nullable<GeometryBufferRenderer>;
-    public _useGeometryBufferFallback = false;
+    private _geometryBuffer: Nullable<GeometryBufferRenderer>;
+    private _useGeometryBufferFallback = true;
+
     /**
      * Uses the geometry buffer renderer as a fallback for non prepass capable effects
      */
@@ -235,13 +235,12 @@ export class PrePassRenderer {
             } else {
                 this._engine.bindAttachments(this._defaultAttachments);
 
-                // TODO : geometry buffer renderer
-                // if (this._geometryBuffer) {
-                //     const material = subMesh.getMaterial();
-                //     if (material && this.excludedMaterials.indexOf(material) === -1) {
-                //         this._geometryBuffer.renderList!.push(subMesh.getRenderingMesh());
-                //     }
-                // }
+                if (this._geometryBuffer && this.currentRTisSceneRT) {
+                    const material = subMesh.getMaterial();
+                    if (material && this.excludedMaterials.indexOf(material) === -1) {
+                        this._geometryBuffer.renderList!.push(subMesh.getRenderingMesh());
+                    }
+                }
             }
         }
     }
@@ -342,17 +341,16 @@ export class PrePassRenderer {
         if (!this._enabled || !this._currentTarget.enabled) {
             // Prepass disabled, we render only on 1 color attachment
             if (texture) {
-                texture._prepareFrame(this._scene, faceIndex, layer, texture.useCameraPostProcesses);
-                this._engine.restoreSingleAttachmentForRenderTarget();
+                // this._engine.restoreSingleAttachment();
+                // texture._prepareFrame(this._scene, faceIndex, layer, texture.useCameraPostProcesses);
             } else {
-                this._engine.restoreDefaultFramebuffer();
-                this._engine.restoreSingleAttachment();
+                // this._engine.restoreDefaultFramebuffer();
+                // this._engine.restoreSingleAttachment();
             }
 
             return;
         }
 
-        // TODO : handle geometry buffer renderer fallback
         if (this._geometryBuffer) {
             this._geometryBuffer.renderList!.length = 0;
         }
@@ -410,13 +408,8 @@ export class PrePassRenderer {
             // Clearing other attachment with 0 on all other attachments
             this._engine.bindAttachments(this._clearAttachments);
             this._engine.clear(this._clearColor, true, false, false);
-
             // Regular clear color with the scene clear color of the 1st attachment
             this._engine.bindAttachments(this._defaultAttachments);
-            this._engine.clear(this._scene.clearColor,
-                this._scene.autoClear || this._scene.forceWireframe || this._scene.forcePointsCloud,
-                this._scene.autoClearDepthAndStencil,
-                this._scene.autoClearDepthAndStencil);
         }
     }
 
@@ -433,7 +426,6 @@ export class PrePassRenderer {
     private _setState(enabled: boolean) {
         this._enabled = enabled;
 
-        // TODO : enable/disable per texture
         for (let i = 0; i < this.renderTargets.length; i++) {
             const prePassRenderTarget = this.renderTargets[i];
 
@@ -473,12 +465,13 @@ export class PrePassRenderer {
             }
         }
 
+        this._updateGeometryBufferLayout();
+
         for (let i = 0; i < this.renderTargets.length; i++) {
             if (this.mrtCount !== previousMrtCount) {
                 this.renderTargets[i].updateCount(this.mrtCount, { types: this._mrtFormats });
             }
-            // TODO : gbr
-            this._updateGeometryBufferLayout();
+
             this.renderTargets[i]._resetPostProcessChain();
 
             for (let j = 0; j < this._effectConfigurations.length; j++) {

src/Rendering/prePassRendererSceneComponent.ts

@@ -112,6 +112,7 @@ export class PrePassRendererSceneComponent implements ISceneComponent {
         this.scene._afterRenderTargetDrawStage.registerStep(SceneComponentConstants.STEP_AFTERCAMERADRAW_PREPASS, this, this._afterRenderTargetDraw);
 
         this.scene._beforeClearStage.registerStep(SceneComponentConstants.STEP_BEFORECLEARSTAGE_PREPASS, this, this._beforeClearStage);
+        this.scene._beforeRenderTargetClearStage.registerStep(SceneComponentConstants.STEP_BEFORERENDERTARGETCLEARSTAGE_PREPASS, this, this._beforeRenderTargetClearStage);
 
         this.scene._beforeRenderingMeshStage.registerStep(SceneComponentConstants.STEP_BEFORERENDERINGMESH_PREPASS, this, this._beforeRenderingMeshStage);
         this.scene._afterRenderingMeshStage.registerStep(SceneComponentConstants.STEP_AFTERRENDERINGMESH_PREPASS, this, this._afterRenderingMeshStage);
@@ -123,7 +124,6 @@ export class PrePassRendererSceneComponent implements ISceneComponent {
                 renderTarget._prePassRenderTarget = this.scene.prePassRenderer._createRenderTarget(renderTarget.name + "_prePassRTT", renderTarget);
             }
             this.scene.prePassRenderer._setRenderTarget(renderTarget._prePassRenderTarget);
-            this.scene.prePassRenderer._clear();
             this.scene.prePassRenderer._beforeDraw(undefined, faceIndex, layer);
         }
     }
@@ -134,6 +134,13 @@ export class PrePassRendererSceneComponent implements ISceneComponent {
         }
     }
 
+    private _beforeRenderTargetClearStage(renderTarget: RenderTargetTexture, faceIndex?: number, layer?: number) {
+        if (this.scene.prePassRenderer) {
+            this.scene.prePassRenderer._setRenderTarget(renderTarget._prePassRenderTarget);
+            this.scene.prePassRenderer._clear();
+        }
+    }
+
     private _beforeCameraDraw(camera: Camera) {
         if (this.scene.prePassRenderer) {
             this.scene.prePassRenderer._setRenderTarget(null);

src/scene.ts

@@ -1286,6 +1286,11 @@ export class Scene extends AbstractScene implements IAnimatable, IClipPlanesHold
     public _beforeClearStage = Stage.Create<SimpleStageAction>();
     /**
      * @hidden
+     * Defines the actions happening before clear the canvas.
+     */
+    public _beforeRenderTargetClearStage = Stage.Create<RenderTargetStageAction>();
+    /**
+     * @hidden
      * Defines the actions when collecting render targets for the frame.
      */
     public _gatherRenderTargetsStage = Stage.Create<RenderTargetsStageAction>();
@@ -3671,7 +3676,7 @@ export class Scene extends AbstractScene implements IAnimatable, IClipPlanesHold
         this.setTransformMatrix(this.activeCamera.getViewMatrix(), this.activeCamera.getProjectionMatrix(force));
     }
 
-    private _bindFrameBuffer() {
+    public _bindFrameBuffer() {
         if (this.activeCamera && this.activeCamera._multiviewTexture) {
             this.activeCamera._multiviewTexture._bindFrameBuffer();
         } else if (this.activeCamera && this.activeCamera.outputRenderTarget) {
@@ -4073,7 +4078,7 @@ export class Scene extends AbstractScene implements IAnimatable, IClipPlanesHold
         }
 
         // Clear
-        if ((this.autoClearDepthAndStencil || this.autoClear) && !this.prePass) {
+        if (this.autoClearDepthAndStencil || this.autoClear) {
             this._engine.clear(this.clearColor,
                 this.autoClear || this.forceWireframe || this.forcePointsCloud,
                 this.autoClearDepthAndStencil,

src/sceneComponent.ts

@@ -87,6 +87,7 @@ export class SceneComponentConstants {
     public static readonly STEP_GATHERACTIVECAMERARENDERTARGETS_DEPTHRENDERER = 0;
 
     public static readonly STEP_BEFORECLEARSTAGE_PREPASS = 0;
+    public static readonly STEP_BEFORERENDERTARGETCLEARSTAGE_PREPASS = 0;
 
     public static readonly STEP_POINTERMOVE_SPRITE = 0;
     public static readonly STEP_POINTERDOWN_SPRITE = 0;