[Unity] ScrollView组件优化-回收机制的滚动窗口

已于 2024-08-03 01:17:53 修改
阅读量389 收藏
点赞数 1
文章标签： unity 游戏引擎 c#
于 2024-06-16 17:27:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_64080879/article/details/139723002
版权

原文链接http://t.csdnimg.cn/D46xT

是这样，本来想学习学习一下这位大佬的滚动窗口，发现CV过去向下/向右滚动窗口没问题，反之则出现问题了，想着来重写修复一下，然后发现越写越像。。我的Version如下，新增了一个列表元素的点击回调事件：

24.8.3 更新子元素的锚点自定义：

FScrollView.cs

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

public class FScrollView : ScrollRect
{
    /// <summary>
    /// 是否为水平滚动
    /// </summary>
    [HideInInspector]
    public bool isHorizontal;
    /// <summary>
    /// 滚动元素的预制体
    /// </summary>
    [HideInInspector]
    public GameObject itemPrefab;
    /// <summary>
    /// 元素大小
    /// </summary>
    [HideInInspector]
    public Vector2 itemSize;
    /// <summary>
    /// 元素间隔
    /// </summary>
    [HideInInspector]
    public Vector2 spaceSize;
    /// <summary>
    /// 每组每行多少个元素
    /// </summary>
    [HideInInspector]
    public int row;
    /// <summary>
    /// 每组每列多少个元素
    /// </summary>
    [HideInInspector]
    public int col;
    /// <summary>
    /// 一共有多少个元素
    /// </summary>
    [HideInInspector]
    public int itemCount;
    /// <summary>
    /// 缓存在mask外的滚动元素数量
    /// </summary>
    [HideInInspector]
    public int cacheCount;
    [HideInInspector]
    public Vector2 anchorMin;
    [HideInInspector]
    public Vector2 anchorMax;
    [HideInInspector]
    public Vector2 pivot;
    /// <summary>
    /// 滚动逻辑单位
    /// </summary>
    FScrollBase scroll;
    public void Init(Action<FScrollItem> onRoll, Action<FScrollItem> onClick = null)
    {
        if(scroll != null)
        {
            scroll.Dispose();
            scroll = null;
        }
        if (isHorizontal)
        {
            scroll = new FScrollHorizontal(this);
        }
        else
        {
            scroll = new FScrollVertical(this);
        }
        scroll.OnInit(onRoll, onClick);
    }

    private void Update()
    {
        scroll?.OnUpdate();
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
        scroll?.Dispose();
    }

