Add typescript support for Render Pipeline.

Fix somes issues in Render Pipeline.

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderEffect.js

@@ -1,239 +1,232 @@
-"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);
-
-		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]);
-			}
-
-			this._indicesForCamera.splice(cameras[i].name, 1);
-			this._cameras.splice(this._cameras.indexOf(cameras[i].name), 1);
-
-			for (var passName in this._renderPasses) {
-			    this._renderPasses[passName].decRefCount();
-			}
-		}
-	};
-
-	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());
+var BABYLON;
+(function (BABYLON) {
+    var PostProcessRenderEffect = (function () {
+        function PostProcessRenderEffect(engine, name, postProcessType, ratio, samplingMode, singleInstance) {
+            this.name = name;
+            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 () {
+            };
         }
-	};
-
-    
-	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;
-	};
-
-})();
+        PostProcessRenderEffect.getInstance = function (engine, postProcessType, ratio, samplingMode) {
+            var tmpClass;
+            var instance;
+            var args = new Array();
+
+            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;
+                }
+            }
+
+            tmpClass = function () {
+            };
+            tmpClass.prototype = postProcessType.prototype;
+
+            instance = new tmpClass();
+            postProcessType.apply(instance, args);
+
+            return instance;
+        };
+
+        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;
+        };
+
+        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 postProcess = null;
+
+            cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < cameras.length; i++) {
+                if (this._singleInstance) {
+                    postProcess = this._postProcesses[0] || PostProcessRenderEffect.getInstance(this._engine, this._postProcessType, this._ratio, this._samplingMode);
+                    this._postProcesses[0] = postProcess;
+                } else {
+                    postProcess = this._postProcesses[cameras[i].name] || 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]) == -1) {
+                    this._cameras.push(cameras[i]);
+                }
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName].incRefCount();
+                }
+            }
+
+            this._linkParameters();
+        };
+
+        PostProcessRenderEffect.prototype.detachCamera = 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]);
+                }
+
+                var index = this._cameras.indexOf(cameras[i].name);
+
+                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) {
+            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();
+                }
+            }
+        };
+
+        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();
+                }
+            }
+        };
+
+        PostProcessRenderEffect.prototype.getPostProcess = function () {
+            return this._postProcesses[0];
+        };
+
+        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);
+                };
+            }
+        };
+
+        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,251 @@
+module BABYLON {
+    export class PostProcessRenderEffect {
+        private _engine: Engine;
+        private _name: string;
+
+        private _postProcesses: PostProcess[];
+        private _postProcessType;
+
+        private _ratio: number;
+        private _samplingMode: number;
+        private _singleInstance: boolean;
+
+        private _cameras: Camera[];
+        private _indicesForCamera: number[];
+
+        private _renderPasses: PostProcessRenderPass[];
+        private _renderEffectAsPasses: PostProcessRenderEffect[];
+
+        public name: string;
+        public parameters: (effect) => void;
+
+
+        constructor(engine: Engine, name: string, postProcessType, ratio: number, samplingMode: number, singleInstance: boolean) {
+            this.name = name;
+            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 () { };
+        }
+
+        public static getInstance(engine: Engine, postProcessType, ratio: number, samplingMode: number): PostProcess {
+            var tmpClass;
+            var instance;
+            var args = new Array();
+
+            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;
+                }
+            }
+
+            tmpClass = function () { };
+            tmpClass.prototype = postProcessType.prototype;
+
+            instance = new tmpClass();
+            postProcessType.apply(instance, args);
+
+            return instance;
+        }
+
+        public static getParametersNames(func): string[] {
+            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;
+        }
+
+        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();
+        }
+
+        public attachCameras(cameras: Camera[]): void {
+            var postProcess = null;
+
+            cameras = Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < cameras.length; i++) {
+                if (this._singleInstance) {
+                    postProcess = this._postProcesses[0] || PostProcessRenderEffect.getInstance(this._engine, this._postProcessType, this._ratio, this._samplingMode);
+                    this._postProcesses[0] = postProcess;
+                }
+                else {
+                    postProcess = this._postProcesses[cameras[i].name] || 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]) == -1) {
+                    this._cameras.push(cameras[i]);
+                }
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName].incRefCount();
+                }
+            }
+
+            this._linkParameters();
+        }
+
+        public detachCamera(cameras): void {
+            cameras = 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]);
+                }
+
+                var index = this._cameras.indexOf(cameras[i].name);
+
+                this._indicesForCamera.splice(index, 1);
+                this._cameras.splice(index, 1);
+
+                for (var passName in this._renderPasses) {
+                    this._renderPasses[passName].decRefCount();
+                }
+            }
+        }
+
+        public enable(cameras: Camera[]): void {
+            cameras = 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();
+                }
+            }
+        }
+
+        public disable(cameras: Camera[]): void {
+            cameras = 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();
+                }
+            }
+        }
+
+        public getPostProcess(): PostProcess {
+            return this._postProcesses[0];
+        }
+
+        private _linkParameters(): void {
+            var that = this;
+            for (var index in this._postProcesses) {
+                this._postProcesses[index].onApply = function (effect) {
+                    that.parameters(effect);
+                    that._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

@@ -5,6 +5,8 @@
             this.name = name;
             this._enabled = true;
             this._refCount = 0;
+            this.name = name;
+
             this._renderTexture = new BABYLON.RenderTargetTexture(name, size, scene);
             this.setRenderList(renderList);
 

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPass.ts

@@ -1,12 +1,15 @@
 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;
+
+        public m_name: string;
 
         constructor(scene: Scene, public name: string, size: number, renderList: Mesh[], beforeRender: () => void, afterRender: () => void) {
+            this.name = name;
 
             this._renderTexture = new RenderTargetTexture(name, size, scene);
             this.setRenderList(renderList);

Babylon/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.js

@@ -1,138 +1,136 @@
-"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._renderEffectsPasses = [];
 
-(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) {
+            cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
 
-		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);
+            var renderEffects = this._renderEffects[renderEffectName];
 
-		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";
-})();
+            if (!renderEffects) {
+                return;
+            }
+
+            renderEffects.enable(cameras);
+        };
+
+        PostProcessRenderPipeline.prototype.disableEffect = function (renderEffectName, cameras) {
+            cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            var renderEffects = this._renderEffects[renderEffectName];
+
+            if (!renderEffects) {
+                return;
+            }
+
+            renderEffects.disable(cameras);
+        };
+
+        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);
+            }
+        };
+
+        PostProcessRenderPipeline.prototype.detachCamera = function (cameras) {
+            cameras = BABYLON.Tools.MakeArray(cameras || this._cameras);
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName].detachCamera(cameras);
+            }
+
+            for (var i = 0; i < cameras.length; i++) {
+                this._cameras.splice(this._cameras.indexOf(cameras[i]), 1);
+            }
+        };
+
+        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 = PostProcessRenderPipeline.PASS_SAMPLER_NAME;
+
+            for (var i = 0; i < cameras.length; i++) {
+                this._renderEffectsPasses[cameras[i].name] = this._renderEffectsPasses[cameras[i].name] || new BABYLON.PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsPasses[cameras[i].name].emptyPasses();
+                this._renderEffectsPasses[cameras[i].name].addPass(pass);
+                this._renderEffectsPasses[cameras[i].name].attachCameras(cameras[i]);
+            }
+        };
+
+        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.PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsPasses[cameras[i].name].disable(cameras[i]);
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName].enable(cameras);
+            }
+        };
+
+        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].name]) {
+                    this._renderEffectsPasses[this._cameras[i].name]._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,144 @@
+module BABYLON {
+    export class PostProcessRenderPipeline {
+        private _engine: Engine;
+
+        private _renderEffects: PostProcessRenderEffect[];
+        private _renderEffectsPasses: PostProcessRenderEffect[];
+
+        private _cameras: Camera[];
+
+        public name: string;
+
+        public static PASS_EFFECT_NAME: string = "passEffect";
+        public static PASS_SAMPLER_NAME: string = "passSampler";
+
+        constructor(engine: Engine, name: string) {
+            this._engine = engine;
+            this.name = name;
+
+            this._renderEffects = [];
+            this._renderEffectsPasses = [];
+
+            this._cameras = [];
+        }
+
+        public addEffect(renderEffect: PostProcessRenderEffect): void {
+            this._renderEffects[renderEffect.name] = renderEffect;
+        }
+
+        public enableEffect(renderEffectName: string, cameras): void {
+            cameras = Tools.MakeArray(cameras || this._cameras);
+
+            var renderEffects = this._renderEffects[renderEffectName];
+
+            if (!renderEffects) {
+                return;
+            }
+
+            renderEffects.enable(cameras);
+        }
+
+        public disableEffect(renderEffectName: string, cameras): void {
+            cameras = Tools.MakeArray(cameras || this._cameras);
+
+            var renderEffects = this._renderEffects[renderEffectName];
+
+            if (!renderEffects) {
+                return;
+            }
+
+            renderEffects.disable(cameras);
+        }
+
+        public attachCameras(cameras, unique: boolean): void {
+            cameras = 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);
+            }
+        }
+
+        public detachCamera(cameras): void {
+            cameras = Tools.MakeArray(cameras || this._cameras);
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName].detachCamera(cameras);
+            }
+
+            for (var i = 0; i < cameras.length; i++) {
+                this._cameras.splice(this._cameras.indexOf(cameras[i]), 1);
+            }
+        }
+
+        public enableDisplayOnlyPass(passName, cameras): void {
+            cameras = 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 = PostProcessRenderPipeline.PASS_SAMPLER_NAME;
+
+            for (var i = 0; i < cameras.length; i++) {
+                this._renderEffectsPasses[cameras[i].name] = this._renderEffectsPasses[cameras[i].name] || new PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsPasses[cameras[i].name].emptyPasses();
+                this._renderEffectsPasses[cameras[i].name].addPass(pass);
+                this._renderEffectsPasses[cameras[i].name].attachCameras(cameras[i]);
+            }
+        }
+
+        public disableDisplayOnlyPass(cameras): void {
+            cameras = Tools.MakeArray(cameras || this._cameras);
+
+            for (var i = 0; i < cameras.length; i++) {
+                this._renderEffectsPasses[cameras[i].name] = this._renderEffectsPasses[cameras[i].name] || new PostProcessRenderEffect(this._engine, PostProcessRenderPipeline.PASS_EFFECT_NAME, "BABYLON.DisplayPassPostProcess", 1.0, null, null);
+                this._renderEffectsPasses[cameras[i].name].disable(cameras[i]);
+            }
+
+            for (var renderEffectName in this._renderEffects) {
+                this._renderEffects[renderEffectName].enable(cameras);
+            }
+        }
+
+        public _update(): void {
+            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].name]) {
+                    this._renderEffectsPasses[this._cameras[i].name]._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.detachCameraFromRenderPipeline = 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,79 @@
+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, unique): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.attachCameras(cameras, unique);
+        }
+
+        public detachCameraFromRenderPipeline(renderPipelineName: string, cameras): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.detachCameras(cameras);
+        }
+
+        public enableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.enableEffect(renderEffectName, cameras);
+        }
+
+        public disableEffectInPipeline(renderPipelineName: string, renderEffectName: string, cameras): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.disableEffect(renderEffectName, cameras);
+        }
+
+        public enableDisplayOnlyPassInPipeline(renderPipelineName: string, passName: string, cameras): void {
+            var renderPipeline = this._renderPipelines[renderPipelineName];
+
+            if (!renderPipeline) {
+                return;
+            }
+
+            renderPipeline.enableDisplayOnlyPass(passName, cameras);
+        }
+
+        public disableDisplayOnlyPassInPipeline(renderPipelineName, cameras): 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

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

Babylon/babylon.scene.ts

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