Merge pull request #212 from michael-korbas/renderPipeline_clean

Typescript support for RenderPipeline

Babylon/Culling/babylon.boundingBox.js

@@ -156,4 +156,4 @@
     })();
     BABYLON.BoundingBox = BoundingBox;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.boundingBox.js.map
+//# sourceMappingURL=babylon.BoundingBox.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js

@@ -1,239 +1,237 @@
-"use strict";
-
-var BABYLON = BABYLON || {};
-
-(function () {
-	BABYLON.PostProcessRenderEffect = function PostProcessRenderEffect(engine, name, postProcessType, ratio, samplingMode, singleInstance) {
-		this._engine = engine;
-
-		this._name = name;
-
-		this._singleInstance = singleInstance || true;
-
-		this._postProcesses = [];
-
-		this._postProcessType = postProcessType;
-
-		this._ratio = ratio || 1.0;
-		this._samplingMode = samplingMode || null;
-
-		this._cameras = [];
-		this._indicesForCamera = [];
-
-		this._renderPasses = [];
-		this._renderEffectAsPasses = [];
-
-		this.parameters = function () { };
-
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.addPass = function(renderPass) {
-		this._renderPasses[renderPass._name] = renderPass;
-
-		this._linkParameters();
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.removePass = function (renderPass) {
-		delete this._renderPasses[renderPass._name];
-
-		this._linkParameters();
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.addRenderEffectAsPass = function(renderEffect) {
-		this._renderEffectAsPasses[renderEffect._name] = renderEffect;
-
-		this._linkParameters();
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.getPass = function (passName) {
-	    for (var renderPassName in this._renderPasses) {
-	        if (renderPassName == passName) {
-	            return this._renderPasses[passName];
-	        }
-	    }
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.emptyPasses = function () {
-		this._renderPasses.length = 0;
-
-		this._linkParameters();
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.attachCameras = function (cameras) {
-		var postProcess = null;
-
-		cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
-		for (var i = 0; i < cameras.length; i++) {
-			if (this._singleInstance) {
-			    postProcess = this._postProcesses[0] || BABYLON.PostProcessRenderEffect.getInstance(this._engine, this._postProcessType, this._ratio, this._samplingMode);
-				this._postProcesses[0] = postProcess;
-			}
-			else {
-			    postProcess = this._postProcesses[cameras[i]] || BABYLON.PostProcessRenderEffect.getInstance(this._engine, this._postProcessType, this._ratio, this._samplingMode);
-				this._postProcesses[cameras[i].name] = postProcess;
-			}
-
-			var index = cameras[i].attachPostProcess(postProcess);
-
-			if (this._indicesForCamera[cameras[i].name] == null) {
-				this._indicesForCamera[cameras[i].name] = [];
-			}
-
-			this._indicesForCamera[cameras[i].name].push(index);
-
-			if (this._cameras.indexOf(cameras[i].name) == -1) {
-				this._cameras.push(cameras[i].name);
-			}
-
-			for (var passName in this._renderPasses) {
-			    this._renderPasses[passName].incRefCount();
-			}
-		}
-
-		this._linkParameters();
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.detachCameras = function (cameras) {
-		cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
+var BABYLON;
+(function (BABYLON) {
+    var PostProcessRenderEffect = (function () {
+        function PostProcessRenderEffect(engine, name, postProcessType, ratio, samplingMode, singleInstance) {
+            this._engine = engine;
+            this._name = name;
+            this._postProcessType = postProcessType;
+            this._ratio = ratio || 1.0;
+            this._samplingMode = samplingMode || null;
+            this._singleInstance = singleInstance || true;
+
+            this._cameras = [];
+
+            this._postProcesses = [];
+            this._indicesForCamera = [];
+
+            this._renderPasses = [];
+            this._renderEffectAsPasses = [];
+
+            this.parameters = function (effect) {
+            };
+        }
+        PostProcessRenderEffect._GetInstance = function (engine, postProcessType, ratio, samplingMode) {
+            var postProcess;
+            var instance;
+            var args = [];
+
+            var parameters = PostProcessRenderEffect._GetParametersNames(postProcessType);
+            for (var i = 0; i < parameters.length; i++) {
+                switch (parameters[i]) {
+                    case "name":
+                        args[i] = postProcessType.toString();
+                        break;
+                    case "ratio":
+                        args[i] = ratio;
+                        break;
+                    case "camera":
+                        args[i] = null;
+                        break;
+                    case "samplingMode":
+                        args[i] = samplingMode;
+                        break;
+                    case "engine":
+                        args[i] = engine;
+                        break;
+                    case "reusable":
+                        args[i] = true;
+                        break;
+                    default:
+                        args[i] = null;
+                        break;
+                }
+            }
+
+            postProcess = function () {
+            };
+            postProcess.prototype = postProcessType.prototype;
+
+            instance = new postProcess();
+            postProcessType.apply(instance, args);
+
+            return instance;
+        };
+
+        PostProcessRenderEffect._GetParametersNames = function (func) {
+            var commentsRegex = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+            var functWithoutComments = func.toString().replace(commentsRegex, '');
+
+            var parameters = functWithoutComments.slice(functWithoutComments.indexOf('(') + 1, functWithoutComments.indexOf(')')).match(/([^\s,]+)/g);
+
+            if (parameters === null)
+                parameters = [];
+
+            return parameters;
+        };
+
+        PostProcessRenderEffect.prototype._update = function () {
+            for (var renderPassName in this._renderPasses) {
+                this._renderPasses[renderPassName]._update();
+            }
+        };
+
+        PostProcessRenderEffect.prototype.addPass = function (renderPass) {
+            this._renderPasses[renderPass._name] = renderPass;
+
+            this._linkParameters();
+        };
+
+        PostProcessRenderEffect.prototype.removePass = function (renderPass) {
+            delete this._renderPasses[renderPass._name];
+
+            this._linkParameters();
+        };
+
+        PostProcessRenderEffect.prototype.addRenderEffectAsPass = function (renderEffect) {
+            this._renderEffectAsPasses[renderEffect._name] = renderEffect;
+
+            this._linkParameters();
+        };
+
+        PostProcessRenderEffect.prototype.getPass = function (passName) {
+            for (var renderPassName in this._renderPasses) {
+                if (renderPassName === passName) {
+                    return this._renderPasses[passName];
+                }
+            }
+        };
+
+        PostProcessRenderEffect.prototype.emptyPasses = function () {
+            this._renderPasses.length = 0;
+
+            this._linkParameters();
+        };
+
+        PostProcessRenderEffect.prototype._attachCameras = function (cameras) {
+            var cameraKey;
+
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                if (this._singleInstance) {
+                    cameraKey = 0;
+                } else {
+                    cameraKey = cameraName;
+                }
+
+                this._postProcesses[cameraKey] = this._postProcesses[cameraKey] || PostProcessRenderEffect._GetInstance(this._engine, this._postProcessType, this._ratio, this._samplingMode);
+
+                var index = camera.attachPostProcess(this._postProcesses[cameraKey]);
+
+                if (this._indicesForCamera[cameraName] === null) {
+                    this._indicesForCamera[cameraName] = [];
+                }
+
+                this._indicesForCamera[cameraName].push(index);
+
+                if (this._cameras.indexOf(camera) === -1) {
+                    this._cameras[cameraName] = camera;
+                }
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._incRefCount();
+                }
+            }
+
+            this._linkParameters();
+        };
 
-		for (var i = 0; i < cameras.length; i++) {
-		    if (this._singleInstance) {
-			    cameras[i].detachPostProcess(this._postProcesses[0], this._indicesForCamera[cameras[i].name]);
-			}
-			else {
-				cameras[i].detachPostProcess(this._postProcesses[cameras[i].name], this._indicesForCamera[cameras[i].name]);
-			}
+        PostProcessRenderEffect.prototype._detachCameras = function (cameras) {
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
 
-			this._indicesForCamera.splice(cameras[i].name, 1);
-			this._cameras.splice(this._cameras.indexOf(cameras[i].name), 1);
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
 
-			for (var passName in this._renderPasses) {
-			    this._renderPasses[passName].decRefCount();
-			}
-		}
-	};
+                camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName]);
 
-	BABYLON.PostProcessRenderEffect.prototype._linkParameters = function () {
-		var that = this;
-		for (var index in this._postProcesses) {
-		    this._postProcesses[index].onApply = function (effect) {
-		        that.parameters(effect);
-		        that._linkTextures(effect);
-		    };
-		}
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype._linkTextures = function (effect) {
-        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());
-        }
-	};
-
-    
-	BABYLON.PostProcessRenderEffect.prototype._update = function () {
-		for (var renderPassName in this._renderPasses) {
-			this._renderPasses[renderPassName]._update();
-		}
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.enable = function (cameras) {
-	    cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
-		for (var i = 0; i < cameras.length; i++) {
-			for (var j = 0; j < this._indicesForCamera[cameras[i].name].length; j++) {
-				if (cameras[i]._postProcesses[this._indicesForCamera[cameras[i].name][j]] === undefined) {
-					if (this._singleInstance) {
-						cameras[i].attachPostProcess(this._postProcesses[0], this._indicesForCamera[cameras[i].name][j]);
-					}
-					else {
-						cameras[i].attachPostProcess(this._postProcesses[cameras[i].name], this._indicesForCamera[cameras[i].name][j]);
-					}
-				}
-			}
-
-			for (var passName in this._renderPasses) {
-			    this._renderPasses[passName].incRefCount();
-			}
-		}
-	};
-
-	BABYLON.PostProcessRenderEffect.prototype.disable = function (cameras) {
-		cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
-		for (var i = 0; i < cameras.length; i++) {
-		    if (this._singleInstance) {
-				cameras[i].detachPostProcess(this._postProcesses[0], this._indicesForCamera[cameras[i].name]);
-			}
-			else {
-				cameras[i].detachPostProcess(this._postProcesses[cameras[i].name], this._indicesForCamera[cameras[i].name]);
-		    }
-
-		    for (var passName in this._renderPasses) {
-		        this._renderPasses[passName].decRefCount();
-		    }
-		}
-	};
-
-
-	BABYLON.PostProcessRenderEffect.prototype.getPostProcess = function(camera) {
-		return this._postProcess;
-	};
-
-	BABYLON.PostProcessRenderEffect.getInstance = function (engine, postProcessType, ratio, samplingMode) {
-	    var tmpClass;
-	    var instance;
-	    var args = new Array();
-
-	    var parameters = BABYLON.PostProcessRenderEffect.getParametersNames(postProcessType);
-	    for (var i = 0; i < parameters.length; i++) {
-	        switch (parameters[i]) {
-	            case "name":
-	                args[i] = postProcessType.toString();
-	                break;
-	            case "ratio":
-	                args[i] = ratio;
-	                break;
-	            case "camera":
-	                args[i] = null;
-	                break;
-	            case "samplingMode":
-	                args[i] = samplingMode;
-	                break;
-	            case "engine":
-	                args[i] = engine;
-	                break;
-	            case "reusable":
-	                args[i] = true;
-	                break;
-	            default:
-	                args[i] = null;
-	                break;
-	        }
-	    }
-
-	    tmpClass = function () { };
-	    tmpClass.prototype = postProcessType.prototype;
-
-	    instance = new tmpClass();
-	    postProcessType.apply(instance, args);
-
-	    return instance;
-	};
-
-	BABYLON.PostProcessRenderEffect.getParametersNames = function (func) {
-	    var commentsRegex = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
-	    var functWithoutComments = eval(func).toString().replace(commentsRegex, '');
-
-	    var parameters = functWithoutComments.slice(functWithoutComments.indexOf('(') + 1, functWithoutComments.indexOf(')')).match(/([^\s,]+)/g);
-
-	    if (parameters === null)
-	        parameters = [];
-	    return parameters;
-	};
-
-})();
+                var index = this._cameras.indexOf(cameraName);
+
+                this._indicesForCamera.splice(index, 1);
+                this._cameras.splice(index, 1);
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._decRefCount();
+                }
+            }
+        };
+
+        PostProcessRenderEffect.prototype._enable = function (cameras) {
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                for (var j = 0; j < this._indicesForCamera[cameraName].length; j++) {
+                    if (camera._postProcesses[this._indicesForCamera[cameraName][j]] === undefined) {
+                        cameras[i].attachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName][j]);
+                    }
+                }
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._incRefCount();
+                }
+            }
+        };
+
+        PostProcessRenderEffect.prototype._disable = function (cameras) {
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.Name;
+
+                camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName]);
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._decRefCount();
+                }
+            }
+        };
+
+        PostProcessRenderEffect.prototype.getPostProcess = function (camera) {
+            if (this._singleInstance) {
+                return this._postProcesses[0];
+            } else {
+                return this._postProcesses[camera.name];
+            }
+        };
+
+        PostProcessRenderEffect.prototype._linkParameters = function () {
+            var _this = this;
+            for (var index in this._postProcesses) {
+                this._postProcesses[index].onApply = function (effect) {
+                    _this.parameters(effect);
+                    _this._linkTextures(effect);
+                };
+            }
+        };
+
+        PostProcessRenderEffect.prototype._linkTextures = function (effect) {
+            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());
+            }
+        };
+        return PostProcessRenderEffect;
+    })();
+    BABYLON.PostProcessRenderEffect = PostProcessRenderEffect;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderEffect.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.ts