    /// <summary>
    /// 滚动窗口基类
    /// </summary>
    public abstract class FScrollBase
    {
        /// <summary>
        /// 滚动方向
        /// </summary>
        public enum MoveDir
        {
            Idle,
            Left,
            Right,
            Up,
            Down
        }
        MoveDir moveDir = MoveDir.Idle;
        public FScrollBase(FScrollView loopScrollView)
        {
            this.isHorizontal = loopScrollView.isHorizontal;
            this.content = loopScrollView.content;
            this.contentSize = content.rect.size;
            this.itemSize = loopScrollView.itemSize;
            this.spaceSize = loopScrollView.spaceSize;
            this.viewport = loopScrollView.viewport;
            this.viewSize = loopScrollView.viewport.rect.size;
            this.itemCount = loopScrollView.itemCount;
            this.row = loopScrollView.row;
            this.col = loopScrollView.col;
            this.cacheCount = loopScrollView.cacheCount;
            this.anchorMin = loopScrollView.anchorMin;
            this.anchorMax = loopScrollView.anchorMax;
            this.pivot = loopScrollView.pivot;
            this.itemPrefab = loopScrollView.itemPrefab;
        }
        public bool isHorizontal;
        public RectTransform content;
        Vector2 contentCurPos;
        Vector2 contentLastPos;
        public Vector2 contentSize;
        public Vector2 itemSize;
        public Vector2 spaceSize;
        /// <summary>
        /// 窗口内可视元素数量
        /// </summary>
        public int visibleCount;
        public int itemCount;
        public int row;
        public int col;
        public int cacheCount;
        public int itemListCount;
        public Vector2 anchorMin;
        public Vector2 anchorMax;
        public Vector2 pivot;
        public List<FScrollItem> itemList;
        GameObject itemPrefab;
        RectTransform viewport;
        public Vector2 viewSize;
        /// <summary>
        /// 滚动回调事件
        /// </summary>
        public Action<FScrollItem> OnRoll;
        /// <summary>
        /// 元素点击事件
        /// </summary>
        public Action<FScrollItem> OnClick;
        public void OnInit(Action<FScrollItem> onRoll, Action<FScrollItem> onClick = null)
        {
            ClearGrid();
            this.OnRoll = onRoll;
            this.OnClick = onClick;
            itemList = new List<FScrollItem>();
            // 保证可视的元素不会超过元素的总数量
            itemListCount = Mathf.Min(visibleCount + cacheCount, itemCount);
            for (int i = 0; i < itemListCount; i++)
            {
                RectTransform item = Instantiate(itemPrefab, content).GetComponent<RectTransform>();
                item.sizeDelta = itemSize;
                SetAnchors(item);
                FScrollItem scrollItem = new FScrollItem(i, CheckIntactGroup(i), this, item);
                OnRoll?.Invoke(scrollItem);
                itemList.Add(scrollItem);
            }
        }
        /// <summary>
        /// 更新方向
        /// </summary>
        public void OnUpdate()
        {
            contentCurPos = content.anchoredPosition;
            Vector2 dir = contentCurPos - contentLastPos;
            if (dir.x > 0)
            {
                moveDir = MoveDir.Right;
            }
            else if (dir.x < 0)
            {
                moveDir = MoveDir.Left;
            }
            else if (dir.y > 0)
            {
                moveDir = MoveDir.Up;
            }
            else if (dir.y < 0)
            {
                moveDir = MoveDir.Down;
            }
            else
            {
                moveDir = MoveDir.Idle;
            }
            contentLastPos = contentCurPos;
            if (moveDir != MoveDir.Idle)
            {
                OnMoving(moveDir);
            }
        }
        /// <summary>
        /// 滚动逻辑
        /// 这里的滚动都指的是窗口（Content）的滚动，即你往下划，窗口向上滚动
        /// </summary>
        /// <param name="moveDir"></param>
        protected abstract void OnMoving(MoveDir moveDir);
        /// <summary>
        /// 设置UI锚点
        /// </summary>
        /// <param name="rect"></param>
        protected void SetAnchors(RectTransform rect)
        {
            rect.anchorMin = anchorMin;
            rect.anchorMax = anchorMax;
            rect.pivot = pivot;
        }
        protected abstract void SetContextAnchors(RectTransform rect);
        /// <summary>
        /// 检查是不是一个完整组
        /// </summary>
        /// <returns></returns>
        protected abstract bool CheckIntactGroup(int itemIdx);
        /// <summary>
        /// 清空滚动元素
        /// </summary>
        protected void ClearGrid()
        {
            if(content == null || content.childCount == 0)
            {
                return;
            }
            for(int i = 0; i < content.childCount; i++)
            {
                Destroy(content.GetChild(i).gameObject);
            }
        }
        /// <summary>
        /// 移除时操作
        /// </summary>
        public void Dispose()
        {
            ClearGrid();
            viewport = null;
            content = null;
            itemPrefab = null;
            if(itemList != null && itemListCount > 0)
            {
                for(int i = itemListCount - 1; i >= 0; i--)
                {
                    itemList[i].Dispose();
                    itemList[i] = null;
                }
                itemList.Clear();
            }
        }
    }

    /// <summary>
    /// 垂直滚动窗口
    /// </summary>
    public class FScrollVertical : FScrollBase
    {
        public FScrollVertical(FScrollView scroll) : base(scroll)
        {
            this.visibleCount = col * (int)Math.Ceiling((viewSize.y + spaceSize.y) / (itemSize.y + spaceSize.y));
            this.cacheCount = cacheCount * col;
            // 设置滚动范围
            int groupNum = itemCount % col == 0 ? itemCount / col : itemCount / col + 1;
            SetContextAnchors(scroll.content);
            scroll.content.sizeDelta = new Vector2(viewSize.x, itemSize.y * groupNum + spaceSize.y * (groupNum - 1));
            scroll.content.anchoredPosition = Vector2.zero;
            this.contentSize = scroll.content.sizeDelta;
        }


        /// <summary>
        /// 设置滚动元素居中对齐上方
        /// </summary>
        /// <param name="rect"></param>
        protected override void SetContextAnchors(RectTransform rect)
        {
            rect.anchorMin = new Vector2(0.5f, 1);
            rect.anchorMax = new Vector2(0.5f, 1);
            rect.pivot = new Vector2(0.5f, 1);
        }
        protected override bool CheckIntactGroup(int itemIdx)
        {
            int leakItem = itemCount % col;
            if (leakItem == 0 || itemIdx<itemCount - leakItem)
            {
                return true;
            }
            return false;
        }

