ScrollView无线列表

最新推荐文章于 2022-05-02 22:27:36 发布
最新推荐文章于 2022-05-02 22:27:36 发布
阅读量100 收藏
点赞数
文章标签： c# unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D3_WN/article/details/124529441
版权

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using UnityEngine.EventSystems;
[DisallowMultipleComponent]
public class UIWarpContent : MonoBehaviour
{

    public delegate void OnInitializeItem(GameObject go, int dataIndex);

    public OnInitializeItem onInitializeItem;

    public delegate void OnInitializeItem1(Item item, int dataIndex);

    public OnInitializeItem1 onInitializeItem1;

    public enum Arrangement
    {
        Horizontal,
        Vertical,
    }

    /// <summary>
    /// Type of arrangement -- vertical or horizontal.
    /// </summary>

    public Arrangement arrangement = Arrangement.Vertical;

    /// <summary>
    /// Maximum children per line.
    /// If the arrangement is horizontal, this denotes the number of columns.
    /// If the arrangement is vertical, this stands for the number of rows.
    /// </summary>
    [Range(1, 50)]
    public int maxPerLine = 1;

    /// <summary>
    /// The width of each of the cells.
    /// </summary>

    public float cellWidth = 200f;

    /// <summary>
    /// The height of each of the cells.
    /// </summary>

    public float cellHeight = 200f;

    /// <summary>
    /// The Width Space of each of the cells.
    /// </summary>
    [Range(0, 200)]
    public float cellWidthSpace = 0f;

    /// <summary>
    /// The Height Space of each of the cells.
    /// </summary>
    [Range(0, 200)]
    public float cellHeightSpace = 0f;


    [Range(0, 30)]
    public int viewCount = 5;

    public ScrollRect scrollRect;

    public RectTransform content;

    public GameObject goItemPrefab;

    private int dataCount;

    private int curScrollPerLineIndex = -1;

    private List<UIWarpContentItem> listItem = new List<UIWarpContentItem>();

    private Queue<UIWarpContentItem> unUseItem = new Queue<UIWarpContentItem>();

    public void Init(int dataCount)
    {

        if (scrollRect == null || content == null || goItemPrefab == null)
        {
            Debug.LogError("异常:请检测<" + gameObject.name + ">对象上UIWarpContent对应ScrollRect、Content、GoItemPrefab 是否存在值...." + scrollRect + " _" + content + "_" + goItemPrefab);
            return;
        }
        scrollRect.onValueChanged.RemoveAllListeners();
        if (dataCount > 0)
        {
            scrollRect.onValueChanged.AddListener(onValueChanged);

        }
        setDataCount(dataCount);
        if (null != unUseItem) unUseItem.Clear();
        if (null != listItem) listItem.Clear();

        setUpdateRectItem(0);
    }

    public void RushData(int dataCount)
    {
        scrollRect.onValueChanged.RemoveAllListeners();
        if (listItem.Count > 0)
        {
            for (int i = listItem.Count - 1; i >= 0; i--)
            {
                UIWarpContentItem item = listItem[i];
                item.Index = -10;
                listItem.Remove(item);
                unUseItem.Enqueue(item);
            }
        } 
        if (dataCount > 0)
        {
            scrollRect.onValueChanged.AddListener(onValueChanged);
        }
        setDataCount(dataCount);
        setUpdateRectItem(0);
    }
    public void ShowItem(int count)
    {
        if (arrangement == Arrangement.Vertical)
        {
            content.anchoredPosition = new Vector2(0, count * cellHeight);
        }
        else
        {
            content.anchoredPosition = new Vector2(count * cellWidth, 0);
        }
    }
    public void setDataCount(int count)
    {
        if (dataCount == count)
        {
            return;
        }
        dataCount = count;
        setUpdateContentSize();
    }
    private void onValueChanged(Vector2 vt2)
    {
        switch (arrangement)
        {
            case Arrangement.Vertical:
                float y = vt2.y;
                if (y >= 1.0f || y <= 0.0f)
                {

                    //                return;
                }
                break;
            case Arrangement.Horizontal:
                float x = vt2.x;
                if (x <= 0.0f || x >= 1.0f)
                {
                    return;
                }
                break;
        }
        int _curScrollPerLineIndex = getCurScrollPerLineIndex();
        if (_curScrollPerLineIndex == curScrollPerLineIndex)
        {
            return;
        }
        setUpdateRectItem(_curScrollPerLineIndex);
    }

