基于Unity的扩展ScrollView开发（自动居中，缩放，明暗变化），用于商城系统，皮肤系统等UI

最新推荐文章于 2024-07-27 14:48:44 发布
最新推荐文章于 2024-07-27 14:48:44 发布
阅读量4.8k 收藏 22
点赞数 5
分类专栏： 游戏UI 文章标签： Unity扩展ScrollView开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/N1ngYue/article/details/79312661
版权

本博客参照于已有的大神博客的代码进行扩展实现。

话不多说，先上测试结果和源码。

下面这是打包运行时的情况，自动将离中心最近的Item平滑拉到中心，并放大，变亮，支持点击某一个Item直接居中。

下面是源码，对Inspector面板进行过重绘，用于bool型属性控制其他属性的显示与隐藏，以及List<>属性的展示。

/******************************************************
* 滚动条扩展脚本 
* Author： liaoweiyu
* function:自动居中最靠近中心的Item
           支持居中Item缩放
           支持非居中Item变暗
           支持点击Item居中
           带有居中Item改变时回调委托：_centerChanged
******************************************************/


using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using System.Collections;
using System.Collections.Generic;
using System;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditorInternal;
#endif
public enum ScrollDir_UGUI
{
    Horizontal,
    Vertical
}
public enum ImageType_UGUI
{
    Image
}
/// <summary>
/// 用于显示在Inspector的类
/// </summary>
[Serializable]
public class ScrollViewImage
{
    public ImageType_UGUI type;
    public Image image;
}
#if UNITY_EDITOR
/// <summary>
/// 重绘Inspector类
/// </summary>
[CustomEditor(typeof(CenterOnChild_UGUI))]
public class OverDrawInspector : Editor
{
    private SerializedObject serial;//序列化
    private ReorderableList list;//数组

    private SerializedProperty TransformSpeed, ScaleSpeed, OpacitySpeed, CenterChildScale, AddMask, MaskOpacity;
    /// <summary>
    /// 初始化
    /// </summary>
    void OnEnable()
    {
        serial = new SerializedObject(target);
        list = new ReorderableList(serial, serial.FindProperty("ChildMasks"), true, true, true, true);
        TransformSpeed = serial.FindProperty("TransformSpeed");
        ScaleSpeed = serial.FindProperty("ScaleSpeed");
        OpacitySpeed = serial.FindProperty("OpacitySpeed");
        CenterChildScale = serial.FindProperty("CenterChildScale");
        AddMask = serial.FindProperty("AddMask");
        MaskOpacity = serial.FindProperty("MaskOpacity");

        //绘制List标题
        list.drawHeaderCallback = (Rect rect) =>
        {
            EditorGUI.LabelField(rect, "MaskList");
        };
        //绘制List
        list.drawElementCallback =
        (Rect rect, int index, bool isActive, bool isFocused) =>
        {       
            var element = list.serializedProperty.GetArrayElementAtIndex(index);
            rect.y += 2;
            //绘制一个单元
            EditorGUI.PropertyField(new Rect(rect.x, rect.y, 60, EditorGUIUtility.singleLineHeight),
            element.FindPropertyRelative("type"), GUIContent.none);
            EditorGUI.PropertyField(new Rect(rect.x + 60, rect.y, rect.width - 60 - 30, EditorGUIUtility.singleLineHeight),
            element.FindPropertyRelative("image"), GUIContent.none);
        };
    }
    /// <summary>
    /// 重绘
    /// </summary>
    public override void OnInspectorGUI()
    {
        serial.Update();
        EditorGUILayout.PropertyField(TransformSpeed);
        EditorGUILayout.PropertyField(ScaleSpeed);
        EditorGUILayout.PropertyField(CenterChildScale);
        EditorGUILayout.PropertyField(AddMask);
        if (AddMask.boolValue == true)
        {
            EditorGUILayout.PropertyField(OpacitySpeed);
            EditorGUILayout.PropertyField(MaskOpacity);
            list.DoLayoutList();
        }
        serial.ApplyModifiedProperties();//应用
    }

}
#endif

