无限滚动列表 更新优化

最新推荐文章于 2024-08-19 10:36:42 发布
最新推荐文章于 2024-08-19 10:36:42 发布
阅读量430 收藏
点赞数
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/satela/article/details/93166040
版权
本文深入探讨了无限滚动列表的实现原理，详细介绍了如何通过优化数据加载策略、使用虚拟化技术和预加载机制来提升用户体验。同时，文章还讨论了在不同场景下如何选择合适的优化方案，以确保列表流畅滚动且资源消耗最小。
摘要由CSDN通过智能技术生成 
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using SimpleJSON;
using YanhuaMMO;
public class DynamicHeightList : MonoBehaviour , IBeginDragHandler, IDragHandler, IEndDragHandler
{

    public Vector2 minCellSize;

    public int maxRowCount = 5;

    public int columeCount = 1;//列数

    public Vector2 spaceSize;

    private List<DynamicInfinityItem> itemList;

    public GameObject renderGo;

    protected IList mDataProviders;

    private Vector2 lastDownMousePos;

    private bool isMouseDown = false;

    public int elasticDist = 25;

    private int validCount = 0;

    private float viewheight;

    private float zuni = 0.95f;

    private Coroutine guanxingCo;

    private List<DynamicInfinityItem> allItemRenders;

    private Vector3 startDownPos;

    // Use this for initialization
    void Awake()
    {
        viewheight = gameObject.GetComponent<RectTransform>().sizeDelta.y;

        itemList = new List<DynamicInfinityItem>();

        initItem();
    }
    void Start () {
       
       
       // updateValidItem();

        //AddTriggersListener(gameObject, EventTriggerType.PointerDown, startDrag);
        //AddTriggersListener(gameObject, EventTriggerType.PointerUp, stopDrag);

    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        startDrag(eventData);
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        stopDrag(eventData);
    }

    public void OnDrag(PointerEventData eventData)
    {

    }

    public void setDataByJsonArray(string dataarr)
    {
        JSONArray dataList = JSON.Parse(dataarr).AsArray;
        if (dataList == null)
        {
            setDataProvider(new List<int>());
            return;
        }
        List<JSONNode> dataNode = new List<JSONNode>();
        for (int i = 0; i < dataList.Count; i++)
            dataNode.Add(dataList[i]);
        setDataProvider(dataNode);
    }

    //只改变数据，不刷新界面
    public void refreshDataProvider(string dataarr)
    {
        JSONArray dataList = JSON.Parse(dataarr).AsArray;
        if (dataList == null)
        {
            setDataProvider(new List<int>());
            return;
        }
        List<JSONNode> dataNode = new List<JSONNode>();
        for (int i = 0; i < dataList.Count; i++)
            dataNode.Add(dataList[i]);

        mDataProviders = dataNode;

    }
    public void setDataProvider(IList dataprovider)
    {
        StopAllCoroutines();
        mDataProviders = dataprovider;
        validCount = Mathf.Min(mDataProviders.Count, maxRowCount * columeCount);

        updateValidItem();
        if (itemList.Count == 0)
            return;
        itemList[0].transform.localPosition = new Vector3(0, 0, 0);
        updateItemPos();
    }
    private void startDrag(BaseEventData data)
    {
        isMouseDown = true;
        if (itemList.Count == 0)
            return;

        lastDownMousePos = Input.mousePosition;
        startDownPos = Input.mousePosition;
        if (guanxingCo != null)
            StopCoroutine(guanxingCo);
        StopAllCoroutines();
        StartCoroutine(moveContent());
    }

    private void stopDrag(BaseEventData data)
    {
        isMouseDown = false;

        if (itemList.Count ==  0)
            return;
        if (itemList[0].itemIndex == 0 && itemList[0].transform.localPosition.y < 0)
        {
            StartCoroutine(tweenToTop());
            return;
        }

        if (itemList[validCount - 1].itemIndex == mDataProviders.Count - 1 &&
               (itemList[validCount - 1].transform.localPosition.y > itemList[validCount - 1].itemHeight - viewheight))
        {
            StartCoroutine(tweenToBottom());

            return;
        }
        guanxingCo = StartCoroutine(guanxingMove(Input.mousePosition.y - lastDownMousePos.y));
       
    }