@@ -0,0 +1,265 @@
+module BABYLON {
+    export class PostProcessRenderEffect {
+        private _engine: Engine;
+
+        private _postProcesses: PostProcess[];
+        private _postProcessType; //The type must inherit from PostProcess (example: BABYLON.BlackAndWhitePostProcess, like this without quotes).
+
+        private _ratio: number;
+        private _samplingMode: number;
+        private _singleInstance: boolean;
+
+        private _cameras: Camera[];
+        private _indicesForCamera: number[][];
+
+        private _renderPasses: PostProcessRenderPass[];
+        private _renderEffectAsPasses: PostProcessRenderEffect[];
+
+        // private
+        public _name: string;
+
+        public parameters: (effect: Effect) => void;
+
+        constructor(engine: Engine, name: string, postProcessType, ratio?: number, samplingMode?: number, singleInstance?: boolean) {
+            this._engine = engine;
+            this._name = name;
+            this._postProcessType = postProcessType;
+            this._ratio = ratio || 1.0;
+            this._samplingMode = samplingMode || null;
+            this._singleInstance = singleInstance || true;
+
+            this._cameras = [];
+
+            this._postProcesses = [];
+            this._indicesForCamera = [];
+
+            this._renderPasses = [];
+            this._renderEffectAsPasses = [];
+
+            this.parameters = (effect: Effect) => { };
+        }
+
+        private static _GetInstance(engine: Engine, postProcessType, ratio: number, samplingMode: number): PostProcess {
+            var postProcess;
+            var instance;
+            var args = [];
+
+            var parameters = PostProcessRenderEffect._GetParametersNames(postProcessType);
+            for (var i = 0; i < parameters.length; i++) {
+                switch (parameters[i]) {
+                    case "name":
+                        args[i] = postProcessType.toString();
+                        break;
+                    case "ratio":
+                        args[i] = ratio;
+                        break;
+                    case "camera":
+                        args[i] = null;
+                        break;
+                    case "samplingMode":
+                        args[i] = samplingMode;
+                        break;
+                    case "engine":
+                        args[i] = engine;
+                        break;
+                    case "reusable":
+                        args[i] = true;
+                        break;
+                    default:
+                        args[i] = null;
+                        break;
+                }
+            }
+
+            postProcess = function () { };
+            postProcess.prototype = postProcessType.prototype;
+
+            instance = new postProcess();
+            postProcessType.apply(instance, args);
+
+            return instance;
+        }
+
+        private static _GetParametersNames(func): string[] {
+            var commentsRegex = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+            var functWithoutComments = func.toString().replace(commentsRegex, '');
+
+            var parameters = functWithoutComments.slice(functWithoutComments.indexOf('(') + 1, functWithoutComments.indexOf(')')).match(/([^\s,]+)/g);
+
+            if (parameters === null)
+                parameters = [];
+
+            return parameters;
+        }
+
+        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): void {
+            for (var renderPassName in this._renderPasses) {
+                if (renderPassName === passName) {
+                    return this._renderPasses[passName];
+                }
+            }
+        }
+
+        public emptyPasses(): void {
+            this._renderPasses.length = 0;
+
+            this._linkParameters();
+        }
+
+        // private
+        public _attachCameras(cameras: Camera);
+        public _attachCameras(cameras: Camera[]);
+        public _attachCameras(cameras: any): void {
+            var cameraKey;
+
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                if (this._singleInstance) {
+                    cameraKey = 0;
+                }
+                else {
+                    cameraKey = cameraName;
+                }
+
+                this._postProcesses[cameraKey] = this._postProcesses[cameraKey] || PostProcessRenderEffect._GetInstance(this._engine, this._postProcessType, this._ratio, this._samplingMode);
+
+                var index = camera.attachPostProcess(this._postProcesses[cameraKey]);
+
+                if (this._indicesForCamera[cameraName] === null) {
+                    this._indicesForCamera[cameraName] = [];
+                }
+
+                this._indicesForCamera[cameraName].push(index);
+
+                if (this._cameras.indexOf(camera) === -1) {
+                    this._cameras[cameraName] = camera;
+                }
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._incRefCount();
+                }
+            }
+
+            this._linkParameters();
+        }
+
+        // private
+        public _detachCameras(cameras: Camera);
+        public _detachCameras(cameras: Camera[]);
+        public _detachCameras(cameras: any): void {
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName]);
+
+                var index = this._cameras.indexOf(cameraName);
+
+                this._indicesForCamera.splice(index, 1);
+                this._cameras.splice(index, 1);
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._decRefCount();
+                }
+            }
+        }
+
+        // private
+        public _enable(cameras: Camera);
+        public _enable(cameras: Camera[]);
+        public _enable(cameras: any): void {
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                for (var j = 0; j < this._indicesForCamera[cameraName].length; j++) {
+                    if (camera._postProcesses[this._indicesForCamera[cameraName][j]] === undefined) {
+                        cameras[i].attachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName][j]);
+                    }
+                }
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._incRefCount();
+                }
+            }
+        }
+
+        // private
+        public _disable(cameras: Camera);
+        public _disable(cameras: Camera[]);
+        public _disable(cameras: any): void {
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.Name;
+
+                camera.detachPostProcess(this._postProcesses[this._singleInstance ? 0 : cameraName], this._indicesForCamera[cameraName]);
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName]._decRefCount();
+                }
+            }
+        }
+
+        public getPostProcess(camera?: Camera): PostProcess {
+            if (this._singleInstance) {
+                return this._postProcesses[0];
+            }
+            else {
+                return this._postProcesses[camera.name];
+            }
+        }
+
+        private _linkParameters(): void {
+            for (var index in this._postProcesses) {
+                this._postProcesses[index].onApply = (effect: Effect) => {
+                    this.parameters(effect);
+                    this._linkTextures(effect);
+                };
+            }
+        }
+
+        private _linkTextures(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());
+            }
+        }
+    }
+}

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js