/// <summary>
/// 逻辑类
/// </summary>
public class CenterOnChild_UGUI : MonoBehaviour, IEndDragHandler, IDragHandler, IBeginDragHandler
{
    public ScrollDir_UGUI Dir = ScrollDir_UGUI.Horizontal;
    /// <summary>
    /// 未居中组件遮罩透明度
    /// </summary>
    [SerializeField, Range(0, 1)]
    public float MaskOpacity = 0.4f;
    /// <summary>
    /// 是否加入遮罩
    /// </summary>
    [Header("---开启遮罩（将每个子组件的遮罩手动拖入）")]
    public bool AddMask = false;
    //是否正在居中
    private bool _isCentering = false;
    //是否正在缩放
    private bool _isScaling = false;
    //是否需要变换透明度
    private bool _needChangingCapacity = false;
    //是否完成透明度还原
    //private bool _needReturnCapacity = false;

    /// <summary>
    /// 居中过程移动速度,超出范围可能会出bug
    /// </summary>
    [SerializeField, Range(5, 25)]
    public float TransformSpeed = 20f;
    /// <summary>
    /// 居中过程缩放，小于15不流畅，大于30没有明显变化
    /// </summary>
    [SerializeField, Range(15, 30)]
    public float ScaleSpeed = 20f;
    /// <summary>
    /// 居中过程明暗变化，小于5等待时间过长，大于40没有明显变化
    /// </summary>
    [SerializeField, Range(5, 40)]
    public float OpacitySpeed = 10f;
    /// <summary>
    /// 居中组件缩放
    /// </summary>
    public Vector3 CenterChildScale = new Vector3(1.3f, 1.3f, 1.3f);
    /// <summary>
    /// 组件的遮罩
    /// </summary>
    [SerializeField]
    public List<ScrollViewImage> ChildMasks = new List<ScrollViewImage>();
    //插值运算临时变量
    private Vector3 Temp_EnlargeScale;//放大
    private Vector3 Temp_ReduceScale;//缩小
    private float Temp_BrightenScale;//变亮
    private float Temp_DarkenScale;//变暗

    private ScrollRect _scrollView;
    //grid
    private Transform _content;
    //子节点的坐标
    private List<float> _childrenPos = new List<float>();
    //当前需要运动到的目标坐标
    private float _targetPos;

    /// <summary>
    /// 当前中心child索引
    /// </summary>
    private int _curCenterChildIndex = 0;
    /// <summary>
    /// 上一次中心child索引
    /// </summary>
    private int _lastCenterChildIndex;
    /// <summary>
    /// 是否改变了中心组件做引
    /// </summary>
    private bool _isChangeCenter = false;
    /// <summary>
    /// 中心组件改变委托
    /// 用于触发改变中心组件后切换对应数据
    /// </summary>
    public delegate void CenterChangedCallBack(int _index);
    public CenterChangedCallBack _centerChanged;

    /// <summary>
    /// 当前中心ChildItem
    /// </summary>
    public GameObject CurCenterChildItem
    {
        get
        {
            GameObject centerChild = null;
            if (_content != null && _curCenterChildIndex >= 0 && _curCenterChildIndex < _content.childCount)
            {
                centerChild = _content.GetChild(_curCenterChildIndex).gameObject;
            }
            return centerChild;
        }
    }

