Merge master

dist/preview release/babylon.max.js

@@ -25402,6 +25402,7 @@ var BABYLON;
         SceneComponentConstants.STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER = 1;
         SceneComponentConstants.STEP_BEFORECAMERADRAW_EFFECTLAYER = 0;
         SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER = 1;
+        SceneComponentConstants.STEP_BEFORERENDERTARGETDRAW_LAYER = 0;
         SceneComponentConstants.STEP_BEFORERENDERINGMESH_OUTLINE = 0;
         SceneComponentConstants.STEP_AFTERRENDERINGMESH_OUTLINE = 0;
         SceneComponentConstants.STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW = 0;
@@ -25409,6 +25410,7 @@ var BABYLON;
         SceneComponentConstants.STEP_BEFORECAMERAUPDATE_SIMPLIFICATIONQUEUE = 0;
         SceneComponentConstants.STEP_BEFORECAMERAUPDATE_GAMEPAD = 1;
         SceneComponentConstants.STEP_BEFORECLEAR_PROCEDURALTEXTURE = 0;
+        SceneComponentConstants.STEP_AFTERRENDERTARGETDRAW_LAYER = 0;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER = 0;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_LENSFLARESYSTEM = 1;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW = 2;
@@ -26180,6 +26182,11 @@ var BABYLON;
             _this._beforeCameraDrawStage = BABYLON.Stage.Create();
             /**
              * @hidden
+             * Defines the actions happening just before a render target is drawing.
+             */
+            _this._beforeRenderTargetDrawStage = BABYLON.Stage.Create();
+            /**
+             * @hidden
              * Defines the actions happening just before a rendering group is drawing.
              */
             _this._beforeRenderingGroupDrawStage = BABYLON.Stage.Create();
@@ -26205,6 +26212,11 @@ var BABYLON;
             _this._afterCameraDrawStage = BABYLON.Stage.Create();
             /**
              * @hidden
+             * Defines the actions happening just after a render target has been drawn.
+             */
+            _this._afterRenderTargetDrawStage = BABYLON.Stage.Create();
+            /**
+             * @hidden
              * Defines the actions happening just after rendering all cameras and computing intersections.
              */
             _this._afterRenderStage = BABYLON.Stage.Create();
@@ -27093,14 +27105,12 @@ var BABYLON;
                         this.onPointerObservable.notifyObservers(pi, type_1);
                     }
                 }
