Let Pointer3DInputModule event behaviour more consistent with StandaloneInputModule

Also add some debug message that can be shown in EventSystem preview window.
Add Press Enter/Exit event:
  - IPointer3DPressEnterHandler
  - IPointer3DPressExitHandler
Their behaviours are like IPointerEnterHandler/IPointerExitHandler, but
press enter happend when the button is pressed and moved in, and press exit
on button released or pointer moved out.

Author: lawwong

Assets/HTC.UnityPlugin/Pointer3D/ExecutePointer3DEvents.cs

@@ -0,0 +1,21 @@
+//========= Copyright 2016-2017, HTC Corporation. All rights reserved. ===========
+
+using UnityEngine.EventSystems;
+
+namespace HTC.UnityPlugin.Pointer3D
+{
+    public static class ExecutePointer3DEvents
+    {
+        public static readonly ExecuteEvents.EventFunction<IPointer3DPressEnterHandler> PressEnterHandler = Execute;
+        private static void Execute(IPointer3DPressEnterHandler handler, BaseEventData eventData)
+        {
+            handler.OnPointer3DPressEnter(ExecuteEvents.ValidateEventData<Pointer3DEventData>(eventData));
+        }
+
+        public static readonly ExecuteEvents.EventFunction<IPointer3DPressExitHandler> PressExitHandler = Execute;
+        private static void Execute(IPointer3DPressExitHandler handler, BaseEventData eventData)
+        {
+            handler.OnPointer3DPressExit(ExecuteEvents.ValidateEventData<Pointer3DEventData>(eventData));
+        }
+    }
+}

Assets/HTC.UnityPlugin/Pointer3D/ExecutePointer3DEvents.cs.meta

@@ -65,6 +65,7 @@ public class Pointer3DEventData : PointerEventData
         public Quaternion pressRotation;
 
         public float pressDistance;
+        public GameObject pressEnter;
 
         public Pointer3DEventData(Pointer3DRaycaster ownerRaycaster, EventSystem eventSystem) : base(eventSystem)
         {
@@ -77,5 +78,17 @@ public Pointer3DEventData(Pointer3DRaycaster ownerRaycaster, EventSystem eventSy
         public virtual bool GetPressDown() { return false; }
 
         public virtual bool GetPressUp() { return false; }
+
+        public override string ToString()
+        {
+            var str = string.Empty;
+            str += "eligibleForClick: " + eligibleForClick + "\n";
+            str += "pointerEnter: " + Pointer3DInputModule.PrintGOPath(pointerEnter) + "\n";
+            str += "pointerPress: " + Pointer3DInputModule.PrintGOPath(pointerPress) + "\n";
+            str += "lastPointerPress: " + Pointer3DInputModule.PrintGOPath(lastPress) + "\n";
+            str += "pressEnter: " + Pointer3DInputModule.PrintGOPath(pressEnter) + "\n";
+            str += "pointerDrag: " + Pointer3DInputModule.PrintGOPath(pointerDrag) + "\n";
+            return str;
+        }
     }
 }

Assets/HTC.UnityPlugin/Pointer3D/Pointer3DEventData.cs

@@ -0,0 +1,16 @@
+//========= Copyright 2016-2017, HTC Corporation. All rights reserved. ===========
+
+using UnityEngine.EventSystems;
+
+namespace HTC.UnityPlugin.Pointer3D
+{
+    public interface IPointer3DPressEnterHandler : IEventSystemHandler
+    {
+        void OnPointer3DPressEnter(Pointer3DEventData eventData);
+    }
+
+    public interface IPointer3DPressExitHandler : IEventSystemHandler
+    {
+        void OnPointer3DPressExit(Pointer3DEventData eventData);
+    }
+}

Assets/HTC.UnityPlugin/Pointer3D/Pointer3DEventInterfaces.cs

@@ -145,11 +145,6 @@ protected override void OnDisable()
                     instance.CleanUpRaycaster(raycasters[i]);
                 }
             }
-
-            if (eventSystem != null)
-            {
-                eventSystem.SetSelectedGameObject(null, GetBaseEventData());
-            }
         }
 
         public static readonly Comparison<RaycastResult> defaultRaycastComparer = RaycastComparer;
