unity UIScrollView覆用

矫情吗；* 2023-02-18 15:28 14阅读 0赞

两个脚本，分别放在ScrollView和content下的item上  
UIScroll  
利用content的位置来计算item的index，用ScrollRect.onValueChanged.AddListener(action)来监听滑动，然后进行相关计算。

using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.UI;
    
    public class UIScroll : MonoBehaviour
    {
        public enum Direction
        {
            Horizontal,
            Vertical,
        }
    
        public Direction direction;
    
        public Vector2 cellSize;
        public Vector2 spacing;
    
        private Action<UIScrolItem, int> updateAction;
    
        private RectTransform rectTransform;
        private ScrollRect scrollRect;
        private RectTransform content;
        private float contentWidth;
        private float contentHeight;
        private Vector2 contentOriginalSize;
    
        private float itemWidth;
        private float itemHeight;
        private int columnCount;
        private int rowCount;
    
        private int createCount;
        private int listCount;
        private int showCount;
    
        private int columnSum;
        private int rowSum;
    
        private int startIndex = 0;
        private int endIndex = 0;
        private int lastStartIndex=0;
    
        private Dictionary<int, Transform> itemIndexDict = new Dictionary<int, Transform>();
    
        private void Awake()
        {
            rectTransform = GetComponent<RectTransform>();
            scrollRect = GetComponent<ScrollRect>();
            
            content = transform.Find("Viewport/Content").GetComponent<RectTransform>();
            contentOriginalSize = content.sizeDelta;
        }
    
        private void OnEnable()
        {
            scrollRect.onValueChanged.AddListener(OnValueChanged);
        }
    
        public void init(int count)
        {
            startIndex = endIndex = lastStartIndex = 0;
    
            itemWidth = cellSize.x;
            itemHeight = cellSize.y;
            
            if (columnCount <= 0)
                columnCount = (int)(contentOriginalSize.x / (itemWidth+spacing.x));
            if (rowCount <= 0)
                rowCount = (int)(contentOriginalSize.y / (itemHeight+spacing .y));
    
            InitData();
            InitList(count);
        }
    
        private void InitData()
        {
            if(direction==Direction.Horizontal)
            {
                scrollRect.horizontal = true;
                scrollRect.vertical = false;
            }
            else
            {
                scrollRect.horizontal = false;
                scrollRect.vertical = true;
            }
    
            foreach (Transform item in content.transform)
            {
                UIScrolItem cell = item.GetComponent<UIScrolItem>();
                if (cell.GetItem() != null)
                {
    
                }
                cell.SetItem(null);
            }
    
            content.pivot =
                content.anchorMin =
                content.anchorMax = new Vector2(0, 1);
            content.sizeDelta = contentOriginalSize;
            content.anchoredPosition = Vector2.zero;
            columnCount = (int)(contentOriginalSize.x / (itemWidth + spacing.x));
            rowCount = (int)(contentOriginalSize.y / (itemHeight + spacing.y));
            int c = columnCount;
            int r = rowCount;
            if (direction == Direction.Horizontal)
                c += 2;
            else r += 2;
            createCount = c * r;
    
        }
    
        private void InitList(int count)
        {
            listCount = count;
            content.transform.localPosition = Vector2.zero;
            if(direction == Direction.Horizontal)
            {
                columnSum = count / rowCount + count % rowCount == 0 ? 0 : 1;
                contentWidth = columnSum * itemWidth + (columnSum - 1) * spacing.x;
                contentHeight = rowCount * itemHeight + (rowCount - 1) * spacing.y;
            }
            else
            {
                rowSum = (count / columnCount) + (count % columnCount == 0 ? 0 : 1); 
                contentWidth = columnCount * itemWidth + (columnCount - 1) * spacing.x;
                contentHeight = rowSum * itemHeight + (rowSum - 1) * spacing.y;
            }
    
            content.sizeDelta = new Vector2(contentWidth, contentHeight);
            startIndex = 0;
            showCount = Math.Min(createCount, count);
            itemIndexDict.Clear();
    
            for(int i=0;i<showCount;i++)
            {
                Transform item = GetItem(i);
                SetItem(item,i);
            }
        }
    
        public Transform GetItem(int index)
        {
            Transform item = null;
            if(index<content.childCount)
            {
                item = content.GetChild(index);
            }
            else
            {
                var go = new GameObject(index.ToString(), typeof(UIScrolItem));
                var uiScrollItem = go.GetComponent<UIScrolItem>();
                uiScrollItem.init(itemWidth, itemHeight);
                go.transform.SetParent(content);
                item = go.transform;
            }
            item.name = index.ToString();
            item.SetParent(content);
            item.localPosition = Vector3.one;
            return item;
        }
    
        public void SetItem(Transform item,int index)
        {
            item.localPosition = GetPos(index);
            item.name = index.ToString();
            item.SetParent(content);
            itemIndexDict.Add(index, item);
            Debug.Log("向itemIndexDict中添加" + index.ToString());
    
        }
    
        public Vector2 GetPos(int index)
        {
            if (direction == Direction.Horizontal)
                return GetPosH(index);
            else return GetPosV(index);
        }
    
        public Vector2 GetPosH(int index)
        {
            Vector2 v = new  Vector2(index / rowCount * (itemWidth + spacing.x), ((((index + 1) % rowCount) == 0 ? rowCount : ((index + 1) % rowCount)) - 1) * (itemHeight + spacing.y));
            return v;
        }
    
        public Vector2 GetPosV(int index)
        {
            Vector2 v = new Vector2(((((index + 1) % columnCount) == 0 ? columnCount : ((index + 1) % columnCount))-1) * (itemWidth + spacing.x), -index / columnCount * (itemHeight + spacing.y));
            return v;
        }
    
        private List<int> newIndexList = new List<int>();
        private List<int> changedIndexList = new List<int>();
        Vector2 _pos;
        public void OnValueChanged(Vector2 pos)
        {
            _pos = pos;
            if (listCount < createCount)
                return;
    
            startIndex = GetStartIndex(content.localPosition);
    
            if (startIndex + createCount > listCount)
            {
                startIndex = listCount - createCount;
                endIndex = listCount - 1;
            }
            else endIndex = startIndex + createCount - 1;
    
            if (startIndex == lastStartIndex)
                return;
    
            lastStartIndex = startIndex;
    
            newIndexList.Clear();
            changedIndexList.Clear();
            for(int i=startIndex;i<=endIndex;i++)
            {
                newIndexList.Add(i);
                Debug.Log("向newIndexList中添加" + i);
            }
    
            var itr = itemIndexDict.GetEnumerator();
            while(itr.MoveNext())
            {
                int idx = itr.Current.Key;
                if(idx>=startIndex && idx<=endIndex)
                {
                    if (newIndexList.Contains(idx))
                    {
                        newIndexList.Remove(idx);
                        Debug.Log("从newIndexList中删除" + idx);
                    }
                    continue;
                }
                else
                {
                    changedIndexList.Add(idx);
                }
            }
    
            for(int i=0;i<newIndexList.Count && i<changedIndexList.Count;i++)
            {
                int newIndex = newIndexList[i];
                int oldIndex = changedIndexList[i];
                if(newIndex >= 0 && newIndex < listCount)
                {
                    var item = itemIndexDict[oldIndex];
                    itemIndexDict.Remove(oldIndex);
                    SetItem(item, newIndex);
                }
            }
    
        }
    
        public int GetStartIndex(Vector2 v)
        {
            if (direction == Direction.Horizontal)
                return GetStartIndexH(v.x);
            else
                return GetStartIndexV(v.y);
        }
    
        public int GetStartIndexH(float x)
        {
            x = -x;
            if (x < itemWidth)
                return 0;
            float scrollWidth = rectTransform.sizeDelta.x;
            if(x>(content.sizeDelta.x - scrollWidth))
            {
                if (listCount < createCount)
                    return 0;
                else
                    return listCount - createCount;
            }
    
            return (int)(x / (itemWidth + spacing.x)) * rowCount + ((x % (itemWidth + spacing.x)) > 0 ? 1 : 0) - 1;
            
        }
    
        public int GetStartIndexV(float y)
        {
            if (y < itemHeight)
                return 0;
    
            float scrollHeight = rectTransform.sizeDelta.y;
            if(y>(content.sizeDelta.y - scrollHeight))
            {
                if (listCount < createCount)
                    return 0;
                else
                    return listCount - createCount;
            }
    
            return (int)(y / (itemHeight + spacing.y)) * columnCount + ((y % (itemHeight + spacing.y)) > 0 ? 1 : 0 )-1;
    
        }
    
    
    }

