示例#1
0
        /// <summary>
        /// Executes the OnPointerDown trigger. You can force an execution of this trigger (regardless if it's enabled or not) by calling this method with forcedExecution set to TRUE
        /// </summary>
        /// <param name="forcedExecution">Fires this trigger regardless if it is enabled or not (default:false)</param>
        public void ExecutePointerDown(bool forcedExecution = false)
        {
            if (forcedExecution)
            {
                if (debugThis)
                {
                    Debug.Log("DebugMode - UIButton - " + name + " | Executing OnPointerDown initiated through forcedExecution");
                }
                OnPointerDown.Invoke();
                return;
            }

            if (useOnPointerDown)
            {
                if (debugThis)
                {
                    Debug.Log("DebugMode - UIButton - " + name + " | Executing OnPointerDown");
                }
                if (interactable)
                {
                    OnPointerDown.Invoke();
                }
            }

            if (useOnLongClick)
            {
                if (interactable)
                {
                    RegisterLongClick();
                }
            }
        }
示例#2
0
        private void Update()
        {
            _prevPointerDownState = _pointerDownState;

            if (UnityEngine.Input.GetMouseButtonDown(0))
            {
                OnPointerDown?.Invoke();
                _pointerDownState = true;
            }

            if (UnityEngine.Input.GetMouseButtonUp(0))
            {
                OnPointerUp?.Invoke();
                _pointerDownState = false;
            }

            Vector2 mousePosition = UnityEngine.Input.mousePosition;
            Vector2 posDifference = mousePosition - _prevMousePos;

            if (posDifference.magnitude > 0f)
            {
                OnPointerMoved?.Invoke(posDifference);
                _prevMousePos = mousePosition;

                if (_prevPointerDownState && _pointerDownState)
                {
                    OnPointerDragged?.Invoke(posDifference);
                }
            }
        }
 private void Interact()
 {
     if (!isInteractable)
     {
         return;
     }
     OnPointerDown?.Invoke(this);
 }
示例#4
0
        public void Update()
        {
            if (!m_IsLeftButtonPressed && Input.GetMouseButton(0))
            {
                m_IsLeftButtonPressed = true;

                RaycastHit2D hit = Physics2D.Raycast(m_Camera.ScreenToWorldPoint(Input.mousePosition), Vector2.zero, 1.0f, m_LayerMask);
                if (hit.collider != null)
                {
                    switch ((ELayerType)hit.collider.gameObject.layer)
                    {
                    case ELayerType.eLayer_Default:
                        break;

                    case ELayerType.eLayer_TransparentFX:
                        break;

                    case ELayerType.eLayer_IgnoreRaycast:
                        break;

                    case ELayerType.eLayer_Water:
                        break;

                    case ELayerType.eLayer_UI:
                        break;

                    case ELayerType.eLayer_Map:
                        OnLayerMapPointerDown?.Invoke(hit.point);
                        break;

                    default:
                        break;
                    }
                }

                OnPointerDown?.Invoke(Input.mousePosition);
            }
            else if (m_IsLeftButtonPressed && !Input.GetMouseButton(0))
            {
                m_IsLeftButtonPressed = false;
            }
        }
示例#5
0
 void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
 {
     OnPointerDown?.Invoke(this);
 }
示例#6
0
 void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
 {
     IsPointerDowned = true;
     OnPointerDown?.Invoke();
 }
 private void OnMouseDown() => OnPointerDown?.Invoke(this);
示例#8
0
 public virtual void InvokeDown() => OnPointerDown?.Invoke();
示例#9
0
    private void Update()
    {
        //Raycast from the current camera forward
        if (Physics.Raycast(transform.position, transform.forward, out pointerHit, 250f))
        {
            //Update the current pointer args
            currPointerArgs.target = pointerHit.transform;
            currPointerArgs.point  = pointerHit.point;
            currPointerArgs.normal = pointerHit.normal;

            if (prevPointerArgs.target == null || pointerHit.transform == prevPointerArgs.target)
            {
                timeToClickCountdown -= Time.deltaTime;

                //Send the entered event
                if (enteredTriggered == false)
                {
                    OnPointerEnter?.Invoke(this, currPointerArgs);
                    enteredTriggered = true;
                }

                if (timeToClickCountdown <= 0)
                {
                    //Send the one time click event
                    if (clickTriggered == false)
                    {
                        OnPointerClicked?.Invoke(this, currPointerArgs);
                        ExecuteEvents.Execute(pointerHit.transform.gameObject, new PointerEventData(EventSystem.current), ExecuteEvents.pointerClickHandler);
                        clickTriggered = true;
                    }

                    OnPointerDown?.Invoke(this, currPointerArgs);

                    //Set the previous hit to the new target
                    prevPointerArgs.target = pointerHit.transform;
                    prevPointerArgs.point  = pointerHit.point;
                    prevPointerArgs.normal = pointerHit.normal;
                }
            }
            else
            {
                //Exit the old target and enter the new one
                OnPointerExit?.Invoke(this, prevPointerArgs);

                OnPointerEnter?.Invoke(this, currPointerArgs);

                //Set the previous hit to the new target
                prevPointerArgs.target = pointerHit.transform;
                prevPointerArgs.point  = pointerHit.point;
                prevPointerArgs.normal = pointerHit.normal;

                //Reset state variables
                timeToClickCountdown = timeToClick;
                enteredTriggered     = false;
                clickTriggered       = false;
            }
        }
        else
        {
            if (prevPointerArgs.target != null)
            {
                //Send the exit event
                OnPointerExit?.Invoke(this, prevPointerArgs);

                //Reset state variables
                prevPointerArgs.target = null;
                timeToClickCountdown   = timeToClick;
                enteredTriggered       = false;
                clickTriggered         = false;
            }
            else
            {
                timeToClickCountdown = timeToClick;
            }
        }

        //Draw the debug gizmos
        if (drawDebug)
        {
            Debug.DrawLine(transform.position, prevPointerArgs.point, Color.red);
        }
    }
 public void PointerDown()
 {
     OnPointerDown?.Invoke();
 }