-                if (pickResult.pickedMesh.actionManager) {
-                    if (clickInfo.ignore) {
-                        pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickUpTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
-                    }
-                    if (!clickInfo.hasSwiped && !clickInfo.ignore && clickInfo.singleClick) {
+                if (pickResult.pickedMesh.actionManager && !clickInfo.ignore) {
+                    pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickUpTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                    if (!clickInfo.hasSwiped && clickInfo.singleClick) {
                         pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
-                    if (clickInfo.doubleClick && !clickInfo.ignore && pickResult.pickedMesh.actionManager.hasSpecificTrigger(BABYLON.ActionManager.OnDoublePickTrigger)) {
+                    if (clickInfo.doubleClick && pickResult.pickedMesh.actionManager.hasSpecificTrigger(BABYLON.ActionManager.OnDoublePickTrigger)) {
                         pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnDoublePickTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
                 }
@@ -29726,11 +29736,13 @@ var BABYLON;
             this._activeMeshStage.clear();
             this._cameraDrawRenderTargetStage.clear();
             this._beforeCameraDrawStage.clear();
+            this._beforeRenderTargetDrawStage.clear();
             this._beforeRenderingGroupDrawStage.clear();
             this._beforeRenderingMeshStage.clear();
             this._afterRenderingMeshStage.clear();
             this._afterRenderingGroupDrawStage.clear();
             this._afterCameraDrawStage.clear();
+            this._afterRenderTargetDrawStage.clear();
             this._afterRenderStage.clear();
             this._beforeCameraUpdateStage.clear();
             this._beforeClearStage.clear();
@@ -49221,6 +49233,7 @@ var BABYLON;
         TargetCamera.prototype._updateRigCameras = function () {
             var camLeft = this._rigCameras[0];
             var camRight = this._rigCameras[1];
+            this.computeWorldMatrix();
             switch (this.cameraRigMode) {
                 case BABYLON.Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
                 case BABYLON.Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
@@ -49250,13 +49263,12 @@ var BABYLON;
             _super.prototype._updateRigCameras.call(this);
         };
         TargetCamera.prototype._getRigCamPosition = function (halfSpace, result) {
-            if (!this._rigCamTransformMatrix) {
-                this._rigCamTransformMatrix = new BABYLON.Matrix();
-            }
             var target = this.getTarget();
-            BABYLON.Matrix.Translation(-target.x, -target.y, -target.z).multiplyToRef(BABYLON.Matrix.RotationY(halfSpace), this._rigCamTransformMatrix);
-            this._rigCamTransformMatrix = this._rigCamTransformMatrix.multiply(BABYLON.Matrix.Translation(target.x, target.y, target.z));
-            BABYLON.Vector3.TransformCoordinatesToRef(this.position, this._rigCamTransformMatrix, result);
+            BABYLON.Matrix.TranslationToRef(-target.x, -target.y, -target.z, TargetCamera._TargetTransformMatrix);
+            TargetCamera._TargetTransformMatrix.multiplyToRef(BABYLON.Matrix.RotationY(halfSpace), TargetCamera._RigCamTransformMatrix);
+            BABYLON.Matrix.TranslationToRef(target.x, target.y, target.z, TargetCamera._TargetTransformMatrix);
+            TargetCamera._RigCamTransformMatrix.multiplyToRef(TargetCamera._TargetTransformMatrix, TargetCamera._RigCamTransformMatrix);
+            BABYLON.Vector3.TransformCoordinatesToRef(this.position, TargetCamera._RigCamTransformMatrix, result);
         };
         /**
          * Gets the current object class name.
@@ -49265,6 +49277,8 @@ var BABYLON;
         TargetCamera.prototype.getClassName = function () {
             return "TargetCamera";
         };
+        TargetCamera._RigCamTransformMatrix = new BABYLON.Matrix();
+        TargetCamera._TargetTransformMatrix = new BABYLON.Matrix();
         __decorate([
             BABYLON.serializeAsVector3()
         ], TargetCamera.prototype, "rotation", void 0);
@@ -74453,8 +74467,18 @@ var BABYLON;
             if (!this._doNotChangeAspectRatio) {
                 scene.updateTransformMatrix(true);
             }
+            // Before Camera Draw
+            for (var _i = 0, _a = scene._beforeRenderTargetDrawStage; _i < _a.length; _i++) {
+                var step = _a[_i];
+                step.action(this);
+            }
             // Render
             this._renderingManager.render(this.customRenderFunction, currentRenderList, this.renderParticles, this.renderSprites);
+            // After Camera Draw
+            for (var _b = 0, _c = scene._afterRenderTargetDrawStage; _b < _c.length; _b++) {
+                var step = _c[_b];
+                step.action(this);
+            }
             if (this._postProcessManager) {
                 this._postProcessManager._finalizeFrame(false, this._texture, faceIndex, this._postProcesses, this.ignoreCameraViewport);
             }
@@ -78485,7 +78509,8 @@ var BABYLON;
                 dataCallback(directLoad);
                 return plugin;
             }
-            if (fileInfo.rootUrl.indexOf("file:") === -1) {
+            var file = BABYLON.FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
+            if (fileInfo.rootUrl.indexOf("file:") === -1 || (fileInfo.rootUrl.indexOf("file:") !== -1 && !file)) {
                 var engine = scene.getEngine();
                 var canUseOfflineSupport = engine.enableOfflineSupport;
                 if (canUseOfflineSupport) {
@@ -78510,7 +78535,6 @@ var BABYLON;
             }
             // Loading file from disk via input file or drag'n'drop
             else {
-                var file = BABYLON.FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
                 if (file) {
                     request = BABYLON.Tools.ReadFile(file, dataCallback, onProgress, useArrayBuffer);
                 }
@@ -115486,8 +115510,10 @@ var BABYLON;
          * Registers the component in a given scene
          */
         LayerSceneComponent.prototype.register = function () {
-            this.scene._beforeCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawBackground);
-            this.scene._afterCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawForeground);
+            this.scene._beforeCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawCameraBackground);
+            this.scene._afterCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawCameraForeground);
+            this.scene._beforeRenderTargetDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORERENDERTARGETDRAW_LAYER, this, this._drawRenderTargetBackground);
+            this.scene._afterRenderTargetDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERRENDERTARGETDRAW_LAYER, this, this._drawRenderTargetForeground);
         };
         /**
          * Rebuilds the elements related to this component in case of
@@ -115509,25 +115535,53 @@ var BABYLON;
                 layers[0].dispose();
             }
         };
-        LayerSceneComponent.prototype._draw = function (camera, isBackground) {
+        LayerSceneComponent.prototype._draw = function (predicate) {
             var layers = this.scene.layers;
             if (layers.length) {
                 this._engine.setDepthBuffer(false);
-                var cameraLayerMask = camera.layerMask;
                 for (var _i = 0, layers_2 = layers; _i < layers_2.length; _i++) {
                     var layer = layers_2[_i];
-                    if (layer.isBackground === isBackground && ((layer.layerMask & cameraLayerMask) !== 0)) {
+                    if (predicate(layer)) {
                         layer.render();
                     }
                 }
                 this._engine.setDepthBuffer(true);
             }
         };
-        LayerSceneComponent.prototype._drawBackground = function (camera) {
-            this._draw(camera, true);
+        LayerSceneComponent.prototype._drawCameraPredicate = function (layer, isBackground, cameraLayerMask) {
+            return !layer.renderOnlyInRenderTargetTextures &&
+                layer.isBackground === isBackground &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
         };
-        LayerSceneComponent.prototype._drawForeground = function (camera) {
-            this._draw(camera, false);
+        LayerSceneComponent.prototype._drawCameraBackground = function (camera) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawCameraPredicate(layer, true, camera.layerMask);
+            });
+        };
+        LayerSceneComponent.prototype._drawCameraForeground = function (camera) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawCameraPredicate(layer, false, camera.layerMask);
+            });
+        };
+        LayerSceneComponent.prototype._drawRenderTargetPredicate = function (layer, isBackground, cameraLayerMask, renderTargetTexture) {
+            return (layer.renderTargetTextures.length > 0) &&
+                layer.isBackground === isBackground &&
+                (layer.renderTargetTextures.indexOf(renderTargetTexture) > -1) &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
+        };
+        LayerSceneComponent.prototype._drawRenderTargetBackground = function (renderTarget) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawRenderTargetPredicate(layer, true, _this.scene.activeCamera.layerMask, renderTarget);
+            });
+        };
+        LayerSceneComponent.prototype._drawRenderTargetForeground = function (renderTarget) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawRenderTargetPredicate(layer, false, _this.scene.activeCamera.layerMask, renderTarget);
+            });
         };
         return LayerSceneComponent;
     }());
@@ -115577,6 +115631,15 @@ var BABYLON;
              * Define a mask to restrict the layer to only some of the scene cameras.
              */
             this.layerMask = 0x0FFFFFFF;
+            /**
+             * Define the list of render target the layer is visible into.
+             */
+            this.renderTargetTextures = [];
+            /**
+             * Define if the layer is only used in renderTarget or if it also
+             * renders in the main frame buffer of the canvas.
+             */
+            this.renderOnlyInRenderTargetTextures = false;
             this._vertexBuffers = {};
             /**
              * An event triggered when the layer is disposed.
@@ -115728,6 +115791,8 @@ var BABYLON;
                 this.texture.dispose();
                 this.texture = null;
             }
+            // Clean RTT list
+            this.renderTargetTextures = [];
             // Remove from scene
             var index = this._scene.layers.indexOf(this);
             this._scene.layers.splice(index, 1);

dist/preview release/babylon.no-module.max.js

@@ -25369,6 +25369,7 @@ var BABYLON;
         SceneComponentConstants.STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER = 1;
         SceneComponentConstants.STEP_BEFORECAMERADRAW_EFFECTLAYER = 0;
         SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER = 1;
+        SceneComponentConstants.STEP_BEFORERENDERTARGETDRAW_LAYER = 0;
         SceneComponentConstants.STEP_BEFORERENDERINGMESH_OUTLINE = 0;
         SceneComponentConstants.STEP_AFTERRENDERINGMESH_OUTLINE = 0;
         SceneComponentConstants.STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW = 0;
@@ -25376,6 +25377,7 @@ var BABYLON;
         SceneComponentConstants.STEP_BEFORECAMERAUPDATE_SIMPLIFICATIONQUEUE = 0;
         SceneComponentConstants.STEP_BEFORECAMERAUPDATE_GAMEPAD = 1;
         SceneComponentConstants.STEP_BEFORECLEAR_PROCEDURALTEXTURE = 0;
+        SceneComponentConstants.STEP_AFTERRENDERTARGETDRAW_LAYER = 0;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER = 0;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_LENSFLARESYSTEM = 1;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW = 2;
@@ -26147,6 +26149,11 @@ var BABYLON;
             _this._beforeCameraDrawStage = BABYLON.Stage.Create();
             /**
              * @hidden
+             * Defines the actions happening just before a render target is drawing.
+             */
+            _this._beforeRenderTargetDrawStage = BABYLON.Stage.Create();
+            /**
+             * @hidden
              * Defines the actions happening just before a rendering group is drawing.
              */
             _this._beforeRenderingGroupDrawStage = BABYLON.Stage.Create();
