Unity ScrollView无限循环左右滑动翻页带阻尼效果

从https://blog.csdn.net/Sam_ONE/article/details/60467911借鉴优化而来

上面的例子是上下滑动，而且滑动的过程中，子节点的顺序会打乱，这里改成左右滑动，并且加了个排序，使滑动过程中子节点保持正确的顺序。把脚本挂在ScrollView上面，子节点加上Item脚本(随意实现)基本上就可以了

using System;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public class MainScrollView : MonoBehaviour, IEndDragHandler, IBeginDragHandler
{
    private LTDescr lt;//需要导入LeanTween插件
    //[组件信息]
    private ScrollRect scrollRect;
    private Transform ContentObj;    //父节点
    private Item[] itemList;                //子节点管理

    //[UI效果设置参数]
    private float m_inertiaTime = 0f;    //惯性作用时间 
    private float m_BackTime = 0.3f;     //回弹时间
    private float m_startDecelert = 0.05f;//初始惯性加速度

    //[Item设置参数]
    private float itemWidth;               //子节点宽度
    private float m_CurPosX;                    //Content相对X位置(0为参考)
    private int m_Index = 0;                    //X位置与子节点宽度的整倍数
    private float m_Surplus = 0;                //X位置与子节点宽度的整倍后剩余
    private float MaxPosX = 0;                  //根据Item数量、间距、item宽度计算得到的X轴最大的数值
    private Vector3 m_StartPos;                 //记录每次需要居中前的Content位置
    private float m_OldPosX;
    //[Item包含数据相关]
    private int RealAmount;             //真实的List<ResResut>Count
    private int IndexPlus;
    private int fistIndex = 0;
    private int lastIndex = 0;
    private int m_CurrentIndex = 0;
    private int m_PreviousIndex = 0;
    [SerializeField]
    private RectTransform content;

    void Awake()
    {
        if (!GetComponent<ScrollRect>())
        {
            gameObject.AddComponent<ScrollRect>();
            var scrollRect = GetComponent<ScrollRect>();
            scrollRect.vertical = false;
            scrollRect.movementType = ScrollRect.MovementType.Unrestricted;
            scrollRect.content = content;
        }
        scrollRect = GetComponent<ScrollRect>();
        ContentObj = scrollRect.content;
        itemWidth = GetComponent<RectTransform>().sizeDelta.x;
        if (ContentObj.GetComponent<GridLayoutGroup>())
            ContentObj.GetComponent<GridLayoutGroup>().enabled = false;
        ContentObj.transform.localPosition = new Vector3(0, ContentObj.localPosition.y);
        if (GetComponent<Image>())
            GetComponent<Image>().raycastTarget = true;
    }

    // Use this for initialization
    void Start()
    {
        //Content下的子物体排序，使子物体在拖动时保持顺序
        Item[] items = ContentObj.GetComponentsInChildren<Item>();
        int itemsLen = items.Length;
        Item[] itemsTmp = new Item[itemsLen];
        int index = (itemsLen - 1) / 2;
        for (int i = 0; i < itemsLen; i++)
        {
            itemsTmp[i] = items[(index - i) >= 0 ? index - i : itemsLen + index - i];
        }
        RefreshMusicList(itemsTmp);
    }

    /// <summary>
    /// Content的初始位置X赋值
    /// </summary>
    void ContentPointInit()
    {
        if (ContentObj.childCount % 2 == 0)//判断子对象的奇偶
        {
            ContentObj.localPosition = new Vector3(ContentObj.localPosition.x - (itemWidth / 2), ContentObj.localPosition.y, ContentObj.localPosition.z);
            m_OldPosX = -itemWidth / 2;
        }
    }

    // Update is called once per frame
    void Update()
    {
        m_PreviousIndex = m_CurrentIndex;
        CalculationContentChanege();
    }

    /// <summary>
    /// 初始更新列表内容
    /// </summary>
    /// <param name="Rr">对象</param>
    public void RefreshMusicList(Item[] Rr)
    {
        MaxPosX = Rr.Length / 2 * itemWidth;      //根据Item数量计算得到最顶上Item的Pos,用于往下一次推算之后的Pos
        if (Rr.Length % 2 == 0)
            MaxPosX -= itemWidth / 2;

        RealAmount = Rr.Length;
        gameObject.SetActive(true);

        itemList = Rr;
        for (int i = 0; i < itemList.Length; i++)
        {
            itemList[i].transform.localPosition = new Vector3(MaxPosX - i * itemWidth, 0, 0);
        }
        ContentPointInit();                     //更新列表初始位置
        fistIndex = 0;                          //记录首末序号
        lastIndex = RealAmount - 1;
    }


    /// <summary>
    /// Item定位
    /// </summary>
    public void LocateItem()
    {
        lt = LeanTween.value(0, 1, m_inertiaTime).setOnStart(() =>
        {
            scrollRect.decelerationRate = m_startDecelert;
        }).setOnUpdate((float f) =>
        {
            scrollRect.decelerationRate = Mathf.Lerp(m_startDecelert, 0, f);
        }).setOnComplete(() =>
        {
            lt = LeanTween.value(0, 1, m_BackTime).setOnStart(() =>
            {
                m_StartPos = ContentObj.localPosition;
                m_CurPosX = ContentObj.localPosition.x;
                m_Index = (int)(ContentObj.childCount % 2 == 0 ? (m_CurPosX + itemWidth / 2) / itemWidth : m_CurPosX / itemWidth);
                m_Surplus = m_CurPosX % itemWidth;
                if (m_CurPosX - m_OldPosX < 0)
                {
                    IndexPlus = m_CurPosX < 0 ? -1 : 0;
                }
                else
                {
                    if (ContentObj.childCount % 2 == 0) m_CurPosX += itemWidth / 2;
                    IndexPlus = m_CurPosX < 0 ? 0 : 1;
                }
                if (Mathf.Abs(m_Surplus) >= (itemWidth / 30))
                    m_Index += IndexPlus;
            }).setOnUpdate((float f) =>
            {
                float posX = m_Index * itemWidth;
                if (ContentObj.childCount % 2 == 0) posX = m_Index * itemWidth - (itemWidth / 2);
                ContentObj.localPosition = Vector3.Lerp(m_StartPos, new Vector3(posX, ContentObj.localPosition.y), f);
                m_OldPosX = ContentObj.localPosition.x;
            });
        });
    }

    void IEndDragHandler.OnEndDrag(PointerEventData eventData)
    {
        scrollRect.OnEndDrag(eventData);
        m_inertiaTime = Mathf.Clamp(Mathf.Clamp01(Math.Abs(eventData.delta.x * 0.008f)), 0, 0.1f);      //根据拖拽的速度限制惯性运行的时间
        LocateItem();
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        if (lt != null)
            lt.reset();
    }

    void Circulation(int _dir)
    {
        if (_dir > 0)
        {
            itemList[fistIndex].transform.localPosition = itemList[lastIndex].transform.localPosition - new Vector3(itemWidth, 0, 0);
            lastIndex = fistIndex;
            fistIndex = (fistIndex + 1) % RealAmount;
        }
        else if (_dir < 0)
        {
            itemList[lastIndex].transform.localPosition = itemList[fistIndex].transform.localPosition + new Vector3(itemWidth, 0, 0);
            fistIndex = lastIndex;
            lastIndex = (lastIndex + RealAmount - 1) % RealAmount;
        }
    }

    private void CalculationContentChanege()
    {
        m_CurrentIndex = Mathf.FloorToInt(ContentObj.localPosition.x / itemWidth);  //向下取整获得变化的Index!!!!!!!!!!
        if (m_PreviousIndex != m_CurrentIndex)
        {
            for (int i = 0; i < Mathf.Abs(m_CurrentIndex - m_PreviousIndex); i++)
                Circulation(m_CurrentIndex - m_PreviousIndex);
        }
    }
}