    void Awake()
    {
        //初始化
        _curCenterChildIndex = 0;
        _lastCenterChildIndex = _curCenterChildIndex;
        Temp_EnlargeScale = CenterChildScale;
        Temp_ReduceScale = CenterChildScale;
        Temp_BrightenScale = MaskOpacity;
        Temp_DarkenScale = MaskOpacity;

        _scrollView = GetComponent<ScrollRect>();
        if (_scrollView == null)
        {
            Debug.LogError("错误：ScrollRect为空");
            return;
        }
        _content = _scrollView.content;

        LayoutGroup layoutGroup = null;
        layoutGroup = _content.GetComponent<LayoutGroup>();

        if (layoutGroup == null)
        {
            Debug.LogError("错误：LayoutGroup Component为空");
        }
        _scrollView.movementType = ScrollRect.MovementType.Unrestricted;
        float spacing = 0f;
        //根据dir计算坐标，Horizontal：存x，Vertical：存y
        switch (Dir)
        {
            case ScrollDir_UGUI.Horizontal:
                if (layoutGroup is HorizontalLayoutGroup)
                {
                    float childPosX = _scrollView.GetComponent<RectTransform>().rect.width * 0.5f - GetChildItemWidth(0) * 0.5f;
                    spacing = (layoutGroup as HorizontalLayoutGroup).spacing;
                    _childrenPos.Add(childPosX);
                    for (int i = 1; i < _content.childCount; i++)
                    {
                        childPosX -= GetChildItemWidth(i) * 0.5f + GetChildItemWidth(i - 1) * 0.5f + spacing;
                        _childrenPos.Add(childPosX);
                    }
                }
                else if (layoutGroup is GridLayoutGroup)
                {
                    GridLayoutGroup grid = layoutGroup as GridLayoutGroup;
                    float childPosX = _scrollView.GetComponent<RectTransform>().rect.width * 0.5f - grid.cellSize.x * 0.5f;
                    _childrenPos.Add(childPosX);
                    for (int i = 0; i < _content.childCount - 1; i++)
                    {
                        childPosX -= grid.cellSize.x + grid.spacing.x;
                        _childrenPos.Add(childPosX);
                    }
                }
                else
                {
                    Debug.LogError("错误：Horizontal ScrollView正在使用VerticalLayoutGroup");
                }
                break;
            case ScrollDir_UGUI.Vertical:
                if (layoutGroup is VerticalLayoutGroup)
                {
                    float childPosY = -_scrollView.GetComponent<RectTransform>().rect.height * 0.5f + GetChildItemHeight(0) * 0.5f;
                    spacing = (layoutGroup as VerticalLayoutGroup).spacing;
                    _childrenPos.Add(childPosY);
                    for (int i = 1; i < _content.childCount; i++)
                    {
                        childPosY += GetChildItemHeight(i) * 0.5f + GetChildItemHeight(i - 1) * 0.5f + spacing;
                        _childrenPos.Add(childPosY);
                    }
                }
                else if (layoutGroup is GridLayoutGroup)
                {
                    GridLayoutGroup grid = layoutGroup as GridLayoutGroup;
                    float childPosY = -_scrollView.GetComponent<RectTransform>().rect.height * 0.5f + grid.cellSize.y * 0.5f;
                    _childrenPos.Add(childPosY);
                    for (int i = 1; i < _content.childCount; i++)
                    {
                        childPosY += grid.cellSize.y + grid.spacing.y;
                        _childrenPos.Add(childPosY);
                    }
                }
                else
                {
                    Debug.LogError("错误：Vertical ScrollView正在使用HorizontalLayoutGroup");
                }
                break;
        }
        //初始化ScrollView起始位置
        SetCenterChild(0);
        _isChangeCenter = true;
    }

    private float GetChildItemWidth(int index)
    {
        return (_content.GetChild(index) as RectTransform).sizeDelta.x;
    }

    private float GetChildItemHeight(int index)
    {
        return (_content.GetChild(index) as RectTransform).sizeDelta.y;
    }