     IEnumerator guanxingMove(float initdist)
    {
        float origindist = initdist;

        while(Mathf.Abs(origindist) > 0.01f)
        {
            // Debug.Log("guangxin:" + origindist);
            if (itemList[0].itemIndex == 0 && itemList[0].transform.localPosition.y < 0)
            {
                StartCoroutine(tweenToTop());

                break;
            }
            if (itemList[validCount - 1].itemIndex == mDataProviders.Count - 1 &&
                (itemList[validCount - 1].transform.localPosition.y > itemList[validCount - 1].itemHeight - viewheight))
            {
                StartCoroutine(tweenToBottom());

                break;
            }
            moveItemPos(origindist);
            origindist *= 0.96f;

            yield return 0;
        }

    }

    IEnumerator moveContent()
    {
        while(isMouseDown && itemList.Count > 0)
        {
            float deltaposy = Input.mousePosition.y - lastDownMousePos.y;
            float zushi = 1;
            if(deltaposy < 0 && itemList[0].itemIndex == 0)
            {
               // if (itemList[0].transform.localPosition.y < -elasticDist)
               //     deltaposy = 0;
                if (itemList[0].transform.localPosition.y < 0)
                    zushi = Mathf.Pow(zuni, elasticDist - itemList[0].transform.localPosition.y);
            }
            else if (deltaposy > 0 && itemList[validCount - 1].itemIndex == mDataProviders.Count - 1)
            {
                float pos = viewheight - itemList[validCount - 1].itemHeight;

                //if (itemList[validCount - 1].transform.localPosition.y > -pos + elasticDist)
                //   deltaposy = 0;
                if (itemList[0].itemIndex == 0 && itemList[0].transform.localPosition.y < 0)
                    zushi = 1;
                else if(itemList[validCount - 1].transform.localPosition.y > -pos)
                    // zushi = Mathf.Pow(zuni, itemList[validCount - 1].transform.localPosition.y + pos);     
                    zushi = Mathf.Pow(zuni, Mathf.Abs(Input.mousePosition.y - startDownPos.y));

            }

           // Debug.Log("delat:" + deltaposy);
            if (Mathf.Abs(zushi) < 0.01f)
                zushi = 0;
            deltaposy *= zushi;
            if(deltaposy != 0)
                moveItemPos(deltaposy);

             lastDownMousePos = Input.mousePosition;
            yield return 0;

        }

    }

    IEnumerator tweenToTop()
    {
        Debug.Log("tweenToTop :");

        while (itemList[0].transform.localPosition.y != 0)
        {
            float dist = Mathf.Min(3f, -itemList[0].transform.localPosition.y);
            for (int i = 0; i < itemList.Count; i++)
            {
                Vector3 lpos = itemList[i].transform.localPosition;
                itemList[i].transform.localPosition = new Vector3(lpos.x, lpos.y + dist, 0);
            }

            yield return 0;
        }

    }

    IEnumerator tweenToBottom()
    {
        Debug.Log("tweenToBottom:");

        float bottomy = itemList[validCount - 1].itemHeight - viewheight;

        while (itemList[validCount - 1].transform.localPosition.y > bottomy && itemList[0].transform.localPosition.y > 0)
        {
           // float dist = 0;
            //if (validCount >= maxRowCount * columeCount)
                float dist = Mathf.Max(-3f,  bottomy - itemList[validCount - 1].transform.localPosition.y);
          

            for (int i = 0; i < itemList.Count; i++)
            {
                Vector3 lpos = itemList[i].transform.localPosition;
                itemList[i].transform.localPosition = new Vector3(lpos.x, lpos.y + dist, 0);
            }

            yield return 0;
        }

    }

