无限滚动 ScrollRect

最新推荐文章于 2025-04-23 22:01:24 发布
最新推荐文章于 2025-04-23 22:01:24 发布
阅读量588 收藏 1
点赞数 4
分类专栏： unity3d 文章标签： ugui scrollRect unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_17813937/article/details/118126403
版权

在这里插入图片描述

无限滚动的ScrollRect
2种布局方式，水平或者垂直
支持跳转索引
支持设置内容的pivot和anchor，从上面开始或者下面开始都可以

原理

创建与数据总数对应的矩形
每帧遍历矩形是否与遮罩矩形相交
如果相交添加到索引列表
遍历格子索引
如果索引存在索引列表里面，列表移除该索引
如果不在索引列表里面，把格子索引设置为-1
遍历索引列表
找一个没有绘制的格子对索引绘制

布局

水平布局：
在这里插入图片描述
格子坐标：

cellPos = new Vector2(index / row,index % row);

垂直布局：
在这里插入图片描述
格子坐标：

cellPos = new Vector2(index % column,index / column);

从公式可以看出水平和垂直只是2个坐标轴调换了一下
已知 Vector2 可以使用this索引访问数据
所以只需要添加一个轴变量即可转换布局

        var pos = Vector2.zero;
        pos[asix] = index / layoutValue;
        pos[(asix + 1) % 2] = index % layoutValue;

显示

首先创建最大可显示数量的格子
只需要 遮罩大小 / 格子大小 +1 就可获得在遮罩内可显示格子数量
200/50 = 4，但是当你拖动列表的时候，就会需要5个格子显示

        var xCount = (Mathf.CeilToInt(m_ViewRect.width / m_CellSize.x) + 1);
        var yCount = (Mathf.CeilToInt(m_ViewRect.height / m_CellSize.y) + 1);
        xCount = !isHorizontal ? Math.Min(xCount, layoutValue) : xCount;
        yCount = isHorizontal ? Math.Min(yCount, layoutValue) : yCount;
        m_RenderCount = xCount * yCount;
渲染

更新遮罩区域坐标，通过计算当前内容的坐标，描点，中心轴，得到遮罩的坐标

        m_ViewRect.x = m_ContentPivotOffset.x - m_ContentRect.anchoredPosition.x - m_ContentAnchorOffset.x;
        m_ViewRect.y = m_ContentPivotOffset.y - m_ViewRect.height - (m_ContentRect.anchoredPosition.y) + m_CellSize.y + m_ContentAnchorOffset.y;

获取与遮罩区域相交的格子

        var count = itemRects.Count;
        for (var i = 0; i < count; i++)
        {
            if (m_ViewRect.Overlaps(itemRects[i]))
            {
                indexs.Add(i);
            }
        }

移除indexs列表中正在显示的格子

        foreach (var item in items)
        {
            if (!indexs.Contains(item.index))
            {
                item.index = -1;
                item.transform.gameObject.SetActive(false);
            }
            else
            {
                indexs.Remove(item.index);
            }
        }

设置格子坐标并渲染

        foreach (var index in indexs)
        {
            var renderRect = GetNullRenderRect();
            RenderItem(renderRect, index);
            renderRect.transform.gameObject.SetActive(true);
            renderRect.index = index;
        }

    void RenderItem(RenderRect rect,int index)
    {
        rect.transform.anchoredPosition = GetRenderItemPos(index);
        onRenderItem?.Invoke(index, rect.transform.gameObject);
    }

在格子上按下

使用OnPointerDown事件接口获取当前点击的对象
向上访问父亲链，如果与格子相等就是点击的索引

    void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
    {
        if (eventData.pointerEnter == null)
            return;

        var pointer = eventData.pointerEnter.transform as RectTransform;

        if (pointer == m_ScrollRect.viewport || pointer == m_ScrollRect.transform)
            return;

        while (pointer != m_ScrollRect.transform)
        {
            foreach (var item in items)
            {
                if (item.transform == pointer)
                {
                    onClickItem?.Invoke(item.index);
                    return;
                }
            }
            pointer = pointer.parent as RectTransform;
        }
    }

跳转索引