        protected override void OnMoving(MoveDir moveDir)
        {
            if (moveDir == MoveDir.Up)
            {
                if (itemList[itemListCount - 1].index >= itemCount - 1)
                {
                    return;
                }
                MoveToUp();

            }
            else if (moveDir == MoveDir.Down)
            {
                if (itemList[0].index == 0)
                {
                    return;
                }
                MoveToDown();
            }
        }

        void MoveToUp()
        {
            FScrollItem firstItem = itemList[0];
            float firstItemDistance2Top = content.anchoredPosition.y + firstItem.position.y - itemSize.y;
            while (firstItemDistance2Top >= 0)
            {
                for (int i = 0; i < col; i++)
                {
                    int targetIndex = itemList[itemListCount - 1].index + 1;
                    if (targetIndex >= itemCount)
                    {
                        // 已经滚动到顶部
                        return;
                    }
                    firstItem.ChangeIndex(targetIndex, CheckIntactGroup(targetIndex));
                    OnRoll?.Invoke(firstItem);
                    itemList.RemoveAt(0);
                    itemList.Insert(itemListCount - 1, firstItem);
                    firstItem = itemList[0];
                }
                firstItemDistance2Top = content.anchoredPosition.y + firstItem.position.y - itemSize.y;
            }
        }

        void MoveToDown()
        {
            FScrollItem lastItem = itemList[itemListCount - 1];
            float lastItemDistance2Buttom = -lastItem.position.y - content.anchoredPosition.y - viewSize.y;
            while(lastItemDistance2Buttom >= 0)
            {
                bool isIntactGroup = lastItem.isIntactGroup;
                for(int i = 0; i < col; i++)
                {
                    int targetIndex = itemList[0].index - 1;
                    if(targetIndex < 0)
                    {
                        // 已经滚动到底部
                        return;
                    }
                    lastItem.ChangeIndex(targetIndex, CheckIntactGroup(targetIndex));
                    OnRoll?.Invoke(lastItem);
                    itemList.RemoveAt(itemListCount - 1);
                    itemList.Insert(0, lastItem);
                    lastItem = itemList[itemListCount - 1];
                    if(!isIntactGroup && lastItem.isIntactGroup)
                    {
                        // 当前元素组已经轮换完
                        break;
                    }
                }
                lastItemDistance2Buttom = -lastItem.position.y - content.anchoredPosition.y - viewSize.y;
            }
        }
    }

    /// <summary>
    /// 水平滚动窗口
    /// </summary>
    public class FScrollHorizontal : FScrollBase
    {
        public FScrollHorizontal(FScrollView scroll) : base(scroll)
        {
            this.visibleCount = row * (int)Math.Ceiling((viewSize.x + spaceSize.x) / (itemSize.x + spaceSize.x));
            this.cacheCount = cacheCount * row;
            // 设置滚动范围
            int groupNum = itemCount % row == 0 ? itemCount / row : itemCount / row + 1;
            SetContextAnchors(scroll.content);
            scroll.content.sizeDelta = new Vector2(itemSize.x * groupNum + spaceSize.x * (groupNum - 1), viewSize.y);
            scroll.content.anchoredPosition = Vector2.zero;
            this.contentSize = scroll.content.sizeDelta;
        }

        /// <summary>
        /// 设置滚动元素居中对齐左侧
        /// </summary>
        /// <param name="rect"></param>
        protected override void SetContextAnchors(RectTransform rect)
        {
            rect.anchorMin = new Vector2(0, 0.5f);
            rect.anchorMax = new Vector2(0, 0.5f);
            rect.pivot = new Vector2(0, 0.5f);
        }
        protected override bool CheckIntactGroup(int itemIdx)
        {
            int leakItem = itemCount % row;
            if (leakItem == 0 || itemIdx < itemCount - leakItem)
            {
                return true;
            }
            return false;
        }

