|
|
@@ -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);
|
David Catuhe