    /**
     * @des:设置更新区域内item
     * 功能:
     * 1.隐藏区域之外对象      
     * 2.更新区域内数据
     */
    private void setUpdateRectItem(int scrollPerLineIndex)
    {
        if (scrollPerLineIndex < 0)
        {
            return;
        }
        curScrollPerLineIndex = scrollPerLineIndex;
        int startDataIndex = curScrollPerLineIndex * maxPerLine;
        int endDataIndex = (curScrollPerLineIndex + viewCount) * maxPerLine;
        if (listItem == null)
        {
            return;
        }
        //移除
        for (int i = listItem.Count - 1; i >= 0; i--)
        {
            UIWarpContentItem item = listItem[i];
            int index = item.Index;
            if (index < startDataIndex || index >= endDataIndex)
            {
                item.Index = -10;
                listItem.Remove(item);
                unUseItem.Enqueue(item);
            }

        }
        //显示
        for (int dataIndex = startDataIndex; dataIndex < endDataIndex; dataIndex++)
        {
            if (dataIndex >= dataCount)
            {
                continue;
            }
            if (isExistDataByDataIndex(dataIndex))
            {
                continue;
            }
            createItem(dataIndex);
        }
    }
    public float getViewItemSize
    { 
        get
        {
            return cellHeight + cellHeightSpace;

        }
    }
    public void UpdateViewCount(int count)
    {
        viewCount = count;
        setUpdateRectItem(viewCount);
    }


    /**
     * @des:添加当前数据索引数据
     */
    public void AddItem(int dataIndex)
    {
        if (dataIndex < 0 || dataIndex > dataCount)
        {
            Debug.Log("过滤了！" + "dataIndex = " + dataIndex + " | dataCount = " + dataCount);
            return;
        }
        //检测是否需添加gameObject
        bool isNeedAdd = false;
        for (int i = listItem.Count - 1; i >= 0; i--)
        {
            UIWarpContentItem item = listItem[i];
            if (item.Index >= (dataCount - 1))
            {
                isNeedAdd = true;
                break;
            }
        }
        setDataCount(dataCount + 1);
        if (isNeedAdd)
        {
            for (int i = 0; i < listItem.Count; i++)
            {
                UIWarpContentItem item = listItem[i];
                int oldIndex = item.Index;
                if (oldIndex >= dataIndex)
                {
                    item.Index = oldIndex + 1;
                }
            }
            setUpdateRectItem(getCurScrollPerLineIndex());
        }
        else
        {
            //重新刷新数据
            //for (int i = 0; i < listItem.Count; i++) {
            //    UIWarpContentItem item = listItem [i];
            //    int oldIndex = item.Index;
            //    if (oldIndex>=dataIndex) {
            //        item.Index = oldIndex;
            //    }
            //    item = null;
            //}
        }

    }
    /**
     * @des:添加当前数据索引数据
     */
    public void UpdataItem(int dataIndex)
    {
        if (dataIndex < 0 || dataIndex > dataCount)
        {
            return;
        }
        if (isExistDataByDataIndex(dataIndex))
        {
            for (int i = 0; i < listItem.Count; i++)
            {
                if (listItem[i].Index == dataIndex)
                {
                    listItem[i].Index = dataIndex;
                    break;
                }
            }
        }
    }
    public UIWarpContentItem GetItem(int dataIndex)
    {
        if (dataIndex < 0 || dataIndex > dataCount)
        {
            return null;
        }
        if (isExistDataByDataIndex(dataIndex))
        {
            //            UIWarpContentItem go = new UIWarpContentItem ();
            for (int i = 0; i < listItem.Count; i++)
            {
                if (listItem[i].Index == dataIndex)
                {
                    return listItem[i];
                }
            }
        }
        return null;
    }
    public void UpdataAllItem()
    {

        for (int i = 0; i < listItem.Count; i++)
        {
            int index = listItem[i].Index;
            if (isExistDataByDataIndex(index))
            {
                listItem[i].Index = index;
            }
        }
    }
    /**
     * @des:删除当前数据索引下数据
     */
    public void DelItem(int dataIndex)
    {
        if (dataIndex < 0 || dataIndex >= dataCount)
        {
            return;
        }
        //删除item逻辑三种情况
        //1.只更新数据，不销毁gameObject,也不移除gameobject
        //2.更新数据，且移除gameObject,不销毁gameObject
        //3.更新数据，销毁gameObject

        bool isNeedDestroyGameObject = (listItem.Count >= dataCount);
        setDataCount(dataCount - 1);

        for (int i = listItem.Count - 1; i >= 0; i--)
        {
            UIWarpContentItem item = listItem[i];
            int oldIndex = item.Index;
            if (oldIndex == dataIndex)
            {
                listItem.Remove(item);
                if (isNeedDestroyGameObject)
                {
                    Destroy(item.gameObject);
                }
                else
                {
                    item.Index = -1;
                    unUseItem.Enqueue(item);
                }
            }
            if (oldIndex > dataIndex)
            {
                item.Index = oldIndex - 1;
            }
        }
        setUpdateRectItem(getCurScrollPerLineIndex());
        if (unUseItem.Count > 0)
        {
            UIWarpContentItem item = unUseItem.Dequeue();
            Destroy(item.gameObject);
        }
    }


