Pointer Over and Out events and lists working

Author: photonstorm

v3/src/checksum.js

@@ -1,4 +1,4 @@
 var CHECKSUM = {
-build: '3d091d10-67d2-11e7-977c-8588186fe9f9'
+build: '29bc3100-6824-11e7-b3dd-8943a02e40de'
 };
 module.exports = CHECKSUM;

v3/src/input/GlobalInputManager.js

@@ -53,12 +53,16 @@ var GlobalInputManager = new Class({
         this.mouse.boot();
     },
 
-    update: function ()
+    update: function (time, delta)
     {
         this.keyboard.update();
 
         var len = this.queue.length;
 
+        var pointer = this.activePointer;
+
+        pointer.hasMoved = false;
+
         if (!this.enabled || len === 0)
         {
             return;
@@ -68,10 +72,6 @@ var GlobalInputManager = new Class({
         //  be modified during the processing phase
         var queue = this.queue.splice(0, len);
 
-        var pointer = this.activePointer;
-
-        pointer.hasMoved = false;
-
         //  Process the event queue, dispatching all of the events that have stored up
         for (var i = 0; i < len; i++)
         {

v3/src/input/events/PointerDownEvent.js

@@ -0,0 +1,23 @@
+var Class = require('../../utils/Class');
+var Event = require('../../events/Event');
+
+var PointerDownEvent = new Class({
+
+    Extends: Event,
+
+    initialize:
+
+    function PointerDownEvent (pointer, gameObject)
+    {
+        Event.call(this, 'POINTER_DOWN_EVENT');
+
+        this.pointer = pointer;
+        this.gameObject = gameObject;
+
+        // this.x;
+        // this.y;
+    }
+
+});
+
+module.exports = PointerDownEvent;

v3/src/input/events/PointerOutEvent.js

@@ -0,0 +1,23 @@
+var Class = require('../../utils/Class');
+var Event = require('../../events/Event');
+
+var PointerOutEvent = new Class({
+
+    Extends: Event,
+
+    initialize:
+
+    function PointerOutEvent (pointer, gameObject)
+    {
+        Event.call(this, 'POINTER_OUT_EVENT');
+
+        this.pointer = pointer;
+        this.gameObject = gameObject;
+
+        // this.x;
+        // this.y;
+    }
+
+});
+
+module.exports = PointerOutEvent;

v3/src/input/events/PointerOverEvent.js

@@ -0,0 +1,23 @@
+var Class = require('../../utils/Class');
+var Event = require('../../events/Event');
+
+var PointerOverEvent = new Class({
+
+    Extends: Event,
+
+    initialize:
+
+    function PointerOverEvent (pointer, gameObject)
+    {
+        Event.call(this, 'POINTER_OVER_EVENT');
+
+        this.pointer = pointer;
+        this.gameObject = gameObject;
+
+        // this.x;
+        // this.y;
+    }
+
+});
+
+module.exports = PointerOverEvent;

v3/src/input/events/PointerUpEvent.js

@@ -0,0 +1,23 @@
+var Class = require('../../utils/Class');
+var Event = require('../../events/Event');
+
+var PointerUpEvent = new Class({
+
+    Extends: Event,
+
+    initialize:
+
+    function PointerUpEvent (pointer, gameObject)
+    {
+        Event.call(this, 'POINTER_UP_EVENT');
+
+        this.pointer = pointer;
+        this.gameObject = gameObject;
+
+        // this.x;
+        // this.y;
+    }
+
+});
+
+module.exports = PointerUpEvent;

v3/src/input/events/index.js

@@ -0,0 +1,10 @@
+//  Phaser.Input.Events
+
+module.exports = {
+
+    DOWN: require('./PointerDownEvent'),
+    OUT: require('./PointerOutEvent'),
+    OVER: require('./PointerOverEvent'),
+    UP: require('./PointerUpEvent')
+
+};

v3/src/input/mouse/events/index.js

@@ -1,3 +1,4 @@
+//  Phaser.Input.Mouse.Events
 
 module.exports = {
     DOWN: require('./MouseDownEvent'),

v3/src/plugins/InputManager.js

@@ -1,4 +1,5 @@
 var Class = require('../utils/Class');
+var InputEvent = require('../input/events');
 
 var InputManager = new Class({
 
@@ -9,7 +10,7 @@ var InputManager = new Class({
         //  The State that owns this plugin
         this.state = state;
 
-        this.cameras = state.cameras.cameras;
+        this.cameras;
 
         //  GlobalInputManager
         this.manager = game.input;
@@ -21,11 +22,23 @@ var InputManager = new Class({
         this.mouse = this.manager.mouse;
 
         this._size = 0;
+
+        //  All interactive objects
         this._list = [];
+
+        //  Only those which are currently below a pointer (any pointer)
+        this._over = [];
+
+        //  Objects waiting to be inserted or removed from the active list
         this._pendingInsertion = [];
         this._pendingRemoval = [];
     },
 
+    boot: function ()
+    {
+        this.cameras = this.state.sys.cameras.cameras;
+    },
+
     begin: function ()
     {
         var toRemove = this._pendingRemoval.length;
@@ -53,13 +66,14 @@ var InputManager = new Class({
             }
         }
 
-        //  Move pending to active
+        //  Move pending to active (can swap for concat splice if we don't need anything extra here)
+
         for (i = 0; i < toInsert; i++)
         {
             gameObject = this._pendingInsertion[i];
 
             //  Swap for Input Enabled Object
-            this._list.push({ gameObject: gameObject, over: false, down: false, localX: 0, localY: 0 });
+            this._list.push(gameObject);
         }
 
         this._size = this._list.length;
@@ -85,20 +99,64 @@ var InputManager = new Class({
 
     processPointer: function (pointer)
     {
-        var over = [];
+        var i;
+        var tested = [];
+        var justOut = [];
+        var justOver = [];
+        var stillOver = [];
 
         //  Returns an array of objects the pointer is over
 
-        for (var i = 0; i < this.cameras.length; i++)
+        for (i = 0; i < this.cameras.length; i++)
         {
             var camera = this.cameras[i];
 
             if (camera.inputEnabled)
             {
-                over = over.concat(this.manager.hitTest(this._list, pointer.x, pointer.y, camera));
+                tested = tested.concat(this.manager.hitTest(this._list, pointer.x, pointer.y, camera));
+            }
+        }
+
+        for (i = 0; i < tested.length; i++)
+        {
+            var item = tested[i];
+
+            if (this._over.indexOf(item) !== -1)
+            {
+                stillOver.push(item);
             }
+            else
+            {
+                justOver.push(item);
+            }
+        }
+
+        this._over.forEach(function(item) {
+
+            if (tested.indexOf(item) === -1)
+            {
+                justOut.push(item);
+            }
+
+        });
+
+        //  Now we can process what has happened
+        for (i = 0; i < justOut.length; i++)
+        {
+            //  Dispatch event? (include the pointer)
+            this.events.dispatch(new InputEvent.OUT(pointer, justOut[i]));
         }
 
+        for (i = 0; i < justOver.length; i++)
+        {
+            //  Dispatch event? (include the pointer)
+            this.events.dispatch(new InputEvent.OVER(pointer, justOver[i]));
+        }
+
+        //  Store everything that is currently over
+        this._over = stillOver.concat(justOver);
+
+        // console.log('tested', tested.length, 'justOver', justOver.length, 'justOut', justOut.length, 'stillOver', stillOver.length, '_over', this._over.length);
     },
 
     add: function (child)

v3/src/state/Systems.js

@@ -93,6 +93,9 @@ var Systems = new Class({
         this.time = new Clock(state);
         this.tweens = new TweenManager(state);
 
+        //  Sometimes the managers need access to a system created after them
+        this.inputManager.boot();
+
         this.inject();
     },