----------------------------------------分割线----------------------------------------------------

上面的版本使用的场景是拖动页数比较多（基本超过5页）且子页宽度超过屏幕2/3的情况，在这样的情况下使用上面的代码没有问题，但是当子页只有只有2、3页且子页的比较小时就有很多问题了。主要问题一是可以把子页全部拖出显示区域造成显示区域空白，二是拖动的时候拖动距离需要超过1/2才会切换，造成一半显示区域是空白。经过几天的修改优化出了一个新版本，拖动的时候可以无缝衔接，同时暴力拖曳不会把所有子页都拖出显示区域，同时还加入了自动切换。

public class FocusScrollView : MonoBehaviour, IEndDragHandler, IBeginDragHandler
{
    private LTDescr lt, ltAuto;

    //[组件信息]
    [SerializeField]
    private ScrollRect scrollRect;
    [SerializeField]
    private Transform contentObj;       //父节点
    private ViewItem[] itemList;             //子节点管理

    //[UI效果设置参数]
    private float m_inertiaTime = 0f;    //惯性作用时间 
    private float m_BackTime = 0.2f;     //回弹时间
    private float m_startDecelert = 0.05f;//初始惯性加速度

    //[ViewItem设置参数]
    private float itemWidth;               //子节点宽度
    private float m_CurPosX;                    //Content相对X位置(0为参考)
    private int m_Index = 0;                    //X位置与子节点宽度的整倍数
    private float m_Surplus = 0;                //最小偏移量，滑动距离超过这个值就切换
    private float MaxPosX = 0;                  //根据ViewItem数量、间距、item宽度计算得到的X轴最大的数值
    private Vector3 m_StartPos;                 //记录每次需要居中前的Content位置
    private float m_OldPosX;
    private int realAmount;             //Count
    private int IndexPlus;
    //[计算相关数值]
    private int firstIndex = 0;
    private int lastIndex = 0;
    private float m_CurrentIndex = 0;
    private float m_PreviousIndex = 0;

