美文网首页
unity 无限滚动

unity 无限滚动

作者: WOTTOW | 来源:发表于2020-03-24 19:41 被阅读0次

我看见有大佬用AnimationCurve 用来做滚动,感觉还不错。

首先图片可以移动

图片的父级继承IBeginDragHandler, IDragHandler, IEndDragHandler。
可以现实图片的拖拽。


image.png

图片的位置用动画表示,我们通过控制时间就可以实现图片的移动

图片摆放的位置

我们知道AnimationCurve的时间可以自己设置,这里把时间这是为(0-1)。以及定义一个时间增量,这个时间增量就相当与图片之间的间隔(这里的位置移动是动画,所以时间增量==图片之间的间距)。通过遍历子集,子集的时间增==(上个子集的时间+时间增量)。


image.png

图片的移动

这里unity 官方提供一个很好用的函数eventData.delta(大概意思:记录当前与上一次的差值)。当鼠标开始拖拽。通过这个函数我们这里计算移动的百分比(eventData.delta.x*1f/宽度),这里的移动百分比==移动的时间。遍历子集每个子集都添加移动的百分比

图片的循环

通过上面的百分比。当百分比大于0是向右运动,当百分比小于0是向左运动。把全部子集转到列表中,向左运动时,动画时间小于0,把时间调大最大(最右边的位置),并把列表中原来的对象删点,把移动过后的对象再次添加,向右时,动画时间大于最大的时间,把时间调到最小(最边), 并把列表中原来的对象删点,把移动过后的对象添加(插入第一个位置)

播放动画

(通过当前的动画时间-开始的动画时间)%时间增量=超出的部分时间(我们这里以时间增量作为定义位置的标准,所以如果‘超出的部分时间’不为0,就说明不是在指定位置)。向左滑动动画时间是减少超出的部分时间,向右滑动时间是时间增量减超出的部分时间,这里相减的时间就是差多少时间到指定位置。

using NSubstitute;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
public class UI_Control_ScrollFlow : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler, IPointerClickHandler
{
    public RectTransform Rect;
    public List<UI_Control_ScrollFlow_Item> Items;

    public float Width = 500;
    public float MaxScale = 1;
    public float StartValue = 0.1f, AddValue = 0.2f, VMin = 0.1f, VMax = 0.9f;
    public AnimationCurve PositionCurve;
    public AnimationCurve ScaleCurve;
    public AnimationCurve ApaCurve;

    private float v = 0;
    private List<UI_Control_ScrollFlow_Item> GotoFirstItems = new List<UI_Control_ScrollFlow_Item>(), GotoLaserItems = new List<UI_Control_ScrollFlow_Item>();

    private Vector2 start_point, add_vect;

    public event Callback<UI_Control_ScrollFlow_Item> MoveEnd;
    public void Refresh()
    {
        for (int i = 0; i < Rect.childCount; i++)
        {
            Transform tran = Rect.GetChild(i);
            UI_Control_ScrollFlow_Item item = tran.GetComponent<UI_Control_ScrollFlow_Item>();
            if (item != null)
            {

                item.transform.GetChild(0).GetComponent<Text>().text = i.ToString();

                Items.Add(item);
                item.Init(this);
                item.Drag(StartValue + i * AddValue);
                if (item.v - 0.5 < 0.05f)
                {
                    Current = Items[i];
                }
            }
        }
        if (Rect.childCount < 5)
        {
            VMax = StartValue + 4 * AddValue;
        }
        else
        {
            VMax = StartValue + (Rect.childCount - 1) * AddValue;
        }
        if (MoveEnd != null)
        {
            MoveEnd(Current);
        }
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        start_point = eventData.position;
        add_vect = Vector3.zero;
        _anim = false;
    }

    public void OnDrag(PointerEventData eventData)
    {
        add_vect = eventData.position - start_point;
        v = eventData.delta.x * 1.00f / Width;
        for (int i = 0; i < Items.Count; i++)
        {
            Items[i].Drag(v);
        }
        Check(v);
    }