根据索引获取跳转坐标，在LateUpdate插值坐标
坐标应设置边界，例如滑动最大值为100，格子坐标为150
当设置为150的时候永远也无法到达，这是不允许的
如果内容比遮罩还小，没必要跳转
假如开启了插值跳转，并且正在跳转中，你滑动了列表，此时应停止跳转

    public void MoveToIndex(int index)
    {
        if (index < 0 || index >= itemRects.Count)
            return;

        m_TargetPos = itemRects[index].position * new Vector2(-1, -1) ;
        m_TargetPos += m_ContentAnchorOffset * new Vector2(-1, 1);
        m_TargetPos += m_ContentPivotOffset;
        
        m_TargetPos.x = Mathf.Max(m_TargetPos.x, -m_ContentRect.sizeDelta.x + m_ViewRect.width - m_ContentAnchorOffset.x + m_ContentPivotOffset.x);
        m_TargetPos.y = Math.Min(m_TargetPos.y, m_ContentRect.sizeDelta.y - m_ViewRect.height + m_ContentAnchorOffset.y + m_ContentPivotOffset.y);

        m_TargetPos.x = m_ContentRect.sizeDelta.x - m_ViewRect.width < 0 ? 0 : m_TargetPos.x;
        m_TargetPos.y = m_ContentRect.sizeDelta.y - m_ViewRect.height < 0 ? 0 : m_TargetPos.y;


        if (m_ScrollRect.inertia)
        {
            m_IsMoveToTarget = true;
        }
        else
        {
            m_ContentRect.anchoredPosition = m_TargetPos;
        }
    }
    
    private void LateUpdate()
    {
        if (!m_IsMoveToTarget)
            return;

        m_ContentRect.anchoredPosition = Vector2.Lerp(m_ContentRect.anchoredPosition, m_TargetPos, m_ScrollRect.decelerationRate);

        if ((m_ContentRect.anchoredPosition - m_TargetPos).sqrMagnitude < 0.05f)
        {
            m_ContentRect.anchoredPosition = m_TargetPos;
            m_IsMoveToTarget = false;
        }
    }

    void IBeginDragHandler.OnBeginDrag(PointerEventData eventData)
    {
        m_IsMoveToTarget = false;
    }

demo

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

public class Test : MonoBehaviour
{
    public Button addData;
    public Button gotoIndex;
    public Button changedLayout;
    public ListView listView;
    private void Awake()
    {
        listView.onRenderItem = OnRenderItem;
        listView.onClickItem = OnClickItem;

        addData.onClick.AddListener(OnAddData);
        gotoIndex.onClick.AddListener(OnMoveToIndex);

        bool isHorizontal = true;
        changedLayout.onClick.AddListener(()=> {
            listView.UpdateLayout(isHorizontal);
            isHorizontal = !isHorizontal;
        });
    }

    void OnRenderItem(int index,GameObject item)
    {
        item.GetComponentInChildren<Text>().text = index.ToString();
    }

    void OnClickItem(int index)
    {
        Debug.Log("click "+index);
    }

    void OnAddData()
    {
        listView.Count = Random.Range(0,100);
        Debug.Log($"添加数据："+listView.Count);
    }

    void OnMoveToIndex()
    {
        var index = Random.Range(0, listView.Count);
        listView.MoveToIndex(index);
        Debug.Log($"moveTo {index}");
    }
}

完整源码

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

public class ListView : MonoBehaviour, IBeginDragHandler, IPointerDownHandler
{
    class RenderRect
    {
        public RectTransform transform;
        public int index = -1;
    }

    /// <summary>
    /// 生成模板
    /// </summary>
    public GameObject itemTemplate;
    /// <summary>
    /// 是否水平布局
    /// </summary>
    [SerializeField] private bool isHorizontal = true;
    /// <summary>
    /// 如果是水平布局，该值为垂直数量，如果是垂直布局，该值为水平数量
    /// </summary>
    public int layoutValue;
    /// <summary>
    /// 间隔
    /// </summary>
    public Vector2 spacing;
    /// <summary>
    /// 渲染回调
    /// </summary>
    public Action<int, GameObject> onRenderItem;
    /// <summary>
    /// 点击回调
    /// </summary>
    public Action<int> onClickItem;

    private bool m_isInitialize = false;
    private bool m_IsMoveToTarget = false;
    private int m_Asix;
    private int m_Count;
    private int m_RenderCount;
    private Vector2 m_SpacingPivot;
    private Vector2 m_CellPivotOffset;
    private Vector2 m_TargetPos;
    private Vector2 m_CellSize;
    private Vector2 m_ContentAnchor;
    private Vector2 m_ItemAnchor;
    private Vector2 m_CellAnchorOffset;
    private Vector2 m_ContentAnchorOffset;
    private Vector2 m_ContentPivotOffset;
    private Rect m_ViewRect;
    private ScrollRect m_ScrollRect;
    private RectTransform m_ContentRect;

