Multi-touch support working properly up to 10 pointers and mouse re-enabled.

Author: photonstorm

src/input/InputManager.js

@@ -127,27 +127,40 @@ var InputManager = new Class({
 
         /**
          * An array of Pointers that have been added to the game.
-         * If you need more than 2 then use the `addPointer` method to create them.
+         * The first entry is reserved for the Mouse Pointer, the rest are Touch Pointers.
+         * 
+         * By default there are 2 pointers enabled. If you need more use the `addPointer` method to create them.
          *
          * @name Phaser.Input.InputManager#pointers
          * @type {Phaser.Input.Pointer[]}
          * @since 3.10.0
          */
         this.pointers = [
             new Pointer(this, 0),
-            new Pointer(this, 1)
+            new Pointer(this, 1),
+            new Pointer(this, 2),
+            new Pointer(this, 3),
+            new Pointer(this, 4),
+            new Pointer(this, 5),
+            new Pointer(this, 6),
+            new Pointer(this, 7),
+            new Pointer(this, 8),
+            new Pointer(this, 9),
+            new Pointer(this, 10)
         ];
 
+        this.pointersTotal = 2;
+
         /**
          * The mouse has its own unique Pointer object, which you can reference directly if making a _desktop specific game_.
          * If you are supporting both desktop and touch devices then do not use this property, instead use `activePointer`
          * which will always map to the most recently interacted pointer.
          *
          * @name Phaser.Input.InputManager#mousePointer
-         * @type {Phaser.Input.Pointer}
+         * @type {?Phaser.Input.Pointer}
          * @since 3.10.0
          */
-        this.mousePointer = this.pointers[0];
+        this.mousePointer = (config.inputMouse) ? this.pointers[0] : null;
 
         /**
          * The most recently active Pointer object.
@@ -327,7 +340,7 @@ var InputManager = new Class({
 
         var pointers = this.pointers;
 
-        for (var i = 0; i < pointers.length; i++)
+        for (var i = 0; i < this.pointersTotal; i++)
         {
             pointers[i].reset();
         }
@@ -337,6 +350,8 @@ var InputManager = new Class({
             return;
         }
 
+        this.dirty = true;
+
         this.updateBounds();
 
         this.scale.x = this.game.config.width / this.bounds.width;
@@ -347,117 +362,86 @@ var InputManager = new Class({
         var queue = this.queue.splice(0, len);
 
         //  Process the event queue, dispatching all of the events that have stored up
-        for (var i = 0; i < len; i++)
+        for (var i = 0; i < len; i += 3)
         {
-            var event = queue[i];
-
-            switch (event.type)
-            {
-                case 'mousemove':
-
-                    this.mousePointer.move(event, time);
-                    break;
-
-                case 'mousedown':
-
-                    this.mousePointer.down(event, time);
-                    break;
-
-                case 'mouseup':
-
-                    this.mousePointer.up(event, time);
-                    break;
-
-                case 'touchmove':
-
-                    for (i = 0; i < event.changedTouches.length; i++)
-                    {
-                        this.updatePointer(event.changedTouches[i], event, time);
-                    }
-
-                    break;
-
-                case 'touchstart':
-
-                    for (i = 0; i < event.changedTouches.length; i++)
-                    {
-                        this.startPointer(event.changedTouches[i], event, time);
-                    }
-
-                    break;
-
-                case 'touchend':
-
-                    for (i = 0; i < event.changedTouches.length; i++)
-                    {
-                        this.stopPointer(event.changedTouches[i], event, time);
-                    }
-
-                    break;
+            var callback = queue[i];
+            var context = queue[i + 1];
+            var event = queue[i + 2];
 
-                case 'pointerlockchange':
+            callback.call(context, event, time);
 
-                    this.events.emit('pointerlockchange', event, this.mouse.locked);
-                    break;
-            }
+            // case 'pointerlockchange':
+            // this.events.emit('pointerlockchange', event, this.mouse.locked);
         }
     },
 
     //  event.targetTouches = list of all touches on the TARGET ELEMENT (i.e. game dom element)
     //  event.touches = list of all touches on the ENTIRE DOCUMENT, not just the target element
     //  event.changedTouches = the touches that CHANGED in this event, not the total number of them
-    startPointer: function (changedTouch, event, time)
+    startPointer: function (event, time)
     {
         var pointers = this.pointers;
 
-        for (var i = 1; i < pointers.length; i++)
+        for (var c = 0; c < event.changedTouches.length; c++)
         {
-            var pointer = pointers[i];
+            var changedTouch = event.changedTouches[c];
 
-            if (!pointer.active)
+            for (var i = 1; i < this.pointersTotal; i++)
             {
-                pointer.touchstart(changedTouch, time);
-                this.activePointer = pointer;
-                this.dirty = true;
-                break;
+                var pointer = pointers[i];
+
+                if (!pointer.active)
+                {
+                    pointer.touchstart(changedTouch, time);
+                    this.activePointer = pointer;
+                    break;
+                }
             }
         }
     },
 
-    updatePointer: function (changedTouch, event, time)
+    updatePointer: function (event, time)
     {
         var pointers = this.pointers;
 
-        for (var i = 1; i < pointers.length; i++)
+        for (var c = 0; c < event.changedTouches.length; c++)
         {
-            var pointer = pointers[i];
+            var changedTouch = event.changedTouches[c];
 
-            if (pointer.active && pointer.identifier === changedTouch.identifier)
+            for (var i = 1; i < this.pointersTotal; i++)
             {
-                pointer.touchmove(changedTouch, time);
-                this.activePointer = pointer;
-                this.dirty = true;
-                break;
+                var pointer = pointers[i];
+
+                if (pointer.active && pointer.identifier === changedTouch.identifier)
+                {
+                    pointer.touchmove(changedTouch, time);
+                    this.activePointer = pointer;
+                    break;
+                }
             }
         }
     },
 
     //  For touch end its a list of the touch points that have been removed from the surface
     //  https://developer.mozilla.org/en-US/docs/DOM/TouchList
     //  event.changedTouches = the touches that CHANGED in this event, not the total number of them
-    stopPointer: function (changedTouch, event, time)
+    stopPointer: function (event, time)
     {
         var pointers = this.pointers;
 
-        for (var i = 1; i < pointers.length; i++)
+        for (var c = 0; c < event.changedTouches.length; c++)
         {
-            var pointer = pointers[i];
+            var changedTouch = event.changedTouches[c];
 
-            if (pointer.active && pointer.identifier === changedTouch.identifier)
+            for (var i = 1; i < this.pointersTotal; i++)
             {
-                pointer.touchend(changedTouch, time);
-                this.dirty = true;
-                break;
+                var pointer = pointers[i];
+
+                if (pointer.active && pointer.identifier === changedTouch.identifier)
+                {
+                    pointer.touchend(changedTouch, time);
+                    break;
+                }
             }
         }
     },
@@ -474,11 +458,22 @@ var InputManager = new Class({
     {
         var id = this.pointers.length;
 
-        var pointer = new Pointer(this, id);
+        if (this.pointersTotal < id)
+        {
+            this.pointersTotal++;
+
+            return this.pointers[this.pointersTotal];
+        }
+        else
+        {
+            var pointer = new Pointer(this, id);
 
-        this.pointers.push(pointer);
+            this.pointers.push(pointer);
 
-        return pointer;
+            this.pointersTotal++;
+
+            return pointer;
+        }
     },
 
     /**

src/input/InputPlugin.js

@@ -1521,7 +1521,7 @@ var InputPlugin = new Class({
 
         var pointers = this.manager.pointers;
 
-        for (var i = 0; i < pointers.length; i++)
+        for (var i = 0; i < this.manager.pointersTotal; i++)
         {
             var pointer = pointers[i];
 
@@ -1550,6 +1550,7 @@ var InputPlugin = new Class({
 
             var total = this.processDragEvents(pointer, time);
 
+            //  TODO: Enable for touch
             if (!pointer.wasTouch)
             {
                 total += this.processOverOutEvents(pointer);
@@ -1687,54 +1688,73 @@ var InputPlugin = new Class({
     },
 
     /**
-     * The current active input Pointer.
+     * The x coordinates of the ActivePointer based on the first camera in the camera list.
+     * This is only safe to use if your game has just 1 non-transformed camera and doesn't use multi-touch.
      *
-     * @name Phaser.Input.InputPlugin#activePointer
-     * @type {Phaser.Input.Pointer}
+     * @name Phaser.Input.InputPlugin#x
+     * @type {number}
      * @readOnly
      * @since 3.0.0
      */
-    activePointer: {
+    x: {
 
         get: function ()
         {
-            return this.manager.activePointer;
+            return this.manager.activePointer.x;
         }
 
     },
 
     /**
-     * The x coordinates of the ActivePointer based on the first camera in the camera list.
+     * The y coordinates of the ActivePointer based on the first camera in the camera list.
      * This is only safe to use if your game has just 1 non-transformed camera and doesn't use multi-touch.
      *
-     * @name Phaser.Input.InputPlugin#x
+     * @name Phaser.Input.InputPlugin#y
      * @type {number}
      * @readOnly
      * @since 3.0.0
      */
-    x: {
+    y: {
 
         get: function ()
         {
-            return this.manager.activePointer.x;
+            return this.manager.activePointer.y;
         }
 
     },
 
     /**
-     * The y coordinates of the ActivePointer based on the first camera in the camera list.
-     * This is only safe to use if your game has just 1 non-transformed camera and doesn't use multi-touch.
+     * The mouse has its own unique Pointer object, which you can reference directly if making a _desktop specific game_.
+     * If you are supporting both desktop and touch devices then do not use this property, instead use `activePointer`
+     * which will always map to the most recently interacted pointer.
      *
-     * @name Phaser.Input.InputPlugin#y
-     * @type {number}
+     * @name Phaser.Input.InputPlugin#mousePointer
+     * @type {Phaser.Input.Pointer}
+     * @readOnly
+     * @since 3.10.0
+     */
+    mousePointer: {
+
+        get: function ()
+        {
+            return this.manager.mousePointer;
+        }
+
+    },
+
+    /**
+     * The current active input Pointer.
+     *
+     * @name Phaser.Input.InputPlugin#activePointer
+     * @type {Phaser.Input.Pointer}
      * @readOnly
      * @since 3.0.0
      */
-    y: {
+    activePointer: {
 
         get: function ()
         {
-            return this.manager.activePointer.y;
+            return this.manager.activePointer;
         }
 
     },