UIScrolItem

using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.UI;
    
    [RequireComponent(typeof(RectTransform),typeof(Image))]
    public class UIScrolItem : MonoBehaviour
    {
        private RectTransform rectTransform;
        private RectTransform item;
    
        private void Awake()
        {
            rectTransform = GetComponent<RectTransform>();
        }
    
        public void init(float w,float h)
        {
            rectTransform.pivot =
                rectTransform.anchorMin =
                rectTransform.anchorMax = new Vector2(0, 1);
            rectTransform.sizeDelta = new Vector2(w, h);
        }
    
        public void SetItem(RectTransform rt)
        {
            if(rt!=item)
            {
                if(rt!=null)
                {
                    rt.SetParent(transform);
                    rt.localPosition = Vector2.one;
                }
                item = rt;
            }
        }
    
        public RectTransform GetItem()
        {
            return item;
        }
    
    }

在随便一个按钮上添加一个事件

using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using UnityEngine.UI;
    
    public class MainUi : MonoBehaviour
    {
        public Button[] buttons=new Button[3];
        public GameObject scrollView;
    
        public UIScroll uIScroll;
    
        public void OnClickBag()
        {
            if(!scrollView.activeInHierarchy)
            {
                scrollView.SetActive(true);
                uIScroll.init(100);
    
            }
            else
            {
                scrollView.SetActive(false);
            }
        }
    
    
    
    }