        protected override void OnMoving(MoveDir moveDir)
        {
            if (moveDir == MoveDir.Left)
            {
                if (itemList[itemListCount - 1].index >= itemCount - 1)
                {
                    return;
                }
                MoveToLeft();

            }
            else if (moveDir == MoveDir.Right)
            {
                if (itemList[0].index == 0)
                {
                    return;
                }
                MoveToRight();
            }
        }
        void MoveToLeft()
        {
            FScrollItem firstItem = itemList[0];
            // 最左侧元素锚点离左边框的距离
            float firstItemDis2Left = content.anchoredPosition.x + firstItem.position.x + itemSize.x;
            while(firstItemDis2Left <= 0)
            {
                for(int i = 0; i < row; i++)
                {
                    int targetIndex = itemList[itemListCount - 1].index + 1;
                    if(targetIndex >= itemCount)
                    {
                        // 已经滚到最左侧
                        return;
                    }
                    firstItem.ChangeIndex(targetIndex, CheckIntactGroup(targetIndex));
                    OnRoll?.Invoke(firstItem);
                    itemList.RemoveAt(0);
                    itemList.Insert(itemListCount - 1, firstItem);
                    firstItem = itemList[0];
                }
                firstItemDis2Left = content.anchoredPosition.x + firstItem.position.x + itemSize.x;
            }
        }
        void MoveToRight()
        {
            FScrollItem lastItem = itemList[itemListCount - 1];
            // 最右侧元素的锚点离右边框的距离
            float lastItemDis2Right = -content.anchoredPosition.x + viewSize.x - lastItem.position.x;
            while(lastItemDis2Right <= 0)
            {
                bool isIntactGroup = lastItem.isIntactGroup;
                for(int i = 0; i < row; i++)
                {
                    int targetIndex = itemList[0].index - 1;
                    if(targetIndex < 0)
                    {
                        // 已经滚动到最右侧
                        return;
                    }
                    lastItem.ChangeIndex(targetIndex, CheckIntactGroup(targetIndex));
                    OnRoll?.Invoke(lastItem);
                    itemList.RemoveAt(itemListCount - 1);
                    itemList.Insert(0, lastItem);
                    lastItem = itemList[itemListCount - 1];
                    if(!isIntactGroup && lastItem.isIntactGroup)
                    {
                        // 当前元素组已经轮换完
                        return;
                    }
                }
                lastItemDis2Right = -content.anchoredPosition.x + viewSize.x - lastItem.position.x;
            }
        }
    }
    /// <summary>
    /// 滚动元素逻辑单元
    /// </summary>
    public class FScrollItem
    {
        public FScrollItem(int index, bool isIntact, FScrollBase scroll, RectTransform rect)
        {
            this.index = index;
            this.isIntactGroup = isIntact;
            this.isHorizontal = scroll.isHorizontal;
            this.row = scroll.row;
            this.col = scroll.col;
            this.itemSize = scroll.itemSize;
            this.spaceSize = scroll.spaceSize;
            position = GetItemPos();
            if (rect)
            {
                this.rect = rect;
                this.rect.anchoredPosition = position;
                this.rect.name = index.ToString();

                this.btn = rect.GetComponent<Button>();
                if (this.btn)
                {
                    this.btn.onClick.AddListener(() =>
                    {
                        scroll.OnClick?.Invoke(this);
                    });
                }
            }
        }
        bool isHorizontal;
        /// <summary>
        /// 滚动元素序号
        /// </summary>
        public int index;
        int row;
        int col;
        /// <summary>
        /// 本元素是否所属完整的一组
        /// </summary>
        public bool isIntactGroup;
        Vector2 itemSize;
        Vector2 spaceSize;
        public Vector2 position;
        public RectTransform rect;
        public Button btn;
        public void ChangeIndex(int index, bool isIntact)
        {
            this.index = index;
            position = GetItemPos();
            rect.anchoredPosition = position;
            rect.name = index.ToString();
            isIntactGroup = isIntact;
        }
        /// <summary>
        /// 获取元素行列对应的实际坐标
        /// </summary>
        /// <returns></returns>
        Vector2 GetItemPos()
        {
            Vector2Int gridPos = GetItemGridPos();
            if(isHorizontal)
            {
                return new Vector2(gridPos.x * (itemSize.x + spaceSize.x), gridPos.y * (itemSize.y + spaceSize.y));
            }
            else
            {
                return new Vector2(gridPos.y * (itemSize.x + spaceSize.x), -gridPos.x * (itemSize.y + spaceSize.y));
            }
        }
        /// <summary>
        /// 获取元素在（第几行，第几列）的索引坐标
        /// </summary>
        /// <returns></returns>
        Vector2Int GetItemGridPos()
        {
            if(isHorizontal)
            {
                return new Vector2Int(index / row, index % row);
            }
            else
            {
                return new Vector2Int(index / col, index % col);
            }
        }