    public void Check(float _v)
    {
        if (_v < 0)
        {//向左运动
            for (int i = 0; i < Items.Count; i++)
            {
                if (Items[i].v < (VMin - AddValue / 2))
                {
                    GotoLaserItems.Add(Items[i]);
                }
            }
            if (GotoLaserItems.Count > 0)
            {
                for (int i = 0; i < GotoLaserItems.Count; i++)
                {
                    GotoLaserItems[i].v = Items[Items.Count - 1].v + AddValue;
                    Items.Remove(GotoLaserItems[i]);
                    Items.Add(GotoLaserItems[i]);
                }
                GotoLaserItems.Clear();
            }
        }
        else if (_v > 0)
        {//向右运动,需要把右边的放到前面来

            for (int i = Items.Count - 1; i > 0; i--)
            {
                if (Items[i].v >= VMax)
                {
                    GotoFirstItems.Add(Items[i]);
                }
            }
            if (GotoFirstItems.Count > 0)
            {
                for (int i = 0; i < GotoFirstItems.Count; i++)
                {
                    GotoFirstItems[i].v = Items[0].v - AddValue;
                    Items.Remove(GotoFirstItems[i]);
                    Items.Insert(0, GotoFirstItems[i]);
                }
                GotoFirstItems.Clear();
            }
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        float k = 0, v1;
        for (int i = 0; i < Items.Count; i++)
        {
            if (Items[i].v >= VMin)
            {
                v1 = (Items[i].v - VMin) % AddValue;   //(0.9-0.1)%0.2   计算超出的时间
                //Debug.Log(v1 + "--" + NextAddValue);
                if (add_vect.x >= 0)     //向右滑动
                {
                    k = AddValue - v1;  //0.2-超出时间
                }
                else
                {
                    k = v1 * -1;    
                }
                break;
            }
        }
        add_vect = Vector3.zero;
        AnimToEnd(k);
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        Debug.Log("OnPointerClick:" + eventData.pointerPressRaycast.gameObject);
        if (add_vect.sqrMagnitude <= 1)
        {
            Debug.Log("============OnPointerClickOK============");
            UI_Control_ScrollFlow_Item script = eventData.pointerPressRaycast.gameObject.GetComponent<UI_Control_ScrollFlow_Item>();
            if (script != null)
            {
                float k = script.v;
                k = 0.5f - k;
                AnimToEnd(k);
            }

        }
    }


    public float GetApa(float v)
    {
        return ApaCurve.Evaluate(v);
    }
    public float GetPosition(float v)
    {
        return PositionCurve.Evaluate(v) * Width;
    }
    public float GetScale(float v)
    {
        return ScaleCurve.Evaluate(v) * MaxScale;
    }


    private List<UI_Control_ScrollFlow_Item> SortValues = new List<UI_Control_ScrollFlow_Item>();
    private int index = 0;
    public void LateUpdate()
    {
        for (int i = 0; i < Items.Count; i++)
        {
            if (Items[i].v >= 0.1f && Items[i].v <= 0.9f)
            {
                index = 0;
                for (int j = 0; j < SortValues.Count; j++)
                {
                    if (Items[i].sv >= SortValues[j].sv)
                    {
                        index = j + 1;
                    }
                }

                SortValues.Insert(index, Items[i]);
            }
        }

        for (int k = 0; k < SortValues.Count; k++)
        {
            SortValues[k].rect.SetSiblingIndex(k);
        }
        SortValues.Clear();
    }

    public void ToLaster(UI_Control_ScrollFlow_Item item)
    {
        item.v = Items[Items.Count - 1].v + AddValue;
        Items.Remove(item);
        Items.Add(item);
    }

    /// <summary>
    /// 是否开启动画
    /// </summary>
    public bool _anim = false;
    private float AddV = 0, Vk = 0, CurrentV = 0, Vtotal = 0, VT = 0;
    private float _v1 = 0, _v2 = 0;
    /// <summary>
    /// 动画速度
    /// </summary>
    public float _anim_speed = 1f;
    private float start_time = 0, running_time = 0;

    public UI_Control_ScrollFlow_Item Current;



    public void AnimToEnd(float k)
    {
        AddV = k;
        if (AddV > 0) { Vk = 1; }
        else if (AddV < 0) { Vk = -1; }
        else
        {
            return;
        }
        Vtotal = 0;
        _anim = true;

    }

    void Update()
    {
        if (_anim)
        {
            CurrentV = Time.deltaTime * _anim_speed * Vk;  //控制动画正反播放
            VT = Vtotal + CurrentV; 
    //0<VT VT>=0.2
            if (Vk > 0 && VT >= AddV) { _anim = false; CurrentV = AddV - Vtotal; }
            if (Vk < 0 && VT <= AddV) { _anim = false; CurrentV = AddV - Vtotal; }
            //==============
            for (int i = 0; i < Items.Count; i++)
            {
                Items[i].Drag(CurrentV);
                if (Items[i].v - 0.5 < 0.05f)
                {
                    Current = Items[i];
                }
            }
            Check(CurrentV);
            Vtotal = VT;


            if (!_anim)
            {
                if (MoveEnd != null) { MoveEnd(Current); }
            }
        }
    }

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

public class UI_Control_ScrollFlow_Item : MonoBehaviour
{
    private UI_Control_ScrollFlow parent;
    [HideInInspector]
    public RectTransform rect;
    public UnityEngine.UI.Image img;

    public float v = 0;
    private Vector3 p, s;
    /// <summary>
    /// 缩放值
    /// </summary>
    public float sv;
    // public float index = 0,index_value;
    private Color color;

    public void Init(UI_Control_ScrollFlow _parent)
    {
        rect = GetComponent<RectTransform>();
        parent = _parent;
        color = img.color;
    }

    public void Drag(float value)
    {
        v += value;
        p = rect.localPosition;
        p.x = parent.GetPosition(v);
        rect.localPosition = p;

        color.a = parent.GetApa(v);
        img.color = color;
        sv = parent.GetScale(v);
        s.x = sv;
        s.y = sv;
        s.z = 1;
        rect.localScale = s;
    }
}
iamge.gif

相关文章

网友评论

      本文标题:unity 无限滚动

      本文链接:https://www.haomeiwen.com/subject/jzuxyhtx.html