    void Update()
    {
        //中心组件改变时触发委托
        if (_isChangeCenter)
        {
            CenterChanged(_curCenterChildIndex);
            _isChangeCenter = false;
            _lastCenterChildIndex = _curCenterChildIndex;
        }
        if (AddMask)
        {
            //开启遮罩标志
            _needChangingCapacity = true;
        }
        else
        {
            //关闭遮罩
            _needChangingCapacity = false;
        }
        if (_isScaling)
        {
            //插值缩放
            for (int i = 0; i < _content.childCount; i++)
            {
                if (i == _curCenterChildIndex)
                {
                    //居中的放大
                    Temp_EnlargeScale = new Vector3(Mathf.Lerp(CurCenterChildItem.transform.localScale.x, CenterChildScale.x, ScaleSpeed * Time.deltaTime),
                                                    Mathf.Lerp(CurCenterChildItem.transform.localScale.y, CenterChildScale.x, ScaleSpeed * Time.deltaTime),
                                                    Mathf.Lerp(CurCenterChildItem.transform.localScale.z, CenterChildScale.x, ScaleSpeed * Time.deltaTime));
                    CurCenterChildItem.transform.localScale = Temp_EnlargeScale;
                }
                else
                {
                    Temp_ReduceScale = new Vector3(Mathf.Lerp(_content.GetChild(i).gameObject.transform.localScale.x, 1f, ScaleSpeed * Time.deltaTime),
                                                   Mathf.Lerp(_content.GetChild(i).gameObject.transform.localScale.y, 1f, ScaleSpeed * Time.deltaTime),
                                                   Mathf.Lerp(_content.GetChild(i).gameObject.transform.localScale.z, 1f, ScaleSpeed * Time.deltaTime));
                    _content.GetChild(i).gameObject.transform.localScale = Temp_ReduceScale;
                }
            }
            //修改透明度
            if (AddMask)
            {
                if (_needChangingCapacity)
                {
                    if (MaskCheck() == false)
                    {
                        Debug.LogError("错误：没有找到遮罩资源或者部分子组件缺少遮罩资源");
                        AddMask = false;
                    }
                    else
                    {
                        for (int i = 0; i < ChildMasks.Count; i++)
                        {
                            if (i == _curCenterChildIndex)
                            {
                                //居中的变亮
                                Temp_BrightenScale = Mathf.Lerp(ChildMasks[i].image.color.a, 0f, OpacitySpeed * Time.deltaTime);
                                SetChildOpacity(ChildMasks[i].image, Temp_BrightenScale);
                            }
                            else
                            {
                                Temp_DarkenScale = Mathf.Lerp(ChildMasks[i].image.color.a, MaskOpacity, OpacitySpeed * Time.deltaTime);
                                SetChildOpacity(ChildMasks[i].image, Temp_DarkenScale);
                            }
                        }
                    }
                    if (ChildMasks[_curCenterChildIndex].image.color.a <= 0.01f)
                    {
                        _needChangingCapacity = false;
                        //_needReturnCapacity = true;
                        _isScaling = false;
                    }
                }
            }
            else
            {
                //去掉遮罩
                for (int i = 0; i < ChildMasks.Count; i++)
                {
                    if (ChildMasks[i].image != null)
                    {
                        SetChildOpacity(ChildMasks[i].image, 0f);
                    }                  
                }
            }
        }
        
        if (_isCentering)
        {
            Vector3 v = _content.localPosition;
         
            //插值居中
            switch (Dir)
            {
                case ScrollDir_UGUI.Horizontal:
                    v.x = Mathf.Lerp(_content.localPosition.x, _targetPos, TransformSpeed * Time.deltaTime);
                    _content.localPosition = v;
                    if (Math.Abs(_content.localPosition.x - _targetPos) < 0.01f)
                    {
                        _isCentering = false;

                    }
                    break;
                case ScrollDir_UGUI.Vertical:
                    v.y = Mathf.Lerp(_content.localPosition.y, _targetPos, TransformSpeed * Time.deltaTime);
                    _content.localPosition = v;
                    if (Math.Abs(_content.localPosition.y - _targetPos) < 0.01f)
                    {
                        _isCentering = false;

                    }
                    break;
            }
        }
    }