    private List<Rect> itemRects = new List<Rect>();
    private List<RenderRect> items = new List<RenderRect>();
    private List<int> indexs = new List<int>();

    /// <summary>
    /// 数据数量
    /// 生成与数据数量相等的格子矩形
    /// </summary>
    public int Count
    {
        get
        {
            return m_Count;
        }
        set
        {
            var v = value - m_Count;
            m_Count = value;
            if (v > 0)
            {
                for (var i = 0; i < v; i++)
                {
                    itemRects.Add(GetLayout(itemRects.Count, m_Asix));
                }
            }
            else
            {
                v = Mathf.Abs(v);
                itemRects.RemoveRange(itemRects.Count - v, v);
            }
            UpdateContentSize(m_Asix);
            RefreshList();
        }
    }

    /// <summary>
    /// 移动至目标索引
    /// </summary>
    /// <param name="index"></param>
    public void MoveToIndex(int index)
    {
        if (index < 0 || index >= itemRects.Count)
            return;

        m_TargetPos = itemRects[index].position * new Vector2(-1, -1) ;
        m_TargetPos += m_ContentAnchorOffset * new Vector2(-1, 1);
        m_TargetPos += m_ContentPivotOffset;
        
        m_TargetPos.x = Mathf.Max(m_TargetPos.x, -m_ContentRect.sizeDelta.x + m_ViewRect.width - m_ContentAnchorOffset.x + m_ContentPivotOffset.x);
        m_TargetPos.y = Math.Min(m_TargetPos.y, m_ContentRect.sizeDelta.y - m_ViewRect.height + m_ContentAnchorOffset.y + m_ContentPivotOffset.y);

        m_TargetPos.x = m_ContentRect.sizeDelta.x - m_ViewRect.width < 0 ? 0 : m_TargetPos.x;
        m_TargetPos.y = m_ContentRect.sizeDelta.y - m_ViewRect.height < 0 ? 0 : m_TargetPos.y;


        if (m_ScrollRect.inertia)
        {
            m_IsMoveToTarget = true;
        }
        else
        {
            m_ContentRect.anchoredPosition = m_TargetPos;
        }
    }
    
    /// <summary>
    /// 初始化
    /// </summary>
    public void Initialize()
    {
        if (m_isInitialize)
            return;
        m_ScrollRect = GetComponent<ScrollRect>();
        m_ViewRect = new Rect(Vector2.zero, (m_ScrollRect.transform as RectTransform).sizeDelta);

        m_ContentRect = m_ScrollRect.content;
        m_ContentAnchor = (m_ContentRect.anchorMax + m_ContentRect.anchorMin) * 0.5f;

        var itemRect = itemTemplate.transform as RectTransform;
        m_CellSize = itemRect.rect.size + spacing;
        m_ItemAnchor = (itemRect.anchorMax + itemRect.anchorMin) * 0.5f;
        m_CellPivotOffset = m_CellSize * (itemRect.pivot - Vector2.up);
         
         m_ContentAnchorOffset = new Vector2(m_ContentAnchor.x, (1 - m_ContentAnchor.y)) * m_ViewRect.size;


        m_SpacingPivot = spacing * new Vector2(-itemRect.pivot.x, 1 - itemRect.pivot.y);

        if (Mathf.Approximately(m_ScrollRect.decelerationRate, 0))
        {
            m_ScrollRect.decelerationRate = 1;
        }

        UpdateLayout(isHorizontal);
        m_isInitialize = true;
    }

    /// <summary>
    /// 更换布局
    /// </summary>
    /// <param name="isHorizontal"></param>
    public void UpdateLayout(bool isHorizontal)
    {
        if(m_isInitialize && this.isHorizontal==isHorizontal)
            return;

        layoutValue = Mathf.Max(layoutValue, 1);
        m_Asix = isHorizontal ? 0 : 1;

        var xCount = (Mathf.CeilToInt(m_ViewRect.width / m_CellSize.x) + 1);
        var yCount = (Mathf.CeilToInt(m_ViewRect.height / m_CellSize.y) + 1);
        xCount = !isHorizontal ? Math.Min(xCount, layoutValue) : xCount;
        yCount = isHorizontal ? Math.Min(yCount, layoutValue) : yCount;
        m_RenderCount = xCount * yCount;

        var v = m_RenderCount - items.Count;
        if (v > 0)
        {
            for (var i = 0; i < v; i++)
            {
                var go = GameObject.Instantiate(itemTemplate);
                go.transform.SetParent(itemTemplate.transform.parent, false);
                items.Add(new RenderRect
                {
                    transform = go.transform as RectTransform
                });
            }
        }

        foreach (var item in items)
        {
            item.index = -1;
        }

        itemRects.Clear();
        var count = m_Count;
        m_Count = 0;
        Count = count;
        this.isHorizontal = isHorizontal;
    }

