BypassRaycastApi.cs

public static class BypassRaycastApi
{
    static EventTriggerType[] All { get; } =
    {
        EventTriggerType.PointerEnter,
        EventTriggerType.PointerExit,
        EventTriggerType.PointerDown,
        EventTriggerType.PointerUp,
        EventTriggerType.PointerClick,
        EventTriggerType.Drag,
        EventTriggerType.Drop,
        EventTriggerType.Scroll,
        EventTriggerType.UpdateSelected,
        EventTriggerType.Select,
        EventTriggerType.Deselect,
        EventTriggerType.Move,
        EventTriggerType.InitializePotentialDrag,
        EventTriggerType.BeginDrag,
        EventTriggerType.EndDrag,
        EventTriggerType.Submit,
        EventTriggerType.Cancel,
    };

    // todo GC
    public static EventTriggerType[] Except(EventTriggerType ett)
    {
        return All.Except(Enumerable.Repeat(ett, 1)).ToArray();
    }

    public static void Bypass(this EventTrigger et, IScope scope, params EventTriggerType[] triggerTypes)
    {
        new BypassRaycast(scope, et, triggerTypes);
    }
}

public class BypassRaycast
{
    static List<RaycastResult> _cache = new List<RaycastResult>();

    public BypassRaycast(IScope scope, EventTrigger et, params EventTriggerType[] triggers)
    {
        Asr.IsTrue(triggers.Distinct().Count() == triggers.Length);
        foreach (var triggerType in triggers)
            Register(scope, triggerType, et);
    }

    static void Register(IScope scope, EventTriggerType et, EventTrigger eventTrigger)
    {
        var sub = eventTrigger.Register(et, scope);
        sub.Subscribe(Inner, scope);

        void Inner(PointerEventData eventData)
        {
            switch (et)
            {
                case EventTriggerType.PointerEnter:
                    Handle(ExecuteEvents.pointerEnterHandler);
                    break;
                case EventTriggerType.PointerExit:
                    Handle(ExecuteEvents.pointerExitHandler);
                    break;
                case EventTriggerType.PointerDown:
                    Handle(ExecuteEvents.pointerDownHandler);
                    break;
                case EventTriggerType.PointerUp:
                    Handle(ExecuteEvents.pointerUpHandler);
                    break;
                case EventTriggerType.PointerClick:
                    Handle(ExecuteEvents.pointerClickHandler);
                    break;
                case EventTriggerType.Drag:
                    Handle(ExecuteEvents.dragHandler);
                    break;
                case EventTriggerType.Drop:
                    Handle(ExecuteEvents.dropHandler);
                    break;
                case EventTriggerType.Scroll:
                    Handle(ExecuteEvents.scrollHandler);
                    break;
                case EventTriggerType.UpdateSelected:
                    Handle(ExecuteEvents.updateSelectedHandler);
                    break;
                case EventTriggerType.Select:
                    Handle(ExecuteEvents.selectHandler);
                    break;
                case EventTriggerType.Deselect:
                    Handle(ExecuteEvents.deselectHandler);
                    break;
                case EventTriggerType.Move:
                    Handle(ExecuteEvents.moveHandler);
                    break;
                case EventTriggerType.InitializePotentialDrag:
                    Handle(ExecuteEvents.initializePotentialDrag);
                    break;
                case EventTriggerType.BeginDrag:
                    Handle(ExecuteEvents.beginDragHandler);
                    break;
                case EventTriggerType.EndDrag:
                    Handle(ExecuteEvents.endDragHandler);
                    break;
                case EventTriggerType.Submit:
                    Handle(ExecuteEvents.submitHandler);
                    break;
                case EventTriggerType.Cancel:
                    Handle(ExecuteEvents.cancelHandler);
                    break;
            }

            void Handle<T>(ExecuteEvents.EventFunction<T> handler) where T : IEventSystemHandler
            {
                EventSystem.current.RaycastAll(eventData, _cache);
                if (_cache.Count < 2)
                    return;

                var found = false;
                foreach (var c in _cache)
                {
                    // next after found
                    if (found)
                    {
                        ExecuteEvents.Execute(c.gameObject, eventData, handler);
                        break;
                    }

                    if (c.gameObject == eventTrigger.gameObject)
                        found = true;
                }
            }
        }
    }

    public static void Handle<T>(EventTrigger et, ExecuteEvents.EventFunction<T> handler, PointerEventData data, List<RaycastResult> list, int skip,
        int countStop)
        where T : IEventSystemHandler
    {
        EventSystem.current.RaycastAll(data, list);
        if (list.Count < 2)
            return;
        var found = false;
        var count = 0;
        var stop = 0;
        foreach (var c in list)
        {
            // next after found
            if (found)
            {
                if (++count <= skip)
                    continue;
                ExecuteEvents.Execute(c.gameObject, data, handler);
                if (++stop > countStop)
                    break;
            }

            if (c.gameObject == et.gameObject)
                found = true;
        }
    }
}