    public Action<int> completeDragHandle;//滑动或者左右按钮切换结束，返回当前页码(从0开始)
    private bool isReadied = false;
    private int curIndex = 0;//当前页码

    private float lerpPos = 0;//页数为奇数时，设置偏移量=itemWidth使列表自动切换，手动切换时置为0
    private Vector3 itemWidthVec;
    private void InitGroup()
    {
        itemWidth = GetComponent<RectTransform>().sizeDelta.x;
        itemWidthVec = new Vector3(itemWidth, 0, 0);
        if (contentObj.GetComponent<GridLayoutGroup>())
            contentObj.GetComponent<GridLayoutGroup>().enabled = false;
        contentObj.transform.localPosition = new Vector3(0, 0);
    }

    private void Start()
    {
        Refresh();//外部调用的接口，页面准备好了调用此方法即可以开始切换
    }

    // Use this for initialization
    public void Refresh()
    {
        InitGroup();
        ViewItem[] items = contentObj.GetComponentsInChildren<ViewItem>(true);
        int itemsLen = items.Length;
        ViewItem[] itemsTmp = new ViewItem[itemsLen];
        int index = itemsLen / 2 + 1;//重新排序，将[len/2 + 1, len]移到数组前面
        for(int i = 0; i < itemsLen; i++)
        {
            itemsTmp[i] = items[i + index < itemsLen ? i + index : index + i - itemsLen];
        }
        RefreshMusicList(itemsTmp);
        if(realAmount == 1) return;
        isReadied = true;
        scrollRect.enabled = true;
        AutoRepeatMove();
    }

    private void AutoRepeatMove()
    {
        lerpPos = itemWidth;
        CancelInvoke("LocateItemAuto");
        InvokeRepeating("LocateItemAuto", 3, 5);
    }