    /// <summary>
    /// 数据更新后手动刷新列表
    /// </summary>
    public void RefreshList()
    {
        foreach (var item in items)
        {
            if(item.index!=-1)
            {
                RenderItem(item, item.index);
            }
        }
    }

    private void Awake()
    {
        Initialize();
    }

    /// <summary>
    /// 移动到目标
    /// </summary>
    private void LateUpdate()
    {
        if (!m_IsMoveToTarget)
            return;

        m_ContentRect.anchoredPosition = Vector2.Lerp(m_ContentRect.anchoredPosition, m_TargetPos, m_ScrollRect.decelerationRate);

        if ((m_ContentRect.anchoredPosition - m_TargetPos).sqrMagnitude < 0.05f)
        {
            m_ContentRect.anchoredPosition = m_TargetPos;
            m_IsMoveToTarget = false;
        }
    }

    /// <summary>
    /// 渲染格子
    /// </summary>
    private void Update()
    {
        m_ViewRect.x = m_ContentPivotOffset.x - m_ContentRect.anchoredPosition.x - m_ContentAnchorOffset.x;
        m_ViewRect.y = m_ContentPivotOffset.y - m_ViewRect.height - (m_ContentRect.anchoredPosition.y) + m_CellSize.y + m_ContentAnchorOffset.y;

        var count = itemRects.Count;
        for (var i = 0; i < count; i++)
        {
            if (m_ViewRect.Overlaps(itemRects[i]))
            {
                indexs.Add(i);
            }
        }

        foreach (var item in items)
        {
            if (!indexs.Contains(item.index))
            {
                item.index = -1;
                item.transform.gameObject.SetActive(false);
            }
            else
            {
                indexs.Remove(item.index);
            }
        }


        foreach (var index in indexs)
        {
            var renderRect = GetNullRenderRect();
            RenderItem(renderRect, index);
            renderRect.transform.gameObject.SetActive(true);
            renderRect.index = index;
        }
        indexs.Clear();
    }

    void RenderItem(RenderRect rect,int index)
    {
        rect.transform.anchoredPosition = GetRenderItemPos(index);
        onRenderItem?.Invoke(index, rect.transform.gameObject);
    }

    Vector2 GetRenderItemPos(int index)
    {
        return itemRects[index].position + m_CellPivotOffset + m_CellAnchorOffset + m_SpacingPivot;
    }

    /// <summary>
    /// 找一个空闲的格子绘制
    /// </summary>
    /// <returns></returns>
    RenderRect GetNullRenderRect()
    {
        foreach (var item in items)
        {
            if (item.index == -1)
            {
                return item;
            }
        }
        throw new System.Exception("Error");
    }

    /// <summary>
    /// 获取当前布局下，index的矩形
    /// </summary>
    /// <param name="index"></param>
    /// <param name="asix"></param>
    /// <returns></returns>
    Rect GetLayout(int index, int asix)
    {
        var pos = Vector2.zero;
        pos[asix] = index / layoutValue;
        pos[(asix + 1) % 2] = index % layoutValue;

        return new Rect(pos * new Vector2(1, -1) * m_CellSize, m_CellSize);
    }

    /// <summary>
    /// 更新内容大小
    /// </summary>
    /// <param name="asix"></param>
    void UpdateContentSize(int asix)
    {
        var count = Vector2.zero;
        count[asix] = Mathf.CeilToInt((float)Count / layoutValue);
        count[(asix + 1) % 2] = layoutValue;
        m_ContentRect.sizeDelta = count * m_CellSize - spacing;

        m_CellAnchorOffset = m_ContentRect.rect.size * new Vector2(-m_ItemAnchor.x, 1 - m_ItemAnchor.y);
        m_ContentPivotOffset = m_ContentRect.rect.size * new Vector2(m_ContentRect.pivot.x, -(1 - m_ContentRect.pivot.y));
    }

