ScrollRectAutoScroll.cs

using System.Collections.Generic;
using Rewired;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public class ScrollRectAutoScroll : MonoBehaviour {

    public Bounds bounds;

    List<Selectable> selectables = new List<Selectable>();

    int elementCount;
    RectTransform scrollRectTransform;

    public float distanceTop;
    public float distanceBottom;

    #region Properties
    Player RewiredPlayer { get; set; }

    ScrollRect ScrollRectComponent { get; set; }
    #endregion

    void OnEnable() {
        if(ScrollRectComponent) {
            ScrollRectComponent.content.GetComponentsInChildren(selectables);
            elementCount = selectables.Count;
        }
    }

    void Awake() {
        RewiredPlayer = ReInput.players.GetPlayer(0);
        ScrollRectComponent = GetComponent<ScrollRect>();
        scrollRectTransform = ScrollRectComponent.transform as RectTransform;
    }

    void Start() {
        ScrollRectComponent.content.GetComponentsInChildren(selectables);
        elementCount = selectables.Count;
    }

    void Update() {
        if(elementCount > 0) {
            var contentRect = ScrollRectComponent.content.rect;
            var selectedElement = EventSystem.current.currentSelectedGameObject ? EventSystem.current.currentSelectedGameObject.GetComponent<Selectable>() : null;

            DrawRect(contentRect, Color.yellow, ScrollRectComponent.content);

            if(selectedElement == null) return;

            var selectedTransform = selectedElement.transform as RectTransform;

            DrawRect2(selectedTransform, selectedTransform.rect, Color.yellow);

            if(RewiredPlayer.GetButtonDown("Menu Horizontal") || RewiredPlayer.GetNegativeButtonDown("Menu Horizontal") || RewiredPlayer.GetButtonDown("Menu Vertical") || RewiredPlayer.GetNegativeButtonDown("Menu Vertical")) {
                if(selectedElement.transform.IsChildOf(ScrollRectComponent.transform)) {
                    ScrollTo(selectedElement);
                }
            }

            void DrawRect(Rect rect, Color color, Transform parent) {
                rect.position = parent.TransformPoint(rect.position);
                rect.size = Vector2.Scale(scrollRectTransform.lossyScale, rect.size);

                Debug.DrawLine(new Vector3(rect.xMin, rect.yMax, -.5f), new Vector3(rect.xMax, rect.yMax, -.5f), color);
                Debug.DrawLine(new Vector3(rect.xMax, rect.yMax, -.5f), new Vector3(rect.xMax, rect.yMin, -.5f), color);
                Debug.DrawLine(new Vector3(rect.xMax, rect.yMin, -.5f), new Vector3(rect.xMin, rect.yMin, -.5f), color);
                Debug.DrawLine(new Vector3(rect.xMin, rect.yMin, -.5f), new Vector3(rect.xMin, rect.yMax, -.5f), color);
            }

            void DrawRect2(RectTransform original, Rect rect, Color color) {
                Vector3[] corners = new Vector3[4];

                original.GetWorldCorners(corners);

                float width = Mathf.Abs(corners[1].x - corners[2].x);
                float height = Mathf.Abs(corners[0].y - corners[1].y);

                //Vector3 size = new Vector3(width, height, 1);
                //Vector3 position = new Vector3(corners[0].x, corners[0].y, corners[0].z);

                Debug.DrawLine(corners[0], corners[1], color);
                Debug.DrawLine(corners[1], corners[2], color);
                Debug.DrawLine(corners[2], corners[3], color);
                Debug.DrawLine(corners[3], corners[0], color);

                Vector3[] contentCorners = new Vector3[4];

                ScrollRectComponent.content.GetWorldCorners(contentCorners);

                //float contentWidth = Mathf.Abs(contentCorners[1].x - contentCorners[2].x);
                float contentHeight = Mathf.Abs(contentCorners[0].y - contentCorners[1].y);

                float distanceFromTop = contentCorners[1].y - corners[1].y;
                float distanceFromBottom = corners[0].y - contentCorners[0].y;

                float normalizedDistanceFromTop = distanceFromTop / contentHeight;
                float normalizedDistanceFromBottom = distanceFromBottom / contentHeight;

                distanceTop = normalizedDistanceFromTop;
                distanceBottom = normalizedDistanceFromBottom;

                Debug.DrawLine(contentCorners[0], contentCorners[1]);
                Debug.DrawRay(corners[1], new Vector3(0, distanceFromTop, 0), Color.magenta);
                Debug.DrawRay(corners[0], new Vector3(0, -distanceFromBottom, 0), Color.cyan);
            }
        }
    }

    void ScrollTo(Selectable selectable) {
        var rectTransform = selectable.transform as RectTransform;

        Vector3[] selectableCorners = new Vector3[4];
        Vector3[] contentCorners = new Vector3[4];
        Vector3[] viewportCorners = new Vector3[4];

        float verticalSliderPosition = ScrollRectComponent.verticalNormalizedPosition;

        rectTransform.GetWorldCorners(selectableCorners);
        ScrollRectComponent.content.GetWorldCorners(contentCorners);
        ScrollRectComponent.viewport.GetWorldCorners(viewportCorners);

        float selectableHeight = Mathf.Abs(selectableCorners[0].y - selectableCorners[1].y);
        float contentHeight = Mathf.Abs(contentCorners[0].y - contentCorners[1].y);
        float viewportHeight = Mathf.Abs(viewportCorners[0].y - viewportCorners[1].y);

        //switch(ScrollRectComponent.verticalScrollbar.direction) {
        //    case Scrollbar.Direction.BottomToTop:
        //        break;
        //    case Scrollbar.Direction.TopToBottom:
        //        break;
        //}

        if(selectableCorners[0].y < viewportCorners[0].y) { // Bottom of selectable is under viewport
            float distanceFromBottom = contentCorners[0].y - selectableCorners[0].y;
            float distanceFromTop = contentCorners[1].y - selectableCorners[0].y;
            //float normalizedPosition = distanceFromTop / (contentHeight - viewportHeight);
            float normalizedPosition = (distanceFromTop - viewportHeight) / (contentHeight - viewportHeight);

            verticalSliderPosition = 1 - normalizedPosition;
        }
        else if(selectableCorners[1].y > viewportCorners[1].y) { // Top of selectable is over viewport
            float distanceFromBottom = contentCorners[0].y - selectableCorners[1].y;
            float distanceFromTop = contentCorners[1].y - selectableCorners[1].y;
            float normalizedPosition = distanceFromTop / (contentHeight - viewportHeight);
            //float normalizedPosition = (distanceFromTop - viewportHeight) / (contentHeight - viewportHeight);

            verticalSliderPosition = 1 - normalizedPosition;
        }

        ScrollRectComponent.verticalNormalizedPosition = verticalSliderPosition;
    }
}