Fixed Up and Down events. Working properly including with topOnly.

Author: photonstorm

v3/src/checksum.js

@@ -1,4 +1,4 @@
 var CHECKSUM = {
-build: '39e871e0-6dc1-11e7-8a70-9f91dc27e295'
+build: '2ba7f500-6dc2-11e7-a19b-db1919761fe1'
 };
 module.exports = CHECKSUM;

v3/src/input/local/SceneInputManager.js

@@ -92,8 +92,12 @@ var SceneInputManager = new Class({
     setOnUpCallback: require('./components/SetOnUpCallback'),
 
     processOverOutEvents: require('./components/ProcessOverOutEvents'),
+    processDownEvents: require('./components/ProcessDownEvents'),
+    processUpEvents: require('./components/ProcessUpEvents'),
     childOnOut: require('./components/ChildOnOut'),
     childOnOver: require('./components/ChildOnOver'),
+    childOnDown: require('./components/ChildOnDown'),
+    childOnUp: require('./components/ChildOnUp'),
     sortInteractiveObjects: require('./components/SortInteractiveObjects'),
     sortIndexHandler: require('./components/SortIndexHandler'),
 

v3/src/input/local/components/ChildOnDown.js

@@ -0,0 +1,15 @@
+var ChildOnDown = function (pointer, interactiveObject)
+{
+    interactiveObject.isDown = true;
+
+    interactiveObject.onDown(interactiveObject.gameObject, pointer, interactiveObject.localX, interactiveObject.localY);
+
+    this.children.down[pointer.id].push(interactiveObject);
+
+    // if (input.draggable && !input.isDragged)
+    // {
+    //     this.gameObjectOnDragStart(pointer, gameObject);
+    // }
+};
+
+module.exports = ChildOnDown;

v3/src/input/local/components/ChildOnUp.js

@@ -0,0 +1,12 @@
+var ChildOnUp = function (index, pointer, interactiveObject)
+{
+    interactiveObject.isDown = false;
+
+    //  If we are not processing topOnly items, or we are and this IS the topmost item, then hit it
+    if (!this.topOnly || (this.topOnly && index === 0))
+    {
+        interactiveObject.onUp(interactiveObject.gameObject, pointer);
+    }
+};
+
+module.exports = ChildOnUp;

v3/src/input/local/components/ProcessDownEvents.js

@@ -0,0 +1,29 @@
+var InputEvent = require('../events');
+
+var ProcessDownEvents = function (pointer, currentlyOver)
+{
+    if (currentlyOver.length === 0)
+    {
+        //  Dispatch DOWN event, even though nothing was below the pointer
+        this.events.dispatch(new InputEvent.DOWN(pointer));
+    }
+    else
+    {
+        //  Go through all objects the pointer was over and set them to down
+        for (var i = 0; i < currentlyOver.length; i++)
+        {
+            var interactiveObject = currentlyOver[i];
+
+            this.events.dispatch(new InputEvent.DOWN(pointer, interactiveObject.gameObject, currentlyOver));
+
+            this.childOnDown(pointer, interactiveObject);
+
+            if (this.topOnly)
+            {
+                break;
+            }
+        }
+    }
+};
+
+module.exports = ProcessDownEvents;

v3/src/input/local/components/ProcessUpEvents.js

@@ -0,0 +1,36 @@
+var InputEvent = require('../events');
+
+var ProcessUpEvents = function (pointer, currentlyOver)
+{
+    //  If the pointer is released we need to reset all 'isDown' IOs, regardless if pointer is still over them or not
+    //  Also concat in the currentlyOver, so we can dispatch an UP event for an IO that has the pointer over it.
+    //  For example if you click down outside a sprite, hold down, move over the sprite, then release, the sprite will
+    //  still fire an UP event, even though it never previously received a DOWN event.
+    var previouslyDown = this.children.down[pointer.id].concat(currentlyOver);
+
+    if (previouslyDown.length === 0)
+    {
+        //  Dispatch UP event, even though nothing was down previously
+        this.events.dispatch(new InputEvent.UP(pointer));
+    }
+    else
+    {
+        //  Go through all objects the pointer was previously down on and set to up
+        for (var i = 0; i < previouslyDown.length; i++)
+        {
+            var interactiveObject = previouslyDown[i];
+
+            if (!this.topOnly || (this.topOnly && i === 0))
+            {
+                this.events.dispatch(new InputEvent.UP(pointer, interactiveObject.gameObject, previouslyDown));
+            }
+
+            this.childOnUp(i, pointer, interactiveObject);
+        }
+    }
+
+    //  Reset the down array
+    this.children.down[pointer.id].length = 0;
+};
+
+module.exports = ProcessUpEvents;