    /**
     * @des:获取当前index下对应Content下的本地坐标
     * @param:index
     * @内部使用
    */
    public Vector3 getLocalPositionByIndex(int index)
    {
        float x = 0f;
        float y = 0f;
        float z = 0f;
        switch (arrangement)
        {
            case Arrangement.Horizontal: //水平方向
                x = (index / maxPerLine) * (cellWidth + cellWidthSpace);
                y = -(index % maxPerLine) * (cellHeight + cellHeightSpace);
                break;
            case Arrangement.Vertical://垂着方向 
                x = (index % maxPerLine) * (cellWidth + cellWidthSpace) + cellWidth / 2 + cellWidthSpace / 2;
                y = -(index / maxPerLine) * (cellHeight + cellHeightSpace) - cellHeight / 2 - cellHeightSpace / 2;
                break;
        }
        return new Vector3(x, y, z);
    }

    /**
     * @des:创建元素
     * @param:dataIndex
     */
    private void createItem(int dataIndex)
    {
        UIWarpContentItem item;
        if (unUseItem.Count > 0)
        {
            item = unUseItem.Dequeue();
        }
        else
        {
            item = addChild(goItemPrefab, content).AddComponent<UIWarpContentItem>();
        }
        item.WarpContent = this;
        item.Index = dataIndex;
        listItem.Add(item);
    }

    /**
     * @des:当前数据是否存在List中
     */
    private bool isExistDataByDataIndex(int dataIndex)
    {
        if (listItem == null || listItem.Count <= 0)
        {
            return false;
        }
        for (int i = 0; i < listItem.Count; i++)
        {
            if (listItem[i].Index == dataIndex)
            {
                return true;
            }
        }
        return false;
    }


    /**
     * @des:根据Content偏移,计算当前开始显示所在数据列表中的行或列
     */
    private int getCurScrollPerLineIndex()
    {
        switch (arrangement)
        {
            case Arrangement.Horizontal: //水平方向
                return Mathf.FloorToInt(Mathf.Abs(content.anchoredPosition.x) / (cellWidth + cellWidthSpace));
            case Arrangement.Vertical://垂着方向
                int count = 0;
                if (content.anchoredPosition.y <= 0)
                {
                    return 0;
                }

                count = Mathf.FloorToInt(Mathf.Abs(content.anchoredPosition.y) / (cellHeight + cellHeightSpace));
                if (count < 0)
                {
                    count = 0;
                }
                else if (count > dataCount)
                {
                    count = dataCount;
                }
                //            return Mathf.FloorToInt(Mathf.Abs(content.anchoredPosition.y)/(cellHeight+cellHeightSpace));
                return count;
        }
        return 0;
    }

