Fixed bug with observable and mouse input only

dist/preview release/babylon.max.js

@@ -11644,6 +11644,9 @@ var BABYLON;
                 var engine = this.camera.getEngine();
                 this._pointerInput = function (p, s) {
                     var evt = p.event;
+                    if (evt.pointerType === "touch") {
+                        return;
+                    }
                     if (p.type === BABYLON.PointerEventTypes.POINTERDOWN) {
                         try {
                             evt.srcElement.setPointerCapture(evt.pointerId);
@@ -11854,14 +11857,13 @@ var BABYLON;
                 };
                 this._pointerInput = function (p, s) {
                     var evt = p.event;
+                    if (evt.pointerType === "mouse") {
+                        return;
+                    }
                     if (p.type === BABYLON.PointerEventTypes.POINTERDOWN) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }
-                        //  evt.srcElement.setPointerCapture(evt.pointerId);
                         _this._pointerPressed.push(evt.pointerId);
                         if (_this._pointerPressed.length !== 1) {
                             return;
@@ -11872,13 +11874,9 @@ var BABYLON;
                         };
                     }
                     else if (p.type === BABYLON.PointerEventTypes.POINTERUP) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }
-                        //  evt.srcElement.releasePointerCapture(evt.pointerId);
                         var index = _this._pointerPressed.indexOf(evt.pointerId);
                         if (index === -1) {
                             return;
@@ -11892,9 +11890,6 @@ var BABYLON;
                         _this._offsetY = null;
                     }
                     else if (p.type === BABYLON.PointerEventTypes.POINTERMOVE) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }
@@ -31192,7 +31187,7 @@ var BABYLON;
                     return;
                 }
                 this._boundingBias = value.clone();
-                this.updateExtend();
+                this.updateBoundingInfo(true, null);
             },
             enumerable: true,
             configurable: true
@@ -31255,24 +31250,27 @@ var BABYLON;
             if (kind === BABYLON.VertexBuffer.PositionKind) {
                 var stride = vertexBuffer.getStrideSize();
                 this._totalVertices = data.length / stride;
+                this.updateBoundingInfo(updateExtends, data);
+            }
+            this.notifyUpdate(kind);
+        };
+        Geometry.prototype.updateBoundingInfo = function (updateExtends, data) {
+            if (updateExtends) {
+                this.updateExtend(data);
+            }
+            var meshes = this._meshes;
+            var numOfMeshes = meshes.length;
+            for (var index = 0; index < numOfMeshes; index++) {
+                var mesh = meshes[index];
+                mesh._resetPointsArrayCache();
                 if (updateExtends) {
-                    this.updateExtend(data);
-                }
-                var meshes = this._meshes;
-                var numOfMeshes = meshes.length;
-                for (var index = 0; index < numOfMeshes; index++) {
-                    var mesh = meshes[index];
-                    mesh._resetPointsArrayCache();
-                    if (updateExtends) {
-                        mesh._boundingInfo = new BABYLON.BoundingInfo(this._extend.minimum, this._extend.maximum);
-                        for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
-                            var subMesh = mesh.subMeshes[subIndex];
-                            subMesh.refreshBoundingInfo();
-                        }
+                    mesh._boundingInfo = new BABYLON.BoundingInfo(this._extend.minimum, this._extend.maximum);
+                    for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
+                        var subMesh = mesh.subMeshes[subIndex];
+                        subMesh.refreshBoundingInfo();
                     }
                 }
             }
