Unity虚拟列表无限列表

已于 2023-03-30 11:11:46 修改
阅读量582 收藏
点赞数
分类专栏： ScrollView ScrollRect 虚拟列表 文章标签： unity c# 游戏引擎
于 2023-03-29 16:55:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52089397/article/details/129839998
版权

直接贴代码

using System.Collections.Generic;
using UnityEngine;
//using UnityEngine.EventSystems;
using UnityEngine.UI;
using DG.Tweening;

/// <summary>
/// 虚拟列表1
/// </summary>
public class VirtualScroll : ScrollRect
{
    public delegate void ListItemRenderer(int index, GameObject item);
    /// <summary>
    /// 刷新项的回调函数
    /// </summary>
    public ListItemRenderer itemRenderer;
    /// <summary>
    /// 最大项数
    /// </summary>
    private int _numItems;
    [Header("自定义项")]
    public RectTransform Item;
    [Tooltip("项的大小")]
    public Vector2 ItemSize;
    [Tooltip("间距")]
    public float Spacing;
    [Tooltip("边距")]
    public RectOffset Padding;
    /// <summary>
    /// 当前组件
    /// </summary>
    private VirtualScroll _parent;
    /// <summary>
    /// 创建的项列表，有序排列和显示顺序一致
    /// </summary>
    private List<ItemInfo> _virtualItems = new List<ItemInfo>();
    /// <summary>
    /// 方向
    /// </summary>
    private enum Direction
    {
        Horizontal,
        Vertical
    }
    

    /// <summary>
    /// 自己的滑动方向
    /// </summary>
    private Direction _direction;
    /// <summary>
    /// 项信息
    /// </summary>
    private class ItemInfo
    {
        /// <summary>
        /// 项
        /// </summary>
        public RectTransform item;
        /// <summary>
        /// 列表索引0开始
        /// </summary>
        public int index;
    }

