private bool HasMouseButtonInput(int button)
        {
            if (Input.GetMouseButtonDown(button))
            {
                OnMouseDown?.Invoke(button, Input.mousePosition);
                return(true);
            }
            else if (Input.GetMouseButton(button))
            {
                OnMouseDrag?.Invoke(button, Input.mousePosition, Input.GetAxis(MouseXAxis), Input.GetAxis(MouseYAxis));
                OnMouseRawDrag?.Invoke(button, Input.mousePosition, Input.GetAxisRaw(MouseXAxis), Input.GetAxisRaw(MouseYAxis));
                return(true);
            }
            else if (Input.GetMouseButtonUp(button))
            {
                OnMouseUp?.Invoke(button, Input.mousePosition);
                return(true);
            }

            return(false);
        }
    private void UpdateButton(int button, int infoIndex)
    {
        bool wasPressed = lastMouseDownState[infoIndex];
        bool isPressed  = Input.GetMouseButton(button);

        if (isPressed != wasPressed)
        {
            //Debug.Log("MOUSE " + wasPressed + " -> " + isPressed);
            if (isPressed)
            {
                // click started
                lastMouseDownPos[infoIndex]  = Input.mousePosition;
                lastMouseDownTime[infoIndex] = Time.realtimeSinceStartup;

                OnMousePress?.Invoke(button, Input.mousePosition);
            }
            else
            {
                // click ended
                OnMouseRelease?.Invoke(button, Input.mousePosition);

                Vector3 lastPosition = lastMouseDownPos[infoIndex];
                float   dragDist     = (Input.mousePosition - lastPosition).sqrMagnitude;

                if (lastMouseWasDragging[infoIndex] || dragDist >= minDistDragScreenSqr)
                {
                    // drag
                    //Debug.Log("MOUSE DRAG from " + lastPosition + " to " + Input.mousePosition + " dist " + String.Format("{0,2}", dragDist));
                    OnMouseDrag?.Invoke(button, lastMouseDownPos[infoIndex], Input.mousePosition, Time.realtimeSinceStartup - lastMouseDownTime[infoIndex], true);
                }
                else
                {
                    OnMouseClick?.Invoke(button, lastMouseDownPos[infoIndex], Input.mousePosition);
                }
            }
            lastMouseDownState[infoIndex] = isPressed;
        }

        if (!isPressed)
        {
            lastMouseWasDragging[infoIndex] = false;
        }

        if (isPressed && wasPressed)
        {
            // potential dragging event

            bool isDrag = false;

            if (lastMouseWasDragging[infoIndex])
            {
                isDrag = true;
            }
            else
            {
                Vector3 startPosition = lastMouseDownPos[infoIndex];

                if ((startPosition - Input.mousePosition).sqrMagnitude >= minDistDragScreenSqr)
                {
                    isDrag = true;
                }
            }

            if (isDrag)
            {
                lastMouseWasDragging[infoIndex] = true;

                OnMouseDrag?.Invoke(button, lastMouseDownPos[infoIndex], Input.mousePosition, Time.realtimeSinceStartup - lastMouseDownTime[infoIndex], false);
            }
        }
    }
    void Awake()
    {
        _originalPos = transform.localPosition;
        _originalRot = transform.localRotation;

        base.Awake();

        _collider = GetComponent <Collider>();


        m_animator = GetComponentInParent <Animator>();

        foreach (InteractionComponent com in m_interactiveComponents)
        {
            // caching lambda
            InteractionComponent currentComponent = com;

            OnMouseClick onClick = com.collider.gameObject.AddComponent <OnMouseClick>();
            OnMouseOver  onOver  = com.collider.gameObject.AddComponent <OnMouseOver>();
            OnMouseDrag  onDrag  = gameObject.AddComponent <OnMouseDrag>();

            onDrag.onMouseDragBegin += OnComponentDragBegin;
            onDrag.onMouseDrag      += OnComponentDragged;
            onDrag.onMouseDragEnd   += OnComponentDragEnd;

            onClick.onMouseClick += (PointerEventData eventData) =>
            {
                if (eventData.dragging)
                {
                    return;
                }

                if (!IsInteracting)
                {
                    return;
                }

                currentComponent.onInteract.Invoke();
            };

            onOver.onMouseOver += (PointerEventData eventData) =>
            {
                if (!IsInteracting)
                {
                    return;
                }

                m_isMouseOverInteraction = false;

                if (currentComponent.onInteract.GetPersistentEventCount() > 0)
                {
                    m_isMouseOverInteraction = true;
                }

                if (!m_isDragging)
                {
                    Cursor.SetCursor(cursorDrag, hotSpot, cursorMode);
                }

                if (m_isMouseOverInteraction && !m_isDragging)
                {
                    Cursor.SetCursor(cursorClick, hotSpot, cursorMode);
                }

                m_isMouseOver = true;
            };

            onOver.onMouseOut += (PointerEventData data) =>
            {
                if (!IsInteracting)
                {
                    return;
                }

                if (!m_isDragging)
                {
                    Cursor.SetCursor(null, Vector2.zero, cursorMode);
                }

                m_isMouseOver = false;
            };
        }
    }