    void IBeginDragHandler.OnBeginDrag(PointerEventData eventData)
    {
        m_IsMoveToTarget = false;
    }

    void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
    {
        if (eventData.pointerEnter == null)
            return;

        var pointer = eventData.pointerEnter.transform as RectTransform;

        if (pointer == m_ScrollRect.viewport || pointer == m_ScrollRect.transform)
            return;

        while (pointer != m_ScrollRect.transform)
        {
            foreach (var item in items)
            {
                if (item.transform == pointer)
                {
                    onClickItem?.Invoke(item.index);
                    return;
                }
            }
            pointer = pointer.parent as RectTransform;
        }
    }
}
Unity -- UI -- Scroll Rect
ishena的博客
08-10 2639
Scroll Rect 与Mask和Scrollbars结合使用。Mask使得只有在scroll rect区域内的内容可见。Scrollbars实现水平或垂直滑动。
Unity scrollRect 无限滚动实现
qq_35037137的博客
05-07 2853
首先是竖直下拉，效果如下： 效果图 其中的minAmount是显示最少需要的个数，个数是整个屏幕最多能放下的个数+1 比如效果中，最多能放下三组，所以设置的是4（这里因为显示效果一行三个为1组 使用1哥prefab） 然后在 scrollRect的 connect组建中 需要使用如下组件 image.png 当前是竖向下拉 所以在GridGroupConnect中需要把 c...
UGUI Scrollrect滚动优化：无限循环利用
06-23
我的其他资源都是免费的，对于初学游戏者的帮助比较大的，其中有单片机，ARM，数据结构，window编程，MFC编程，cocos2dx，unity3d自己编写的小游戏。
Unity-无限滚动列表实现&&Timer时间管理实现
最新发布
lastXuanGod的博客
04-23 967
然后在我们的update里，我们会把准备加入数组的计时器加入数组并清空另一个数组，然后对数组中每一个计时器执行Update函数（前文已定义），最后我们批量删除满足IsDone的计时器。第三个函数计算两次更新之间的时间间隔。渲染函数中，我们先移除头部尾部元素，之后如果链表的长度为0则一口气填充所有可视区域，否则我们就填充滑动离开列表的空缺，对于已经离开列表的元素我们进行清除。GetIndex函数的作用是根据具体的坐标得到具体的序号，RoundToInt的用法就是一个基于四舍五入的将浮点数转换成整数的方法。
UGUI ScrollRect滚动优化：无限循环利用Item
08-17
参考NGUI ScrollView的例子写的一个UGUI下的循环利用滚动框。 好几年前的了，因为Unity版本可能有些报错 稍作修改就行。
Scroll Rect（滚动矩形）弹性
Gxy_w的博客
02-15 1267
最近有用到这个Scroll Rect组件，在之前也用过几次，但是许久没有用了，有些东西忘了，在此记录下！ 里面的内容滑动有三种性质，在此记录弹性性质，其余两种作简单说明！ 不受限制 既是对内容随意拖动，甚至会使内容不在矩形显示范围内---------一般不用这个性质 夹紧Clamped 强制将内容保持在Scroll Rect矩形中，切没有视觉效果，即拖动的时候到达边界就会立刻停止！ 弹性Elastic 也是强制将内容保持在 Scroll Rect 的范围内，但是弹性模式在内容到达 Scroll Rect 的
scrollRect
wyr0924的专栏
11-21 768
var rect:Rectangle = new Rectangle(0,0,100,100); image_mc.scrollRect=rect; stage.addEventListener('mouseDown',d); function d(event:MouseEvent):void { rect.x = Math.random() * image_mc.width;
infinite-scroll-unity:无限滚动是一个脚本扩展，允许您将ScrollRect控件用作无限微调器。 这是一种快速，简单且易于移动的方式来创建具有数千行的列表
05-17
无限滚动是一个脚本扩展，允许您将ScrollRect控件用作无限微调器。 这是一种快速，简单且易于移动的方式来创建具有数千行的列表。 它易于使用，并且斋戒，没有时差，没有抖动。 在iOS和Android上进行了测试。 特征 ...
Unity组件大全之 UI 组件 |（9）Scroll Rect组件
Unity打怪升级
09-14 2206
在Unity的游戏开发中，UI组件是玩家与游戏互动的重要桥梁。ScrollRect组件作为UI系统中的核心组件之一，允许玩家通过滚动来查看超出屏幕范围的内容。本文将详细介绍Unity中的ScrollRect组件，包括其基本属性、事件处理以及一些高级使用技巧。
优化UGUI的ScrollRect 实现无尽模式
qq_37700578的博客
07-10 472
UGUI的ScrollRect在加载太多物体的时候，第一次弹出界面会非常卡顿，而且不在界面里的内容依然会参与绘制，导致毫无意义的浪费。笔者对此进行了一番研究，并将心得与大家分享。 介绍 每个元素知道自己的序号，可以根据需要修改自己的内容、大小等信息。 此外支持了ScrollBar，支持横向、纵向及正反向。 在关闭Mask后可以看到，只有当需要的时候才动态实例化元素，使用完后回收。 最原始版本的代码是@ivomarel的InfinityScroll。我改到后来，基本和原始版没啥相同的了。 原代码使用了size
Unity ScrollRect无限拖动.unitypackage
10-29
支持多行,多列. Scrollbar 组件跟ScrollView交互 封装好的接口,拿来就能用 打开demo场景,可以直接运行
Recyclable-Scroll-Rect：Recyclable-Scroll-Rect可重复使用或回收填充视口所需的最少数量的像元。 结果，可以在列表中显示大量项目，而不会影响性能
02-06
可回收滚动矩形 || || 可Unity Asset Store上找到 概要 更新：可回收滚动矩形现在支持水平和网格布局。 使用默认的Scroll-Rect创建包含大量项目的列表会导致性能下降。 尤其是在创建包含成百上千个项目的列表时，将无法以默认方式使用Scroll Rect，即实例化多个项目。 可回收滚动矩形可重复使用或回收填充视口所需的最少数量的像元。 结果，可以在列表中显示大量项目，而不会影响性能。 支持垂直，水平和网格布局。 回收利用 与默认方法的比较 快速入门指南 ： 查看演示场景以获取完整示例用法和结构类似于Native iOS TableViewController
4.unity UI ScrollRect 无限滚动条(最详细)
s_xiajunjun1986的博客
09-19 3839
在游戏开发中 经常遇到滚动显示的数据 特别是商店商品 排行榜 .......等 数据很多，每一条数据去加载一个UI来显示显然对内存浪费很大，这种情况处理一般就是用几个显示条可滚动循环显示无限数据条。本篇介绍实现过程和大体思路以及可重用的滑动脚本InfinityGridLayoutGroup和MarketLayoutGroup数据管理刷新脚本。MarketElement类要看具体项目中具体数据结构...
UGUI源码解析（十）ScrollRect
qq826364410的专栏
03-04 3045
ScrollRect ScrollRect继承自UIBehaviour，另外还继承了IInitializePotentialDragHandler, IBeginDragHandler, IEndDragHandler, IDragHandler, IScrollHandler, ICanvasElement, ILayoutElement, ILayoutGroup这些接口。 OnEnabl...
UGUI组件ScrollRect扩展,自动移动到中心位置
qq_32470423的博客
02-10 548
UGUI ScrollRect扩展,自动移动到中间,自动移动到中心点
UGUI Selectable之三（ScrollRect与ScrollBar）
ttod的博客
12-15 211
UGUI Selectable之四（ScrollRect与ScrollBar）
UGUI的ScrollRect
超胆孤侠
09-03 478
卷动区域 scrollbar单独是没有用的，需要和ScorllRect配合使用 构成分析 ScrollRect Image Mask Image 空物体【用于卷动显示的数据】需要添加text组件 横向卷动条 纵向卷动条【ScrollBar 游戏物体】 三种形态 它是根据content的框子范围来决定的 无卷动条，当框子没有超过Mask范围 纵向卷动条，当数据量...
UGUI使用小技巧（五） Scroll Rect组件的使用
不文不武的禾文
10-28 5246
在功能开发中，由于可能需要显示很多数据，但是一个界面显示不下，经常都会遇到需要滑动的列表，如背包，排行榜等，这些地方基本都会用到Unity3D的Scroll Rect组件来实现滑动功能。除此之外，Scroll Rect还有一些小技巧，可以用来滑动文字，图片，达到一些别的功能。 一、基本用法 经常使用到的组件：Scroll Rect、Mask、GridLayoutGroup 首先Unity的H...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鱼游戏开发

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值