    public void OnDrag(PointerEventData eventData)
    {
        _isScaling = true;
        switch (Dir)
        {
            case ScrollDir_UGUI.Horizontal:
                _targetPos = FindClosestChildPos(_content.localPosition.x, out _curCenterChildIndex);
                break;
            case ScrollDir_UGUI.Vertical:
                _targetPos = FindClosestChildPos(_content.localPosition.y, out _curCenterChildIndex);
                break;
        }
        _needChangingCapacity = true;
        _isChangeCenter = true;
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        switch (Dir)
        {
            case ScrollDir_UGUI.Horizontal:
                _targetPos = FindClosestChildPos(_content.localPosition.x, out _curCenterChildIndex);
                break;
            case ScrollDir_UGUI.Vertical:
                _targetPos = FindClosestChildPos(_content.localPosition.y, out _curCenterChildIndex);
                break;
        }
        _isCentering = true;
        _needChangingCapacity = true;
        if (_lastCenterChildIndex != _curCenterChildIndex)
        {
            _isChangeCenter = true;
        }
        //_isScaling = false;
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        _isCentering = false;

        _curCenterChildIndex = -1;
    }
    /// <summary>
    /// 计算离中心最近的子组件
    /// </summary>
    /// <param name="currentPos"></param>
    /// <param name="curCenterChildIndex"></param>
    /// <returns></returns>
    private float FindClosestChildPos(float currentPos, out int curCenterChildIndex)
    {
        float closest = 0;
        float distance = Mathf.Infinity;
        curCenterChildIndex = -1;
        for (int i = 0; i < _childrenPos.Count; i++)
        {
            float p = _childrenPos[i];
            float d = Mathf.Abs(p - currentPos);
            if (d < distance)
            {
                distance = d;
                closest = p;
                curCenterChildIndex = i;
            }
        }
        return closest;
    }
    /// <summary>
    /// 检查遮罩是否丢失,True-未丢失，False-丢失
    /// </summary>
    /// <returns></returns>
    public bool MaskCheck()
    {
        if (ChildMasks == null || ChildMasks.Count == 0 || ChildMasks.Count != _content.childCount)
        {
            return false;
        }
        else
        {
            for (int i = 0; i < ChildMasks.Count; i++)
            {
                if (ChildMasks[i].image == null)
                {
                    return false;
                }               
            }
        }
        return true;
    }
    /// <summary>
    /// 设置组件的遮罩透明度
    /// </summary>
    public void SetChildOpacity(Image img, float opacity)
    {
        if (img != null)
        {
            img.color = new Color(1, 1, 1, opacity);
        }
    }
    /// <summary>
    /// 强制设置当前居中的子物体
    /// 用于点击事件
    /// </summary>
    /// <param name="_index"></param>
    public void SetCenterChild(int _index) 
    {      
        _curCenterChildIndex = _index;
        _isCentering = true;
        _needChangingCapacity = true;
        _isScaling = true;
        _targetPos = _childrenPos[_index];
        if (_curCenterChildIndex != _lastCenterChildIndex)
        {
            _isChangeCenter = true;
        }
    }
    /// <summary>
    /// 中心组件改变（委托）
    /// 用于根据中心组件变化触发对应数据变化
    /// </summary>
    public void CenterChanged(int _index)
    {
        if (_centerChanged != null)
        {
            _centerChanged(_index);          
        }

    }
}
动态滚动条：CenterOnChild_UGUI.cs
目前功能：
1、自动将离中心点最近的Item平滑居中。
2、居中Item平滑缩放。
3、居中Item平滑变亮，其余Item变暗。
4、点击Item居中。
5、附带居中Item改变时需要改变显示数据的委托

1和2可直接使用，3、4和5需要写一点调用代码。

功能1和2基本使用：

创建prefab，按照常规ScrollView结构。


注意Item摆放一定要左右靠边，gird节点的X坐标尽可能为0。（不为0可能有计算错误）


将脚本挂在ScrollView上。


同时在Grid节点上挂载一个HorizontalLayoutGroup（VerticalLayoutGroup）组件，用于自动设置间距。


此时可以直接运行使用1和2功能，平滑居中和平滑缩放。


以下功能3，4，5的使用需要有一定的Unity开发基础。

功能3的使用：

点击脚本的AddMask属性打钩，根据多少个子Item在MaskList创建多少个单元。（固定Item数量可以使用网上的无限循环ScrollView插件）

在下面的界面，参数可在运行时调整。


需要创建一个Mask物体把整个Item遮住。


然后将遮罩ImageExt拖入到脚本。（这里的ImageExt是我使用的扩展版Image，上面的源码是Image版本的，这个不用管）


即完成了对Item变亮变暗的引用。


功能4的使用：

将遮罩物体射线检测打开。


在Item的脚本中，关联点击委托。


写入委托，ItemIndex一定要设置一下，用来判断点击的哪一个，从0开始。


在遮罩物体上设置按钮事件。


然后进入主UI的脚本。（这里的主UI脚本也是我用的扩展型的，这些杂七杂八的参数不用管）


写下委托调用的方法。


最后在主UI的初始化时关联委托，m_content为ScrollView下面的grid。


完成了对功能4的引用。


功能5的使用：
在居中Item改变时触发委托事件。（在源码中）


只需要在外部关联委托函数即可完成改变中心Item切换显示数据。


以上是文字说明，具体测试工程，以及打包编译的exe进入下载链接使用参考。