        public void Dispose()
        {
            rect = null;
        }
    }
}

需要重写一下该类的Editor，不然会根据ScrollRect的界面来显示 

 FScrollViewEditor.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEngine.UI;

[CustomEditor(typeof(FScrollView))]
public class FScrollViewEditor : Editor
{
    private FScrollView scroll;
    private SerializedProperty prefab;

    private void Awake()
    {
        scroll = target as FScrollView;
        prefab = this.serializedObject.FindProperty("itemPrefab");

    }

    public override void OnInspectorGUI()
    {
        EditorGUILayout.BeginHorizontal();
        scroll.isHorizontal = EditorGUILayout.Toggle("是否为横向滑动(isHorizontal)", scroll.isHorizontal);
        scroll.horizontal = scroll.isHorizontal;
        scroll.vertical = !scroll.horizontal;
        if (scroll.isHorizontal)
        {
            scroll.row = EditorGUILayout.IntField("行数", scroll.row);
        }
        else
        {
            scroll.col = EditorGUILayout.IntField("列数", scroll.col);
        }
        EditorGUILayout.EndHorizontal();
        scroll.itemSize = EditorGUILayout.Vector2Field("元素大小", scroll.itemSize);
        scroll.spaceSize = EditorGUILayout.Vector2Field("元素间隔", scroll.spaceSize);
        scroll.itemCount = EditorGUILayout.IntField("元素数量", scroll.itemCount);
        scroll.cacheCount = EditorGUILayout.IntField("缓存数量", scroll.cacheCount);
        EditorGUILayout.PropertyField(serializedObject.FindProperty("itemPrefab"), new GUIContent("元素预制体"));
        if (GUI.changed)
        {
            // 保存在预制体下对属性的修改
            Undo.RecordObject(scroll, "modify scroll");
            EditorUtility.SetDirty(scroll);
            serializedObject.ApplyModifiedProperties();
        }

        base.OnInspectorGUI();
    }
}

 然后对应的使用方法就是

FScrollView scroll;
scroll.Init(
(item)=>
{
    Func1(); // 元素滚动事件（可用来对元素内容进行更新）
},
(item)=>
{
    Func2(); // 你的点击事件
});