@@ -2,9 +2,10 @@
 (function (BABYLON) {
     var PostProcessRenderPass = (function () {
         function PostProcessRenderPass(scene, name, size, renderList, beforeRender, afterRender) {
-            this.name = name;
             this._enabled = true;
             this._refCount = 0;
+            this._name = name;
+
             this._renderTexture = new BABYLON.RenderTargetTexture(name, size, scene);
             this.setRenderList(renderList);
 
@@ -13,15 +14,16 @@
 
             this._scene = scene;
         }
-        PostProcessRenderPass.prototype.incRefCount = function () {
-            if (this._refCount == 0) {
+        // private
+        PostProcessRenderPass.prototype._incRefCount = function () {
+            if (this._refCount === 0) {
                 this._scene.customRenderTargets.push(this._renderTexture);
             }
 
             return ++this._refCount;
         };
 
-        PostProcessRenderPass.prototype.decRefCount = function () {
+        PostProcessRenderPass.prototype._decRefCount = function () {
             this._refCount--;
 
             if (this._refCount <= 0) {
@@ -31,6 +33,11 @@
             return this._refCount;
         };
 
+        PostProcessRenderPass.prototype._update = function () {
+            this.setRenderList(this._renderList);
+        };
+
+        // public
         PostProcessRenderPass.prototype.setRenderList = function (renderList) {
             this._renderTexture.renderList = renderList;
         };
@@ -38,10 +45,6 @@
         PostProcessRenderPass.prototype.getRenderTexture = function () {
             return this._renderTexture;
         };
-
-        PostProcessRenderPass.prototype._update = function () {
-            this.setRenderList(this._renderList);
-        };
         return PostProcessRenderPass;
     })();
     BABYLON.PostProcessRenderPass = PostProcessRenderPass;

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPass.ts

@@ -1,12 +1,16 @@
 module BABYLON {
     export class PostProcessRenderPass {
-        private _enabled = true;
+        private _enabled: boolean = true;
         private _renderList: Mesh[];
         private _renderTexture: RenderTargetTexture;
         private _scene: Scene;
-        private _refCount = 0;
+        private _refCount: number = 0;
 
-        constructor(scene: Scene, public name: string, size: number, renderList: Mesh[], beforeRender: () => void, afterRender: () => void) {
+        // 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);
@@ -17,15 +21,17 @@
             this._scene = scene;
         }
 
-        public incRefCount(): number {
-            if (this._refCount == 0) {
+        // private
+
+        public _incRefCount(): number {
+            if (this._refCount === 0) {
                 this._scene.customRenderTargets.push(this._renderTexture);
             }
 
             return ++this._refCount;
         }
 
-        public decRefCount(): number {
+        public _decRefCount(): number {
             this._refCount--;
 
             if (this._refCount <= 0) {
@@ -35,6 +41,12 @@
             return this._refCount;
         }
 
+        public _update(): void {
+            this.setRenderList(this._renderList);
+        }
+
+        // public
+
         public setRenderList(renderList: Mesh[]): void {
             this._renderTexture.renderList = renderList;
         }
@@ -42,9 +54,5 @@
         public getRenderTexture(): RenderTargetTexture {
             return this._renderTexture;
         }
-
-        public _update(): void {
-            this.setRenderList(this._renderList);
-        }
     }
 }

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js

@@ -1,138 +1,142 @@
-"use strict";
+var BABYLON;
+(function (BABYLON) {
+    var PostProcessRenderPipeline = (function () {
+        function PostProcessRenderPipeline(engine, name) {
+            this._engine = engine;
+            this._name = name;
 
-var BABYLON = BABYLON || {};
+            this._renderEffects = [];
+            this._renderEffectsForIsolatedPass = [];
 
-(function () {
-	BABYLON.PostProcessRenderPipeline = function PostProcessRenderPipeline(engine, name) {
-		this._engine = engine;
-
-		this._name = name;
+            this._cameras = [];
+        }
+        PostProcessRenderPipeline.prototype.addEffect = function (renderEffect) {
+            this._renderEffects[renderEffect._name] = renderEffect;
+        };
 
-		this._renderEffects = [];
-		this._renderEffectsPasses = [];
+        PostProcessRenderPipeline.prototype._enableEffect = function (renderEffectName, cameras) {
+            var renderEffects = this._renderEffects[renderEffectName];
 
-		this._cameras = [];
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype.addEffect = function (renderEffect) {
-		this._renderEffects[renderEffect._name] = renderEffect;
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype.enableEffect = function (renderEffectName, cameras) {
-	    cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
+            if (!renderEffects) {
+                return;
+            }
 
-		var renderEffects = this._renderEffects[renderEffectName];
-
-		if (!renderEffects) {
-			return;
-		}
-
-		renderEffects.enable(cameras);
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype.disableEffect = function (renderEffectName, cameras) {
-	    cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
-		var renderEffects = this._renderEffects[renderEffectName];
-
-		if (!renderEffects) {
-			return;
-		}
-
-		renderEffects.disable(cameras);
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype.attachCameras = function (cameras, unique) {
-		cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-		
-		var indicesToDelete = [];
-
-		for (var i = 0; i < cameras.length; i++) {
-			if (this._cameras.indexOf(cameras[i]) == -1) {
-				this._cameras.push(cameras[i]);
-			}
-			else if(unique) {
-				indicesToDelete.push(i);
-			}
-		}
-
-		for (var i = 0; i < indicesToDelete.length; i++) {
-			cameras.splice(indicesToDelete[i], 1);
-		}
-
-		for(var renderEffectName in this._renderEffects) {
-			this._renderEffects[renderEffectName].attachCameras(cameras);
-		}
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype.detachCameras = function (cameras) {
-		cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
-		for (var renderEffectName in this._renderEffects) {
-			this._renderEffects[renderEffectName].detachCameras(cameras);
-		}
-
-		for (var i = 0; i < cameras.length; i++) {
-			this._cameras.splice(this._cameras.indexOf(cameras[i]), 1);
-		}
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype.enableDisplayOnlyPass = function (passName, cameras) {
-		cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
-		var pass = null;
-
-		for (var renderEffectName in this._renderEffects) {
-			pass = this._renderEffects[renderEffectName].getPass(passName);
-
-			if (pass != null) {
-				break;
-			}
-		}
-
-		if (pass == null) {
-			return;
-		}
-		
-		for (var renderEffectName in this._renderEffects) {
-			this._renderEffects[renderEffectName].disable(cameras);
-		}
-		
-		pass._name = BABYLON.PostProcessRenderPipeline.PASS_SAMPLER_NAME;
-		
-		for (var i = 0; i < cameras.length; i++) {
-		    this._renderEffectsPasses[cameras[i].name] = this._renderEffectsPasses[cameras[i].name] || new BABYLON.RenderEffect(this._engine, BABYLON.PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0);
-			this._renderEffectsPasses[cameras[i].name].emptyPasses();
-			this._renderEffectsPasses[cameras[i].name].addPass(pass);
-			this._renderEffectsPasses[cameras[i].name].attachCameras(cameras[i]);
-		}
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype.disableDisplayOnlyPass = function (cameras) {
-	    cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
-
-		for (var i = 0; i < cameras.length; i++) {
-		    this._renderEffectsPasses[cameras[i].name] = this._renderEffectsPasses[cameras[i].name] || new BABYLON.RenderEffect(this._engine, BABYLON.PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0);
-		    this._renderEffectsPasses[cameras[i].name].disable(cameras[i]);
-		}
-
-		for (var renderEffectName in this._renderEffects) {
-			this._renderEffects[renderEffectName].enable(cameras);
-		}
-	};
-
-	BABYLON.PostProcessRenderPipeline.prototype._update = function () {
-		for (var renderEffectName in this._renderEffects) {
-			this._renderEffects[renderEffectName]._update();
-		}
-
-		for(var i = 0; i < this._cameras.length; i++) {
-			if (this._renderEffectsPasses[this._cameras[i]]) {
-				this._renderEffectsPasses[this._cameras[i]]._update();
-			}
-		}
-	};
-
-	BABYLON.PostProcessRenderPipeline.PASS_EFFECT_NAME = "passEffect";
-	BABYLON.PostProcessRenderPipeline.PASS_SAMPLER_NAME = "passSampler";
-})();
+            renderEffects.enable(BABYLON.Tools.MakeArray(cameras || this._cameras));
+        };
+
+        PostProcessRenderPipeline.prototype._disableEffect = function (renderEffectName, cameras) {
+            var renderEffects = this._renderEffects[renderEffectName];
+
+            if (!renderEffects) {
+                return;
+            }
+
+            renderEffects.disable(BABYLON.Tools.MakeArray(cameras || this._cameras));
+        };
+
+        PostProcessRenderPipeline.prototype._attachCameras = function (cameras, unique) {
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            var indicesToDelete = [];
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                if (this._cameras.indexOf(camera) === -1) {
+                    this._cameras[cameraName] = camera;
+                } else if (unique) {
+                    indicesToDelete.push(i);
+                }
+            }
+
+            for (var i = 0; i < indicesToDelete.length; i++) {
+                cameras.splice(indicesToDelete[i], 1);
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._attachCameras(_cam);
+            }
+        };
+
+        PostProcessRenderPipeline.prototype._detachCameras = function (cameras) {
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._detachCameras(_cam);
+            }
+
+            for (var i = 0; i < _cam.length; i++) {
+                this._cameras.splice(this._cameras.indexOf(_cam[i]), 1);
+            }
+        };
+
+        PostProcessRenderPipeline.prototype._enableDisplayOnlyPass = function (passName, cameras) {
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            var pass = null;
+
+            for (var renderEffectName in this._renderEffects) {
+                pass = this._renderEffects[renderEffectName].getPass(passName);
+
+                if (pass != null) {
+                    break;
+                }
+            }
+
+            if (pass === null) {
+                return;
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._disable(_cam);
+            }
+
+            pass._name = PostProcessRenderPipeline.PASS_SAMPLER_NAME;
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new BABYLON.PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsForIsolatedPass[cameraName].emptyPasses();
+                this._renderEffectsForIsolatedPass[cameraName].addPass(pass);
+                this._renderEffectsForIsolatedPass[cameraName]._attachCameras(camera);
+            }
+        };
+
+        PostProcessRenderPipeline.prototype._disableDisplayOnlyPass = function (cameras) {
+            var _cam = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new BABYLON.PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsForIsolatedPass[cameraName]._disable(camera);
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._enable(_cam);
+            }
+        };
+
+        PostProcessRenderPipeline.prototype._update = function () {
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._update();
+            }
+
+            for (var i = 0; i < this._cameras.length; i++) {
+                var cameraName = this._cameras[i].name;
+                if (this._renderEffectsForIsolatedPass[cameraName]) {
+                    this._renderEffectsForIsolatedPass[cameraName]._update();
+                }
+            }
+        };
+        PostProcessRenderPipeline.PASS_EFFECT_NAME = "passEffect";
+        PostProcessRenderPipeline.PASS_SAMPLER_NAME = "passSampler";
+        return PostProcessRenderPipeline;
+    })();
+    BABYLON.PostProcessRenderPipeline = PostProcessRenderPipeline;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPipeline.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.ts

@@ -0,0 +1,165 @@
+module BABYLON {
+    export class PostProcessRenderPipeline {
+        private _engine: Engine;
+
+        private _renderEffects: PostProcessRenderEffect[];
+        private _renderEffectsForIsolatedPass: PostProcessRenderEffect[];
+
+        private _cameras: Camera[];
+
+        // private
+        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 = [];
+            this._renderEffectsForIsolatedPass = [];
+
+            this._cameras = [];
+        }
+
+        public addEffect(renderEffect: PostProcessRenderEffect): void {
+            this._renderEffects[renderEffect._name] = renderEffect;
+        }
+
+        // private
+
+        public _enableEffect(renderEffectName: string, cameras: Camera);
+        public _enableEffect(renderEffectName: string, cameras: Camera[]);
+        public _enableEffect(renderEffectName: string, cameras: any): void {
+            var renderEffects = this._renderEffects[renderEffectName];
+
+            if (!renderEffects) {
+                return;
+            }
+
+            renderEffects.enable(Tools.MakeArray(cameras || this._cameras));
+        }
+
+        public _disableEffect(renderEffectName: string, cameras: Camera);
+        public _disableEffect(renderEffectName: string, cameras: Camera[]);
+        public _disableEffect(renderEffectName: string, cameras): void {
+            var renderEffects = this._renderEffects[renderEffectName];
+
+            if (!renderEffects) {
+                return;
+            }
+
+            renderEffects.disable(Tools.MakeArray(cameras || this._cameras));
+        }
+
+        public _attachCameras(cameras: Camera, unique: boolean);
+        public _attachCameras(cameras: Camera[], unique: boolean);
+        public _attachCameras(cameras: any, unique: boolean): void {
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            var indicesToDelete = [];
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                if (this._cameras.indexOf(camera) === -1) {
+                    this._cameras[cameraName] = camera;
+                }
+                else if (unique) {
+                    indicesToDelete.push(i);
+                }
+            }
+
+            for (var i = 0; i < indicesToDelete.length; i++) {
+                cameras.splice(indicesToDelete[i], 1);
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._attachCameras(_cam);
+            }
+        }
+
+        public _detachCameras(cameras: Camera);
+        public _detachCameras(cameras: Camera[]);
+        public _detachCameras(cameras: any): void {
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._detachCameras(_cam);
+            }
+
+            for (var i = 0; i < _cam.length; i++) {
+                this._cameras.splice(this._cameras.indexOf(_cam[i]), 1);
+            }
+        }
+
+        public _enableDisplayOnlyPass(passName, cameras: Camera);
+        public _enableDisplayOnlyPass(passName, cameras: Camera[]);
+        public _enableDisplayOnlyPass(passName, cameras: any): void {
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            var pass = null;
+
+            for (var renderEffectName in this._renderEffects) {
+                pass = this._renderEffects[renderEffectName].getPass(passName);
+
+                if (pass != null) {
+                    break;
+                }
+            }
+
+            if (pass === null) {
+                return;
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._disable(_cam);
+            }
+
+            pass._name = PostProcessRenderPipeline.PASS_SAMPLER_NAME;
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsForIsolatedPass[cameraName].emptyPasses();
+                this._renderEffectsForIsolatedPass[cameraName].addPass(pass);
+                this._renderEffectsForIsolatedPass[cameraName]._attachCameras(camera);
+            }
+        }
+
+        public _disableDisplayOnlyPass(cameras: Camera);
+        public _disableDisplayOnlyPass(cameras: Camera[]);
+        public _disableDisplayOnlyPass(cameras: any): void {
+            var _cam = Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < _cam.length; i++) {
+                var camera = _cam[i];
+                var cameraName = camera.name;
+
+                this._renderEffectsForIsolatedPass[cameraName] = this._renderEffectsForIsolatedPass[cameraName] || new PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsForIsolatedPass[cameraName]._disable(camera);
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._enable(_cam);
+            }
+        }
+
+        public _update(): void {
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName]._update();
+            }
+
+            for (var i = 0; i < this._cameras.length; i++) {
+                var cameraName = this._cameras[i].name;
+                if (this._renderEffectsForIsolatedPass[cameraName]) {
+                    this._renderEffectsForIsolatedPass[cameraName]._update();
+                }
+            }
+        }
+    }
+}

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js

@@ -1,81 +1,80 @@
-"use strict";
-
-var BABYLON = BABYLON || {};
-
-(function () {
-	BABYLON.PostProcessRenderPipelineManager = function PostProcessRenderPipelineManager() {
-		this._renderPipelines = [];
-	};
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.addPipeline = function(renderPipeline) {
-		this._renderPipelines[renderPipeline._name] = renderPipeline;
-	};
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.update = function () {
-		for (var renderPipelineName in this._renderPipelines) {
-			this._renderPipelines[renderPipelineName]._update();
-		}
-	};
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.attachCamerasToRenderPipeline = function (renderPipelineName, cameras, unique) {
-		var renderPipeline = this._renderPipelines[renderPipelineName];
-
-		if (!renderPipeline) {
-			return;
-		}
-
-		renderPipeline.attachCameras(cameras, unique);
-	};
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.detachCamerasFromRenderPipeline = function (renderPipelineName, cameras) {
-		var renderPipeline = this._renderPipelines[renderPipelineName];
-
-		if (!renderPipeline) {
-			return;
-		}
-
-		renderPipeline.detachCameras(cameras);
-	};
-
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.enableEffectInPipeline = function (renderPipelineName, renderEffectName, cameras) {
-		var renderPipeline = this._renderPipelines[renderPipelineName];
-
-		if (!renderPipeline) {
-			return;
-		}
-
-		renderPipeline.enableEffect(renderEffectName, cameras);
-	};
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.disableEffectInPipeline = function (renderPipelineName, renderEffectName, cameras) {
-		var renderPipeline = this._renderPipelines[renderPipelineName];
-
-		if (!renderPipeline) {
-			return;
-		}
-
-		renderPipeline.disableEffect(renderEffectName, cameras);
-	};
-
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.enableDisplayOnlyPassInPipeline = function (renderPipelineName, passName, cameras) {
-		var renderPipeline = this._renderPipelines[renderPipelineName];
-
-		if (!renderPipeline) {
-			return;
-		}
-
-		renderPipeline.enableDisplayOnlyPass(passName, cameras);
-	};
-
-	BABYLON.PostProcessRenderPipelineManager.prototype.disableDisplayOnlyPassInPipeline = function (renderPipelineName, cameras) {
-		var renderPipeline = this._renderPipelines[renderPipelineName];
-
-		if (!renderPipeline) {
-			return;
-		}
-
-		renderPipeline.disableDisplayOnlyPass(cameras);
-	};
-})();
+var BABYLON;
+(function (BABYLON) {
+    var PostProcessRenderPipelineManager = (function () {
+        function PostProcessRenderPipelineManager() {
+            this._renderPipelines = [];
+        }
+        PostProcessRenderPipelineManager.prototype.addPipeline = function (renderPipeline) {
+            this._renderPipelines[renderPipeline._name] = renderPipeline;
+        };
+
+        PostProcessRenderPipelineManager.prototype.attachCamerasToRenderPipeline = function (renderPipelineName, cameras, unique) {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.attachCameras(cameras, unique);
+        };
+
+        PostProcessRenderPipelineManager.prototype.detachCamerasFromRenderPipeline = function (renderPipelineName, cameras) {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.detachCameras(cameras);
+        };
+
+        PostProcessRenderPipelineManager.prototype.enableEffectInPipeline = function (renderPipelineName, renderEffectName, cameras) {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.enableEffect(renderEffectName, cameras);
+        };
+
+        PostProcessRenderPipelineManager.prototype.disableEffectInPipeline = function (renderPipelineName, renderEffectName, cameras) {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.disableEffect(renderEffectName, cameras);
+        };
+
+        PostProcessRenderPipelineManager.prototype.enableDisplayOnlyPassInPipeline = function (renderPipelineName, passName, cameras) {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.enableDisplayOnlyPass(passName, cameras);
+        };
+
+        PostProcessRenderPipelineManager.prototype.disableDisplayOnlyPassInPipeline = function (renderPipelineName, cameras) {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.disableDisplayOnlyPass(cameras);
+        };
+
+        PostProcessRenderPipelineManager.prototype.update = function () {
+            for (var renderPipelineName in this._renderPipelines) {
+                this._renderPipelines[renderPipelineName]._update();
+            }
+        };
+        return PostProcessRenderPipelineManager;
+    })();
+    BABYLON.PostProcessRenderPipelineManager = PostProcessRenderPipelineManager;
+})(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.postProcessRenderPipelineManager.js.map

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.ts

@@ -0,0 +1,91 @@
+module BABYLON {
+    export class PostProcessRenderPipelineManager {
+        private _renderPipelines: PostProcessRenderPipeline[];
+
+        constructor() {
+            this._renderPipelines = [];
+        }
+
+        public addPipeline(renderPipeline: PostProcessRenderPipeline): void {
+            this._renderPipelines[renderPipeline._name] = renderPipeline;
+        }
+
+        public attachCamerasToRenderPipeline(renderPipelineName: string, cameras: Camera, unique?: boolean);
+        public attachCamerasToRenderPipeline(renderPipelineName: string, cameras: Camera[], unique?: boolean);
+        public attachCamerasToRenderPipeline(renderPipelineName: string, cameras: any, unique?: boolean): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.attachCameras(cameras, unique);
+        }
+
+        public detachCamerasFromRenderPipeline(renderPipelineName: string, cameras: Camera);
+        public detachCamerasFromRenderPipeline(renderPipelineName: string, cameras: Camera[]);
+        public detachCamerasFromRenderPipeline(renderPipelineName: string, cameras: any): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.detachCameras(cameras);
+        }
+
+        public enableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera);
+        public enableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera[]);
+        public enableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: any): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.enableEffect(renderEffectName, cameras);
+        }
+
+        public disableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera);
+        public disableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: Camera[]);
+        public disableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras: any): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.disableEffect(renderEffectName, cameras);
+        }
+
+        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: Camera);
+        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: Camera[]);
+        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras: any): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.enableDisplayOnlyPass(passName, cameras);
+        }
+
+        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: Camera);
+        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: Camera[]);
+        public disableDisplayOnlyPassInPipeline(renderPipelineName: string, cameras: any): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.disableDisplayOnlyPass(cameras);
+        }
+
+        public update(): void {
+            for (var renderPipelineName in this._renderPipelines) {
+                this._renderPipelines[renderPipelineName]._update();
+            }
+        }
+    }
+}