    private void moveItemPos(float dist)
    {
        if (columeCount > 1)
        {
            for (int i = 0; i < itemList.Count; i++)
            {

                Vector3 lpos = itemList[i].transform.localPosition;

                itemList[i].transform.localPosition = new Vector3(lpos.x, lpos.y + dist, 0);
            }

        }
        else
        {
            if (itemList.Count > 0)
            {
                Vector3 lpos = itemList[0].transform.localPosition;

                itemList[0].transform.localPosition = new Vector3(lpos.x, lpos.y + dist, 0);
            }

            for (int i = 1; i < itemList.Count; i++)
            {

                Vector3 lpos = itemList[i].transform.localPosition;

                itemList[i].transform.localPosition = new Vector3(lpos.x, itemList[i - 1].transform.localPosition.y - itemList[i - 1].itemHeight - spaceSize.y, 0);
            }
        }


        for (int i = 0; i < itemList.Count; i++)
        {
            Vector3 lpos = itemList[i].transform.localPosition;
            float heightitem = itemList[i].itemHeight;
            if (dist >= 0 && lpos.y > heightitem && itemList[itemList.Count - 1].itemIndex < mDataProviders.Count - 1)
            {

                DynamicInfinityItem rd = itemList[i];
                rd.itemIndex = itemList[itemList.Count - 1].itemIndex + 1;

                int row = Mathf.FloorToInt(rd.itemIndex/columeCount);
                int row1 = Mathf.FloorToInt((rd.itemIndex - 1)/ columeCount);

                rd.SetData(mDataProviders[rd.itemIndex]);

                if (row > row1)
                    lpos.y = itemList[itemList.Count - 1].transform.localPosition.y - itemList[itemList.Count - 1].itemHeight - spaceSize.y;
                else
                    lpos.y = itemList[itemList.Count - 1].transform.localPosition.y ;

                itemList[i].transform.localPosition = lpos;

                //Debug.Log("data index:" + rd.itemIndex);
                itemList.RemoveAt(i);
                itemList.Add(rd);
                i--;

            }
            else if (dist < 0 && lpos.y < -viewheight && itemList[0].itemIndex > 0)
            {

                DynamicInfinityItem rd = itemList[i];
                rd.itemIndex = itemList[0].itemIndex - 1;

                int row = Mathf.FloorToInt(rd.itemIndex / columeCount);
                int row1 = Mathf.FloorToInt((rd.itemIndex + 1) / columeCount);

                rd.SetData(mDataProviders[rd.itemIndex]);

                if (row < row1)
                    lpos.y = itemList[0].transform.localPosition.y + itemList[i].itemHeight + spaceSize.y;
                else
                    lpos.y = itemList[0].transform.localPosition.y;

                int column = rd.itemIndex % columeCount;
                lpos.x = (minCellSize.x + spaceSize.x) * column;

                itemList[i].transform.localPosition = lpos;

                itemList.RemoveAt(i);
                itemList.Insert(0, rd);
            }
        }
    }
    private void AddTriggersListener(GameObject obj, EventTriggerType eventID, UnityAction<BaseEventData> action)
    {
        EventTrigger trigger = obj.GetComponent<EventTrigger>();
        if (trigger == null)
        {
            trigger = obj.AddComponent<EventTrigger>();
        }

        if (trigger.triggers.Count == 0)
        {
            trigger.triggers = new List<EventTrigger.Entry>();
        }

        UnityAction<BaseEventData> callback = new UnityAction<BaseEventData>(action);
        EventTrigger.Entry entry = new EventTrigger.Entry();
        entry.eventID = eventID;
        entry.callback.AddListener(callback);
        trigger.triggers.Add(entry);

       
       }
    private void initItem()
    {
        int total = maxRowCount * columeCount;
        allItemRenders = new List<DynamicInfinityItem>();
        for (int i=0;i < total;i++)
        {
            GameObject itemgo = Instantiate(renderGo);
            ItemRender render= itemgo.GetComponent<ItemRender>();
            itemgo.transform.SetParent(transform);
            itemgo.SetActive(false);
            int row = Mathf.FloorToInt(i / columeCount);
            int column = i % columeCount;

            itemgo.transform.localPosition = new Vector3((minCellSize.x + spaceSize.x) * column, -(minCellSize.y + spaceSize.y) * row, 0);
            itemgo.transform.localScale = Vector3.one;
            itemgo.transform.localEulerAngles = Vector3.zero;

            allItemRenders.Add(render);         

        }

    }

    private void updateValidItem()
    {
        itemList = new List<DynamicInfinityItem>();
        for (int i = 0; i < allItemRenders.Count; i++)
        {
            GameObject itemgo = allItemRenders[i].gameObject;

           

            allItemRenders[i].itemIndex = i;

            if (i < mDataProviders.Count)
            {
                itemgo.gameObject.SetActive(true);
                allItemRenders[i].SetData(mDataProviders[i]);
                itemList.Add(allItemRenders[i]);

            }
            else
                itemgo.gameObject.SetActive(false);
        }

    }

