unity 无限循环列表

最新推荐文章于 2025-05-25 15:46:51 发布
最新推荐文章于 2025-05-25 15:46:51 发布
阅读量4.2k 收藏 9
点赞数
分类专栏： unity UGUI UI

具体下载地址不记得了，以下是网上代码贴出
三个 类
UILoopList ，
UILoopItem ，
UILoopListEzample 

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

public class UILoopListEzample : MonoBehaviour {

    public UILoopList uiList;
    // Use this for initialization
    void Start () {
        uiList.onSelectedEvent = OnSelectedEventHandler;
        List<int> listData = new List<int>();
        for (int i = 0; i < 1000; i++)
        {
            listData.Add(i);
        }
        uiList.Data(listData);
    }

    private void OnSelectedEventHandler(UILoopItem item)
    {
        Debug.LogError("选择的单元数据为:" + item.GetData().ToString());
    }

    // Update is called once per frame
    void Update () {

    }
}
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
public class UILoopItem : MonoBehaviour {

    [System.NonSerialized]
    public int itemIndex;
    [System.NonSerialized]
    public GameObject itemObject;
    private object data;
    public void UpdateItem(int index,GameObject item)
    {
        itemIndex = index;
        itemObject = item;
    }
    public virtual void Data(object data)
    {
        this.data = data;
        transform.FindChild ("Text").GetComponent<Text> ().text = "数据" + data.ToString ();
    }
    public virtual object GetData()
    {
        return data;
    }
    public virtual void SetSelected(bool selected)
    {

    }
}

**

**

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

public class UILoopList : MonoBehaviour
{
    /// <summary>
    /// 滚动的方向
    /// </summary>
    enum Direction
    {
        Horizontal,//水平方向
        Vertical//垂直方向
    }
    /// <summary>
    /// 离上边的距离
    /// </summary>
    [SerializeField]
    private float topPadding = 0;
    /// <summary>
    /// 离下边的距离
    /// </summary>
    [SerializeField]
    private float bottomPadding = 0;
    [SerializeField]
    private RectTransform m_Cell;
    [SerializeField]
    private Vector2 m_Page = new Vector2(1,1);//必须设置；几行几列
    [SerializeField]
    Direction direction = Direction.Horizontal;
    [SerializeField,Range(4,10)]
    private int m_BufferNo;
    /// <summary>
    /// 间隔
    /// </summary>
    [SerializeField]
    private float cellGapX = 0f;
    [SerializeField]
    private float cellGapY = 0f;
    public delegate void OnSelectedEvent(UILoopItem item);
    /// <summary>
    /// 选择事件 但组件上一定要有Button组件 设置要在Data()设置数据前
    /// </summary>
    public OnSelectedEvent onSelectedEvent;//
    private List<RectTransform> m_InstantiateItems = new List<RectTransform>();
    private List<RectTransform> m_oldItems = new List<RectTransform>();
    private IList m_Datas;
    public Vector2 CellRect { 
        get {
            return m_Cell != null ? new Vector2(cellGapX + m_Cell.sizeDelta.x, cellGapY + m_Cell.sizeDelta.y) : new Vector2(100, 100);
        }
    }
    public float CellScale { get { return direction == Direction.Horizontal ? CellRect.x : CellRect.y; } }
    private float m_PrevPos = 0;
    public float DirectionPos { get { return direction == Direction.Horizontal ? m_Rect.anchoredPosition.x : m_Rect.anchoredPosition.y; } }
    private int m_CurrentIndex;//页面的第一行（列）在整个conten中的位置
    private Vector2 m_InstantiateSize = Vector2.zero;
    public Vector2 InstantiateSize
    {
        get
        {
            if (m_InstantiateSize == Vector2.zero)
            {
                float rows, cols;
                if (direction == Direction.Horizontal)
                {
                    rows = m_Page.x;
                    cols = m_Page.y + (float)m_BufferNo;
                }
                else
                {
                    rows = m_Page.x + (float)m_BufferNo;
                    cols = m_Page.y;
                }
                m_InstantiateSize = new Vector2(rows, cols);
            }
            return m_InstantiateSize;
        }
    }
    public int PageCount { get { return (int)m_Page.x * (int)m_Page.y; } }
    public int PageScale { get { return direction == Direction.Horizontal ? (int)m_Page.x : (int)m_Page.y; } }
    private ScrollRect m_ScrollRect;
    private RectTransform m_Rect;
    public int InstantiateCount { get { return (int)InstantiateSize.x * (int)InstantiateSize.y; } }
    protected void Awake()
    {
        m_ScrollRect = GetComponentInParent<ScrollRect>();
        m_ScrollRect.horizontal = direction == Direction.Horizontal;
        m_ScrollRect.vertical = direction == Direction.Vertical;
        m_Rect = GetComponent<RectTransform>();
        if (m_Cell.transform.parent != null)
        m_Cell.gameObject.SetActive(false);
        m_Rect.anchorMax = Vector2.up;
        m_Rect.anchorMin = Vector2.up;
        m_Rect.pivot = Vector2.up;
        m_Rect.anchoredPosition = new Vector2 (0f,0f);
    }