@@ -26172,6 +26179,11 @@ var BABYLON;
             _this._afterCameraDrawStage = BABYLON.Stage.Create();
             /**
              * @hidden
+             * Defines the actions happening just after a render target has been drawn.
+             */
+            _this._afterRenderTargetDrawStage = BABYLON.Stage.Create();
+            /**
+             * @hidden
              * Defines the actions happening just after rendering all cameras and computing intersections.
              */
             _this._afterRenderStage = BABYLON.Stage.Create();
@@ -27060,14 +27072,12 @@ var BABYLON;
                         this.onPointerObservable.notifyObservers(pi, type_1);
                     }
                 }
-                if (pickResult.pickedMesh.actionManager) {
-                    if (clickInfo.ignore) {
-                        pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickUpTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
-                    }
-                    if (!clickInfo.hasSwiped && !clickInfo.ignore && clickInfo.singleClick) {
+                if (pickResult.pickedMesh.actionManager && !clickInfo.ignore) {
+                    pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickUpTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                    if (!clickInfo.hasSwiped && clickInfo.singleClick) {
                         pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
-                    if (clickInfo.doubleClick && !clickInfo.ignore && pickResult.pickedMesh.actionManager.hasSpecificTrigger(BABYLON.ActionManager.OnDoublePickTrigger)) {
+                    if (clickInfo.doubleClick && pickResult.pickedMesh.actionManager.hasSpecificTrigger(BABYLON.ActionManager.OnDoublePickTrigger)) {
                         pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnDoublePickTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
                 }
@@ -29693,11 +29703,13 @@ var BABYLON;
             this._activeMeshStage.clear();
             this._cameraDrawRenderTargetStage.clear();
             this._beforeCameraDrawStage.clear();
+            this._beforeRenderTargetDrawStage.clear();
             this._beforeRenderingGroupDrawStage.clear();
             this._beforeRenderingMeshStage.clear();
             this._afterRenderingMeshStage.clear();
             this._afterRenderingGroupDrawStage.clear();
             this._afterCameraDrawStage.clear();
+            this._afterRenderTargetDrawStage.clear();
             this._afterRenderStage.clear();
             this._beforeCameraUpdateStage.clear();
             this._beforeClearStage.clear();
@@ -49188,6 +49200,7 @@ var BABYLON;
         TargetCamera.prototype._updateRigCameras = function () {
             var camLeft = this._rigCameras[0];
             var camRight = this._rigCameras[1];
+            this.computeWorldMatrix();
             switch (this.cameraRigMode) {
                 case BABYLON.Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
                 case BABYLON.Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
@@ -49217,13 +49230,12 @@ var BABYLON;
             _super.prototype._updateRigCameras.call(this);
         };
         TargetCamera.prototype._getRigCamPosition = function (halfSpace, result) {
-            if (!this._rigCamTransformMatrix) {
-                this._rigCamTransformMatrix = new BABYLON.Matrix();
-            }
             var target = this.getTarget();
-            BABYLON.Matrix.Translation(-target.x, -target.y, -target.z).multiplyToRef(BABYLON.Matrix.RotationY(halfSpace), this._rigCamTransformMatrix);
-            this._rigCamTransformMatrix = this._rigCamTransformMatrix.multiply(BABYLON.Matrix.Translation(target.x, target.y, target.z));
-            BABYLON.Vector3.TransformCoordinatesToRef(this.position, this._rigCamTransformMatrix, result);
+            BABYLON.Matrix.TranslationToRef(-target.x, -target.y, -target.z, TargetCamera._TargetTransformMatrix);
+            TargetCamera._TargetTransformMatrix.multiplyToRef(BABYLON.Matrix.RotationY(halfSpace), TargetCamera._RigCamTransformMatrix);
+            BABYLON.Matrix.TranslationToRef(target.x, target.y, target.z, TargetCamera._TargetTransformMatrix);
+            TargetCamera._RigCamTransformMatrix.multiplyToRef(TargetCamera._TargetTransformMatrix, TargetCamera._RigCamTransformMatrix);
+            BABYLON.Vector3.TransformCoordinatesToRef(this.position, TargetCamera._RigCamTransformMatrix, result);
         };
         /**
          * Gets the current object class name.
@@ -49232,6 +49244,8 @@ var BABYLON;
         TargetCamera.prototype.getClassName = function () {
             return "TargetCamera";
         };
+        TargetCamera._RigCamTransformMatrix = new BABYLON.Matrix();
+        TargetCamera._TargetTransformMatrix = new BABYLON.Matrix();
         __decorate([
             BABYLON.serializeAsVector3()
         ], TargetCamera.prototype, "rotation", void 0);
@@ -74420,8 +74434,18 @@ var BABYLON;
             if (!this._doNotChangeAspectRatio) {
                 scene.updateTransformMatrix(true);
             }
+            // Before Camera Draw
+            for (var _i = 0, _a = scene._beforeRenderTargetDrawStage; _i < _a.length; _i++) {
+                var step = _a[_i];
+                step.action(this);
+            }
             // Render
             this._renderingManager.render(this.customRenderFunction, currentRenderList, this.renderParticles, this.renderSprites);
+            // After Camera Draw
+            for (var _b = 0, _c = scene._afterRenderTargetDrawStage; _b < _c.length; _b++) {
+                var step = _c[_b];
+                step.action(this);
+            }
             if (this._postProcessManager) {
                 this._postProcessManager._finalizeFrame(false, this._texture, faceIndex, this._postProcesses, this.ignoreCameraViewport);
             }
@@ -78452,7 +78476,8 @@ var BABYLON;
                 dataCallback(directLoad);
                 return plugin;
             }
-            if (fileInfo.rootUrl.indexOf("file:") === -1) {
+            var file = BABYLON.FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
+            if (fileInfo.rootUrl.indexOf("file:") === -1 || (fileInfo.rootUrl.indexOf("file:") !== -1 && !file)) {
                 var engine = scene.getEngine();
                 var canUseOfflineSupport = engine.enableOfflineSupport;
                 if (canUseOfflineSupport) {
@@ -78477,7 +78502,6 @@ var BABYLON;
             }
             // Loading file from disk via input file or drag'n'drop
             else {
-                var file = BABYLON.FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
                 if (file) {
                     request = BABYLON.Tools.ReadFile(file, dataCallback, onProgress, useArrayBuffer);
                 }
@@ -115453,8 +115477,10 @@ var BABYLON;
          * Registers the component in a given scene
          */
         LayerSceneComponent.prototype.register = function () {
-            this.scene._beforeCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawBackground);
-            this.scene._afterCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawForeground);
+            this.scene._beforeCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawCameraBackground);
+            this.scene._afterCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawCameraForeground);
+            this.scene._beforeRenderTargetDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORERENDERTARGETDRAW_LAYER, this, this._drawRenderTargetBackground);
+            this.scene._afterRenderTargetDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERRENDERTARGETDRAW_LAYER, this, this._drawRenderTargetForeground);
         };
         /**
          * Rebuilds the elements related to this component in case of
@@ -115476,25 +115502,53 @@ var BABYLON;
                 layers[0].dispose();
             }
         };
-        LayerSceneComponent.prototype._draw = function (camera, isBackground) {
+        LayerSceneComponent.prototype._draw = function (predicate) {
             var layers = this.scene.layers;
             if (layers.length) {
                 this._engine.setDepthBuffer(false);
-                var cameraLayerMask = camera.layerMask;
                 for (var _i = 0, layers_2 = layers; _i < layers_2.length; _i++) {
                     var layer = layers_2[_i];
-                    if (layer.isBackground === isBackground && ((layer.layerMask & cameraLayerMask) !== 0)) {
+                    if (predicate(layer)) {
                         layer.render();
                     }
                 }
                 this._engine.setDepthBuffer(true);
             }
         };
-        LayerSceneComponent.prototype._drawBackground = function (camera) {
-            this._draw(camera, true);
+        LayerSceneComponent.prototype._drawCameraPredicate = function (layer, isBackground, cameraLayerMask) {
+            return !layer.renderOnlyInRenderTargetTextures &&
+                layer.isBackground === isBackground &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
         };
-        LayerSceneComponent.prototype._drawForeground = function (camera) {
-            this._draw(camera, false);
+        LayerSceneComponent.prototype._drawCameraBackground = function (camera) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawCameraPredicate(layer, true, camera.layerMask);
+            });
+        };
+        LayerSceneComponent.prototype._drawCameraForeground = function (camera) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawCameraPredicate(layer, false, camera.layerMask);
+            });
+        };
+        LayerSceneComponent.prototype._drawRenderTargetPredicate = function (layer, isBackground, cameraLayerMask, renderTargetTexture) {
+            return (layer.renderTargetTextures.length > 0) &&
+                layer.isBackground === isBackground &&
+                (layer.renderTargetTextures.indexOf(renderTargetTexture) > -1) &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
+        };
+        LayerSceneComponent.prototype._drawRenderTargetBackground = function (renderTarget) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawRenderTargetPredicate(layer, true, _this.scene.activeCamera.layerMask, renderTarget);
+            });
+        };
+        LayerSceneComponent.prototype._drawRenderTargetForeground = function (renderTarget) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawRenderTargetPredicate(layer, false, _this.scene.activeCamera.layerMask, renderTarget);
+            });
         };
         return LayerSceneComponent;
     }());
@@ -115544,6 +115598,15 @@ var BABYLON;
              * Define a mask to restrict the layer to only some of the scene cameras.
              */
             this.layerMask = 0x0FFFFFFF;