    public void updateItemPos()
    {
        if (columeCount > 1)
        {
            for (int i = 0; i < itemList.Count; i++)
            {
                GameObject itemgo = itemList[i].gameObject;
                int row = Mathf.FloorToInt(i / columeCount);
                int column = i % columeCount;

                itemgo.transform.localPosition = new Vector3((minCellSize.x + spaceSize.x) * column, -(minCellSize.y + spaceSize.y) * row, 0);
                itemgo.transform.localScale = Vector3.one;
                itemgo.transform.localEulerAngles = Vector3.zero;
            }
            return;

        }

        for (int i=1;i < itemList.Count;i++)
        {
            float tempposy = itemList[i - 1].transform.localPosition.y - itemList[i - 1].itemHeight - spaceSize.y;
            itemList[i].transform.localPosition = new Vector3(itemList[i].transform.localPosition.x, tempposy, 0);
        }
        moveItemPos(0);
    }

    public void moveToIndex(int dataIndex,bool imediate)
    {
        if (mDataProviders.Count <= dataIndex)
            return;

       
        DynamicInfinityItem fisrtitem = null;//= itemList[0].itemIndex;
        for (int i = 0; i < itemList.Count; i++)
        {
            if (itemList[i].transform.localPosition.y <= 0)
            {
                fisrtitem = itemList[i];
                break;
            }
        }

        if (fisrtitem != null && fisrtitem.itemIndex >= dataIndex)
        {
           // if(itemList[0].transform.localPosition.y >= 0)
            {
                StartCoroutine(scrollToIndex(dataIndex, -1, imediate));
            }
        }
        else
            StartCoroutine(scrollToIndex(dataIndex, 1, imediate));
    }

    IEnumerator scrollToIndex(int moveIndex, float direct,bool imediate)
    {
        if (direct < 0)
        {
            while (true)
            {
                moveItemPos(-10);
                for(int i=0;i < itemList.Count;i++)
                {
                    if (itemList[i].itemIndex == moveIndex && itemList[i].transform.localPosition.y <= 0)
                    {
                        moveItemPos(-itemList[i].transform.localPosition.y);
                        yield break;
                    }
                }
                if(!imediate)
                yield return new WaitForSeconds(0.001f);
            }

        }
        if (direct > 0)
        {
            while (itemList[0].itemIndex != moveIndex && (itemList[validCount - 1].itemIndex < mDataProviders.Count - 1 || itemList[validCount - 1].transform.localPosition.y < itemList[validCount - 1].itemHeight - viewheight))
            {
                moveItemPos(10);
                if (!imediate)
                    yield return new WaitForSeconds(0.001f);
            }

            for (int i = 0; i < itemList.Count; i++)
            {
                if (itemList[i].transform.localPosition.y - itemList[i].itemHeight <= 0)
                {
                    moveItemPos(-itemList[i].transform.localPosition.y);
                    yield break;
                }
            }

        }
    }
   
 }

 