@@ -225,30 +220,38 @@ public static void RemoveRaycaster(Pointer3DRaycaster raycaster)
 
         protected void CleanUpRaycaster(Pointer3DRaycaster raycaster)
         {
+            if (raycaster == null) { return; }
+
             var hoverEventData = raycaster.HoverEventData;
+            if (hoverEventData == null || raycaster.ButtonEventDataList.Count == 0) { return; }
 
             hoverEventData.Reset();
 
-            if (hoverEventData.pointerEnter != null)
-            {
-                hoverEventData.pointerEnter = null;
-                HandlePointerExitAndEnter(hoverEventData, null);
-            }
-
             // buttons event
             for (int i = 0, imax = raycaster.ButtonEventDataList.Count; i < imax; ++i)
             {
                 var buttonEventData = raycaster.ButtonEventDataList[i];
-                if (buttonEventData == null) { continue; }
+                if (buttonEventData == null || buttonEventData == hoverEventData) { continue; }
 
                 buttonEventData.Reset();
 
-                ProcessPressUp(buttonEventData);
+                if (buttonEventData.eligibleForClick)
+                {
+                    ProcessPressUp(buttonEventData);
+                    HandlePressExitAndEnter(buttonEventData, null);
+                }
 
                 if (buttonEventData.pointerEnter != null)
                 {
-                    hoverEventData.pointerEnter = null;
-                    HandlePointerExitAndEnter(buttonEventData, null);
+                    if (i == 0)
+                    {
+                        // perform exit event for hover event data
+                        HandlePointerExitAndEnter(buttonEventData, null);
+                    }
+                    else
+                    {
+                        buttonEventData.pointerEnter = null;
+                    }
                 }
             }
 
@@ -259,9 +262,6 @@ protected void CleanUpRaycaster(Pointer3DRaycaster raycaster)
                 raycaster.ButtonEventDataList[i].pointerPressRaycast = default(RaycastResult);
                 raycaster.ButtonEventDataList[i].pointerCurrentRaycast = default(RaycastResult);
             }
-
-            hoverEventData.pointerPressRaycast = default(RaycastResult);
-            hoverEventData.pointerCurrentRaycast = default(RaycastResult);
         }
 
         protected virtual void ProcessRaycast()
@@ -284,6 +284,10 @@ protected virtual void ProcessRaycast()
             for (var i = processingRaycasters.Count - 1; i >= 0; --i)
             {
                 var raycaster = processingRaycasters[i];
+                if (raycaster == null) { continue; }
+
+                var hoverEventData = raycaster.HoverEventData;
+                if(hoverEventData == null || raycaster.ButtonEventDataList.Count == 0) { continue; }
 
                 raycaster.Raycast();
                 var result = raycaster.FirstRaycastResult();
@@ -293,8 +297,7 @@ protected virtual void ProcessRaycast()
                 var raycasterPos = raycaster.transform.position;
                 var raycasterRot = raycaster.transform.rotation;
 
-                // hover event
-                var hoverEventData = raycaster.HoverEventData;
+                // gen shared data and put in hover event
                 hoverEventData.Reset();
                 hoverEventData.delta = Vector2.zero;
                 hoverEventData.scrollDelta = scrollDelta;
@@ -306,16 +309,11 @@ protected virtual void ProcessRaycast()
                 hoverEventData.rotationDelta = Quaternion.Inverse(hoverEventData.rotation) * raycasterRot;
                 hoverEventData.rotation = raycasterRot;
 
-                if (hoverEventData.pointerEnter != result.gameObject)
-                {
-                    HandlePointerExitAndEnter(hoverEventData, result.gameObject);
-                }
-
-                // buttons event
+                // copy data to other button event
                 for (int j = 0, jmax = raycaster.ButtonEventDataList.Count; j < jmax; ++j)
                 {
                     var buttonEventData = raycaster.ButtonEventDataList[j];
-                    if (buttonEventData == null) { continue; }
+                    if (buttonEventData == null || buttonEventData == hoverEventData) { continue; }
 
                     buttonEventData.Reset();
                     buttonEventData.delta = Vector2.zero;
@@ -327,15 +325,21 @@ protected virtual void ProcessRaycast()
                     buttonEventData.position3D = hoverEventData.position3D;
                     buttonEventData.rotationDelta = hoverEventData.rotationDelta;
                     buttonEventData.rotation = hoverEventData.rotation;
+                }
 
-                    ProcessPress(buttonEventData);
+                ProcessPress(hoverEventData);
+                ProcessMove(hoverEventData);
+                ProcessDrag(hoverEventData);
 
-                    var hoverGO = buttonEventData.eligibleForClick ? result.gameObject : null;
-                    if (buttonEventData.pointerEnter != hoverGO)
-                    {
-                        HandlePointerExitAndEnter(buttonEventData, hoverGO);
-                    }
+                // other buttons event
+                for (int j = 1, jmax = raycaster.ButtonEventDataList.Count; j < jmax; ++j)
+                {
+                    var buttonEventData = raycaster.ButtonEventDataList[j];
+                    if (buttonEventData == null || buttonEventData == hoverEventData) { continue; }
+
+                    buttonEventData.pointerEnter = hoverEventData.pointerEnter;
 
+                    ProcessPress(buttonEventData);
                     ProcessDrag(buttonEventData);
                 }
 
@@ -369,21 +373,31 @@ protected virtual void ProcessRaycast()
             processingRaycasters.Clear();
         }
 