    protected override void Awake()
    {
        base.Awake();
        if (transform.parent)
        {
            _parent = transform.GetComponentInParent<VirtualScroll>();
        }
        _direction = horizontal ? Direction.Horizontal : Direction.Vertical;
    }
    /// <summary>
    /// 变化值
    /// </summary>
    private void ListenerChange(Vector2 changeV)
    {
        RefreshItemInfo();
    }
    #region 计算个数
    /// <summary>
    /// 计算最大个数
    /// </summary>
    private void CalcuglateCount()
    {
        if (_direction == Direction.Vertical)//垂直滑动
        {
            ///初始化容器
            _parent.content.anchorMin = new Vector2(0, 1);
            _parent.content.anchorMax = new Vector2(1, 1);
            _parent.content.anchoredPosition = new Vector2(_parent.content.anchoredPosition.x, 0);
            float ContentHeight = ItemSize.y * _numItems + (_numItems - 1) * Spacing + Padding.top + Padding.bottom;
            _parent.content.sizeDelta = new Vector2(_parent.content.sizeDelta.x, ContentHeight);//设置大小 项越多值越大
                                                                                                //初始化项 对齐顶上
            Item.pivot = new Vector2(0.5f, 1);
            Item.anchorMin = new Vector2(0.5f, 1);
            Item.anchorMax = new Vector2(0.5f, 1);
            //计算可显示的项数
            float height = _parent.GetComponent<RectTransform>().rect.height;
            height -= (Padding.top + Padding.bottom);
            //最少项数
            int LeastItemCount = Mathf.CeilToInt(height / (ItemSize.y + Spacing));
            LeastItemCount += 2;
            LeastItemCount = LeastItemCount > _numItems ? _numItems : LeastItemCount;
            int MaxNum = LeastItemCount - _virtualItems.Count;
            //生成项
            if (MaxNum > 0)
            {
                for (int i = _virtualItems.Count; i < LeastItemCount; i++)
                {
                    GameObject item = GameObject.Instantiate(Item.gameObject);
                    item.transform.SetParent(_parent.content);
                    ItemInfo itemInfo = new ItemInfo();
                    itemInfo.item = item.GetComponent<RectTransform>();
                    itemInfo.index = i;
                    _virtualItems.Add(itemInfo);
                    item.SetActive(false);
                    item.GetComponent<RectTransform>().localScale = Vector3.one;
                }
            }
            else
            {
                MaxNum = -MaxNum;
                for (int i = 0; i < MaxNum; i++)
                {
                    GameObject gameObject = _virtualItems[_virtualItems.Count - 1].item.gameObject;
                    _virtualItems.RemoveAt(_virtualItems.Count - 1);
                    Destroy(gameObject);
                }
            }
            if (_parent)
            {
                _parent.onValueChanged.RemoveAllListeners();
                _parent.onValueChanged.AddListener(ListenerChange);
            }
        }
        else
        {
            _parent.content.anchorMin = new Vector2(0, 0);
            _parent.content.anchorMax = new Vector2(0, 1);
            _parent.content.anchoredPosition = new Vector2(0, _parent.content.anchoredPosition.y);
            float ContentHeight = ItemSize.x * _numItems + (_numItems - 1) * Spacing + Padding.left + Padding.right;
            _parent.content.sizeDelta = new Vector2(ContentHeight, _parent.content.sizeDelta.y);//设置大小 项越多值越大
                                                                                                //初始化项 对齐顶上
            Item.pivot = new Vector2(0f, 0.5f);
            Item.anchorMin = new Vector2(0f, 0.5f);
            Item.anchorMax = new Vector2(0f, 0.5f);
            //计算可显示的项数
            float height = _parent.GetComponent<RectTransform>().rect.width;
            height -= (Padding.left + Padding.right);
            //最少项数
            int LeastItemCount = Mathf.CeilToInt(height / (ItemSize.x + Spacing));
            LeastItemCount += 2;
            LeastItemCount = LeastItemCount > _numItems ? _numItems : LeastItemCount;
            int MaxNum = LeastItemCount - _virtualItems.Count;
            //生成项
            if (MaxNum > 0)
            {
                for (int i = _virtualItems.Count; i < LeastItemCount; i++)
                {
                    GameObject item = GameObject.Instantiate(Item.gameObject);
                    item.transform.SetParent(_parent.content);
                    ItemInfo itemInfo = new ItemInfo();
                    itemInfo.item = item.GetComponent<RectTransform>();
                    itemInfo.item.anchoredPosition = new Vector2(0,0);
                    itemInfo.index = i;
                    _virtualItems.Add(itemInfo);
                    item.SetActive(false);
                    item.GetComponent<RectTransform>().localScale = Vector3.one;
                }
            }
            else
            {
                MaxNum = -MaxNum;
                for (int i = 0; i < MaxNum; i++)
                {
                    GameObject gameObject = _virtualItems[_virtualItems.Count - 1].item.gameObject;
                    _virtualItems.RemoveAt(_virtualItems.Count - 1);
                    Destroy(gameObject);
                }
            }
            if (_parent)
            {
                _parent.onValueChanged.RemoveAllListeners();
                _parent.onValueChanged.AddListener(ListenerChange);
            }
        }
    }
    #endregion
    /// <summary>
    /// 设置总项数，虚拟列表创建显示个数
    /// 最大个数必须大于可视化个数1倍
    /// </summary>
    public int numItems
    {
        get { return _numItems; }
        set
        {
            if (Padding==null)
                throw new System.Exception("VirtualScroll: Set Padding first!");
            if (itemRenderer == null)
                throw new System.Exception("VirtualScroll: Set itemRenderer first!");
            _numItems = value;
            CalcuglateCount();
            RefreshList();
        }
    }
    /// <summary>
    /// 刷新 无方向
    /// </summary>
    private void RefreshItem()
    {
        //直接刷新就全部刷新
        for (int i = 0; i < _virtualItems.Count; i++)
        {
            if (!_virtualItems[i].item.gameObject.activeSelf)
            {
                _virtualItems[i].item.gameObject.SetActive(true);
            }
            CalibrationPos(_virtualItems[i]);
            itemRenderer?.Invoke(_virtualItems[i].index, _virtualItems[i].item.gameObject);//
        }
    }
    /// <summary>
    /// 校准位置
    /// 向上对齐,所以索引越大,负数越大
    /// </summary>
    private void CalibrationPos(ItemInfo itemInfo)
    {
        if (_direction == Direction.Vertical)
        {
            float _oldPos = itemInfo.item.anchoredPosition.y;
            float Y = Padding.top + itemInfo.index * ItemSize.y + itemInfo.index * Spacing;
            Y *= -1;
            if (!Mathf.Approximately(_oldPos, Y))
            {
                itemInfo.item.anchoredPosition = new Vector2(itemInfo.item.anchoredPosition.x, Y);
            }
        }
        else
        {
            float _oldPos = itemInfo.item.anchoredPosition.x;
            float Y = Padding.left + itemInfo.index * ItemSize.x + itemInfo.index * Spacing;
            if (!Mathf.Approximately(_oldPos, Y))
            {
                itemInfo.item.anchoredPosition = new Vector2(Y, itemInfo.item.anchoredPosition.y);
            }
        }
    }
    #region 刷新项信息
    private void RefreshItemInfo()
    {
        if (_direction == Direction.Vertical)
        {
            RefreshVItem();
        }
        else
        {
            RefreshHItem();
        }
    }
    /// <summary>
    /// 刷新垂直
    /// </summary>
    private void RefreshVItem()
    {
        float contentY = _parent.content.anchoredPosition.y;
        contentY -= Padding.top;
        //当前可显示的下标
        int index = (int)Mathf.Floor(contentY / (ItemSize.y + Spacing));
        index = index < 0 ? 0 : index;
        int VirtualIndex = _virtualItems[0].index;
        if (index == VirtualIndex)//第一索引和当前索引一致就返回过滤
        {
            return;
        }
        else if (index < VirtualIndex)
        {
            //根据索引移动元素
            for (int i = 0; i < _virtualItems.Count; i++)
            {
                VirtualIndex -= 1;
                ItemInfo itemInfo = _virtualItems[_virtualItems.Count - 1];
                GameObject gameObject = itemInfo.item.gameObject;
                _virtualItems.RemoveAt(_virtualItems.Count - 1);
                _virtualItems.Insert(0, itemInfo);
                if (VirtualIndex == index)
                {
                    break;
                }
            }
        }
        else
        {
            for (int i = 0; i < _virtualItems.Count; i++)
            {
                VirtualIndex += 1;
                ItemInfo itemInfo = _virtualItems[0];
                GameObject gameObject = itemInfo.item.gameObject;
                _virtualItems.RemoveAt(0);
                _virtualItems.Add(itemInfo);
                if (VirtualIndex == index)
                {
                    break;
                }
            }
        }
        //获取位置为负数
        float startY = (Padding.top + index * (ItemSize.y + Spacing)) * -1;
        int itemIndex = 0;
        for (int i = index; i < _numItems; i++)
        {
            if (_virtualItems.Count <= itemIndex)//最多只允许刷新项那么多
            {
                break;
            }
            if (!_virtualItems[itemIndex].item.gameObject.activeSelf)
            {
                _virtualItems[itemIndex].item.gameObject.SetActive(true);
            }
            if (_virtualItems[itemIndex].index != i)//只有索引不一致才刷新
            {
                _virtualItems[itemIndex].index = i;
                _virtualItems[itemIndex].item.anchoredPosition = new Vector2(_virtualItems[itemIndex].item.anchoredPosition.x, startY);
                itemRenderer?.Invoke(i, _virtualItems[itemIndex].item.gameObject);
            }
            startY -= ItemSize.y + Spacing;
            itemIndex++;
        }

        //多余的项隐藏
        //for (int i = itemIndex; i < _virtualItems.Count; i++)
        //{
        //    if (_virtualItems[i].item.gameObject.activeSelf)
        //    {
        //        _virtualItems[i].item.gameObject.SetActive(false);
        //    }
        //}
    }
    /// <summary>
    /// 刷新水平
    /// </summary>
    private void RefreshHItem()
    {
        float contentY = _parent.content.anchoredPosition.x;
        contentY += Padding.left;
        contentY = -contentY;
        //当前可显示的数据下标
        int index = (int)Mathf.Floor(contentY / (ItemSize.x + Spacing));
        index = index < 0 ? 0 : index;
        int VirtualIndex = _virtualItems[0].index;
        if (index == VirtualIndex)//第一索引和当前索引一致就返回过滤
        {
            return;
        }
        else if (index < VirtualIndex)
        {
            //根据索引移动元素
            for (int i = 0; i < _virtualItems.Count; i++)
            {
                VirtualIndex -= 1;
                ItemInfo itemInfo = _virtualItems[_virtualItems.Count - 1];
                GameObject gameObject = itemInfo.item.gameObject;
                _virtualItems.RemoveAt(_virtualItems.Count - 1);
                _virtualItems.Insert(0, itemInfo);
                if (VirtualIndex == index)
                {
                    break;
                }
            }
        }
        else
        {
            for (int i = 0; i < _virtualItems.Count; i++)
            {
                VirtualIndex += 1;
                ItemInfo itemInfo = _virtualItems[0];
                GameObject gameObject = itemInfo.item.gameObject;
                _virtualItems.RemoveAt(0);
                _virtualItems.Add(itemInfo);
                if (VirtualIndex == index)
                {
                    break;
                }
            }
        }
        //获取位置为负数
        float startY = Padding.left + index * (ItemSize.x + Spacing);
        int itemIndex = 0;
        for (int i = index; i < _numItems; i++)
        {
            if (_virtualItems.Count <= itemIndex)//最多只允许刷新项那么多
            {
                break;
            }
            if (!_virtualItems[itemIndex].item.gameObject.activeSelf)
            {
                _virtualItems[itemIndex].item.gameObject.SetActive(true);
            }
            if (_virtualItems[itemIndex].index != i)//只有索引不一致才刷新
            {
                _virtualItems[itemIndex].index = i;
                _virtualItems[itemIndex].item.anchoredPosition = new Vector2(startY, _virtualItems[itemIndex].item.anchoredPosition.y);
                itemRenderer?.Invoke(i, _virtualItems[itemIndex].item.gameObject);
            }
            startY += ItemSize.x + Spacing;
            itemIndex++;
        }

        //多余的项隐藏
        //for (int i = itemIndex; i < _virtualItems.Count; i++)
        //{
        //    if (_virtualItems[i].item.gameObject.activeSelf)
        //    {
        //        _virtualItems[i].item.gameObject.SetActive(false);
        //    }
        //}
    }
    #endregion
    //===========================================外部调用
    /// <summary>
    /// 校准刷新项
    /// </summary>
    public void CalibrationRefresh()
    {
        RefreshItemInfo();
    }
    /// <summary>
    /// 获取指定索引的项
    /// </summary>
    public GameObject GetListAt(int index)
    {
        ItemInfo itemInfo = _virtualItems.Find(item=>(item.index == index));
        if (itemInfo!=null)
        {
            return itemInfo.item.gameObject;
        }
        return null;
    }
    /// <summary>
    /// 刷新当前显示列表的数据
    /// </summary>
    public void RefreshList()
    {
        RefreshItem();
    }
    /// <summary>
    /// 刷新指定索引的数据
    /// </summary>
    public void RefreshListIndex(int index)
    {
        ItemInfo itemInfo = _virtualItems.Find(item => (item.index == index));
        if (itemInfo==null)
        {
            throw new System.Exception("RefreshListIndex: index out:"+ index);
        }
        else
        {
            itemRenderer?.Invoke(index, itemInfo.item.gameObject);
        }
    }
    /// <summary>
    /// 跳转到指定索引
    /// </summary>
    /// <param name="first"></param>
    public void ScrollToView(ScrollTo scrollTo,bool anim =false)
    {
        if (scrollTo == ScrollTo.First)
        {
            ScrollToView(0, anim);
        }
        else if (scrollTo== ScrollTo.Last)
        {
            ScrollToView(_numItems-1, anim);
        }
        else
        {
            throw new System.Exception("ScrollToView: ScrollTo is null!");
        }
    }
    /// <summary>
    /// 跳转到指定索引
    /// </summary>
    public void ScrollToView(int index, bool anim = false)
    {
        if (index < 0)
        {
            throw new System.Exception("ScrollToView: index < 0!");
        }
        else if (index > (_numItems - 1))
        {
            throw new System.Exception("ScrollToView: index > Max Value!");
        }
        else
        {
            if (_direction == Direction.Vertical)
            {
                float height = (ItemSize.y + Spacing) * index;//+ Padding.top
                //
                float MaxHeight = _parent.content.rect.height - _parent.viewport.rect.height - Padding.bottom;
                if (height > MaxHeight)
                {
                    height = MaxHeight;
                }
                if (anim)
                {
                    _parent.content.DOAnchorPosY(height, 0.5f, true);
                }
                else
                {
                    _parent.content.anchoredPosition = new Vector2(_parent.content.anchoredPosition.x, height);
                }
            }
            else
            {
                float height = (ItemSize.x + Spacing) * index;//+ Padding.left
                float MaxHeight = _parent.content.rect.width - _parent.viewport.rect.width - Padding.right;
                if (height > MaxHeight)
                {
                    height = MaxHeight;
                }
                if (anim)
                {
                    _parent.content.DOAnchorPosX(-height, 0.5f, true);
                }
                else
                {
                    _parent.content.anchoredPosition = new Vector2(-height, _parent.content.anchoredPosition.y);
                }
            }
        }
    }
}
/// <summary>
/// 跳转到
/// </summary>
public enum ScrollTo
{
    /// <summary>
    /// 第一
    /// </summary>
    First,
    /// <summary>
    /// 最后
    /// </summary>
    Last
}