好帆果子
关注
Unity 面试篇|（四）Unity性能优化篇 【全面总结 | 持续更新】
游戏开发小Y的博客
01-12 9万+
Unity中，CPU准备好需要绘制的元素，对底层图形程序接口进行调用的过程，每次引擎准备数据并通知GPU的过程称为一次Draw Call。DrawCall越高对显卡的消耗就越大。降低DrawCall的方法：动态合批静态合批降低shader的等级特性场景优化策略——遮挡技术。rectMask2D替代Mask。
unity scrollview 优化 高效重复利用 动态增删
08-14
unity scrollview 优化， 通过将显示区域外的子物体，重新赋值达到重复利用 示例效果： https://blog.youkuaiyun.com/weixin_41843959/article/details/81668685
Unity UGUI优化之Scroll view优化
qq_42720695的博客
04-25 2512
Unity原来的Scroll view会一次性实例化所有的元素，然后使用遮罩使固定区域显示一部分元素，这种情况会占用多余资源，所以Scroll view的优化方案就是只实例化界面内同时最多能显示的元素数量，然后在滑动时修改应该隐藏的元素的位置与内容，使其出现在应该新出现的元素的位置，实现元素的重复使用。 使用方法： 首先将MyScrollView脚本挂到ScrollView上，然后设置好行、列间距； 然后将SVController脚本也挂在ScrollView上，设置好myScrollView属性为S
【unity游戏开发入门到精通——UGUI】UI控件 —— ScrollView滚动视图
最新发布
向宇
04-24 1146
【unity游戏开发入门到精通——UGUI】UI控件 —— ScrollView滚动视图
Unity优化篇——ScrollView
weixin_36464906的博客
03-07 3942
ScrollView的优化ScrollView优化的基本思想实现后的效果功能实现思想核心代码 ScrollView优化的基本思想 一个列表数据可能是几十上百条的，而在UGUI中，虽然Item移出了Content为不可见但其任然占用了资源，而我们能看到的Item数量仅仅是在界面上的五六个。 那么我们优化的方式就是重复利用这五六个Item，超出的Item补位到即将出现的Item位置。 实现后的效果 ...
Unity Scroll View优化
qq_34987964的博客
04-08 587
之前写过相关组件:https://blog.youkuaiyun.com/qq_34987964/article/details/100937002 这次遇到项目需求,重写并优化了代码 结构上面基本没有变化 ,包含一个使用示例: 代码部分: using System; using System.Collections.Generic; using UnityEngine; usi...
unity 优化 ScrollView
FireworksFlower的博客
03-19 5044
using DG.Tweening; using XLua; using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; /// <summary> /// 子物体横向移动左上对齐，纵向移动左上对齐 /// </summary> public class ScrollableAreaController : Mon
NGUI实现Unity无限滚动列表的方法
-可以进一步细化回收机制，例如，根据用户滚动速度动态调整预加载的列表项数量，或者在用户停止滚动后一段时间才开始回收列表项。 6. **脚本编写和事件监听**： -编写一个管理无限滚动列表的脚本，通常需要监听...
UGUI Super ScrollView v2.4.4：Unity界面开发利器
资源摘要信息: "UGUI Super ScrollView v2.4.4是一个专门为Unity游戏引擎开发的超级滚动视图组件。此版本的ScrollView插件支持Unity的UGUI系统，使得开发者能够创建流畅、高效且可扩展的用户界面，特别是对于需要...
UGUI Super ScrollView v2.5.4高级滚动效果实现：视觉盛宴打造术
文章深入探讨了滚动视图组件的工作原理、性能优化方法、交互式效果的实现、自定义UI组件的设计、动态内容更新和滚动监听技术等关键内容。通过对实际项目案例的分析，本文还提供了性能瓶颈诊断和兼容性问题解决的实用...
UGUI Super ScrollView v2.5.4自定义Cell布局专家技巧
本文对UGUI Super ScrollView v2.5.4的自定义Cell布局进行了详尽的探讨，首先介绍了组件的基本概念及版本更新亮点，接着阐述了Cell布局设计的理论基础，包括布局设计原则、数据驱动以及性能优化。在实践技巧章节中，...
(ScrollView优化)UnityTest1.rar
05-09
(ScrollView优化)UnityTest1.rar是一个基于unity5.5.6f1 vs2017的ScrollView优化测试，包含水平和竖直方向的应用！这里只给出了竖直方向的应用示例，水平方向同理！
unity3d_5_3_6__UGUI_ScrollView重复利用优化资源item
05-08
unity3d_5_3_6 UGUI ScrollView 重复利用 优化资源item 学习链接:http://blog.youkuaiyun.com/mutou_222/article/details/50455729
unity自制scroll view面板，scroll bar 可一拖动drag
04-25
unity自制scroll view面板，scroll bar 可一拖动drag 拖动图标进入指定位置，drop即可更改grid内容 可以修改成选择制定内容
ScrollView优化
04-14
ScrollView优化
Unity中ScrollView/ScrollRect的优化，实现自动布局和可复用Item的滑动列表
weixin_44068264的博客
06-13 2694
2.根据需要添加的item数量和高确定Content的高。 3.根据ScrollRect的高即遮罩区域大小和item的高确定当前可视区域内可容纳的行数 4.获取Content与ScrollRect的相对坐标的偏移量，确定当前滑动列表滑动了几行。比如当偏移了一个Item的高我们就当作Content滑动了一行。 5.我们给Item定义一个属性值Index。记录它在Content中的位置。 比如Index=0相当于这个Item的位于Content的最左上角。比如当初始状态时起始Index值为0，结束值为初始...
推荐文章：优化你的Unity滚动列表体验 —— 从ScrollView到ScrollViewEx
gitblog_00155的博客
08-15 599
推荐文章：优化你的Unity滚动列表体验 —— 从ScrollView到ScrollViewEx 项目地址:https://gitcode.com/gh_mirrors/un/UnityDynamicScrollView 在Unity引擎开发中，处理大量数据展示的需求总是让人头疼。然而，有了ScrollView及其进阶版本ScrollViewEx，这一挑战迎刃而解。让我们一起探索这个基于UGUI的...
uGUI练习(六) ScrollView
weixin_33962621的博客
09-15 827
练习目标 练习uGUI的滑动组件 一、相关组件 ScrollRect Mask Grid Layout Group Scrollbar 二、步骤 1、创建一个Panel,命名为ScrollRect，添加 ScrollRect组件 2、在ScrollRect下创建一个子Panel,命名为Grid，添加Grid Layout Group 组件 3、在Grid下，创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值