-            this.notifyUpdate(kind);
         };
         Geometry.prototype.getTotalVertices = function () {
             if (!this.isReady()) {

src/Cameras/Inputs/babylon.freecamera.input.mouse.js

@@ -17,6 +17,9 @@ var BABYLON;
                 var engine = this.camera.getEngine();
                 this._pointerInput = function (p, s) {
                     var evt = p.event;
+                    if (evt.pointerType === "touch") {
+                        return;
+                    }
                     if (p.type === BABYLON.PointerEventTypes.POINTERDOWN) {
                         try {
                             evt.srcElement.setPointerCapture(evt.pointerId);

src/Cameras/Inputs/babylon.freecamera.input.mouse.ts

@@ -17,6 +17,11 @@ module BABYLON {
                 var engine = this.camera.getEngine();
                 this._pointerInput = (p, s) => {
                     var evt = <PointerEvent>p.event;
+
+                    if (evt.pointerType === "touch") {
+                        return;
+                    }
+
                     if (p.type === PointerEventTypes.POINTERDOWN) {
                         try {
                             evt.srcElement.setPointerCapture(evt.pointerId);

src/Cameras/Inputs/babylon.freecamera.input.touch.js

@@ -25,14 +25,13 @@ var BABYLON;
                 };
                 this._pointerInput = function (p, s) {
                     var evt = p.event;
+                    if (evt.pointerType === "mouse") {
+                        return;
+                    }
                     if (p.type === BABYLON.PointerEventTypes.POINTERDOWN) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }
-                        //  evt.srcElement.setPointerCapture(evt.pointerId);
                         _this._pointerPressed.push(evt.pointerId);
                         if (_this._pointerPressed.length !== 1) {
                             return;
@@ -43,13 +42,9 @@ var BABYLON;
                         };
                     }
                     else if (p.type === BABYLON.PointerEventTypes.POINTERUP) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }
-                        //  evt.srcElement.releasePointerCapture(evt.pointerId);
                         var index = _this._pointerPressed.indexOf(evt.pointerId);
                         if (index === -1) {
                             return;
@@ -63,9 +58,6 @@ var BABYLON;
                         _this._offsetY = null;
                     }
                     else if (p.type === BABYLON.PointerEventTypes.POINTERMOVE) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }

src/Cameras/Inputs/babylon.freecamera.input.touch.ts

@@ -27,16 +27,17 @@ module BABYLON {
 
                 this._pointerInput = (p, s) => {
                     var evt = <PointerEvent>p.event;
+
+                    if (evt.pointerType === "mouse") {
+                        return;
+                    }
+
                     if (p.type === PointerEventTypes.POINTERDOWN) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
 
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }
 
-                      //  evt.srcElement.setPointerCapture(evt.pointerId);
                         this._pointerPressed.push(evt.pointerId);
 
                         if (this._pointerPressed.length !== 1) {
@@ -50,15 +51,10 @@ module BABYLON {
                     }
 
                     else if (p.type === PointerEventTypes.POINTERUP) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
-
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }
 
-                      //  evt.srcElement.releasePointerCapture(evt.pointerId);
                         var index: number = this._pointerPressed.indexOf(evt.pointerId);
 
                         if (index === -1) {
@@ -75,10 +71,6 @@ module BABYLON {
                     }
 
                     else if (p.type === PointerEventTypes.POINTERMOVE) {
-                        if (evt.pointerType === "mouse") {
-                            return;
-                        }
-
                         if (!noPreventDefault) {
                             evt.preventDefault();
                         }

src/Mesh/babylon.geometry.js

@@ -48,7 +48,7 @@ var BABYLON;
                     return;
                 }
                 this._boundingBias = value.clone();
-                this.updateExtend();
+                this.updateBoundingInfo(true, null);
             },
             enumerable: true,
             configurable: true
@@ -111,24 +111,27 @@ var BABYLON;
             if (kind === BABYLON.VertexBuffer.PositionKind) {
                 var stride = vertexBuffer.getStrideSize();
                 this._totalVertices = data.length / stride;
+                this.updateBoundingInfo(updateExtends, data);
+            }
+            this.notifyUpdate(kind);
+        };
+        Geometry.prototype.updateBoundingInfo = function (updateExtends, data) {
+            if (updateExtends) {
+                this.updateExtend(data);
+            }
+            var meshes = this._meshes;
+            var numOfMeshes = meshes.length;
+            for (var index = 0; index < numOfMeshes; index++) {
+                var mesh = meshes[index];
+                mesh._resetPointsArrayCache();
                 if (updateExtends) {
-                    this.updateExtend(data);
-                }
-                var meshes = this._meshes;
-                var numOfMeshes = meshes.length;
-                for (var index = 0; index < numOfMeshes; index++) {
-                    var mesh = meshes[index];
-                    mesh._resetPointsArrayCache();
-                    if (updateExtends) {
-                        mesh._boundingInfo = new BABYLON.BoundingInfo(this._extend.minimum, this._extend.maximum);
-                        for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
-                            var subMesh = mesh.subMeshes[subIndex];
-                            subMesh.refreshBoundingInfo();
-                        }
+                    mesh._boundingInfo = new BABYLON.BoundingInfo(this._extend.minimum, this._extend.maximum);
+                    for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
+                        var subMesh = mesh.subMeshes[subIndex];
+                        subMesh.refreshBoundingInfo();
                     }
                 }
             }
-            this.notifyUpdate(kind);
         };
         Geometry.prototype.getTotalVertices = function () {
             if (!this.isReady()) {

src/Mesh/babylon.geometry.ts

@@ -36,7 +36,8 @@
             }
 
             this._boundingBias = value.clone();
-            this.updateExtend();
+
+            this.updateBoundingInfo(true, null);
         }
 
         constructor(id: string, scene: Scene, vertexData?: VertexData, updatable?: boolean, mesh?: Mesh) {
@@ -143,28 +144,32 @@
                 var stride = vertexBuffer.getStrideSize();
                 this._totalVertices = data.length / stride;
 
-                if (updateExtends) {
-                    this.updateExtend(data);
-                }
+                this.updateBoundingInfo(updateExtends, data);
+            }
+            this.notifyUpdate(kind);
+        }
 
-                var meshes = this._meshes;
-                var numOfMeshes = meshes.length;
+        private updateBoundingInfo(updateExtends: boolean, data: number[] | Float32Array) {
+            if (updateExtends) {
+                this.updateExtend(data);
+            }
 
-                for (var index = 0; index < numOfMeshes; index++) {
-                    var mesh = meshes[index];
-                    mesh._resetPointsArrayCache();
-                    if (updateExtends) {
-                        mesh._boundingInfo = new BoundingInfo(this._extend.minimum, this._extend.maximum);
+            var meshes = this._meshes;
+            var numOfMeshes = meshes.length;
 
-                        for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
-                            var subMesh = mesh.subMeshes[subIndex];
+            for (var index = 0; index < numOfMeshes; index++) {
+                var mesh = meshes[index];
+                mesh._resetPointsArrayCache();
+                if (updateExtends) {
+                    mesh._boundingInfo = new BoundingInfo(this._extend.minimum, this._extend.maximum);
 
-                            subMesh.refreshBoundingInfo();
-                        }
+                    for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
+                        var subMesh = mesh.subMeshes[subIndex];
+
+                        subMesh.refreshBoundingInfo();
                     }
                 }
             }
-            this.notifyUpdate(kind);
         }
 
         public getTotalVertices(): number {
@@ -1228,4 +1233,3 @@
 }
 
 
-