Babylon/babylon.scene.js

@@ -84,6 +84,8 @@
 
             this.postProcessManager = new BABYLON.PostProcessManager(this);
 
+            this.postProcessRenderPipelineManager = new BABYLON.PostProcessRenderPipelineManager();
+
             this._boundingBoxRenderer = new BABYLON.BoundingBoxRenderer(this);
 
             this.attachControl();
@@ -906,6 +908,9 @@
                 }
             }
 
+            // RenderPipeline
+            this.postProcessRenderPipelineManager.update();
+
             // Multi-cameras?
             if (this.activeCameras.length > 0) {
                 var currentRenderId = this._renderId;

Babylon/babylon.scene.ts

@@ -82,6 +82,7 @@
         // Postprocesses
         public postProcessesEnabled = true;
         public postProcessManager: PostProcessManager;
+        public postProcessRenderPipelineManager: PostProcessRenderPipelineManager;
 
         // Customs render targets
         public renderTargetsEnabled = true;
@@ -160,6 +161,8 @@
 
             this.postProcessManager = new PostProcessManager(this);
 
+            this.postProcessRenderPipelineManager = new PostProcessRenderPipelineManager();
+
             this._boundingBoxRenderer = new BoundingBoxRenderer(this);
 
             this.attachControl();
@@ -972,6 +975,9 @@
                 }
             }
 