还需要在Editor文件夹下创建一个脚本用于编辑器显示

using UnityEditor;
[CustomEditor(typeof(VirtualScroll))]
public class CustomVirtualScroll : Editor
{
   
}

显示出来是这样的

 下面参数是新加的，类似GridLayoutGroup组件参数，上面参数是原本就有的

参数都可以代码加载，需要自己去添加方法

使用方式也很简单，和FGUI列表使用类似

VirtualScroll VScrollRect;
public void Init()
{
    VScrollRect.itemRenderer = ItemRenderer;
    VScrollRect.numItems = MaxNum;
    //VScrollRect.RefreshList();//全部刷新
}
/// <summary>
/// 渲染刷新
/// </summary>
/// <param name="index">当前索引</param>
/// <param name="item">返回的对象</param>
public void ItemRenderer(int index,GameObject item)
{
    //处理逻辑
}

这个只适用于项的大小一致，不一致的需要自己去修改，我的代码有点乱，不太好看，里面用了DG.Tweening来跳转，不使用的直接注释掉就行了

Is_Not_Function
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity的list列表操作（结合Linq整理的一些高级写法Sort、Where等）
谁为拨动染血的时空苍穹
11-24 2741
1、List.Sort（） Unity的List.Sort有三种结果 1,-1,0分别是大，小，相等。默认List的排序是升序排序，如果要降序排序，也很简单，只需要在前面加一个负号即可。 List<int> m_temp = new List<int>(){6,1,3,5,4}; // 升序 m_temp.Sort((x, y) => x.CompareTo(y)); // 降序 m_temp.Sort((x, y) => -x.CompareTo(y)
Unity学习（C#）——列表List的创建和使用
weixin_45045387的博客
06-18 1万+
集合类：数组的大小是固定的，有时候不方便，需要使用集合来管理，列表是集合类的一组，且可以方便的添加和删除数据。 创建和访问、插入数据。 static void Main(string[] args) { List<int> scoreList = new List<int>(); var scoreList1 = new List<int>(); var scoreList2 = n
unity基于UGUI的虚拟列表
折木、沐白的博客
03-30 2286
Unity自带的滚动列表如果创建过多，如同时创建上千，上万，易引起卡顿，为解决这种现象的发生，这里实现虚拟列表来处理这种情况。原理就是初始化固定个数的item数，当滚动列表向下滚动至可视范围外的时候将第一个Item移动至最底层，如此循环执行，向上滚动如是，于是我们只用关注数据的变化，动态改变item的数据即可。 站在巨人的肩膀上才能看的更远（拿来主义与总结） using UnityEngin...
unity中ScrollRect虚拟化列表的简单实现
lbfht的专栏
12-16 748
ScrollRect算是项目中需要经常用到的一个组件。但是因为unity本身并不支持scrollrect的虚拟化显示。在数据量很大时scrollrect中就会创建了过多的子项，导致项目卡顿。所以抽空简单实现了下项的重复使用，以达到性能优化的目的。然后就是公布一个外部可调用的接口方法。具体使用的时候就只需要刷新数据长度和绑定OnItemChanged事件回调进行数据刷新就好啦。这是测试代码：先根据输入的数字创建指定长度的数据。因为当前并不处理横向滚动，故先将横向的Scrollbar干点了。
Unity制作下拉列表
最新发布
guwen2233的博客
05-31 332
4.在Content下新建Image改名为Obj，手动调整至Content同等大小,然后选择Content把Content Size Fitter组件下的Vertical Fit改为Perferred Size,随后把Viewport和Content拖入Scroll View组件下的同名选项里。2.在Scroll View下新建Image，改名为Viewport，点击锚点按住alt，点击随父物体全屏，然后添加Mask组件，取消勾选Show Mask Graphic。
UGUI自定义ListView列表组件（虚拟列表）
QO_GQ的博客
08-11 2297
最近在尝试使用ugui，发现这个还真的不方便，很多都是基础组件。自带的ScrollRect没有虚拟列表，如果有10000个，那岂不是需要创建10000个子对象？ 不过，身为程序员怎么能不偷懒呢？就打算自己封装一个组件： 效果： 用途一般是用来做排行榜啊，显示列表等：像这种 首先需要一个数据结构体，作为后续存数据： public struct ItemDate { public int index; public object data; public UIList m_paren
unity使用虚拟列表方法实现九宫格加载地形地图
weixin_39889192的博客
05-06 482
点击地图计算在地形上的位置（可用于导航移动）地形块地图块统一计算。
Unity简单的无限列表
04-10
在Unity引擎中，"无限列表"（Infinite List）是一种常见的UI设计，它允许用户滚动浏览数量庞大的数据项，而无需一次性加载所有内容。这种技术主要用于优化性能，尤其是在移动设备上，避免一次性加载大量对象导致内存...
unity实现无限列表功能
01-20
本文实例为大家分享了unity实现无限列表功能的具体代码，供大家参考，具体内容如下 public static class RectTransformExtensions { public static bool Overlaps(this RectTransform a, RectTransform b) { ...
unity 无限循环列表
04-09
在提供的压缩包文件"unity3D无限列表"中，可能包含了实现这一功能的源代码、示例场景和预制体资源。你可以通过研究这些文件来理解具体实现细节，并将其应用到自己的项目中。记住，理解并灵活运用这些知识对于提升...
【Unity无限循环列表工具】EnhancedScroller 2.18.1
04-12
可选循环允许您显示无限数据列表。每个单元格可以有自己的大小，或者它们都可以共享相同的大小。可选的捕捉使您可以将单元格锁定到特定位置。补间操作可以减轻您的跳跃和捕捉过渡，以提供流畅的用户体验。
unity UGUI 无限list
03-11
unity的一个无限列表的demo，ScrollView的无限列表，打开scene文件夹下的场景 1
MFC-Listcontrol控件虚拟列表 多个例子代码
05-07
MFC-Listcontrol控件虚拟列表 这里收集到好几个例子代码觉得对初学者很有帮助，欢迎下载学习
unity3d 无限循环滑动列表
04-26
该资源是无限循环滑动列表 , 可拖拽 , 可滑动 , 可定位item , 可向上定位item滑动 , 可向下定位item滑动 , 可附近定位item滑动 , 可增加列表长度倍数滑动item , 支持鼠标中建滑动 UNITY_STANDALONE_OSX || UNITY_STANDALONE_WIN || UNITY_EDITOR
unity 树形列表 ugui
04-20
unity 树形列表 ugui
Unity3D插件FancyScrollView，UI滑动列表
07-20
《Unity3D插件FancyScrollView：打造动态UI滑动列表》 Unity3D作为一款强大的游戏开发引擎...同时，这个插件也为UI设计提供了无限可能，无论是简单的列表展示，还是复杂的交互设计，FancyScrollView都能助你一臂之力。
Unity 循环列表 EnhancedScroller
明明明的博客
07-26 2298
Unity 无限列表 EnhancedScroller
Unity VideoPlayer组件一个接一个的播放视频
mine0928的博客
11-16 3733
       前几天做开发播放视频，想视频一播放完成后接着播放视频二，视频二播放完成后接着播放视频三。。。。结果给难倒了，开始用的videoplayer中的loopPointReached。loopPointReached是当VideoPlayer到达要播放的内容的结尾时调用。使用如下图：         真是糟心啊，也可能是我的判断条件给的不对，反正是纠结了好几天，没研究出用loopPoi...
unity3d两种播放视频的方式
热门推荐
u010179789的博客
01-26 1万+
在Unity3D中播放游戏视频的方式有两种，第一种是在游戏对象中播放，就好比在游戏世界中创建一个Plane面对象，摄像机直直的照射在这个面上。第二种是在GUI层面上播放视频。播放视频其实和贴图非常相像，因为播放视频用到的MovieTexture属于贴图Texture的子类，那么本章我们就好好学习一下Unity中播放视频的这两种方式。   Unity支持的播放视频格式有.mov、.mpg、.m
unity 虚拟列表 代码
06-09
以下是 Unity 中实现虚拟列表的示例代码： ```csharp using UnityEngine; using UnityEngine.UI; using System.Collections.Generic; public class VirtualList : MonoBehaviour { public GameObject listItemPrefab; public Transform contentPanel; public ScrollRect scrollRect; public int itemCount = 100; public int visibleItemCount = 10; private List<GameObject> listItemPool = new List<GameObject>(); private List<GameObject> activeListItems = new List<GameObject>(); private Vector2 listItemSize; private int firstVisibleIndex = 0; void Start() { listItemSize = listItemPrefab.GetComponent<RectTransform>().rect.size; contentPanel.GetComponent<RectTransform>().sizeDelta = new Vector2(contentPanel.GetComponent<RectTransform>().sizeDelta.x, listItemSize.y * itemCount); scrollRect.onValueChanged.AddListener(OnScroll); for (int i = 0; i < visibleItemCount; i++) { GameObject listItem = CreateListItem(); listItem.transform.SetParent(contentPanel, false); activeListItems.Add(listItem); } } void OnScroll(Vector2 scrollPos) { int newFirstVisibleIndex = Mathf.FloorToInt(scrollPos.y * (itemCount - visibleItemCount)); if (newFirstVisibleIndex != firstVisibleIndex) { int offset = newFirstVisibleIndex - firstVisibleIndex; for (int i = 0; i < activeListItems.Count; i++) { int newIndex = firstVisibleIndex + i + offset; if (newIndex >= 0 && newIndex < itemCount) { activeListItems[i].GetComponentInChildren<Text>().text = "Item " + newIndex.ToString(); activeListItems[i].SetActive(true); activeListItems[i].GetComponent<RectTransform>().anchoredPosition = new Vector2(0, -newIndex * listItemSize.y); } else { activeListItems[i].SetActive(false); } } firstVisibleIndex = newFirstVisibleIndex; } } GameObject CreateListItem() { GameObject listItem = null; if (listItemPool.Count > 0) { listItem = listItemPool[0]; listItemPool.RemoveAt(0); } else { listItem = Instantiate(listItemPrefab); } return listItem; } void RecycleListItem(GameObject listItem) { listItem.SetActive(false); listItemPool.Add(listItem); } } ``` 这个脚本会在 Start() 方法中计算列表项的大小，设置滚动内容面板的大小，并创建足够数量的列表项。当滚动位置发生变化时，它会检查第一个可见项的索引是否有变化，如果有则更新列表项的内容并将它们放置在正确的位置上。当列表项不再可见时，它会回收它们并将它们添加到池中以供重用。 在这个示例中，列表项是简单的 Text 对象，但你可以根据需要将其替换为任何其他对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值