    /// <summary>
    /// 设置数据 数据格式为IList
    /// </summary>
    /// <param name="data">Data.</param>
    public void Data(object data)
    {
        Reset();
        m_Datas = data as IList;
        if (m_Datas.Count > PageCount)
        {
            setBound(getRectByNum(m_Datas.Count));
        }
        else
        {
            setBound(m_Page);
        }
        if (m_Datas.Count > InstantiateCount)
        {
            while (m_InstantiateItems.Count < InstantiateCount)
            {
                createItem(m_InstantiateItems.Count);
            }
        }
        else
        {
            while (m_InstantiateItems.Count > m_Datas.Count)
            {
                removeItem(m_InstantiateItems.Count - 1);
            }
            while (m_InstantiateItems.Count < m_Datas.Count)
            {
                createItem(m_InstantiateItems.Count);
            }
        }
        if(m_Datas.Count>0)
        {
            int count = Mathf.Min(m_InstantiateItems.Count, m_Datas.Count);
            for (int i = 0; i < count; i++)
            {
                updateItem(i, m_InstantiateItems[i].gameObject);
            }
        }
    }

    private void Reset()
    {

        for (int i = 0; i < m_InstantiateItems.Count; i++)
        {
            m_InstantiateItems[i].gameObject.SetActive(false);
            m_oldItems.Add(m_InstantiateItems[i]);
        }
        m_InstantiateItems.Clear();
        m_PrevPos = 0;
        m_CurrentIndex = 0;
        selectedObject = null;
        selectedItem = null;
        this.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0);
    }
    public void SetIndexToBottom(int itemIndex)
    {
        this.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, CellRect.y * itemIndex - m_ScrollRect.GetComponent<RectTransform>().sizeDelta.y + CellRect.y*2 + topPadding + bottomPadding);
    }
    private void createItem(int index)
    {
        RectTransform item = null;
        if(m_oldItems.Count > 0)
        {
            item = m_oldItems[0];
            m_oldItems.Remove(item);
        }else{
            item = GameObject.Instantiate(m_Cell);
            item.SetParent(transform, false);
            item.anchorMax = Vector2.up;
            item.anchorMin = Vector2.up;
            item.pivot = Vector2.up;
        }

        item.name = "item" + index;
        item.anchoredPosition = getPosByIndex(index);
        m_InstantiateItems.Add(item);
        item.gameObject.SetActive(true);
        //updateItem(index, item.gameObject);
    }
    private void removeItem(int index)
    {
        RectTransform item = m_InstantiateItems[index];
        m_InstantiateItems.Remove(item);
        item.gameObject.SetActive(false);
        m_oldItems.Add(item);
        //RectTransform.Destroy(item.gameObject);
    }
    /// <summary>
    /// 由格子数量获取多少行多少列
    /// </summary>
    /// <param name="num"></param>格子个数
    /// <returns></returns>
    private Vector2 getRectByNum(int num)
    {
        return direction == Direction.Horizontal ? 
            new Vector2(m_Page.x, Mathf.CeilToInt(num / m_Page.x)) : 
                new Vector2(Mathf.CeilToInt(num / m_Page.y), m_Page.y);
    }
    /// <summary>
    /// 设置content的大小
    /// </summary>
    /// <param name="rows"></param>行数
    /// <param name="cols"></param>列数
    private void setBound(Vector2 bound)
    {
        m_Rect.sizeDelta = new Vector2(bound.y * CellRect.x, bound.x * CellRect.y + bottomPadding + topPadding);
    }
    public float MaxPrevPos
    {
        get
        {
            float result;
            Vector2 max = getRectByNum(m_Datas.Count);
            if(direction == Direction.Horizontal)
            {
                result = max.y - m_Page.y;
            }
            else
            {
                result = max.x - m_Page.x;
            }
            return result * CellScale;
        }
    }
    public float scale { get { return direction == Direction.Horizontal ? 1f : -1f; } }
    private bool isFirst = true;
    void Update()
    {
        if (isFirst == true)
        {
            isFirst = false;
            return;
        }
        while (scale * DirectionPos - m_PrevPos < -CellScale * 2) 
        {
            if (m_PrevPos <= -MaxPrevPos) return;
            m_PrevPos -= CellScale;
            List<RectTransform> range = m_InstantiateItems.GetRange(0, PageScale);
            m_InstantiateItems.RemoveRange(0, PageScale);
            m_InstantiateItems.AddRange(range);
            for (int i = 0; i < range.Count; i++)
            {
                moveItemToIndex(m_CurrentIndex * PageScale + m_InstantiateItems.Count + i, range[i]);
            }
            m_CurrentIndex++;
        }
        while (scale * DirectionPos - m_PrevPos > -CellScale) 
        {
            if (Mathf.RoundToInt(m_PrevPos) >= 0) return;
            m_PrevPos += CellScale;
            m_CurrentIndex--;
            if (m_CurrentIndex < 0) return;
            List<RectTransform> range = m_InstantiateItems.GetRange(m_InstantiateItems.Count - PageScale, PageScale);
            m_InstantiateItems.RemoveRange(m_InstantiateItems.Count - PageScale, PageScale);
            m_InstantiateItems.InsertRange(0, range);
            for (int i = 0; i < range.Count; i++)
            {
                moveItemToIndex(m_CurrentIndex * PageScale + i, range[i]);
            }
        }
    }
    private void moveItemToIndex(int index, RectTransform item)
    {
        item.anchoredPosition = getPosByIndex(index);
        updateItem(index, item.gameObject);
    }
    private Vector2 getPosByIndex(int index)
    {
        return direction == Direction.Horizontal ?
            new Vector2(Mathf.Floor(index / InstantiateSize.x) * CellRect.x, -(index % InstantiateSize.x) * CellRect.y) :
                new Vector2((index % InstantiateSize.y) * CellRect.x, -Mathf.Floor(index / InstantiateSize.y) * CellRect.y - topPadding);
        //float x, y;
        //if(direction == Direction.Horizontal)
        //{
        //    x = index % m_Page.x;
        //    y = Mathf.FloorToInt(index / m_Page.x);
        //}
        //else
        //{
        //    x = Mathf.FloorToInt(index / m_Page.y);
        //    y = index % m_Page.y;
        //}
        //return new Vector2(y * CellRect.x, -x * CellRect.y);
    }
    private object selectedObject = null;
    [System.NonSerialized]
    public UILoopItem selectedItem = null;
    private void updateItem(int index, GameObject item)
    {
        item.SetActive(index < m_Datas.Count);
        if(item.activeSelf)
        {
            UILoopItem lit = item.GetComponent<UILoopItem>();
            lit.UpdateItem(index, item);
            lit.Data(m_Datas[index]);
            if (selectedObject == m_Datas[index])
            {
                lit.SetSelected(true);
            }
            else
            {
                lit.SetSelected(false);
            }
            if (lit.GetComponent<Button>() != null && onSelectedEvent != null && addClickEventList.IndexOf(lit.GetComponent<Button>()) < 0)
            {
                addClickEventList.Add(lit.GetComponent<Button>());
                lit.GetComponent<Button>().onClick.AddListener(delegate()
                {
                    if (onSelectedEvent != null)
                    {
                        if (selectedItem != null && selectedItem != item.GetComponent<UILoopItem>())
                        {
                            selectedItem.SetSelected(false);
                        }
                        selectedItem = item.GetComponent<UILoopItem>();
                        selectedObject = selectedItem.GetData();
                        selectedItem.SetSelected(true);
                        onSelectedEvent(selectedItem);
                    }
                });
            }
        }
    }
    private List<Button> addClickEventList = new List<Button>();
    //void Start()
    //{
    //    List<int> a = new List<int>();
    //    for (int i = 0; i < 30; i++)
    //    {
    //        a.Add(i);
    //    }
    //    Data(a);
    //}
    /// <summary>
    /// 选中的对象
    /// </summary>
    /// <returns></returns>
    public object GetSelectedData()
    {
        return selectedObject;
    }
    /// <summary>
    /// 设置选中对象
    /// </summary>
    /// <param name="selectedIndex"></param>
    public void SetSelectedIndex(int selectedIndex)
    {
        if(m_Datas.Count>0 && m_Datas.Count> selectedIndex)
        {
            selectedObject = m_Datas[selectedIndex];
            if (selectedItem != null)
            {
                selectedItem.SetSelected(false);
            }
            for (int i = 0; i < m_InstantiateItems.Count; i++)
            {
                if (selectedObject == m_InstantiateItems[i].GetComponent<UILoopItem>().GetData())
                {
                    m_InstantiateItems[i].GetComponent<UILoopItem>().SetSelected(true);
                    selectedItem = m_InstantiateItems[i].GetComponent<UILoopItem>();
                }
            }
        }
    }
}
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
努力前行，总会成为自己心中的那道光
02-23 15万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
Unity 面试题篇|（一）C#基础篇 【全面总结 | 持续更新】
热门推荐
游戏开发小Y的博客
01-06 10万+
里氏替换原则(Liskov Substitution Principle LSP)⾯向对象设计的基本原则之⼀。里氏替换原则中说，任何基类可以出现的地⽅，⼦类⼀定可以出现，作⽤⽅便扩展功能能子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法。子类中可以增加自己特有的方法。当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。代理就是⽤来定义指向⽅法的引⽤。
Unity - 无限循环列表
the_vnas的博客
02-02 3428
Unity无限循环列表
Unity循环滑动列表插件EnhancedScroller2：让滑动效果更流畅、更强大
最新发布
gitblog_06757的博客
05-25 370
Unity循环滑动列表插件EnhancedScroller2：让滑动效果更流畅、更强大 【下载地址】Unity循环滑动列表插件EnhancedScroller2 Unity循环滑动列表插件EnhancedScroller2是一款功能强大的Unity工具，专为开发者设计，帮助轻松实现多样化的UI滑动效果。插件内置9个精心制...
unity无限循环列表
weixin_56164608的博客
09-03 1051
然后声明 ScrollRectList viewList;当生成的资源过多，可以采用无限循环列表来防止生成的时候发生卡顿。首先在scrollview加上脚本ScrollRectList。
Unity无限循环列表demo
07-08
Unity无限循环列表demo
Unity3D界面管理——无限列表（基于UGUI）
海王星很危险的博客
09-17 5901
1.主要思路: 根据列表项的大小与可视框生成大于可视框一个数量的列表项 根据列表项距离可视框中间的距离进行上下切换(使用数据结构为链表) 根据滚动距离做累加,求得当前的索引值,并通过索引值获取对应数据对列表项赋值   验证:提供有边界和无边界两种虚拟列表 有边界的列表将会在临界值(0或者1000)无法向上一个索引值(0)或下一个索引值(1000)滚动 无边界的列表将会在临界值时进行循环...
UGUI无限循环滚动优化技巧：提高Item利用效率
从给出的【压缩包子文件的文件名称列表】中，"LoopScrollRect-master"这一名称暗示这是一个开源项目或者示例代码，可能包含了实现上述“无限循环利用Item”优化机制的源代码或相关文档。这个项目可以作为学习和实践...
Unity游戏开发客户端面经——数据结构（初级）
Sea3752的博客
10-25 1万+
Unity游戏开发客户端面经 之 数据结构篇
unity3d 无限循环滑动列表
04-26
该资源是无限循环滑动列表 , 可拖拽 , 可滑动 , 可定位item , 可向上定位item滑动 , 可向下定位item滑动 , 可附近定位item滑动 , 可增加列表长度倍数滑动item , 支持鼠标中建滑动 UNITY_STANDALONE_OSX || UNITY_STANDALONE_WIN || UNITY_EDITOR
Unity无限循环滚动列表Demo
03-25
UGUI无限循环滚动列表
unity实现无限列表功能
08-19
主要介绍了unity实现无限列表功能，水平方向，竖直方向滑动，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
unity ugui无限循环列表
m0_53049789的博客
04-28 566
效果是引用scrollview组件，自己添加item个数，然后循环出现这几个。
Unity 无限滚动列表
Zybdads的博客
11-29 1792
5.在content下排好一行三个字段视图，table-row 挂载脚本row ，三个Text 拖过去分别关联脚本字段，然后做出预制体。1.使用scroll view，设置（例如width 500，height 200），关联脚本ScrollList。4.Content 配置，对应配置Height，cell size （每行的配置），spacing 间隔。2.scroll view 对应的配置，脚本组件对应拖过去。
unity-UI篇-无限循环列表
qq_39121279的博客
04-07 1156
这个主要就展示列表的代码 using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.Events; using UnityEngine.UI; public class InfinitySV : MonoBehaviour { private RectTransform content; //item的宽和高 private Vector2 ce
【Unity3D】无限循环列表（扩展版）
两水先木示的博客
12-15 907
注意事项：无限循环列表的Item物体是重复利用的，因此OnHide回调后必须将传递进来的物体所有相关的缓存引用清空，例如案例是将其从字典移除。
Unity 无限循环滚动列表
qq_33547099的博客
12-26 6420
Unity 无限滑动列表制作 Unity 无限滚动列表功能，效果，循环滚动，并且可以点击交互。 下面展示一些 内联代码片。 public class SlideList : MonoBehaviour,IDragHandler { public static SlideList Instance; public List<RectTransform> itemDataArray = new List<RectTransform>(); private L
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值