satela
关注
专栏目录
元素高度可变 无限滚动列表
satela的博客
06-14 588
必须继承IBeginDragHandler, IDragHandler, IEndDragHandler 这几个接口，否则拖动的时候会响应列表元素的点击 事件。 using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.Events; using Unity...
UGUI的无限滚动列表
LSC112的博客
04-23 517
using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; /// <summary> /// UGUI无限滚动列表 ///（by:羽落星辰） /// </summary> public class UGUILoopScrollView : MonoBehaviour { //方向 publi...
vue 列表无限滚动列表，循环完自动切换tab
最新发布
qq_61869009的博客
08-19 494
​ 记录一下大屏常用的滚动组件vue-seamless-scroll 以及滚动完自动切换tab效果。 官网没有介绍，这个方法是列表滚动完毕一次就会执行。需要用到插件的一个方法。
UGUI无限滚动列表
Er_nameSpace的博客
04-18 560
正在忙别的东东，突然公司来了个需求，要加个什么无限滚动列表需求，再三确认，没错他就要这个（心想这玩意都烂大街，分分钟给你复制粘贴一个），然后就找啊找，找了一堆，没有找到正好对应需求的，然后找了个靠近需求的源码，改啊改，改啊改..... 我吐了！！！ 思路： 1.无限滚动，Object肯定得重复利用 （位置循环） 2.保证循序正确，如果当前界面显示3个image，那我就生成9个image，canvas左边三个，右边三个，一摸一样的（因为我就三个数据，如果要是做成游戏那种无限滚动用来显示不用数据的，需要加
Unity UGUI实现无限滚动列表
Zyt
05-27 1007
在游戏开发中，列表视图是一个常见的UI组件。实现一个高效的列表视图尤其重要，尤其是在需要展示大量数据时。本文将介绍如何在Unity中实现一个高效的无限滚动列表，包括两个关键脚本：InfiniteScroll 和 ListItem 两个脚本 话不多说直接上代码。Unity版本2022.3.X。
列表页无限滚动翻页组件--解决性能问题
weixin_30588729的博客
07-04 169
解决性能问题 使用demo <scroller :data="card_group" @loadmore="next"> <div class="box" slot-scope="props"> <question :question='props.item' :qindex="props.index" >&l...
Vue.js 无限滚动列表性能优化方案
10-15
本文将详细介绍Vue.js实现无限滚动列表的性能优化策略。 首先，理解性能问题的核心：DOM操作。每次修改DOM，浏览器需要进行重排和重绘，这在包含大量元素的页面中尤其耗时。在大数据量的无限滚动列表中，如果一次性...
微信小程序实现无限滚动列表
10-17
在微信小程序中，实现无限滚动列表是一种常见的需求，主要用于展示大量数据，如商品列表、用户信息等。这种滚动效果能够给用户带来流畅的浏览体验，同时也优化了性能，避免一次性加载过多数据导致页面卡顿。以下是...
轻量级列表无限滚动组件
01-24
在IT领域，尤其是在Web开发中，轻量级列表无限滚动组件是一种常见的用户界面设计技术，它使得用户在浏览长列表时无需手动翻页，而是通过滚动页面，内容会自动加载更多，提供无缝的浏览体验。这种组件对于提高用户...
vue无限滚动列表加载的性能优化及思考
weixin_48111982的博客
05-26 1019
1
UGUI无限滑动列表
weixin_41995872的博客
12-25 561
https://github.com/rlafydid/UGUICircularScrollView
Unity UGUI滚动视图无限滚动
05-17
Unity UGUI滚动视图无限滚动，内容很实用，稍加修改就可以适用于自己的需求。
无限循环列表 SuperScrollView
09-22
SuperScrollView 无限循环列表插件 有十几个例子的实现 SuperScrollView 无限循环列表插件 有十几个例子的实现 SuperScrollView 无限循环列表插件 有十几个例子的实现
UGUI中滚动列表插件，再多的item都不卡顿
08-21
如果不经过任何处理就往ScrollRect中加入新的Item，如果Item数量过多，肯定会造成整个界面的卡顿，ScrollView就是很完美的解决了这个问题，通过复用Item，只加载看得见的那一部分来达到优化的目的
Unity无限滚动列表(自动分页和网络请求) ScrollView
06-04
1.项目中应用组件，分享出来 2.支持横向和竖向无限滑动，基于ScrollView扩展 3.滑动时，自动计算分页，通过回调自动获取调用获取分页数据 4.使用简单，组件代码注释详细 5.例子简单明了
Unity无限滑动列表插件EnhancedScroller v2
12-13
Unity 无限滑动列表插件，Item循环使用，优化滑动列表。 EnhancedScroller v2
Unity实现一个可扩展的UGUI无限滑动列表控件
.
11-18 5374
采用对象池+存储布局坐标实现的一个基于UGUI的可横向或纵向的无限滑动列表。
UGUI 实现无限滚动
qq_44952746的博客
05-02 310
UGUI 实现无限滚动
Web滚动性能优化实战
热门推荐
蒋宇捷的专栏
01-24 1万+
我的前言        HTML5的API体系是重要知识，但是如何写出更高效的Web App对于从程序员进阶为高级程序员来说更为重要。技很重要，但是容易学会，术才是茫茫人海中鹤立鸡群，安生立命之本。        码农们容易吗？是的，我们必须要不断努力和学习才能进化为高级码农乃至顶级码农。        Web App的性能优化非常重要，之前我有过一篇LinkedIn的相关文章《用HTML5实现i
unity 无限滚动列表
09-09
在实现无限滚动列表时，可以使用对象池来优化性能。对象池可以缓存已经创建的列表项对象，而不是每次滚动时都创建新的对象。这样可以避免频繁的对象创建和销毁，提高性能。 此外，还可以将无限滚动列表与数据源绑定...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值