+            // RenderPipeline
+            this.postProcessRenderPipelineManager.update();
+
             // Multi-cameras?
             if (this.activeCameras.length > 0) {
                 var currentRenderId = this._renderId;

Tools/BuildOurOwnBabylonJS/BuildOurOwnBabylonJS/babylonJS.xml

@@ -2,28 +2,40 @@
 <files xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="babylonJS.xsd">
   <script src="Babylon/Tools/babylon.gamepads.js"></script>
   <script src="Babylon/Cameras/babylon.gamepadCamera.js"></script>
+  <script src="Babylon/Mesh/babylon.GroundMesh.js"></script>
+  <script src="Babylon/Mesh/babylon.geometry.js"></script>
+  <script src="Babylon/Actions/babylon.directActions.js"></script>
+  <script src="Babylon/Actions/babylon.interpolateValueAction.js"></script>
+  <script src="Babylon/Actions/babylon.actionManager.js"></script>
+  <script src="Babylon/Actions/babylon.action.js"></script>
+  <script src="Babylon/Actions/babylon.condition.js"></script>
+  <script src="Babylon/Rendering/babylon.boundingBoxRenderer.js"></script>
+  <script src="Babylon/PostProcess/babylon.displayPassPostProcess.js"></script>
+  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js"></script>
+  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js"></script>
+  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js"></script>
+  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js"></script>
+  <script src="Babylon/Tools/babylon.andOrNotEvaluator.js"></script>
+  <script src="Babylon/Tools/babylon.tags.js"></script>
+  <script src="Babylon/PostProcess/babylon.anaglyphPostProcess.js"></script>
+  <script src="Babylon/Cameras/babylon.anaglyphCamera.js"></script>
+  <script src="Babylon/Mesh/babylon.mesh.vertexData.js"></script>
   <script src="Babylon/Materials/babylon.shaderMaterial.js"></script>
+  <script src="Babylon/Cameras/Controllers/babylon.globalAxisFactorsFilter.js"></script>
+  <script src="Babylon/Cameras/Controllers/babylon.gravityInputController.js"></script>
+  <script src="Babylon/Cameras/Controllers/babylon.inputCollisionFilter.js"></script>
+  <script src="Babylon/Cameras/Controllers/babylon.keyboardMoveController.js"></script>
   <script src="Babylon/Cameras/babylon.virtualJoysticksCamera.js"></script>
-  <script src="Babylon/Tools/babylon.virtualJoystick.js"></script>
   <script src="Babylon/Cameras/babylon.oculusOrientedCamera.js"></script>
-  <script src="Babylon/PostProcess/babylon.oculusDistortionCorrectionPostProcess.js"></script>
   <script src="Babylon/Cameras/Controllers/babylon.oculusController.js"></script>
-  <script src="Babylon/Cameras/Controllers/babylon.keyboardMoveController.js"></script>
-  <script src="Babylon/Cameras/Controllers/babylon.inputController.js"></script>
+  <script src="Babylon/Tools/babylon.virtualJoystick.js"></script>
+  <script src="Babylon/PostProcess/babylon.oculusDistortionCorrectionPostProcess.js"></script>
   <script src="Babylon/Mesh/babylon.csg.js"></script>
   <script src="Babylon/Tools/babylon.sceneSerializer.js"></script>
   <script src="Babylon/Physics/babylon.physicsEngine.js"></script>
   <script src="Babylon/Physics/Plugins/babylon.cannonJSPlugin.js"></script>
-  <script src="Babylon/Tools/babylon.filesInput.js"></script>
-  <script src="Babylon/Collisions/babylon.pickingInfo.js"></script>
   <script src="Babylon/LensFlare/babylon.lensFlareSystem.js"></script>
   <script src="Babylon/LensFlare/babylon.lensFlare.js"></script>
-  <script src="Babylon/PostProcess/babylon.anaglyphPostProcess.js"></script>
-  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPass.js"></script>
-  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js"></script>
-  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js"></script>
-  <script src="Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.js"></script>
-  <script src="Babylon/PostProcess/babylon.displayPassPostProcess.js"></script>
   <script src="Babylon/PostProcess/babylon.fxaaPostProcess.js"></script>
   <script src="Babylon/PostProcess/babylon.filterPostProcess.js"></script>
   <script src="Babylon/PostProcess/babylon.convolutionPostProcess.js"></script>
@@ -33,8 +45,8 @@
   <script src="Babylon/PostProcess/babylon.passPostProcess.js"></script>
   <script src="Babylon/PostProcess/babylon.postProcessManager.js"></script>
   <script src="Babylon/PostProcess/babylon.postProcess.js"></script>
-  <script src="Babylon/Bones/babylon.skeleton.js"></script>
   <script src="Babylon/Bones/babylon.bone.js"></script>
+  <script src="Babylon/Bones/babylon.skeleton.js"></script>
   <script src="Babylon/Culling/Octrees/babylon.octreeBlock.js"></script>
   <script src="Babylon/Culling/Octrees/babylon.octree.js"></script>
   <script src="Babylon/Animations/babylon.animatable.js"></script>
@@ -46,7 +58,6 @@
   <script src="Babylon/Sprites/babylon.spriteManager.js"></script>
   <script src="Babylon/Loading/Plugins/babylon.babylonFileLoader.js"></script>
   <script src="Babylon/Loading/babylon.sceneLoader.js"></script>
-  <script src="Babylon/Tools/babylon.database.js"></script>
   <script src="Babylon/Materials/babylon.multiMaterial.js"></script>
   <script src="Babylon/Materials/babylon.standardMaterial.js"></script>
   <script src="Babylon/Materials/babylon.material.js"></script>
@@ -57,47 +68,39 @@
   <script src="Babylon/Materials/textures/babylon.renderTargetTexture.js"></script>
   <script src="Babylon/Materials/textures/babylon.cubeTexture.js"></script>
   <script src="Babylon/Materials/textures/babylon.texture.js"></script>
-  <script src="Babylon/Rendering/babylon.renderingManager.js"></script>
-  <script src="Babylon/Rendering/babylon.renderingGroup.js"></script>
   <script src="Babylon/Materials/textures/babylon.baseTexture.js"></script>
   <script src="Babylon/Mesh/babylon.subMesh.js"></script>
   <script src="Babylon/Mesh/babylon.mesh.js"></script>
-  <script src="Babylon/Mesh/babylon.GroundMesh.js"></script>
   <script src="Babylon/Mesh/babylon.InstancedMesh.js"></script>
-  <script src="Babylon/Mesh/babylon.AbstractMesh.js"></script>
-  <script src="Babylon/Mesh/babylon.geometry.js"></script>
-  <script src="Babylon/Mesh/babylon.mesh.vertexData.js"></script>
   <script src="Babylon/Mesh/babylon.vertexBuffer.js"></script>
   <script src="Babylon/babylon.scene.js"></script>
-  <script src="Babylon/Rendering/babylon.boundingBoxRenderer.js"></script>
-  <script src="Babylon/Actions/babylon.condition.js"></script>
-  <script src="Babylon/Actions/babylon.actionManager.js"></script>
-  <script src="Babylon/Actions/babylon.interpolateValueAction.js"></script>
-  <script src="Babylon/Actions/babylon.directActions.js"></script>
-  <script src="Babylon/Actions/babylon.action.js"></script>
-  <script src="Babylon/Cameras/babylon.anaglyphCamera.js"></script>
-  <script src="Babylon/Cameras/babylon.arcRotateCamera.js"></script>
+  <script src="Babylon/Rendering/babylon.renderingGroup.js"></script>
+  <script src="Babylon/Rendering/babylon.renderingManager.js"></script>
   <script src="Babylon/Cameras/babylon.deviceOrientationCamera.js"></script>
+  <script src="Babylon/Cameras/babylon.arcRotateCamera.js"></script>
   <script src="Babylon/Cameras/babylon.touchCamera.js"></script>
   <script src="Babylon/Cameras/babylon.freeCamera.js"></script>
   <script src="Babylon/Cameras/babylon.camera.js"></script>
+  <script src="Babylon/Cameras/Controllers/babylon.inputController.js"></script>
   <script src="Babylon/Collisions/babylon.collider.js"></script>
-  <script src="Babylon/Lights/babylon.hemisphericLight.js"></script>
   <script src="Babylon/Lights//Shadows/babylon.shadowGenerator.js"></script>
   <script src="Babylon/Lights/babylon.directionalLight.js"></script>
+  <script src="Babylon/Lights/babylon.hemisphericLight.js"></script>
   <script src="Babylon/Lights/babylon.spotlight.js"></script>
   <script src="Babylon/Lights/babylon.pointLight.js"></script>
   <script src="Babylon/Lights/babylon.light.js"></script>
+  <script src="Babylon/Mesh/babylon.AbstractMesh.js"></script>
+  <script src="Babylon/Collisions/babylon.pickingInfo.js"></script>
   <script src="Babylon/Culling/babylon.boundingInfo.js"></script>
   <script src="Babylon/Culling/babylon.boundingBox.js"></script>
   <script src="Babylon/Culling/babylon.boundingSphere.js"></script>
+  <script src="Babylon/Tools/babylon.filesInput.js"></script>
+  <script src="Babylon/babylon.node.js"></script>
   <script src="Babylon/babylon.engine.js"></script>
-  <script src="Babylon/Math/babylon.math.js"></script>
-  <script src="Babylon/Tools/babylon.tags.js"></script>
-  <script src="Babylon/Tools/babylon.andOrNotEvaluator.js"></script>
+  <script src="Babylon/Tools/babylon.tools.js"></script>
   <script src="Babylon/Tools/babylon.smartArray.js"></script>
-  <script src="Babylon/Tools/babylon.tools.tga.js"></script>
   <script src="Babylon/Tools/babylon.tools.dds.js"></script>
-  <script src="Babylon/Tools/babylon.tools.js"></script>
-  <script src="Babylon/babylon.node.js"></script>
+  <script src="Babylon/Tools/babylon.tools.tga.js"></script>
+  <script src="Babylon/Tools/babylon.database.js"></script>
+  <script src="Babylon/Math/babylon.math.js"></script>
 </files>