+            /**
+             * Define the list of render target the layer is visible into.
+             */
+            this.renderTargetTextures = [];
+            /**
+             * Define if the layer is only used in renderTarget or if it also
+             * renders in the main frame buffer of the canvas.
+             */
+            this.renderOnlyInRenderTargetTextures = false;
             this._vertexBuffers = {};
             /**
              * An event triggered when the layer is disposed.
@@ -115695,6 +115758,8 @@ var BABYLON;
                 this.texture.dispose();
                 this.texture = null;
             }
+            // Clean RTT list
+            this.renderTargetTextures = [];
             // Remove from scene
             var index = this._scene.layers.indexOf(this);
             this._scene.layers.splice(index, 1);

dist/preview release/es6.js

@@ -25369,6 +25369,7 @@ var BABYLON;
         SceneComponentConstants.STEP_CAMERADRAWRENDERTARGET_EFFECTLAYER = 1;
         SceneComponentConstants.STEP_BEFORECAMERADRAW_EFFECTLAYER = 0;
         SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER = 1;
+        SceneComponentConstants.STEP_BEFORERENDERTARGETDRAW_LAYER = 0;
         SceneComponentConstants.STEP_BEFORERENDERINGMESH_OUTLINE = 0;
         SceneComponentConstants.STEP_AFTERRENDERINGMESH_OUTLINE = 0;
         SceneComponentConstants.STEP_AFTERRENDERINGGROUPDRAW_EFFECTLAYER_DRAW = 0;
@@ -25376,6 +25377,7 @@ var BABYLON;
         SceneComponentConstants.STEP_BEFORECAMERAUPDATE_SIMPLIFICATIONQUEUE = 0;
         SceneComponentConstants.STEP_BEFORECAMERAUPDATE_GAMEPAD = 1;
         SceneComponentConstants.STEP_BEFORECLEAR_PROCEDURALTEXTURE = 0;
+        SceneComponentConstants.STEP_AFTERRENDERTARGETDRAW_LAYER = 0;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER = 0;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_LENSFLARESYSTEM = 1;
         SceneComponentConstants.STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW = 2;
@@ -26147,6 +26149,11 @@ var BABYLON;
             _this._beforeCameraDrawStage = BABYLON.Stage.Create();
             /**
              * @hidden
+             * Defines the actions happening just before a render target is drawing.
+             */
+            _this._beforeRenderTargetDrawStage = BABYLON.Stage.Create();
+            /**
+             * @hidden
              * Defines the actions happening just before a rendering group is drawing.
              */
             _this._beforeRenderingGroupDrawStage = BABYLON.Stage.Create();