    /// <summary>
    /// Content的初始位置X赋值
    /// </summary>
    void ContentPointInit()
    {
        if (contentObj.childCount % 2 == 0)//判断子对象的奇偶
        {
            contentObj.localPosition = new Vector3(contentObj.localPosition.x - (itemWidth / 2), 0);
            m_OldPosX = -itemWidth / 2;
        }
    }

    // Update
    void Update()
    {
        if (!isReadied || !this || !contentObj) return;
        m_PreviousIndex = m_CurrentIndex;
        CalculationContentChanege(contentObj.localPosition.x);
    }

    /// <summary>
    /// 初始更新列表内容
    /// </summary>
    /// <param name="Rr">对象</param>
    private void RefreshMusicList(ViewItem[] Rr)
    {
        realAmount = Rr.Length;
        MaxPosX = realAmount / 2 * itemWidth;      //根据Item数量计算得到最顶上Item的Pos,用于往下一次推算之后的Pos
        if (realAmount % 2 == 0)
            MaxPosX -= itemWidth / 2;


        itemList = Rr;
        for (int i = 0; i < realAmount; i++)
        {
            itemList[i].transform.localPosition = new Vector3(MaxPosX - i * itemWidth, 0, 0);
            itemList[i].gameObject.SetActive(true);
        }
        ContentPointInit();                     //更新列表初始位置
        firstIndex = 0;                          //记录首末序号
        lastIndex = realAmount - 1;
    }

    /// <summary>
    /// ViewItem定位
    /// </summary>
    private void LocateItem()
    {
        lt = LeanTween.value(0, 1, m_inertiaTime)
        .setOnStart(InitOnStart)
        .setOnUpdate(InitOnUpdate)
        .setOnComplete(InitOnComplete);
    }

    private void InitOnStart()
    {
        scrollRect.decelerationRate = m_startDecelert;
    }

    private void InitOnUpdate(float f)
    {
        scrollRect.decelerationRate = Mathf.Lerp(m_startDecelert, 0, f);
    }

    private void InitOnComplete()
    {
        lt = LeanTween.value(0, 1, m_BackTime)
        .setOnStart(OnStart)
        .setOnUpdate(OnUpdate)
        .setOnComplete(OnComplete);
    }

    private void LocateItemAuto()
    {
        ltAuto = LeanTween.value(0, 1, m_inertiaTime)
        .setOnStart(InitOnStart)
        .setOnUpdate(InitOnUpdate)
        .setOnComplete(InitOnCompleteAuto);
    }

    private void InitOnCompleteAuto()
    {
        ltAuto = LeanTween.value(0, 1, m_BackTime)
        .setOnStart(OnStart)
        .setOnUpdate(OnUpdateAuto)
        .setOnComplete(OnComplete);
    }

    int previous_m_Index = 0;
    private void OnUpdateAuto(float f)
    {
        if(!this || !contentObj) return;
        //包含偶数子项时，快速向左滑动后切换到自动滑动，列表可能不会动，
        // 而是一直重复显示当前页，原因未明(m_Index未变)
        if(m_Index == previous_m_Index && contentObj.childCount % 2 == 0)
        {
           previous_m_Index = m_Index++;
        }
        posX = m_Index * itemWidth + lerpPos;
        UpdatePos(f, posX);
    }

    private void OnStart()
    {
        if(!this || !contentObj) return;
        m_StartPos = contentObj.localPosition;
        m_CurPosX = contentObj.localPosition.x;
        m_Index = (int)(contentObj.childCount % 2 == 0 ? (m_CurPosX + itemWidth / 2) / itemWidth : m_CurPosX / itemWidth);
        m_Surplus = m_CurPosX % itemWidth;
        if (m_CurPosX - m_OldPosX < 0)
        {
            IndexPlus = m_CurPosX < 0 ? -1 : 0;
        }
        else
        {
            if (contentObj.childCount % 2 == 0) m_CurPosX += itemWidth / 2;
            IndexPlus = m_CurPosX < 0 ? 0 : 1;
        }
        if (Mathf.Abs(m_Surplus) >= (itemWidth / 30))
            m_Index += IndexPlus;
            
    }

