fixing stencil

src/Materials/Textures/multiRenderTarget.ts

@@ -166,8 +166,10 @@ export class MultiRenderTarget extends RenderTargetTexture {
 
         this._count = count;
 
-        this._createInternalTextures();
-        this._createTextures();
+        if (count > 0) {
+            this._createInternalTextures();
+            this._createTextures();
+        }
     }
 
     private _initTypes(count: number, types: number[], samplingModes: number[], options?: IMultiRenderTargetOptions) {

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/Materials/materialHelper.ts

@@ -348,7 +348,7 @@ export class MaterialHelper {
             index: "PREPASS_DEPTHNORMAL_INDEX",
         }];
 
-        if (scene.prePassRenderer && scene.prePassRenderer.enabled && scene.prePassRenderer.getRenderTarget().enabled && canRenderToMRT) {
+        if (scene.prePassRenderer && scene.prePassRenderer.enabled && canRenderToMRT) {
             defines.PREPASS = true;
             defines.SCENE_MRT_COUNT = scene.prePassRenderer.mrtCount;
 

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
      */
@@ -209,7 +209,7 @@ export class PrePassRenderer {
 
     public _createRenderTarget(name: string, renderTargetTexture: Nullable<RenderTargetTexture>) : PrePassRenderTarget {
         const rt = new PrePassRenderTarget(name, renderTargetTexture, { width: this._engine.getRenderWidth(), height: this._engine.getRenderHeight() }, 0, this._scene,
-            { generateMipMaps: false, generateDepthTexture: true, defaultType: Constants.TEXTURETYPE_UNSIGNED_INT, types: [] });
+            { generateMipMaps: false, generateStencilBuffer: true, defaultType: Constants.TEXTURETYPE_UNSIGNED_INT, types: [] });
         rt.samples = 1;
 
         this.renderTargets.push(rt);
@@ -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());
+                    }
+                }
             }
         }
     }
@@ -344,17 +343,16 @@ export class PrePassRenderer {
         if (previousEnabled && (!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;
         }
@@ -385,10 +383,10 @@ export class PrePassRenderer {
 
         // Activates and renders the chain
         if (postProcessChain.length) {
+            // Do not mess with stencil
             this._scene.postProcessManager._prepareFrame(this._currentTarget.getInternalTexture()!, postProcessChain);
             this._scene.postProcessManager.directRender(postProcessChain, outputTexture, false, faceIndex);
         }
-
     }
 
     /**
@@ -412,13 +410,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);
         }
     }
 
@@ -437,13 +430,11 @@ export class PrePassRenderer {
     }
 
     private _setRenderTargetState(prePassRenderTarget: PrePassRenderTarget, enabled: boolean) {
-        for (let i = 0; i < this.renderTargets.length; i++) {
-            prePassRenderTarget.enabled = enabled;
+        prePassRenderTarget.enabled = enabled;
 
-            if (prePassRenderTarget.imageProcessingPostProcess) {
-                prePassRenderTarget.imageProcessingPostProcess.imageProcessingConfiguration.applyByPostProcess = enabled;
-            }  
-        }
+        if (prePassRenderTarget.imageProcessingPostProcess) {
+            prePassRenderTarget.imageProcessingPostProcess.imageProcessingConfiguration.applyByPostProcess = enabled;
+        }  
     }
 
     /**
@@ -474,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++) {
@@ -520,16 +512,6 @@ export class PrePassRenderer {
         }
     }
 
-    // private _bindPostProcessChain() {
-    //     if (this._postProcesses.length) {
-    //         this._postProcesses[0].inputTexture = this.defaultRT.getInternalTexture()!;
-    //     } else {
-    //         const pp = this._scene.activeCamera?._getFirstPostProcess();
-    //         if (pp) {
-    //             pp.inputTexture = this.defaultRT.getInternalTexture()!;
-    //         }
-    //     }
-    // }
     private _getPostProcessesSource(prePassRenderTarget: PrePassRenderTarget, camera?: Camera) : Nullable<PostProcess>[] {
         if (camera) {
             return camera._postProcesses;
@@ -561,7 +543,6 @@ export class PrePassRenderer {
         const firstPrePassPP = prePassRenderTarget._beforeCompositionPostProcesses && prePassRenderTarget._beforeCompositionPostProcesses[0];
         let firstPP = null;
 
-
         // Setting the prePassRenderTarget as input texture of the first PP
         if (firstPrePassPP) {
             firstPrePassPP.inputTexture = prePassRenderTarget.getInternalTexture()!;
@@ -640,9 +621,11 @@ export class PrePassRenderer {
             if (this._scene.materials[i].setPrePassRenderer(this)) {
                 enablePrePass = true;
 
-                for (let j = 0; j < this.renderTargets.length; j++) {
-                    this._setRenderTargetState(this.renderTargets[j], true);
-                }
+                this._setRenderTargetState(this.defaultRT, true);
+                // TODO : desactivate sss for render targets
+                // for (let j = 0; j < this.renderTargets.length; j++) {
+                //     this._setRenderTargetState(this.renderTargets[j], true);
+                // }
             }
         }
 

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

@@ -47,9 +47,9 @@ export class SceneComponentConstants {
 
     public static readonly STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER = 1;
 
-    public static readonly STEP_BEFORECAMERADRAW_EFFECTLAYER = 0;
-    public static readonly STEP_BEFORECAMERADRAW_LAYER = 1;
-    public static readonly STEP_BEFORECAMERADRAW_PREPASS = 2;
+    public static readonly STEP_BEFORECAMERADRAW_PREPASS = 0;
+    public static readonly STEP_BEFORECAMERADRAW_EFFECTLAYER = 1;
+    public static readonly STEP_BEFORECAMERADRAW_LAYER = 2;
 
     public static readonly STEP_BEFORERENDERTARGETDRAW_PREPASS = 0;
     public static readonly STEP_BEFORERENDERTARGETDRAW_LAYER = 1;
@@ -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;