@@ -26172,6 +26179,11 @@ var BABYLON;
             _this._afterCameraDrawStage = BABYLON.Stage.Create();
             /**
              * @hidden
+             * Defines the actions happening just after a render target has been drawn.
+             */
+            _this._afterRenderTargetDrawStage = BABYLON.Stage.Create();
+            /**
+             * @hidden
              * Defines the actions happening just after rendering all cameras and computing intersections.
              */
             _this._afterRenderStage = BABYLON.Stage.Create();
@@ -27060,14 +27072,12 @@ var BABYLON;
                         this.onPointerObservable.notifyObservers(pi, type_1);
                     }
                 }
-                if (pickResult.pickedMesh.actionManager) {
-                    if (clickInfo.ignore) {
-                        pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickUpTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
-                    }
-                    if (!clickInfo.hasSwiped && !clickInfo.ignore && clickInfo.singleClick) {
+                if (pickResult.pickedMesh.actionManager && !clickInfo.ignore) {
+                    pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickUpTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+                    if (!clickInfo.hasSwiped && clickInfo.singleClick) {
                         pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnPickTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
-                    if (clickInfo.doubleClick && !clickInfo.ignore && pickResult.pickedMesh.actionManager.hasSpecificTrigger(BABYLON.ActionManager.OnDoublePickTrigger)) {
+                    if (clickInfo.doubleClick && pickResult.pickedMesh.actionManager.hasSpecificTrigger(BABYLON.ActionManager.OnDoublePickTrigger)) {
                         pickResult.pickedMesh.actionManager.processTrigger(BABYLON.ActionManager.OnDoublePickTrigger, BABYLON.ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
                 }
@@ -29693,11 +29703,13 @@ var BABYLON;
             this._activeMeshStage.clear();
             this._cameraDrawRenderTargetStage.clear();
             this._beforeCameraDrawStage.clear();
+            this._beforeRenderTargetDrawStage.clear();
             this._beforeRenderingGroupDrawStage.clear();
             this._beforeRenderingMeshStage.clear();
             this._afterRenderingMeshStage.clear();
             this._afterRenderingGroupDrawStage.clear();
             this._afterCameraDrawStage.clear();
+            this._afterRenderTargetDrawStage.clear();
             this._afterRenderStage.clear();
             this._beforeCameraUpdateStage.clear();
             this._beforeClearStage.clear();
@@ -49188,6 +49200,7 @@ var BABYLON;
         TargetCamera.prototype._updateRigCameras = function () {
             var camLeft = this._rigCameras[0];
             var camRight = this._rigCameras[1];
+            this.computeWorldMatrix();
             switch (this.cameraRigMode) {
                 case BABYLON.Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
                 case BABYLON.Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
@@ -49217,13 +49230,12 @@ var BABYLON;
             _super.prototype._updateRigCameras.call(this);
         };
         TargetCamera.prototype._getRigCamPosition = function (halfSpace, result) {
-            if (!this._rigCamTransformMatrix) {
-                this._rigCamTransformMatrix = new BABYLON.Matrix();
-            }
             var target = this.getTarget();
-            BABYLON.Matrix.Translation(-target.x, -target.y, -target.z).multiplyToRef(BABYLON.Matrix.RotationY(halfSpace), this._rigCamTransformMatrix);
-            this._rigCamTransformMatrix = this._rigCamTransformMatrix.multiply(BABYLON.Matrix.Translation(target.x, target.y, target.z));
-            BABYLON.Vector3.TransformCoordinatesToRef(this.position, this._rigCamTransformMatrix, result);
+            BABYLON.Matrix.TranslationToRef(-target.x, -target.y, -target.z, TargetCamera._TargetTransformMatrix);
+            TargetCamera._TargetTransformMatrix.multiplyToRef(BABYLON.Matrix.RotationY(halfSpace), TargetCamera._RigCamTransformMatrix);
+            BABYLON.Matrix.TranslationToRef(target.x, target.y, target.z, TargetCamera._TargetTransformMatrix);
+            TargetCamera._RigCamTransformMatrix.multiplyToRef(TargetCamera._TargetTransformMatrix, TargetCamera._RigCamTransformMatrix);
+            BABYLON.Vector3.TransformCoordinatesToRef(this.position, TargetCamera._RigCamTransformMatrix, result);
         };
         /**
          * Gets the current object class name.
@@ -49232,6 +49244,8 @@ var BABYLON;
         TargetCamera.prototype.getClassName = function () {
             return "TargetCamera";
         };
+        TargetCamera._RigCamTransformMatrix = new BABYLON.Matrix();
+        TargetCamera._TargetTransformMatrix = new BABYLON.Matrix();
         __decorate([
             BABYLON.serializeAsVector3()
         ], TargetCamera.prototype, "rotation", void 0);
@@ -74420,8 +74434,18 @@ var BABYLON;
             if (!this._doNotChangeAspectRatio) {
                 scene.updateTransformMatrix(true);
             }
+            // Before Camera Draw
+            for (var _i = 0, _a = scene._beforeRenderTargetDrawStage; _i < _a.length; _i++) {
+                var step = _a[_i];
+                step.action(this);
+            }
             // Render
             this._renderingManager.render(this.customRenderFunction, currentRenderList, this.renderParticles, this.renderSprites);
+            // After Camera Draw
+            for (var _b = 0, _c = scene._afterRenderTargetDrawStage; _b < _c.length; _b++) {
+                var step = _c[_b];
+                step.action(this);
+            }
             if (this._postProcessManager) {
                 this._postProcessManager._finalizeFrame(false, this._texture, faceIndex, this._postProcesses, this.ignoreCameraViewport);
             }
@@ -78452,7 +78476,8 @@ var BABYLON;
                 dataCallback(directLoad);
                 return plugin;
             }
-            if (fileInfo.rootUrl.indexOf("file:") === -1) {
+            var file = BABYLON.FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
+            if (fileInfo.rootUrl.indexOf("file:") === -1 || (fileInfo.rootUrl.indexOf("file:") !== -1 && !file)) {
                 var engine = scene.getEngine();
                 var canUseOfflineSupport = engine.enableOfflineSupport;
                 if (canUseOfflineSupport) {
@@ -78477,7 +78502,6 @@ var BABYLON;
             }
             // Loading file from disk via input file or drag'n'drop
             else {
-                var file = BABYLON.FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
                 if (file) {
                     request = BABYLON.Tools.ReadFile(file, dataCallback, onProgress, useArrayBuffer);
                 }
@@ -115453,8 +115477,10 @@ var BABYLON;
          * Registers the component in a given scene
          */
         LayerSceneComponent.prototype.register = function () {
-            this.scene._beforeCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawBackground);
-            this.scene._afterCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawForeground);
+            this.scene._beforeCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawCameraBackground);
+            this.scene._afterCameraDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawCameraForeground);
+            this.scene._beforeRenderTargetDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_BEFORERENDERTARGETDRAW_LAYER, this, this._drawRenderTargetBackground);
+            this.scene._afterRenderTargetDrawStage.registerStep(BABYLON.SceneComponentConstants.STEP_AFTERRENDERTARGETDRAW_LAYER, this, this._drawRenderTargetForeground);
         };
         /**
          * Rebuilds the elements related to this component in case of
@@ -115476,25 +115502,53 @@ var BABYLON;
                 layers[0].dispose();
             }
         };
-        LayerSceneComponent.prototype._draw = function (camera, isBackground) {
+        LayerSceneComponent.prototype._draw = function (predicate) {
             var layers = this.scene.layers;
             if (layers.length) {
                 this._engine.setDepthBuffer(false);
-                var cameraLayerMask = camera.layerMask;
                 for (var _i = 0, layers_2 = layers; _i < layers_2.length; _i++) {
                     var layer = layers_2[_i];
-                    if (layer.isBackground === isBackground && ((layer.layerMask & cameraLayerMask) !== 0)) {
+                    if (predicate(layer)) {
                         layer.render();
                     }
                 }
                 this._engine.setDepthBuffer(true);
             }
         };
-        LayerSceneComponent.prototype._drawBackground = function (camera) {
-            this._draw(camera, true);
+        LayerSceneComponent.prototype._drawCameraPredicate = function (layer, isBackground, cameraLayerMask) {
+            return !layer.renderOnlyInRenderTargetTextures &&
+                layer.isBackground === isBackground &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
         };
-        LayerSceneComponent.prototype._drawForeground = function (camera) {
-            this._draw(camera, false);
+        LayerSceneComponent.prototype._drawCameraBackground = function (camera) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawCameraPredicate(layer, true, camera.layerMask);
+            });
+        };
+        LayerSceneComponent.prototype._drawCameraForeground = function (camera) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawCameraPredicate(layer, false, camera.layerMask);
+            });
+        };
+        LayerSceneComponent.prototype._drawRenderTargetPredicate = function (layer, isBackground, cameraLayerMask, renderTargetTexture) {
+            return (layer.renderTargetTextures.length > 0) &&
+                layer.isBackground === isBackground &&
+                (layer.renderTargetTextures.indexOf(renderTargetTexture) > -1) &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
+        };
+        LayerSceneComponent.prototype._drawRenderTargetBackground = function (renderTarget) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawRenderTargetPredicate(layer, true, _this.scene.activeCamera.layerMask, renderTarget);
+            });
+        };
+        LayerSceneComponent.prototype._drawRenderTargetForeground = function (renderTarget) {
+            var _this = this;
+            this._draw(function (layer) {
+                return _this._drawRenderTargetPredicate(layer, false, _this.scene.activeCamera.layerMask, renderTarget);
+            });
         };
         return LayerSceneComponent;
     }());
@@ -115544,6 +115598,15 @@ var BABYLON;
              * Define a mask to restrict the layer to only some of the scene cameras.
              */
             this.layerMask = 0x0FFFFFFF;
+            /**
+             * Define the list of render target the layer is visible into.
+             */
+            this.renderTargetTextures = [];
+            /**
+             * Define if the layer is only used in renderTarget or if it also
+             * renders in the main frame buffer of the canvas.
+             */
+            this.renderOnlyInRenderTargetTextures = false;
             this._vertexBuffers = {};
             /**
              * An event triggered when the layer is disposed.
@@ -115695,6 +115758,8 @@ var BABYLON;
                 this.texture.dispose();
                 this.texture = null;
             }
+            // Clean RTT list
+            this.renderTargetTextures = [];
             // Remove from scene
             var index = this._scene.layers.indexOf(this);
             this._scene.layers.splice(index, 1);

dist/preview release/what's new.md

@@ -60,6 +60,7 @@
 - Added opacity texture support to `GridMaterial` ([Deltakosh](https://github.com/deltakosh))
 - Added support for deserializing morph target animations in animation groups
 - AssetContainer dispose method ([TrevorDev](https://github.com/TrevorDev))
+- `Layer` are now supported in `RenderTargetTexture` ([Sebavan](https://github.com/Sebavan))
 
 ### glTF Loader
 

src/Cameras/babylon.targetCamera.ts

@@ -5,6 +5,8 @@ module BABYLON {
      * @see http://doc.babylonjs.com/features/cameras
      */
     export class TargetCamera extends Camera {
+        private static _RigCamTransformMatrix = new Matrix();
+        private static _TargetTransformMatrix = new Matrix();
 
         /**
          * Define the current direction the camera is moving to
@@ -59,7 +61,6 @@ module BABYLON {
         public _cameraTransformMatrix = Matrix.Zero();
         /** @hidden */
         public _cameraRotationMatrix = Matrix.Zero();
-        private _rigCamTransformMatrix: Matrix;
 
         /** @hidden */
         public _referencePoint = new Vector3(0, 0, 1);
@@ -435,6 +436,8 @@ module BABYLON {
             var camLeft = <TargetCamera>this._rigCameras[0];
             var camRight = <TargetCamera>this._rigCameras[1];
 
+            this.computeWorldMatrix();
+
             switch (this.cameraRigMode) {
                 case Camera.RIG_MODE_STEREOSCOPIC_ANAGLYPH:
                 case Camera.RIG_MODE_STEREOSCOPIC_SIDEBYSIDE_PARALLEL:
@@ -467,15 +470,14 @@ module BABYLON {
         }
 
         private _getRigCamPosition(halfSpace: number, result: Vector3) {
-            if (!this._rigCamTransformMatrix) {
-                this._rigCamTransformMatrix = new Matrix();
-            }
             var target = this.getTarget();
-            Matrix.Translation(-target.x, -target.y, -target.z).multiplyToRef(Matrix.RotationY(halfSpace), this._rigCamTransformMatrix);
+            Matrix.TranslationToRef(-target.x, -target.y, -target.z, TargetCamera._TargetTransformMatrix);
+            TargetCamera._TargetTransformMatrix.multiplyToRef(Matrix.RotationY(halfSpace), TargetCamera._RigCamTransformMatrix);
+            Matrix.TranslationToRef(target.x, target.y, target.z, TargetCamera._TargetTransformMatrix);
 
-            this._rigCamTransformMatrix = this._rigCamTransformMatrix.multiply(Matrix.Translation(target.x, target.y, target.z));
+            TargetCamera._RigCamTransformMatrix.multiplyToRef(TargetCamera._TargetTransformMatrix, TargetCamera._RigCamTransformMatrix);
 
-            Vector3.TransformCoordinatesToRef(this.position, this._rigCamTransformMatrix, result);
+            Vector3.TransformCoordinatesToRef(this.position, TargetCamera._RigCamTransformMatrix, result);
         }
 
         /**

src/Layer/babylon.layer.ts

@@ -48,6 +48,17 @@ module BABYLON {
          */
         public layerMask: number = 0x0FFFFFFF;
 
+        /**
+         * Define the list of render target the layer is visible into.
+         */
+        public renderTargetTextures: RenderTargetTexture[] = [];
+
+        /**
+         * Define if the layer is only used in renderTarget or if it also
+         * renders in the main frame buffer of the canvas.
+         */
+        public renderOnlyInRenderTargetTextures = false;
+
         private _scene: Scene;
         private _vertexBuffers: { [key: string]: Nullable<VertexBuffer> } = {};
         private _indexBuffer: Nullable<WebGLBuffer>;
@@ -198,7 +209,7 @@ module BABYLON {
 
             // Check
             if (!currentEffect.isReady() || !this.texture || !this.texture.isReady()) {
-                return;
+                return;
             }
 
             var engine = this._scene.getEngine();
@@ -256,6 +267,9 @@ module BABYLON {
                 this.texture = null;
             }
 
+            // Clean RTT list
+            this.renderTargetTextures = [];
+
             // Remove from scene
             var index = this._scene.layers.indexOf(this);
             this._scene.layers.splice(index, 1);

src/Layer/babylon.layerSceneComponent.ts

@@ -37,8 +37,11 @@ module BABYLON {
          * Registers the component in a given scene
          */
         public register(): void {
-            this.scene._beforeCameraDrawStage.registerStep(SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawBackground);
-            this.scene._afterCameraDrawStage.registerStep(SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawForeground);
+            this.scene._beforeCameraDrawStage.registerStep(SceneComponentConstants.STEP_BEFORECAMERADRAW_LAYER, this, this._drawCameraBackground);
+            this.scene._afterCameraDrawStage.registerStep(SceneComponentConstants.STEP_AFTERCAMERADRAW_LAYER, this, this._drawCameraForeground);
+
+            this.scene._beforeRenderTargetDrawStage.registerStep(SceneComponentConstants.STEP_BEFORERENDERTARGETDRAW_LAYER, this, this._drawRenderTargetBackground);
+            this.scene._afterRenderTargetDrawStage.registerStep(SceneComponentConstants.STEP_AFTERRENDERTARGETDRAW_LAYER, this, this._drawRenderTargetForeground);
         }
 
         /**
@@ -64,14 +67,13 @@ module BABYLON {
             }
         }
 
-        private _draw(camera: Camera, isBackground: boolean): void {
+        private _draw(predicate: (layer: Layer) => boolean): void {
             let layers = this.scene.layers;
 
             if (layers.length) {
                 this._engine.setDepthBuffer(false);
-                const cameraLayerMask = camera.layerMask;
                 for (let layer of layers) {
-                    if (layer.isBackground === isBackground && ((layer.layerMask & cameraLayerMask) !== 0)) {
+                    if (predicate(layer)) {
                         layer.render();
                     }
                 }
@@ -79,12 +81,41 @@ module BABYLON {
             }
         }
 
-        private _drawBackground(camera: Camera): void {
-            this._draw(camera, true);
+        private _drawCameraPredicate(layer: Layer, isBackground: boolean, cameraLayerMask: number): boolean {
+            return !layer.renderOnlyInRenderTargetTextures &&
+                layer.isBackground === isBackground &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
+        }
+
+        private _drawCameraBackground(camera: Camera): void {
+            this._draw((layer: Layer) => {
+                return this._drawCameraPredicate(layer, true, camera.layerMask);
+            });
+        }
+
+        private _drawCameraForeground(camera: Camera): void {
+            this._draw((layer: Layer) => {
+                return this._drawCameraPredicate(layer, false, camera.layerMask);
+            });
+        }
+
+        private _drawRenderTargetPredicate(layer: Layer, isBackground: boolean, cameraLayerMask: number, renderTargetTexture: RenderTargetTexture): boolean {
+            return (layer.renderTargetTextures.length > 0) &&
+                layer.isBackground === isBackground &&
+                (layer.renderTargetTextures.indexOf(renderTargetTexture) > -1) &&
+                ((layer.layerMask & cameraLayerMask) !== 0);
+        }
+
+        private _drawRenderTargetBackground(renderTarget: RenderTargetTexture): void {
+            this._draw((layer: Layer) => {
+                return this._drawRenderTargetPredicate(layer, true, this.scene.activeCamera!.layerMask, renderTarget);
+            });
         }
 
-        private _drawForeground(camera: Camera): void {
-            this._draw(camera, false);
+        private _drawRenderTargetForeground(renderTarget: RenderTargetTexture): void {
+            this._draw((layer: Layer) => {
+                return this._drawRenderTargetPredicate(layer, false, this.scene.activeCamera!.layerMask, renderTarget);
+            });
         }
     }
 }

src/Loading/babylon.sceneLoader.ts

@@ -403,7 +403,9 @@ module BABYLON {
                 return plugin;
             }
 
-            if (fileInfo.rootUrl.indexOf("file:") === -1) {
+            const file = FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
+
+            if (fileInfo.rootUrl.indexOf("file:") === -1 || (fileInfo.rootUrl.indexOf("file:") !== -1 && !file)) {
                 let engine = scene.getEngine();
                 let canUseOfflineSupport = engine.enableOfflineSupport;
                 if (canUseOfflineSupport) {
@@ -429,7 +431,6 @@ module BABYLON {
             }
             // Loading file from disk via input file or drag'n'drop
             else {
-                const file = FilesInput.FilesToLoad[fileInfo.name.toLowerCase()];
                 if (file) {
                     request = Tools.ReadFile(file, dataCallback, onProgress, useArrayBuffer);
                 } else {

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -754,9 +754,19 @@ module BABYLON {
                 scene.updateTransformMatrix(true);
             }
 
+            // Before Camera Draw
+            for (let step of scene._beforeRenderTargetDrawStage) {
+                step.action(this);
+            }
+
             // Render
             this._renderingManager.render(this.customRenderFunction, currentRenderList, this.renderParticles, this.renderSprites);
 
+            // After Camera Draw
+            for (let step of scene._afterRenderTargetDrawStage) {
+                step.action(this);
+            }
+
             if (this._postProcessManager) {
                 this._postProcessManager._finalizeFrame(false, this._texture, faceIndex, this._postProcesses, this.ignoreCameraViewport);
             }

src/babylon.scene.ts

@@ -1172,6 +1172,11 @@ module BABYLON {
         public _beforeCameraDrawStage = Stage.Create<CameraStageAction>();
         /**
          * @hidden
+         * Defines the actions happening just before a render target is drawing.
+         */
+        public _beforeRenderTargetDrawStage = Stage.Create<RenderTargetStageAction>();
+        /**
+         * @hidden
          * Defines the actions happening just before a rendering group is drawing.
          */
         public _beforeRenderingGroupDrawStage = Stage.Create<RenderingGroupStageAction>();
@@ -1197,6 +1202,11 @@ module BABYLON {
         public _afterCameraDrawStage = Stage.Create<CameraStageAction>();
         /**
          * @hidden
+         * Defines the actions happening just after a render target has been drawn.
+         */
+        public _afterRenderTargetDrawStage = Stage.Create<RenderTargetStageAction>();
+        /**
+         * @hidden
          * Defines the actions happening just after rendering all cameras and computing intersections.
          */
         public _afterRenderStage = Stage.Create<SimpleStageAction>();
@@ -1724,14 +1734,13 @@ module BABYLON {
                         this.onPointerObservable.notifyObservers(pi, type);
                     }
                 }
-                if (pickResult.pickedMesh.actionManager) {
-                    if (clickInfo.ignore) {
-                        pickResult.pickedMesh.actionManager.processTrigger(ActionManager.OnPickUpTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
-                    }
-                    if (!clickInfo.hasSwiped && !clickInfo.ignore && clickInfo.singleClick) {
+                if (pickResult.pickedMesh.actionManager && !clickInfo.ignore) {
+                    pickResult.pickedMesh.actionManager.processTrigger(ActionManager.OnPickUpTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
+
+                    if (!clickInfo.hasSwiped && clickInfo.singleClick) {
                         pickResult.pickedMesh.actionManager.processTrigger(ActionManager.OnPickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
-                    if (clickInfo.doubleClick && !clickInfo.ignore && pickResult.pickedMesh.actionManager.hasSpecificTrigger(ActionManager.OnDoublePickTrigger)) {
+                    if (clickInfo.doubleClick && pickResult.pickedMesh.actionManager.hasSpecificTrigger(ActionManager.OnDoublePickTrigger)) {
                         pickResult.pickedMesh.actionManager.processTrigger(ActionManager.OnDoublePickTrigger, ActionEvent.CreateNew(pickResult.pickedMesh, evt));
                     }
                 }
@@ -4782,11 +4791,13 @@ module BABYLON {
             this._activeMeshStage.clear();
             this._cameraDrawRenderTargetStage.clear();
             this._beforeCameraDrawStage.clear();
+            this._beforeRenderTargetDrawStage.clear();
             this._beforeRenderingGroupDrawStage.clear();
             this._beforeRenderingMeshStage.clear();
             this._afterRenderingMeshStage.clear();
             this._afterRenderingGroupDrawStage.clear();
             this._afterCameraDrawStage.clear();
+            this._afterRenderTargetDrawStage.clear();
             this._afterRenderStage.clear();
             this._beforeCameraUpdateStage.clear();
             this._beforeClearStage.clear();

src/babylon.sceneComponent.ts

@@ -35,6 +35,8 @@ module BABYLON {
         public static readonly STEP_BEFORECAMERADRAW_EFFECTLAYER = 0;
         public static readonly STEP_BEFORECAMERADRAW_LAYER = 1;
 
+        public static readonly STEP_BEFORERENDERTARGETDRAW_LAYER = 0;
+
         public static readonly STEP_BEFORERENDERINGMESH_OUTLINE = 0;
 
         public static readonly STEP_AFTERRENDERINGMESH_OUTLINE = 0;
@@ -47,6 +49,8 @@ module BABYLON {
 
         public static readonly STEP_BEFORECLEAR_PROCEDURALTEXTURE = 0;
 
+        public static readonly STEP_AFTERRENDERTARGETDRAW_LAYER = 0;
+
         public static readonly STEP_AFTERCAMERADRAW_EFFECTLAYER = 0;
         public static readonly STEP_AFTERCAMERADRAW_LENSFLARESYSTEM = 1;
         public static readonly STEP_AFTERCAMERADRAW_EFFECTLAYER_DRAW = 2;
@@ -146,6 +150,11 @@ module BABYLON {
     export type CameraStageAction = (camera: Camera) => void;
 
     /**
+     * Strong typing of a Render Target related stage step action
+     */
+    export type RenderTargetStageAction = (renderTarget: RenderTargetTexture) => void;
+
+    /**
      * Strong typing of a RenderingGroup related stage step action
      */
     export type RenderingGroupStageAction = (renderingGroupId: number) => void;