    float posX;
    private void OnUpdate(float f)
    {
        previous_m_Index = m_Index;
        posX = m_Index * itemWidth;
        UpdatePos(f, posX);
    }
    
    private void OnComplete()
    {
        if(!this || !contentObj) return;
        int index = realAmount / 2 + 1;
        for(int i = 0; i < realAmount; i++)
        {
            //父容器与卡片相对运动，所以最终显示在中间的卡片其坐标与父容器坐标和为0
            if(contentObj.localPosition.x + itemList[i].transform.localPosition.x == 0)
            {
                //因为数组的[len/2 + 1, len]项被移到了前面，所以curIndex需要重新计算
                if(realAmount - index > i)
                {
                    curIndex = i + index;
                }else
                {
                    curIndex = i + index - realAmount;
                }
                break;
            }
        }
        completeDragHandle?.Invoke(curIndex);
    }

    private void UpdatePos(float f, float p)
    {
        if(!this || !contentObj) return;
        if (contentObj.childCount % 2 == 0) p = m_Index * itemWidth - (itemWidth / 2);
        contentObj.localPosition = Vector3.Lerp(m_StartPos, new Vector3(p, 0), f);
        m_OldPosX = contentObj.localPosition.x;
    }
    
    void IEndDragHandler.OnEndDrag(PointerEventData eventData)
    {
        scrollRect.enabled = true;
        isStartMove = false;
        scrollRect.OnEndDrag(eventData);
        ChildScrollEndDrag(eventData);
        AutoRepeatMove();
    }

    bool isStartMove = false;
    float oldPosX = 0;
    public void ChildScrollEndDrag(PointerEventData eventData)
    {
        m_inertiaTime = Mathf.Clamp(Mathf.Clamp01(Math.Abs(eventData.delta.x * 0.008f)), 0, 0.1f);      //根据拖拽的速度限制惯性运行的时间
        LocateItem();
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        lerpPos = 0;
        CancelInvoke("LocateItemAuto");
        isStartMove = true;
        oldPosX = contentObj.localPosition.x;
    }

    void Circulation(float _dir)
    {
        if(itemList == null) return;
        if (_dir > 0)
        {
            itemList[firstIndex].transform.localPosition = itemList[lastIndex].transform.localPosition - itemWidthVec;
            lastIndex = firstIndex;
            firstIndex = (firstIndex + 1) % realAmount;
        }
        else if (_dir < 0)
        {
            itemList[lastIndex].transform.localPosition = itemList[firstIndex].transform.localPosition + itemWidthVec;
            firstIndex = lastIndex;
            lastIndex = (lastIndex + realAmount - 1) % realAmount;
        }
    }

    private void CalculationContentChanege(float pos)
    {
        //拖动的时候，防止暴力拖曳把整个列表拖出显示区域
        if(isStartMove && Mathf.Abs(pos - oldPosX) > itemWidth) 
        {
            scrollRect.enabled = false;
            return;
        }
        m_CurrentIndex = Mathf.FloorToInt((pos + itemWidth / 2) / itemWidth);  //向下取整获得变化的Index!!!!!!!!!!

        if (m_PreviousIndex != m_CurrentIndex)
        {
            for (int i = 0; i < Mathf.Abs(m_CurrentIndex - m_PreviousIndex); i++)
                Circulation(m_CurrentIndex - m_PreviousIndex);
        }
    }

    //重置状态
    public void Reset() 
    {
        CancelInvoke("LocateItemAuto");
        isReadied = false;
        scrollRect.enabled = false;
        m_CurrentIndex = 0;
        m_PreviousIndex = 0;
    }
}