Fix for pointer position (Trying to check if this works better)

Babylon/Mesh/babylon.groundMesh.js

@@ -22,8 +22,9 @@ var BABYLON;
         });
 
         GroundMesh.prototype.optimize = function (chunksCount) {
+            if (typeof chunksCount === "undefined") { chunksCount = 32; }
             this.subdivide(this._subdivisions);
-            this.createOrUpdateSubmeshesOctree(32);
+            this.createOrUpdateSubmeshesOctree(chunksCount);
         };
 
         GroundMesh.prototype.getHeightAtCoordinates = function (x, z) {

Babylon/Mesh/babylon.groundMesh.ts

@@ -13,9 +13,9 @@
             return this._subdivisions;
         }
 
-        public optimize(chunksCount: number): void {
+        public optimize(chunksCount: number = 32): void {
             this.subdivide(this._subdivisions);
-            this.createOrUpdateSubmeshesOctree(32);
+            this.createOrUpdateSubmeshesOctree(chunksCount);
         }
 
         public getHeightAtCoordinates(x: number, z: number): number {

Babylon/babylon.scene.js

@@ -172,16 +172,24 @@
             return this._renderId;
         };
 
+        Scene.prototype._updatePointerPosition = function (evt) {
+            var canvas = this._engine.getRenderingCanvas();
+            var rect = canvas.getBoundingClientRect();
+
+            this._pointerX = evt.clientX - rect.left;
+            this._pointerY = evt.clientY - rect.top;
+        };
+
         // Pointers handling
         Scene.prototype.attachControl = function () {
             var _this = this;
             this._onPointerMove = function (evt) {
                 var canvas = _this._engine.getRenderingCanvas();
 
-                _this._pointerX = evt.offsetX || evt.layerX;
-                _this._pointerY = evt.offsetY || evt.layerY;
+                _this._updatePointerPosition(evt);
+
                 var pickResult = _this.pick(_this._pointerX, _this._pointerY, function (mesh) {
-                    return mesh.actionManager && mesh.isPickable;
+                    return mesh.actionManager && mesh.isPickable && mesh.isVisible && mesh.isReady();
                 });
 
                 if (pickResult.hit) {
@@ -197,7 +205,16 @@
             };
 
             this._onPointerDown = function (evt) {
-                var pickResult = _this.pick(evt.offsetX || evt.layerX, evt.offsetY || evt.layerY);
+                var predicate = null;
+
+                if (!_this.onPointerDown) {
+                    predicate = function (mesh) {
+                        return mesh.actionManager && mesh.isPickable && mesh.isVisible && mesh.isReady();
+                    };
+                }
+
+                _this._updatePointerPosition(evt);
+                var pickResult = _this.pick(_this._pointerX, _this._pointerY, predicate);
 
                 if (pickResult.hit) {
                     if (pickResult.pickedMesh.actionManager) {

Babylon/babylon.scene.ts

@@ -238,14 +238,22 @@
             return this._renderId;
         }
 
+        private _updatePointerPosition(evt: PointerEvent): void {
+            var canvas = this._engine.getRenderingCanvas();
+            var rect = canvas.getBoundingClientRect();
+
+            this._pointerX = evt.clientX - rect.left; 
+            this._pointerY = evt.clientY - rect.top;
+        }
+
         // Pointers handling
         public attachControl() {
             this._onPointerMove = (evt: PointerEvent) => {
                 var canvas = this._engine.getRenderingCanvas();
 
-                this._pointerX = evt.offsetX || evt.layerX;
-                this._pointerY = evt.offsetY || evt.layerY;
-                var pickResult = this.pick(this._pointerX, this._pointerY, mesh => mesh.actionManager && mesh.isPickable);
+                this._updatePointerPosition(evt);
+
+                var pickResult = this.pick(this._pointerX, this._pointerY, (mesh: AbstractMesh): boolean => mesh.actionManager && mesh.isPickable && mesh.isVisible && mesh.isReady());
 
                 if (pickResult.hit) {
                     this.setPointerOverMesh(pickResult.pickedMesh);
@@ -260,7 +268,16 @@
             };
 
             this._onPointerDown = (evt: PointerEvent) => {
-                var pickResult = this.pick(evt.offsetX || evt.layerX, evt.offsetY || evt.layerY);
+                var predicate = null;
+
+                if (!this.onPointerDown) {
+                    predicate = (mesh: AbstractMesh): boolean => {
+                        return mesh.actionManager && mesh.isPickable && mesh.isVisible && mesh.isReady();
+                    };
+                }
+
+                this._updatePointerPosition(evt);
+                var pickResult = this.pick(this._pointerX, this._pointerY, predicate);
 
                 if (pickResult.hit) {
                     if (pickResult.pickedMesh.actionManager) {
@@ -1207,7 +1224,7 @@
             return pickingInfo || new BABYLON.PickingInfo();
         }
 
-        public pick(x: number, y: number, predicate?: (mesh: Mesh) => boolean, fastCheck?: boolean, camera?: Camera): PickingInfo {
+        public pick(x: number, y: number, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, camera?: Camera): PickingInfo {
             /// <summary>Launch a ray to try to pick a mesh in the scene</summary>
             /// <param name="x">X position on screen</param>
             /// <param name="y">Y position on screen</param>