Merge pull request #3623 from TrevorDev/properlyUsePostProcessRenderEffect

Remove postProcessRenderPass and properly use post process render effect

Tools/Gulp/config.json

@@ -841,7 +841,6 @@
         "renderingPipeline": {
             "files": [
                 "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js",
-                "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js",
                 "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js",
                 "../../src/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js"
             ],

dist/preview release/what's new.md

@@ -43,3 +43,4 @@
 - Fixed a bug with merging vertex data ([bghgary](https://github.com/bghgary))
 
 ## Breaking changes
+- Removed unused PostProcessRenderPass class and extended postProcessingRenderingEffect to support multiple PostProcesses ([trevordev](https://github.com/trevordev))

src/PostProcess/RenderPipeline/Pipelines/babylon.defaultRenderingPipeline.ts

@@ -242,7 +242,8 @@
             }
 
             if(this.depthOfFieldEnabled){
-                this.depthOfField = new DepthOfFieldEffect(this, this._scene, this._cameras[0], this._defaultPipelineTextureType);
+                this.depthOfField = new DepthOfFieldEffect(this._scene, this._defaultPipelineTextureType);
+                this.addEffect(this.depthOfField);
             }
 
             if (this._imageProcessingEnabled) {

src/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.ts

@@ -1,22 +1,21 @@
 module BABYLON {
     export class PostProcessRenderEffect {
         private _postProcesses: any;
-        private _getPostProcess: () => Nullable<PostProcess>;
+        private _getPostProcess: () => Nullable<PostProcess | Array<PostProcess>>;
 
         private _singleInstance: boolean;
 
         private _cameras: { [key: string]: Nullable<Camera> };
         private _indicesForCamera: { [key: string]: number[] };
 
-        private _renderPasses: any;
         private _renderEffectAsPasses: any;
 
         // private
         public _name: string;
 
         public applyParameters: (postProcess: PostProcess) => void;
-
-        constructor(engine: Engine, name: string, getPostProcess: () => Nullable<PostProcess>, singleInstance?: boolean) {
+        
+        constructor(engine: Engine, name: string, getPostProcess: () => Nullable<PostProcess | Array<PostProcess>>, singleInstance?: boolean) {
             this._name = name;
             this._singleInstance = singleInstance || true;
 
@@ -27,59 +26,28 @@ module BABYLON {
 
             this._postProcesses = {};
 
-            this._renderPasses = {};
             this._renderEffectAsPasses = {};
         }
 
         public get isSupported(): boolean {
             for (var index in this._postProcesses) {
-                if (!this._postProcesses[index].isSupported) {
-                    return false;
+                for(var ppIndex in this._postProcesses[index]){
+                    if (!this._postProcesses[index][ppIndex].isSupported) {
+                        return false;
+                    }
                 }
             }
             return true;
         }
 
         public _update(): void {
-            for (var renderPassName in this._renderPasses) {
-                this._renderPasses[renderPassName]._update();
-            }
-        }
-
-        public addPass(renderPass: PostProcessRenderPass): void {
-            this._renderPasses[renderPass._name] = renderPass;
-
-            this._linkParameters();
-        }
-
-        public removePass(renderPass: PostProcessRenderPass): void {
-            delete this._renderPasses[renderPass._name];
-
-            this._linkParameters();
         }
-
         public addRenderEffectAsPass(renderEffect: PostProcessRenderEffect): void {
             this._renderEffectAsPasses[renderEffect._name] = renderEffect;
 
             this._linkParameters();
         }
 
-        public getPass(passName: string): Nullable<PostProcessRenderPass> {
-            for (var renderPassName in this._renderPasses) {
-                if (renderPassName === passName) {
-                    return this._renderPasses[passName];
-                }
-            }
-
-            return null;
-        }
-
-        public emptyPasses(): void {
-            this._renderPasses = {};
-
-            this._linkParameters();
-        }
-
         // private
         public _attachCameras(cameras: Camera): void;
         public _attachCameras(cameras: Camera[]): void;
@@ -103,23 +71,27 @@ module BABYLON {
                     cameraKey = cameraName;
                 }
 
-                this._postProcesses[cameraKey] = this._postProcesses[cameraKey] || this._getPostProcess();
-
-                var index = camera.attachPostProcess(this._postProcesses[cameraKey]);
+                if(!this._postProcesses[cameraKey]){
+                    var postProcess = this._getPostProcess();
+                    if(postProcess){
+                        this._postProcesses[cameraKey] = Array.isArray(postProcess) ? postProcess :[postProcess];
+                    }
+                }
 
                 if (!this._indicesForCamera[cameraName]) {
                     this._indicesForCamera[cameraName] = [];
                 }
 
-                this._indicesForCamera[cameraName].push(index);
-
+                this._postProcesses[cameraKey].forEach((postProcess:PostProcess) => {
+                    var index = camera.attachPostProcess(postProcess);
+    
+                    this._indicesForCamera[cameraName].push(index);
+                });
+                
                 if (!this._cameras[cameraName]) {
                     this._cameras[cameraName] = camera;
                 }
 
-                for (var passName in this._renderPasses) {
-                    this._renderPasses[passName]._incRefCount();
-                }
             }
 
             this._linkParameters();
@@ -138,17 +110,14 @@ module BABYLON {
             for (var i = 0; i < cams.length; i++) {
                 var camera: Camera = cams[i];
                 var cameraName: string = camera.name;
-
-                camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName]);
+                this._postProcesses[this._singleInstance ? 0 : cameraName].forEach((postProcess:PostProcess)=>{
+                    camera.detachPostProcess(postProcess);
+                })
 
                 if (this._cameras[cameraName]) {
                     //this._indicesForCamera.splice(index, 1);
                     this._cameras[cameraName] = null;
                 }
-
-                for (var passName in this._renderPasses) {
-                    this._renderPasses[passName]._decRefCount();
-                }
             }
         }
 
@@ -171,10 +140,6 @@ module BABYLON {
                         cameras[i].attachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName][j]);
                     }
                 }
-
-                for (var passName in this._renderPasses) {
-                    this._renderPasses[passName]._incRefCount();
-                }
             }
         }
 
@@ -193,43 +158,37 @@ module BABYLON {
                 var cameraName = camera.Name;
 
                 camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName]);
-
-                for (var passName in this._renderPasses) {
-                    this._renderPasses[passName]._decRefCount();
-                }
             }
         }
 
         public getPostProcess(camera?: Camera): Nullable<PostProcess> {
             if (this._singleInstance) {
-                return this._postProcesses[0];
+                return this._postProcesses[0][0];
             }
             else {
 
                 if (!camera) {
                     return null;
                 }
-                return this._postProcesses[camera.name];
+                return this._postProcesses[camera.name][0];
             }
         }
 
         private _linkParameters(): void {
             for (var index in this._postProcesses) {
-                if (this.applyParameters) {
-                    this.applyParameters(this._postProcesses[index]);
-                }
+                this._postProcesses[index].forEach((postProcess:PostProcess)=>{
+                    if (this.applyParameters) {
+                        this.applyParameters(postProcess);
+                    }
 
-                this._postProcesses[index].onBeforeRenderObservable.add((effect: Effect) => {
-                    this._linkTextures(effect);
+                    postProcess.onBeforeRenderObservable.add((effect: Effect) => {
+                        this._linkTextures(effect);
+                    });
                 });
             }
         }
 
         private _linkTextures(effect: Effect): void {
-            for (var renderPassName in this._renderPasses) {
-                effect.setTexture(renderPassName, this._renderPasses[renderPassName].getRenderTexture());
-            }
-
             for (var renderEffectName in this._renderEffectAsPasses) {
                 effect.setTextureFromPostProcess(renderEffectName + "Sampler", this._renderEffectAsPasses[renderEffectName].getPostProcess());
             }

src/PostProcess/RenderPipeline/babylon.postProcessRenderPass.ts

@@ -1,58 +0,0 @@
-module BABYLON {
-    export class PostProcessRenderPass {
-        private _renderList: Mesh[];
-        private _renderTexture: RenderTargetTexture;
-        private _scene: Scene;
-        private _refCount: number = 0;
-
-        // private
-        public _name: string;
-
-        constructor(scene: Scene, name: string, size: number, renderList: Mesh[], beforeRender: () => void, afterRender: () => void) {
-            this._name = name;
-
-            this._renderTexture = new RenderTargetTexture(name, size, scene);
-            this.setRenderList(renderList);
-
-            this._renderTexture.onBeforeRenderObservable.add(beforeRender);
-            this._renderTexture.onAfterRenderObservable.add(afterRender);
-
-            this._scene = scene;
-
-            this._renderList = renderList;
-        }
-
-        // private
-        public _incRefCount(): number {
-            if (this._refCount === 0) {
-                this._scene.customRenderTargets.push(this._renderTexture);
-            }
-
-            return ++this._refCount;
-        }
-
-        public _decRefCount(): number {
-            this._refCount--;
-
-            if (this._refCount <= 0) {
-                this._scene.customRenderTargets.splice(this._scene.customRenderTargets.indexOf(this._renderTexture), 1);
-            }
-
-            return this._refCount;
-        }
-
-        public _update(): void {
-            this.setRenderList(this._renderList);
-        }
-
-        // public
-
-        public setRenderList(renderList: Mesh[]): void {
-            this._renderTexture.renderList = renderList;
-        }
-
-        public getRenderTexture(): RenderTargetTexture {
-            return this._renderTexture;
-        }
-    }
-}

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.ts

@@ -1,6 +1,5 @@
 module BABYLON {
     export class PostProcessRenderPipeline {
-        private _engine: Engine;
 
         private _renderEffects: {[key: string]: PostProcessRenderEffect};
         private _renderEffectsForIsolatedPass: PostProcessRenderEffect[];
@@ -11,11 +10,7 @@ module BABYLON {
         @serialize()
         public _name: string;
 
-        private static PASS_EFFECT_NAME: string = "passEffect";
-        private static PASS_SAMPLER_NAME: string = "passSampler";
-
         constructor(engine: Engine, name: string) {
-            this._engine = engine;
             this._name = name;
 
             this._renderEffects = {};
@@ -128,76 +123,6 @@ module BABYLON {
             }
         }
 
-        public _enableDisplayOnlyPass(passName: string, cameras: Camera): void;
-        public _enableDisplayOnlyPass(passName: string, cameras: Nullable<Camera[]>): void;
-        public _enableDisplayOnlyPass(passName: string, cameras: any): void {
-            var cams = Tools.MakeArray(cameras || this._cameras);
-
-            if (!cams) {
-                return;
-            }
-
-            var pass: Nullable<PostProcessRenderPass> = null;
-            var renderEffectName;
-            for (renderEffectName in this._renderEffects) {
-                if (this._renderEffects.hasOwnProperty(renderEffectName)) {
-                    pass = this._renderEffects[renderEffectName].getPass(passName);
-
-                    if (pass != null) {
-                        break;
-                    }
-                }
-            }
-
-            if (pass === null) {
-                return;
-            }
-
-            for (renderEffectName in this._renderEffects) {
-                if (this._renderEffects.hasOwnProperty(renderEffectName)) {
-                    this._renderEffects[renderEffectName]._disable(cams);
-                }
-            }
-
-            pass._name = PostProcessRenderPipeline.PASS_SAMPLER_NAME;
-
-            for (var i = 0; i < cams.length; i++) {
-                var camera = cams[i];
-                var cameraName = camera.name;
-
-                this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME,
-                    () => {return new DisplayPassPostProcess(PostProcessRenderPipeline.PASS_EFFECT_NAME, 1.0, null, undefined, this._engine, true) });
-                this._renderEffectsForIsolatedPass[cameraName].emptyPasses();
-                this._renderEffectsForIsolatedPass[cameraName].addPass(pass);
-                this._renderEffectsForIsolatedPass[cameraName]._attachCameras(camera);
-            }
-        }
-
-        public _disableDisplayOnlyPass(cameras: Camera): void;
-        public _disableDisplayOnlyPass(cameras: Camera[]): void;
-        public _disableDisplayOnlyPass(cameras: any): void {
-            var cams = Tools.MakeArray(cameras || this._cameras);
-
-            if (!cams) {
-                return;
-            }
-
-            for (var i = 0; i < cams.length; i++) {
-                var camera = cams[i];
-                var cameraName = camera.name;
-
-                this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, 
-                                    () => {return new DisplayPassPostProcess(PostProcessRenderPipeline.PASS_EFFECT_NAME, 1.0, null, undefined, this._engine, true) });
-                this._renderEffectsForIsolatedPass[cameraName]._disable(camera);
-            }
-
-            for (var renderEffectName in this._renderEffects) {
-                if (this._renderEffects.hasOwnProperty(renderEffectName)) {
-                    this._renderEffects[renderEffectName]._enable(cams);
-                }
-            }
-        }
-
         public _update(): void {
             for (var renderEffectName in this._renderEffects) {
                 if (this._renderEffects.hasOwnProperty(renderEffectName)) {

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.ts

@@ -58,30 +58,6 @@ module BABYLON {
             renderPipeline._disableEffect(renderEffectName, cameras);
         }
 
-        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: Camera): void;
-        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: Camera[]): void;
-        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: any): void {
-            var renderPipeline: PostProcessRenderPipeline = this._renderPipelines[renderPipelineName];
-
-            if (!renderPipeline) {
-                return;
-            }
-
-            renderPipeline._enableDisplayOnlyPass(passName, cameras);
-        }
-
-        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: Camera): void;
-        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: Camera[]): void;
-        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: any): void {
-            var renderPipeline: PostProcessRenderPipeline = this._renderPipelines[renderPipelineName];
-
-            if (!renderPipeline) {
-                return;
-            }
-
-            renderPipeline._disableDisplayOnlyPass(cameras);
-        }
-
         public update(): void {
             for (var renderPipelineName in this._renderPipelines) {
                 if (this._renderPipelines.hasOwnProperty(renderPipelineName)) {

src/PostProcess/babylon.depthOfFieldEffect.ts

@@ -4,12 +4,6 @@ module BABYLON {
      * The depth of field effect applies a blur to objects that are closer or further from where the camera is focusing.
      */
     export class DepthOfFieldEffect extends PostProcessRenderEffect{
-        private readonly DepthOfFieldPassPostProcessId: string = "DepthOfFieldPassPostProcessId";
-        private readonly CircleOfConfusionPostProcessId: string = "CircleOfConfusionPostProcessEffect"; 
-        private readonly DepthOfFieldBlurXPostProcessId: string = "DepthOfFieldBlurXPostProcessEffect";
-        private readonly DepthOfFieldBlurYPostProcessId: string = "DepthOfFieldBlurYPostProcessEffect";
-        private readonly DepthOfFieldMergePostProcessId: string = "DepthOfFieldMergePostProcessEffect";
-
         private depthOfFieldPass: PassPostProcess;
         private circleOfConfusion: CircleOfConfusionPostProcess;
         private depthOfFieldBlurX: DepthOfFieldBlurPostProcess;
@@ -65,33 +59,23 @@ module BABYLON {
 
         /**
          * Creates a new instance of @see DepthOfFieldEffect
-         * @param pipeline The pipeline to add the depth of field effect to.
          * @param scene The scene the effect belongs to.
-         * @param camera The camera to apply the depth of field on.
          * @param pipelineTextureType The type of texture to be used when performing the post processing.
          */
-        constructor(pipeline: PostProcessRenderPipeline, scene: Scene, camera:Camera, pipelineTextureType = 0) {
-            super(scene.getEngine(), "depth of field", ()=>{return this.circleOfConfusion}, true);
+        constructor(scene: Scene, pipelineTextureType = 0) {
+            super(scene.getEngine(), "depth of field", ()=>{return [this.circleOfConfusion, this.depthOfFieldPass, this.depthOfFieldBlurX, this.depthOfFieldBlurY, this.depthOfFieldMerge]}, true);
             // Enable and get current depth map
             var depthMap = scene.enableDepthRenderer().getDepthMap();
             // Circle of confusion value for each pixel is used to determine how much to blur that pixel
             this.circleOfConfusion = new BABYLON.CircleOfConfusionPostProcess("circleOfConfusion", scene, depthMap, 1, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType);
-            pipeline.addEffect(new PostProcessRenderEffect(scene.getEngine(), this.CircleOfConfusionPostProcessId, () => { return this.circleOfConfusion; }, true));  
-         
             // Capture circle of confusion texture
             this.depthOfFieldPass = new PassPostProcess("depthOfFieldPass", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType);
-            pipeline.addEffect(new PostProcessRenderEffect(scene.getEngine(), this.DepthOfFieldPassPostProcessId, () => { return this.depthOfFieldPass; }, true));
-
             // Blur the image but do not blur on sharp far to near distance changes to avoid bleeding artifacts 
             // See section 2.6.2 http://fileadmin.cs.lth.se/cs/education/edan35/lectures/12dof.pdf
             this.depthOfFieldBlurY = new DepthOfFieldBlurPostProcess("verticle blur", scene, new Vector2(0, 1.0), 15, 1.0, null, depthMap, this.circleOfConfusion, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType);
-            pipeline.addEffect(new PostProcessRenderEffect(scene.getEngine(), this.DepthOfFieldBlurYPostProcessId, () => { return this.depthOfFieldBlurY; }, true));
             this.depthOfFieldBlurX = new DepthOfFieldBlurPostProcess("horizontal blur", scene, new Vector2(1.0, 0), 15, 1.0, null,  depthMap, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType);
-            pipeline.addEffect(new PostProcessRenderEffect(scene.getEngine(), this.DepthOfFieldBlurXPostProcessId, () => { return this.depthOfFieldBlurX; }, true));
-
             // Merge blurred images with original image based on circleOfConfusion
             this.depthOfFieldMerge = new DepthOfFieldMergePostProcess("depthOfFieldMerge", this.circleOfConfusion, this.depthOfFieldPass, 1, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType);
-            pipeline.addEffect(new PostProcessRenderEffect(scene.getEngine(), this.DepthOfFieldMergePostProcessId, () => { return this.depthOfFieldMerge; }, true));
         }
 
         /**