http://download.csdn.net/download/n1ngyue/10249844


N1ngYue
关注
专栏目录
UnityUGUI实现ScrollView 滑动居中的放大、其他的缩小，简单实现方法
lq1340817945的博客
10-27 4699
效果图： 使用到的技术： UGUI的ScrollView DoTween 实现原理： 首先创建一个ScrollView组件用于放置节点 创建一个空的RectTransForm作为中心标识组件 原理 贴上Lua伪代码 首先将生成在ScrollView的所有物体保存到self.itemList 然后每次刷新的时候遍历所有子物 function HolidayPage3ItemCtrl:FreshItem( ) local centerPosX = self.view.UI.RectTransfo
UGUI组件ScrollRect扩展,自动移动到中心位置
qq_32470423的博客
02-10 421
UGUI ScrollRect扩展,自动移动到中间,自动移动到中心点
Unity滚动条ScrollView自动居中、缩放、变暗扩展
02-11
类似于网络游戏的商品切换滚动条，皮肤切换滚动条，自动居中离中心最近的Item，居中Item进行缩放，明暗变化。
【Unity-UGUI】ScrollView自动定位到指定的Item
最新发布
manqi的博客
07-27 498
ScrollView自动定位到指定的Item
uGUI练习(六) ScrollView
weixin_33962621的博客
09-15 750
练习目标 练习uGUI的滑动组件 一、相关组件 ScrollRect Mask Grid Layout Group Scrollbar 二、步骤 1、创建一个Panel,命名为ScrollRect，添加 ScrollRect组件 2、在ScrollRect下创建一个子Panel,命名为Grid，添加Grid Layout Group 组件 3、在Grid下，创建...
unity Scroll View元素拖拽自动吸附居中、卡牌效果
zjh_368的博客
04-15 5563
利用Scroll View控件做拖拽自动吸附居中效果 1、新建一个Scrool View控件，去掉两个Scroolbar，因为不需要； 然后在Viewport下建一个CenterPoint空对象跟Content同级作为中心位置用来比较； 最后给Content添加元素。 2、取消垂直拖拽，即去掉Vertical的勾选；Movement Type 设置为Unrestricted，如下图...
Unity——Scroll View 滑动居中、居中的放大、其他的缩小（支持横竖Scroll View）
SiReSo
04-23 6583
一、效果 二、上代码，两种方式。 (第一种是在Update中用插值完成的，如果不想再项目中看到Update，下面的另一种改了一段用DoTween实现的，需要导入一下DoTween) using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using Unit...
u3d滑动条自动居中放大
01-12
在Unity3D（通常简称为u3d）中，滑动条（Scroll Rect）是一种非常常用的UI组件，用于实现用户界面中的滚动效果。本项目"u3d滑动条自动居中放大"专注于优化和扩展了这个功能，使得在滑动多个子物体时，能够实现滑动...
unity Scroll 滑动 缩放
08-14
Unity3D是一款强大的跨平台游戏开发引擎，广泛用于制作2D和3D游戏、应用程序以及虚拟现实内容。在Unity的用户界面（UI）系统中，UGUI（Unity Graphical User Interface）提供了一系列组件来帮助开发者创建丰富的交互...
Unity Ugui 实现 列表item居中放大效果
qq_37775368的博客
06-23 2323
通过拖拽或者点击图片 使图片居中放大使用scroll view组件 并为子节点conter添加 Grid layout Group 组件实现逻辑记录每个item到scroll中心点的距离的数据在拖拽过程中 通过当前conter的localpostion位置 去判断离中心点距离最短的item找到对应item 让conter的localpostion通过插值lerp 移动到对应的位置 使其item居中并缩放水平拖拽 这里知晓localpostion关于x的信息即可垂直拖拽 即y。 在拖拽接口中不断实
Unity 插件：Simple UI - Scroll View Extensions v1.0
10-19
The Scroll View Extensions drastically extend the utility of the Unity UI Scroll Rect. Smooth and eased snapping (works great whether dragging using touch, mouse or scroll wheel) and user input dependent animation make it possible to use the Scroll Rect in a wide range of scenarios such as level menus, item menus or interactive maps. Features : • Focus the Scroll Rect on any element within the Scroll Rect • Great control over snapping (animation, inertia etc.) • Extensible system for animating elements that are moving into or out of focus.
unity3d-UGUI仿3D滑动
06-08
Unity3d仿3D滑动很真实,基于UGUI实现 例如卡牌的选择，关卡选择都能使用。
Unity NGUI之ScrollView扩展-2
文刀雨田
02-26 1163
Unity NGUI插件中，UIScrollView与UICenterOn配合使用时的一点改动，可以让列表的起始段和末尾端不现实到裁剪区域的中间。
Unity 滚轮实现UGUI ScrollView的缩放
weixin_30292843的博客
11-28 622
本文原创，转载请注明出处http://www.cnblogs.com/AdvancePikachu/p/7908754.html 前段时间在做一个类似AnimationCurve的可视化编辑器，其中在做内部缩放的时候略有所感，把利用滚轮+焦点的缩放分享一下。 其中一个脚本处理内部逻辑 public class ResizeScrollEvent : UnityE...
unity ScrollRect列表自动居中
L_yijun的博客
07-27 1875
unity滑动列表自动居中
Unity ScrollView和GridLayout
bingheliefeng的专栏
02-04 443
scollRect.onValueChanged.AddListener((Vector2 v)=>{ ScrollContent.SetHeight(grid.preferredHeight + 20f); }); 获取Layout的高度，用于设置ScrollView的滚动高度
【Uniy3d之EnhanceScollView选择角色3D循环滚动效果实现】
Render-better-life
09-26 3477
在Unity3D中使用AnimationCurve实现酷炫的3D选人效果，使用Curve分别控制缩放，位移，层级关系，github查看具体实现和效果
ScrollView无限循环阻尼居中（带缩放）
Sam_ONE的博客
03-05 4533
前两天写的SceollView阻尼居中的忘了加入循环列表的功能，本来我以为加入循环的功能不难，当写了才发现，因为上一个版本的Content里为了方便加的两个挂件（Content Size Fitter 和 Grid Layout Group）让我很尴尬，中间我试着实现了循环功能，发现在运行情况下我切换至VS后切换回Unity之后它又让我回到解放前（交换的Item位置又倍还原了。。），其中的原有我大
unity ScrollView 无限滑动自动居中
03-26
要实现 ScrollView 的无限滑动自动居中的功能，可以通过计算当前可见区域内的子项数量，然后根据剩余的空间进行自动居中。 以下是一个示例代码，可以将其挂载在 ScrollView 的 content 对象上： ```csharp using UnityEngine; using UnityEngine.UI; public class InfiniteScrollView : MonoBehaviour { public GameObject[] contentItems; public ScrollRect scrollRect; private RectTransform contentRectTransform; private int itemHeight; private int visibleItemCount; void Start() { contentRectTransform = GetComponent<RectTransform>(); itemHeight = (int)contentItems[0].GetComponent<RectTransform>().rect.height; visibleItemCount = Mathf.CeilToInt(scrollRect.GetComponent<RectTransform>().rect.height / itemHeight); } void Update() { float contentY = contentRectTransform.anchoredPosition.y; int firstVisibleIndex = Mathf.FloorToInt(-contentY / itemHeight); int lastVisibleIndex = Mathf.Min(firstVisibleIndex + visibleItemCount, contentItems.Length) - 1; int centerIndex = (firstVisibleIndex + lastVisibleIndex) / 2; float centerY = -centerIndex * itemHeight; float newY = Mathf.Lerp(contentY, centerY, Time.deltaTime * 5f); contentRectTransform.anchoredPosition = new Vector2(contentRectTransform.anchoredPosition.x, newY); if (contentY < -itemHeight * contentItems.Length + scrollRect.GetComponent<RectTransform>().rect.height) contentRectTransform.anchoredPosition = new Vector2(contentRectTransform.anchoredPosition.x, 0f); if (contentY > 0f) contentRectTransform.anchoredPosition = new Vector2(contentRectTransform.anchoredPosition.x, -itemHeight * contentItems.Length + scrollRect.GetComponent<RectTransform>().rect.height); } } ``` 以上代码基本上实现了无限滑动和自动居中的功能，可以根据实际需要调整一些参数或者添加额外的逻辑。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值