    /**
     * @des:更新Content SizeDelta
     */
    private void setUpdateContentSize()
    {
        int lineCount = Mathf.CeilToInt((float)dataCount / maxPerLine);
        switch (arrangement)
        {
            case Arrangement.Horizontal:
                content.sizeDelta = new Vector2(cellWidth * lineCount + cellWidthSpace * (lineCount - 1), content.sizeDelta.y);
                break;
            case Arrangement.Vertical:
                content.sizeDelta = new Vector2(content.sizeDelta.x, cellHeight * lineCount + cellHeightSpace * (lineCount - 1));
                break;
        }
    }
    private RectTransform _rectTransform;
    private RectTransform rectTransform
    {
        get
        {
            if (_rectTransform == null)
            {
                _rectTransform = scrollRect.GetComponent<RectTransform>();

            }
            return _rectTransform;
        }
    }
    /**
     * @des:实例化预设对象 、添加实例化对象到指定的子对象下
     */
    private GameObject addChild(GameObject goPrefab, Transform parent)
    {
        if (goPrefab == null || parent == null)
        {
            Debug.LogError("异常。UIWarpContent.cs addChild(goPrefab = null  || parent = null)");
            return null;
        }
        GameObject goChild = Instantiate(goPrefab);
        goChild.layer = parent.gameObject.layer;
        goChild.transform.SetParent(parent, false);
        if (maxPerLine <= 1)
        {

            switch (arrangement)
            {
                case Arrangement.Horizontal:
                    goChild.transform.GetComponent<RectTransform>().sizeDelta = new Vector2(goChild.transform.GetComponent<RectTransform>().rect.width, rectTransform.rect.height);
                    break;
                case Arrangement.Vertical:
                    goChild.transform.GetComponent<RectTransform>().sizeDelta = new Vector2(cellWidth, cellHeight);
                    break;
            }
        }
        goChild.gameObject.SetActive(true);

        return goChild;
    }
    public void ClearAllData()
    {
        scrollRect.onValueChanged.RemoveAllListeners();
        if (listItem != null && listItem.Count > 0)
        {
            foreach (var item in listItem)
            {
                Destroy(item.gameObject);
            }
            //foreach (var item in unUseItem)
            //{
            //    GameObject go = item.gameObject;
            //    Destroy(go);
            //}
            listItem.Clear();
            if (null != unUseItem)
            {
                unUseItem.Clear();
            }

            onInitializeItem = null;
            //重置上一次的操作位置
            if (null != scrollRect.verticalScrollbar)
            {
                scrollRect.verticalScrollbar.value = 1;
            }
            //重置上一次的操作位置
            if (null != scrollRect.horizontalScrollbar)
            {
                scrollRect.horizontalScrollbar.value = 1;
                content.anchoredPosition = Vector2.zero;
            }

        }
        if (content != null)
        {
            int childCount = content.transform.childCount;
            for (int i = 0; i < childCount; i++)
            {
                Destroy(content.transform.GetChild(i).gameObject);
            }

        }
    }
    void OnDestroy()
    {

        scrollRect = null;
        content = null;
        goItemPrefab = null;
        onInitializeItem = null;

        listItem.Clear();
        unUseItem.Clear();
    }
}

using UnityEngine;
using System.Collections;
/***
 *@des:warp下Element对应标记
 */
[DisallowMultipleComponent]
public class UIWarpContentItem : MonoBehaviour {

    private int index;
    private UIWarpContent warpContent;


    private RectTransform mtransform;

    private RectTransform mYtransform {

        get
        {
            if (mtransform == null)
            {
                mtransform = transform.GetComponent<RectTransform>();
            }
            return mtransform;
        }
    }

    void OnDestroy(){
        warpContent = null;
    }