+        protected virtual void ProcessMove(PointerEventData eventData)
+        {
+            var hoverGO = eventData.pointerCurrentRaycast.gameObject;
+            if (eventData.pointerEnter != hoverGO)
+            {
+                HandlePointerExitAndEnter(eventData, hoverGO);
+            }
+        }
+
         protected virtual void ProcessPress(Pointer3DEventData eventData)
         {
-            if (!eventData.eligibleForClick)
+            if (eventData.GetPressDown())
             {
-                if (eventData.GetPress())
-                {
-                    ProcessPressDown(eventData);
-                }
+                ProcessPressDown(eventData);
+                HandlePressExitAndEnter(eventData, eventData.pointerCurrentRaycast.gameObject);
             }
-            else
+            else if (eventData.GetPress())
             {
-                if (!eventData.GetPress())
-                {
-                    ProcessPressUp(eventData);
-                }
+                HandlePressExitAndEnter(eventData, eventData.pointerCurrentRaycast.gameObject);
+            }
+
+            if (eventData.GetPressUp())
+            {
+                ProcessPressUp(eventData);
+                HandlePressExitAndEnter(eventData, null);
             }
         }
 
@@ -414,7 +428,7 @@ protected void ProcessPressDown(Pointer3DEventData eventData)
                 newPressed = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
             }
 
-            float time = Time.unscaledTime;
+            var time = Time.unscaledTime;
 
             if (newPressed == eventData.lastPress)
             {
@@ -452,21 +466,17 @@ protected void ProcessPressUp(Pointer3DEventData eventData)
         {
             var currentOverGo = eventData.pointerCurrentRaycast.gameObject;
 
-            if (eventData.pointerPress != null)
-            {
-                ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
+            ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
 
-                // see if we mouse up on the same element that we clicked on...
-                var pointerUpHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
+            // see if we mouse up on the same element that we clicked on...
+            var pointerUpHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(currentOverGo);
 
-                if (eventData.pointerPress == pointerUpHandler && eventData.eligibleForClick)
-                {
-                    ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerClickHandler);
-                }
+            // PointerClick and Drop events
+            if (eventData.pointerPress == pointerUpHandler && eventData.eligibleForClick)
+            {
+                ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerClickHandler);
             }
-
-            // Drop events
-            if (currentOverGo != null && eventData.pointerDrag != null && eventData.dragging)
+            else if (eventData.pointerDrag != null && eventData.dragging)
             {
                 ExecuteEvents.ExecuteHierarchy(currentOverGo, eventData, ExecuteEvents.dropHandler);
             }
@@ -508,7 +518,7 @@ protected void ProcessDrag(Pointer3DEventData eventData)
             {
                 // Before doing drag we should cancel any pointer down state
                 // And clear selection!
-                if (eventData.pointerPress != null && eventData.pointerPress != eventData.pointerDrag)
+                if (eventData.pointerPress != eventData.pointerDrag)
                 {
                     ExecuteEvents.Execute(eventData.pointerPress, eventData, ExecuteEvents.pointerUpHandler);
 
@@ -520,6 +530,35 @@ protected void ProcessDrag(Pointer3DEventData eventData)
             }
         }
 
+        protected static void HandlePressExitAndEnter(Pointer3DEventData eventData, GameObject newEnterTarget)
+        {
+            if (eventData.pressEnter == newEnterTarget) { return; }
+
+            var oldTarget = eventData.pressEnter == null ? null : eventData.pressEnter.transform;
+            var newTarget = newEnterTarget == null ? null : newEnterTarget.transform;
+            var commonRoot = default(Transform);
+
+            for (var t = oldTarget; t != null; t = t.parent)
+            {
+                if (newTarget != null && newTarget.IsChildOf(t))
+                {
+                    commonRoot = t;
+                    break;
+                }
+                else
+                {
+                    ExecuteEvents.Execute(t.gameObject, eventData, ExecutePointer3DEvents.PressExitHandler);
+                }
+            }
+
+            eventData.pressEnter = newEnterTarget;
+
+            for (var t = newTarget; t != commonRoot; t = t.parent)
+            {
+                ExecuteEvents.Execute(t.gameObject, eventData, ExecutePointer3DEvents.PressEnterHandler);
+            }
+        }
+
         protected void DeselectIfSelectionChanged(GameObject currentOverGo, BaseEventData pointerEvent)
         {
             // Selection tracking
@@ -562,5 +601,37 @@ public bool SendMoveEventToSelectedObject(float x, float y, float moveDeadZone)
             ExecuteEvents.Execute(selected, data, ExecuteEvents.moveHandler);
             return data.used;
         }
+
+        public static string PrintGOPath(GameObject go)
+        {
+            var str = string.Empty;
+
+            if (go != null)
+            {
+                for (var t = go.transform; t != null; t = t.parent)
+                {
+                    if (!string.IsNullOrEmpty(str)) { str = "." + str; }
+                    str = t.name + str;
+                }
+            }
+
+            return str;
+        }
+
+        public override string ToString()
+        {
+            var str = string.Empty;
+
+            for (int i = 0, imax = raycasters.Count; i < imax; ++i)
+            {
+                var raycaster = raycasters[i];
+                if (raycaster == null) { continue; }
+
+                str += "<b>Raycaster: [" + i + "]</b>\n";
+                str += raycaster.ToString() + "\n";
+            }
+
+            return str;
+        }
     }
 }