    public UIWarpContent WarpContent{
        set{ 
            warpContent = value;
        }
    }
    public string getName()
    {
        return gameObject.name;
    }
    private Item item;
    public Item getItem()
    {
        if (item == null)
            item  = gameObject.GetComponent<Item>();    
        return item;
    }
    public int Index {
        set{
            index = value; 
            mYtransform.localPosition = warpContent.getLocalPositionByIndex(index);
            gameObject.name = index.ToString(); 
                //(index<10)?("0"+index):(""+index);
            if (warpContent.onInitializeItem1 != null && index>=0) {
                warpContent.onInitializeItem1 (getItem(), index);
                //Debug.Log("index = " + index);
            }
        }
        get{ 
            return index;
        }
    }
}
 

D3_WN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Unity系列——UGUI创建滑动列表tableview
Rambo的专栏
09-06 1万+
UGUI创建滑动列表步骤 1、创建一个panel，命名moveLayer，添加mask组件进行遮罩裁剪，添加scrollRect进行滑动。 2、为moveLayer创建一个容器也是panel，为容器命名content，在容器content里面添加layout组件，并把content设置到scrollRect里面；添加小孩的长度和高度要动态改变容器的宽高，才可以进行滑动。 滑动原理：主要是通过
UGUI源码分析：Scrollbar与ScrollRect滑动列表组件
vin129的博客
05-11 3929
系列 UGUI源码分析系列总览 相关前置： UGUI EventSystem源码分析 UGUI源码分析：Selectable交互组件的基类 文章目录系列UML图一览Scrollbar属性介绍实现ScrollRect属性介绍初始化滑动条交互拖拽交互滚轮交互 UML图一览 UGUI中的滑动组件主要由ScrollRect与Scrollbar构成，首先先简单介绍以下Scrollbar组件的实现原理。 Scrollbar BaseClass: Selectable Interface: IInitializeP
❤️UNITY实战进阶-ScrollView无限循环列表-3
欲望如海水，越喝越渴。
09-13 1912
前言 先来展示下效果 自治盗版UI的网抑云 基于GF框架开发 目前我们只有一个主界面,功能: 1.用户头像和昵称 2.搜索InputField入口,显示搜索到的歌曲列表 3.用户拥有的歌单列表 4.用户某一个歌单中的歌曲列表 5.播放器-开始/暂停按钮-进度条-音量调节-歌曲ICON-歌曲名称和艺术家 6.歌曲播放列表未开发 (1).在界面配置表中(DataTable\UIForm)加入这...
Unity笔记:虚拟摇杆思路
云端马匪的博客
06-09 793
一、基本组件装配1.大圆是滑动范围，小圆是手柄。小圆是大圆的子物体。  2.大圆组件挂一个脚本，继承ScrollRect，设置一个滑动半径，允许水平和垂直滑动。  滑动半径R：可以直接用大圆的半径 也可超出或者小于一点点RectTransform类里有类变量rect，rect可以获得矩形的长宽。锚点四个雪花在一起时，sizeDelta就是矩形的长宽 详细见 Anchor Pivot RectTra...
UGUI内核大探究（十一）ScrollRect与ScrollBar
凯奥斯的注释
09-17 1万+
当我们在Unity Editor里创建一个Scroll View的时候含有ScrollRect的对象，它下面还有三个子对象，两个含有ScrollBar组件的子对象是作为滚动条，一个Viewport用于限定显示区域。我们可以为Viewport下面的Content对象添加组件（例如Image）或者子对象。点击运行，我们就可以拖动Scroll View，并且看到里面的内容也跟着在滚动。本文就详细分析一下
Super ScrollView无线滑动列表.rar
08-23
在Unity游戏开发中，"Super ScrollView无线滑动列表"是一个高效且易用的插件，专为实现无限滚动效果而设计。它适用于那些需要展示大量数据或者内容的场景，如商品列表、用户评论等，可以极大地提升用户体验。该插件...
UGUI Super ScrollView v2.5.4.unitypackage
最新发布
05-11
UGUI Super ScrollView v2.5.4.unitypackage 特征： - 列表视图和网格视图 - 交错视图。垂直/水平视图可用于 创建网格视图，项目具有不同的高度/宽度 - GridView可以同时垂直和水平滚动 - 无限物品 - 不同尺寸的物品...
UGUI实现ScrollView无限滚动效果
01-01
抽空做了一个UGUI的无限滚动的效果。只做了一半（向下无限滚动）。网上也看了很多教程，感觉还是按照自己的...这点类似于Queue的先见先出原则，再把Dequeue出来的元素添加到末尾，就很类似于ScrollView的无限滚动的原
Unity无限循环列表demo
07-08
在Unity中，无限循环列表（Infinite ScrollView）是一种常见的用户界面（UI）设计，它允许用户在一个列表中无缝滚动，仿佛列表是无尽的。这种设计常见于移动游戏或应用的滚动菜单、广告轮播等场景。 在Unity中实现...
spuerSV.unitypackage无限循环列表Unity
08-07
无限循环列表Unity，ScrollView可以拥有多个Item，可以不同大小，插件自动排列。非常好用。
unity简单摇杆（二）之美
游戏开发、游戏引擎开发、逆向破解爱好者
07-31 377
实现代码： using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.EventSystems; using UnityEngine.UI; public class Joystick : ScrollRect { float mRadius...
综述iOS视图的frame、bounds、center、position、anchorPosition等与位置、大小有关的属性
赤条条的博客
11-20 3571
在iOS开发开发过程中经常会用到界面元素的frame、bounds表示大小和位置的属性以及center、position、anchorPosition等单纯表示位置的属性。这些属性究竟什么含义？彼此间又什么关系呢？下面就来浅谈一番。 首先来说说frame和bounds。         frame：描述当前界面元素在其父界面元素中的位置和大小。         bounds：描述当前界面
Unity UGUI无限循环列表ScrollView（横向）
yffgamestart的博客
10-15 3538
Unity做游戏避免不了使用列表，比如关卡游戏 有可能会有上千个关卡，这个使用UGUI原生列表会非常卡，下面提供了一种方法，可以无限循环列表，并且很流畅 列表循环展示： 1：功能实现代码 using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class MainStart : MonoBehaviour {
unity开发遇到的几个坑（UGUI等）
热门推荐
码农成长日记
01-13 8万+
总结一些unity现有版本中遇到的坑。
三种方法 解决 scrollView在content修改后无法将scrollBar设为0/1的问题
weixin_42767868的博客
05-02 1356
解决 scrollView在content修改后无法将scrollBar设为0/1的问题
RectTransform中localPosition与anchoredPosition的区别
asitini的博客
04-08 1万+
1. Inspector面板中Transform的位置信息显示的是localPosition 2. Inspector面板中RectTransform的位置信息显示的是anchoredPosition3D 2.1 localPosition表示的是子物体的pivot相对于父物体的pivot的坐标 2.2 anchoredPosition3D表示的是子物体的pivot相对于anchor的坐标，当a...
List.clear方法——从列表中移除所有元素
习惯有你&的博客
11-12 2万+
系统中获取一个集合，循环一直出现重复数据，查找资料使用List.clear方法移除列表中的数据，这样展示的数据就是查询所需要的数据。 参考：https://book.2cto.com/201309/31794.html 该方法用于从列表中移除所有元素。该方法没有返回值。 语法  clear()  示例  本示例使用List接口的实现类ArrayList，初始
【UGUI】无限列表 ScrollView List
Garsonlab
05-02 4974
无线列表的实现好处有一些，主要方法是在ScrollView的值改变的时候改变已存在的渲染子节点位置。最核心的是计算Content的大小及里面的节点位置设置。 using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; name
Unity RectTransform 的 anchoredPosition 与 positoin 属性辨析
xxm的个人世界杯要开始了
08-14 1353
— layout: post title: “Unity RectTransform 的 anchoredPosition 与 positoin 属性辨析” categories: Concept math — 测试一下啊 ~~~啊 啊
unity scrollview 列表自动循环滚动
05-25
您可以使用以下代码来实现Unity ScrollView列表自动循环滚动： ``` using UnityEngine; using UnityEngine.UI; public class AutoScroll : MonoBehaviour { public float speed = 0.5f; private ScrollRect ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值