Unity NGUI 滑动列表3D效果，渐变缩放，偏移，渐变效果实现

最新推荐文章于 2024-05-11 20:52:09 发布
最新推荐文章于 2024-05-11 20:52:09 发布
阅读量7.4k 收藏 52
点赞数 6
文章标签： Unity NGUI Unity 滑动列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30259857/article/details/79562652
版权

 

 

3D效果如下

 

无3D效果如下

弯曲度调整效果如下：

 

缩放调整效果如下图：

渐变调整效果如下图：

 

Unity Demo 地址：https://download.csdn.net/download/qq_30259857/10893338

常见问题：

  1.  位置错误，位置偏移，位置不居中：  在你的UIPanel 底下 重新创建 ScrollView 然后位置不动只动Size

 

参考来自：https://www.cnblogs.com/SHOR/p/5458538.html

 

使用和调用方法请看下面说明：

第一步：挂脚本

在ScrollView控件挂的脚本和大致参数如下图：

 

第二步：初始化

 

初始化：OnInit(OnRefreshCallBack, OnSelectCenterCallBack, OnLastSelectCenterCallBack)

第一个参数为所有项刷新回调函数，第二个参数为中间选中物体回调函数，第三个参数为上一个选中物体回调函数(主要用于初始化上一个选中物体)。所有回调函数的参数类型是GameObject, object，然后在回调函数把object转成数据类型即可,如下图

第三步：传入List 数据类型

刷新数据函数：OnRefresh<数据类型>(数据列表)

传入后回调 初始化函数(OnInit())当中传的第一个函数。

 

3D效果调整：

1. 需把UICamera调整为3D摄像机，关闭此界面的时候再调整为2D摄像机即可。

调整为3D摄像机 代码如下：

UICamera.currentCamera.orthographic = false;
UICamera.currentCamera.transform.localPosition = new Vector3(0, 0, -845);

UICamera.currentCamera.nearClipPlane = 0.1f;

 

2.脚本上把 isUsedRote 勾上

 

注：上图中 IsLoop 为首尾相连功能。

 

直接上整体代码：

 

/**
* @Author Leon Kim
*
*
*/
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;


namespace projectQ
{
    public class UIScrollAnimationList : MonoBehaviour
    {
        [Range(0, 2)]
        public float curveValue = 0.8f; //弯曲度
        [Range(0, 10)]
        public float scaleValue = 1.5f; //渐变缩放
        [Range(0, 10)]
        public float alphaValue = 0; //渐变透明
        public float offsetValue = 0; //每个物体的偏移值


        public bool isLoop = false; //是否循环（首尾相连）
        public int loopCount = 4; //多少个数量开始 首尾循环


        public UIGrid grid;
        public GameObject mItem;
        public bool isUsedRote = false;


        private Transform[] ItemsArr;
        private Vector3[] PosArr;


        private bool isInited = false;


        private float itemWidth;
        private float itemHeight;


        private bool isDrag = false;


        private int itemCount; //数量


        private List<object> DataList = new List<object>();


        private Dictionary<GameObject, object> ItemsDict = new Dictionary<GameObject, object>();


        private UIScrollView.Movement movement; //方向


        private GameObject content;


        private GameObject lastOnClickItem; //上一次点击的物体


        private Action<GameObject, object> OnCenterCallBack; //中间物体回调
        private Action<GameObject, object> OnLastCenterCallBack; //上一次中间物体回调 (比如 上一个选中物体 初始化用)
        private Action<GameObject, object> OnRefreshCallBack; //刷新物体


        private UICenterOnChild CenterOnChild;


        private Vector2 panelOffset;
        private float panelWidth;
        private float panelHeight;


        private Vector2 initPos;


        private bool isCanLoop = false;


        public void OnInit(Action<GameObject, object> OnRefreshCallBack, Action<GameObject, object> OnCenterCallBack = null, Action<GameObject, object> OnLastCenterCallBack = null)
        {
            content = transform.GetChild(0).gameObject;
            CenterOnChild = content.GetComponent<UICenterOnChild>();
            if(CenterOnChild == null)
            {
                CenterOnChild = content.AddComponent<UICenterOnChild>();
            }
            CenterOnChild.onCenter = OnCenterClick;
            CenterOnChild.onFinished = OnFinished;


            this.GetComponent<UIScrollView>().onDragStarted = OnDragStart;
            //this.GetComponent<UIScrollView>().onDragFinished = OnStopDrag;


            panelOffset = this.GetComponent<UIPanel>().clipOffset;
            panelHeight = this.GetComponent<UIPanel>().height;
            panelWidth = this.GetComponent<UIPanel>().width;


            movement = this.GetComponent<UIScrollView>().movement;


            this.OnCenterCallBack = OnCenterCallBack;
            this.OnRefreshCallBack = OnRefreshCallBack;
            this.OnLastCenterCallBack = OnLastCenterCallBack;


            mItem = mItem == null ? transform.Find("Item").gameObject : mItem;
            mItem.transform.SetParent(this.transform);


            content.transform.DestroyChildren();


            mItem.SetActive(false);


            if(grid == null)
            {
                grid = transform.GetChild(0).GetComponent<UIGrid>();
            }


            itemWidth = grid.cellWidth;
            itemHeight = grid.cellHeight;


            initPos = transform.localPosition;
        }


        public void OnRefresh<T>(List<T> list = null, int index = -1)
        {
            //仅刷新
            if (list == null)
            {
                int listCount = DataList.Count;
                for (int i = 0; i < listCount; i++)
                {
                    OnRefreshCallBack(ItemsArr[i].gameObject, DataList[i]);
                }
                return;
            }


            lastOnClickItem = null;
            isDrag = false;


            DataList.Clear();
            int count = list.Count;
            for (int i = 0; i < count; i++)
            {
                DataList.Add(list[i] as object);
            }
            this.itemCount = count;
            ItemsArr = new Transform[count];
            PosArr = new Vector3[count];


            int dataCount = DataList.Count;
            int childCount = content.transform.childCount;
            int forCount = dataCount > childCount ? dataCount : childCount;
            for(int i = 0; i < forCount; i++)
            {
                GameObject obj = null;
                if(i < childCount)
                {
                    Transform trans = content.transform.GetChild(i);
                    obj = trans.gameObject;
                    if(i >= dataCount)
                    {
                        obj.SetActive(false);
                        continue;
                    }
                }
                else if(i < dataCount)
                {
                    obj = Clone(i);
                }
                ItemsArr[i] = obj.transform;
                obj.SetActive(true);
                obj.name = i.ToString();
                ItemsDict[obj] = DataList[i];
                OnRefreshCallBack(obj, DataList[i]);
            }




            panelOffset = this.GetComponent<UIPanel>().clipOffset;


            float offsetX = panelOffset.x;
            float offsetY = panelOffset.y;


            //还原到初始位置
            transform.localPosition = initPos;


            if (movement == UIScrollView.Movement.Horizontal)
            {
                offsetX = -transform.localPosition.x;
            }
            else
            {
                offsetY = -transform.localPosition.y;
            }


            this.GetComponent<UIPanel>().clipOffset = new Vector2(offsetX, offsetY);


            grid.Reposition();


            for (int i = 0; i < count; i++)
            {
                if (ItemsArr[i] != null)
                {
                    PosArr[i] = ItemsArr[i].transform.localPosition;
                }
            }


            if(index == -1 || index >= count)
            {
                index = Mathf.FloorToInt(count / 2f);
            }


            if(DataList.Count > 0)
            {
                JumpToCenter(index);
            }


            //是否可循环（首尾相连）
            CheckCanLoop();


            isInited = true;
        }


        //是否可循环（首尾相连）
        private Transform minItem;
        private Transform maxItem;
        void CheckCanLoop()
        {
            OnUpdateScale();


            float minScale = minItem.localScale.x;
            float maxScale = maxItem.localScale.x;


            isCanLoop = isLoop;
            if(ItemsArr.Length < loopCount)
            {
                isCanLoop = false;
            }
        }


        //跳转到某一个物体
        public void JumpToCenter(int index)
        {
            CenterOnChild.CenterOn(ItemsArr[index].transform);
        }
        //跳转到某一个物体
        public void JumpToCenter(GameObject target)
        {
            if (CenterOnChild == null) return;
            CenterOnChild.CenterOn(target.transform);
        }


        //克隆物体
        GameObject Clone(int i)
        {
            GameObject _clone = Instantiate(mItem) as GameObject;
            _clone.transform.SetParent(grid.transform);
            _clone.transform.localScale = Vector3.one;
            _clone.SetActive(true);
            _clone.name = i.ToString();


            if(alphaValue > 0 && _clone.GetComponent<AnimatedAlpha>() == null)
            {
                _clone.AddComponent<AnimatedAlpha>();
            }


            return _clone;
        }


        //开始滑动回调
        private void OnDragStart()
        {
            isDrag = true;
        }


        //滑动停止
        void OnFinished()
        {
            isDrag = false;
        }


        //刷新列表滑动反向 相关参数
        private float lastPosX = 0;
        private float lastPosY = 0;
        private bool isBigDirection = false; //是否往 坐标大的方向移动 （Horizontal时是 左方向, Vertical是 上方向）


        //刷新列表滑动反向
        void UpdateSliderMovement()
        {
            if (movement == UIScrollView.Movement.Horizontal)
            {
                if (lastPosX != transform.localPosition.x)
                {
                    if (lastPosX < transform.localPosition.x)
                    {
                        isBigDirection = true;
                    }
                    else
                    {
                        isBigDirection = false;
                    }
                    lastPosX = transform.localPosition.x;
                }
            }
            else
            {
                if (lastPosY != transform.localPosition.y)
                {
                    if (lastPosY < transform.localPosition.y)
                    {
                        isBigDirection = true;
                    }
                    else
                    {
                        isBigDirection = false;
                    }
                    lastPosY = transform.localPosition.y;
                }
            }
        }
        
        private void Update()
        {
            if (!isInited) return;


            //刷新缩放值和偏移值
            OnUpdateScale();
            //刷新滑动的方向
            UpdateSliderMovement();
            //首尾相连
            LoopItem();
            
            if(!isDrag)
            {
                //选中物体移动到中间位置
                MoveToCenter();
            }
        }


        //刷新缩放值,弯曲值，透明值
        private void OnUpdateScale()
        {
            float tempMinPos = -1;
            float tempMaxPos = -1;


            float interval = isDrag ? 0 : 0.02f;


            for (int i = 0; i < itemCount; i++)
            {
                Transform itemTrans = ItemsArr[i];
                float alpha = 0;
                if (movement == UIScrollView.Movement.Horizontal)
                {
                    Vector3 Ipos = PosArr[i];
                    float val = (Ipos.x + transform.localPosition.x) / 1335f;


                    float factor = Mathf.Abs(val);


                    float yCurve = (factor + factor * curveValue) * (factor * curveValue * offsetValue); //曲线


                    alpha = 1 - factor * alphaValue;
                    float scale = 1 - factor * scaleValue;
                    if (scale < 0.1f)
                    {
                        scale = 0.1f;
                    }
                    if (scale > 0.98f)
                    {
                        scale = 1;
                        alpha = 1;
                    }


                    float v = GetValueX(val < 0 ? true : false, scale, Ipos.x);


                    if (v < 0.1f) v = 0;


                    float posX = val < 0 ? Ipos.x + v : Ipos.x - v;


                    Vector3 p = Vector3.one * scale;


                    if(Mathf.Abs(p.x - itemTrans.localScale.x) > interval)
                    {
                        itemTrans.localScale = p;
                    }


                    if (isUsedRote)
                    {
                        itemTrans.transform.rotation = Quaternion.Euler(0, val < 0 ? (90.0f * (1.0f - scale)) : -(90.0f * (1.0f - scale)), 0);
                    }


                    if(Mathf.Abs(itemTrans.localPosition.x - posX) > interval)
                    {
                        itemTrans.localPosition = new Vector2(posX, yCurve);
                    }


                    if (Ipos.x < tempMinPos || tempMinPos == -1)
                    {
                        tempMinPos = Ipos.x;
                        minPos = posX;
                        minPosIndex = i;
                        minItem = itemTrans;
                    }
                    if (Ipos.x > tempMaxPos || tempMaxPos == -1)
                    {
                        tempMaxPos = Ipos.x;
                        maxPos = posX;
                        maxPosIndex = i;
                        maxItem = itemTrans;
                    }
                }
                else
                {
                    Vector3 Ipos = PosArr[i];
                    float val = (Ipos.y + transform.localPosition.y) / 750f;


                    float factor = Mathf.Abs(val);


                    float xCurve = (factor + factor * curveValue) * (factor * curveValue * offsetValue); //曲线
                    alpha = 1 - factor * alphaValue;


                    float scale = 1 - factor * scaleValue;
                    if (scale < 0.1f)
                    {
                        scale = 0.1f;
                    }
                    if (scale > 0.98f)
                    {
                        scale = 1;
                    }


                    float v = GetValueY(val < 0 ? true : false, scale, Ipos.y);


                    if (v < 0.1f) v = 0;


                    float posY = val < 0 ? Ipos.y + v : Ipos.y - v;


                    Vector3 p = Vector3.one * scale;
                    if (Mathf.Abs(p.x - itemTrans.localScale.x) > interval)
                    {
                        itemTrans.localScale = p;
                    }


                    if (isUsedRote)
                    {
                        itemTrans.transform.rotation = Quaternion.Euler(0, val < 0 ? (90.0f * (1.0f - scale)) : -(90.0f * (1.0f - scale)), 0);
                    }


                    if (Mathf.Abs(itemTrans.localPosition.y - posY) > interval)
                    {
                        itemTrans.localPosition = new Vector2(xCurve, posY);
                    }


                    if (Ipos.y < tempMinPos || tempMinPos == -1)
                    {
                        tempMinPos = Ipos.y;
                        minPos = posY;
                        minPosIndex = i;
                        minItem = itemTrans;
                    }
                    if (Ipos.y > tempMaxPos || tempMaxPos == -1)
                    {
                        tempMaxPos = Ipos.y;
                        maxPos = posY;
                        maxPosIndex = i;
                        maxItem = itemTrans;
                    }


                }


                if (alphaValue > 0)
                {
                    itemTrans.GetComponent<AnimatedAlpha>().alpha = alpha;
                }
            }  
        }


        //首尾相连 相关参数
        private int minPosIndex;
        private int maxPosIndex;
        private float minPos = 0;
        private float maxPos = 0;


        //首尾相连
        void LoopItem()
        {
            if (!isCanLoop) return;


            if (movement == UIScrollView.Movement.Horizontal)
            {
                float panelPosX = transform.localPosition.x;
                if(isBigDirection)
                {
                    if (Mathf.Abs(maxPos + panelPosX) > panelWidth / 2)
                    {
                        float posX = PosArr[minPosIndex].x - itemWidth;
                        PosArr[maxPosIndex] = new Vector2(posX, PosArr[maxPosIndex].y);
                    }
                }
                else
                {
                    if (Mathf.Abs(minPos + panelPosX) > panelWidth / 2)
                    {
                        float posX = PosArr[maxPosIndex].x + itemWidth;
                        PosArr[minPosIndex] = new Vector2(posX, PosArr[minPosIndex].y);
                    }
                }
            }
            else
            {
                float panelPosY = transform.localPosition.y;


                if(isBigDirection)
                {
                    if (Mathf.Abs(maxPos + panelPosY) > panelHeight / 2)
                    {
                        float posY = PosArr[minPosIndex].y - itemHeight;
                        PosArr[maxPosIndex] = new Vector2(PosArr[maxPosIndex].x, posY);
                    }
                }
                else
                {
                    if (Mathf.Abs(minPos + panelPosY) > panelHeight / 2)
                    {
                        float posY = PosArr[maxPosIndex].y + itemHeight;
                        PosArr[minPosIndex] = new Vector2(PosArr[minPosIndex].x, posY);
                    }
                }
            }
        }


        //物体 lerp 移动到中间位置
        void MoveToCenter()
        {
            if (lastOnClickItem != null)
            {
                float posX = this.transform.localPosition.x;
                float posY = this.transform.localPosition.y;


                float value = 0;


                float panelOffsetX = panelOffset.x;
                float panelOffsetY = panelOffset.y;


                if (movement == UIScrollView.Movement.Horizontal)
                {
                    value = lastOnClickItem.transform.localPosition.x + posX;
                    posX -= value;
                }
                else
                {
                    value = lastOnClickItem.transform.localPosition.y + posY;
                    posY -= value;
                }


                if (Mathf.Abs(value) > 0.2f)
                {
                    LoopItem();//首尾相连


                    Vector2 pos = Vector2.Lerp(transform.localPosition, new Vector2(posX, posY), Time.deltaTime * 5);
                    transform.localPosition = pos;


                    if (movement == UIScrollView.Movement.Horizontal)
                        panelOffsetX = -transform.localPosition.x;
                    else
                        panelOffsetY = -transform.localPosition.y;


                    this.GetComponent<UIPanel>().clipOffset = new Vector2(panelOffsetX, panelOffsetY);


                }
            }
        }


        //中间放大的物体 回调
        void OnCenterClick(GameObject centerObj)
        {
            if (centerObj == null || (lastOnClickItem != null && lastOnClickItem == centerObj))
                return;


            //上一个选中物体回调
            if (lastOnClickItem != null && ItemsDict.ContainsKey(lastOnClickItem) && OnLastCenterCallBack != null)
            {
                OnLastCenterCallBack(lastOnClickItem, ItemsDict[lastOnClickItem]);
            }


            lastOnClickItem = centerObj;


            if (ItemsDict.ContainsKey(centerObj) && OnCenterCallBack != null)
            {
                OnCenterCallBack(centerObj, ItemsDict[centerObj]);
            }


            isDrag = false;
        }


        //返回当前物体坐标 需要增加或减的值
        float GetValueX(bool isLeft, float curScale, float posX)
        {
            float reValue = 0;
            for (int i = 0; i < itemCount; i++)
            {
                Vector3 Ipos = PosArr[i];
                float val = (Ipos.x + transform.localPosition.x) / 1335f;


                if (isLeft)
                {
                    if (val >= 0 || Ipos.x <= posX)
                    {
                        continue;
                    }
                }
                else
                {
                    if (val <= 0 || Ipos.x >= posX)
                    {
                        continue;
                    }
                }


                float factor = Mathf.Abs(val);


                float scale = 1 - factor * scaleValue;
                if (scale < 0.1f)
                {
                    scale = 0.1f;
                }
                if (scale > 0.98f)
                {
                    scale = 1;
                }


                if (scale >= curScale && scale != 1)
                {
                    reValue += (1 - scale) * itemWidth;
                }
            }
            reValue += (1 - curScale) / 2 * itemWidth;
            return reValue;
        }


        //返回当前物体坐标 需要增加或减的值
        float GetValueY(bool isDown, float curScale, float posY)
        {
            float reValue = 0;
            for (int i = 0; i < itemCount; i++)
            {
                Vector3 Ipos = PosArr[i];
                float val = (Ipos.y + transform.localPosition.y) / 750f;


                if (isDown)
                {
                    if (val >= 0 || Ipos.y <= posY)
                    {
                        continue;
                    }
                }
                else
                {
                    if (val <= 0 || Ipos.y >= posY)
                    {
                        continue;
                    }
                }


                float factor = Mathf.Abs(val);


                float scale = 1 - factor * scaleValue;
                if (scale < 0.1f)
                {
                    scale = 0.1f;
                }
                if (scale > 0.98f)
                {
                    scale = 1;
                }


                if (scale >= curScale && scale != 1)
                {
                    reValue += (1 - scale) * itemHeight;
                }
            }
            reValue += (1 - curScale) / 2 * itemHeight;
            return reValue;
        }
    }


    /* 暂时无用
    //获取离中间位置最近的物体
    private Transform GetCenterMinPosX()
    {
        Transform item = ItemsArr[0];
        float min = Mathf.Abs(ItemsArr[0].localPosition.x + transform.localPosition.x);
        for (int i = 0; i < itemCount; i++)
        {
            Vector3 Ipos = ItemsArr[i].localPosition;
            float factor = Mathf.Abs(Ipos.x + transform.localPosition.x);
            if (factor < min)
            {
                min = factor;
                item = ItemsArr[i];
            }
        }
        return item;
    }


    private Transform GetCenterMinPosY()
    {
        Transform item = ItemsArr[0];
        float min = Mathf.Abs(ItemsArr[0].localPosition.y + transform.localPosition.y);
        for (int i = 0; i < itemCount; i++)
        {
            Vector3 Ipos = ItemsArr[i].localPosition;
            float factor = Mathf.Abs(Ipos.y + transform.localPosition.y);
            if (factor < min)
            {
                min = factor;
                item = ItemsArr[i];
            }
        }
        return item;
    }
    */
}

 

 

 

 

 

龙笑~
关注
  • 6
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
Unity3D UGUI实现缩放循环拖动卡牌展示效果
08-26
主要为大家详细介绍了Unity3D UGUI实现缩放循环拖动展示卡牌效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Unity3d UGUI缩放循环拖动展示卡牌效果
没钱装电脑的程序猿
05-16 3762
需求:游戏中展示卡牌这种效果也是蛮酷炫并且使用的一种常见效果，下面我们就来实现以下这个效果是如何实现。 思考:第一看看到这个效果，我们首先会想到UGUI里面的ScrollRect，当然也可以用ScrollRect来实现缩短ContentSize的width来自动实现重叠效果，然后中间左右的卡牌通过计算来显示缩放，这里我并没有用这种思路来实现，我提供另外一种思路，就是自己去计算当前每个卡牌的
Unity 如何实现卡片循环滚动效果
当代野生程序猿
12-08 7033
如何在Unity中实现卡片循环滚动的效果。
Unity跨平台UI解决方案：可能是最全的FairyGUI系列教程
最新发布
2301_82243816的博客
05-11 640
希望大家能有一个好心态，想进什么样的公司要想清楚，并不一定是大公司，我选的也不是特大厂。当然如果你不知道选或是没有规划，那就选大公司！希望我们能先选好想去的公司再投或内推，而不是有一个公司要我我就去！还有就是不要害怕，也不要有压力，平常心对待就行，但准备要充足。最后希望大家都能拿到一份满意的 offer！如果目前有一份工作也请好好珍惜好好努力，找工作其实挺累挺辛苦的。这里附上上述的面试题相关的几十套字节跳动，京东，小米，腾讯、头条、阿里、美团等公司19年的面试题。
android 搜索栏滑动跟随缩放和移动，缩放变形问题
u013140516的博客
12-14 3401
  这两天新版界面改版，有个页面要求搜索栏跟随滑动会位移和缩放， 心想这还不简单么，具体如下是实现好的效果：    心想这还不简单么，第一想法是用 recyclerView.addOnScrollListener 计算好Y轴移动的距离和x缩放值再根据这些算出X轴偏移位置不就ok了么。 想法总是美好的，现实总是残酷的，view自带的setScale 缩放后导致搜索栏里的文字和图片同时放大...
React-Native 实现列表顶部随滑动渐变效果
JJochen的博客
01-12 1925
React-Native列表顶部随滑动渐变效果概要顶部view区域颜色随滑动渐变顶部图片透明度随滑动渐变滑动监听源码 概要 本篇文章的内容在于通过React-Native实现一个列表顶部随滑动渐变的效果。 一开始使用state来保存顶部需要变动样式的值，后来发现由于RN对state状态改变时的处理机制，导致页面呈现的效果不具实时性且不太流畅，所以改进使用了RN自己提供的Animated动画和ScrollView滑动组件。 Animated 动画 点此进入学习 ScrollView 滑动组件 点此进入学
Unity Scroll View 滑动边界透明度渐变效果
bingo105的博客
10-14 2149
最近有个需求，就是要求内容在滑动的时候边界Item透明度要有渐变效果，效果如下 有好的新鲜玩意不妨分享出来，方便自己（备忘）也方便他人！！！ #首先搭建个简单UI 各主要组件属性： 注意相机模式 好了，这样UI方便的准备工作就完成了，接着创建一个入口（挂载）脚本：TestGradientChange 下面展示一些 内联代码片。 using System.Collections; using System.Collections.Generic; using UnityEngine; using
unity Scroll 滑动 缩放
08-14
unity的UGUI组件 Scroll中可以拖动Connent中的物体 但是无法缩放。次项目很好解决此问题
NGUI的Widget固定UI位置不会跑偏
github_38633141的博客
06-20 795
Pivot 属于这个UI的中轴点，默认UI的中心点是它的localPosition所在，如下图这个label 当切换pivot到左上时，它的坐标也会发生变化，当拖动这个控件的时候，就会根据中轴而改变坐标，如图pivot改为左上，它的坐标也就发生变化了 Depth是用来控制显示顺序的，当两个UI控件在同一个Panel上，那么depth高的就会显示在高层，depth低的就会显示在底层，如图
Unity游戏开始界面渐变
T_h_e_shy____的博客
02-23 115
Unity游戏开始界面渐变
Unity NGUI 滑动列表渐变缩放，偏移，渐变 Demo
01-03
Unity NGUI 滑动列表渐变缩放，偏移，渐变 Demo 博客地址：https://blog.csdn.net/qq_30259857/article/details/79562652
UnityUGUI实现ScrollView 滑动居中的放大、其他的缩小，简单实现方法
01-21
UnityUGUI实现ScrollView 滑动居中的放大、其他的缩小，简单实现方法 配套资源文章：https://blog.csdn.net/lq1340817945/article/details/121001075
Unity3D实现渐变颜色效果
08-26
Unity3D实现渐变颜色效果 Unity3D 渐变颜色效果是指在 Unity3D 游戏引擎中实现颜色的渐变效果。这种效果可以应用于游戏中的各种场景，例如按钮、面板、文字等元素。下面是实现 Unity3D 渐变颜色效果的详细介绍。 ...
Unity实现UI渐变效果
01-20
本文实例为大家分享了Unity实现UI渐变效果的具体代码，供大家参考，具体内容如下 在做背包系统时，在提示面板中想实现的更加炫酷点，决定使用渐变效果来提示档次 渐变效果实现采用改变该UI的透明度来控制其显示和...
UnityShader 实现3D模型颜色渐变效果
05-11
本教程将探讨如何利用Unity Shader实现3D模型的颜色渐变效果。颜色渐变是一种常见的视觉表现手法，它可以让模型看起来更加生动和有层次感。 首先，我们需要理解Unity中的Standard Shader，这是Unity默认提供的一个...
使用UGUI实现NGUI的Flip翻转效果
素颜悠悠的博客
01-30 743
新的项目从NGUI换到了UGUI，在实现策划需求的时候遇到了一个问题：有一张图片在某些时候需要以垂直翻转的效果来呈现。下意识的，我就去找Image上的Flip按钮：。纳尼？UGUI的Image上没有flip选项。 这时候最简单的方法其实可以直接修改location的X或者Y为-1，来实现水平或者垂直翻转的效果。但是这种情况并不适用于所有的情况，譬如：这个图片上有animation动画，修改了图片的scale，难道还需要不同翻转效果时，animation也要动态的更改吗？所以最普适的做法应该是更改image
Unity——Scroll View 滑动居中、居中的放大、其他的缩小（支持横竖Scroll View）
SiReSo
04-23 6332
一、效果 二、上代码，两种方式。 (第一种是在Update中用插值完成的，如果不想再项目中看到Update，下面的另一种改了一段用DoTween实现的，需要导入一下DoTween) using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using Unit...
UnityShader_UI从上往下从左往右渐变出现
StephenCurryLiu的博客
10-21 850
这是在学习UnityShader已经有几个月了，从刚开始开shder代码像看天书一样的小白，到现在略懂一二的入坑新人，一路走来体会到了shader神奇的力量。这次是我首次针对项目需求实现的shader，实现UI从上往下渐变，心里还是有点小小窃喜 哈哈哈哈。
UIScrollView 两边渐变效果
weixin_34291004的博客
12-19 384
在继承自UIScrollView的类的layoutSubViews中设置- (void)layoutSubviews {[super layoutSubviews];NSObject *transparent = (NSObject*) [[UIColor colorWithWhite:0 alpha:0] CGColor];...
unity3d循环滑动_Unity实现3D循环滚动效果
06-03
要在Unity中实现3D循环滚动效果，可以按照以下步骤进行操作： 1.将需要循环滚动的对象放置在一个空的游戏对象中，使其成为该对象的子对象。 2.对该空对象添加一个脚本，该脚本将控制游戏对象的滚动效果。 3.在脚本中，使用Translate函数控制游戏对象的移动。 4.当游戏对象超出了指定的范围时，将其移回到起始位置。 5.在Update函数中，不断地调用该脚本以实现循环滚动效果。 以下是一份示例代码，可以帮助你更好地理解： ``` public class LoopScroll : MonoBehaviour { public Transform scrollObject; public float scrollSpeed; public float scrollRange; private float startPosition; void Start() { startPosition = scrollObject.position.x; } void Update() { float newPosition = Mathf.Repeat(Time.time * scrollSpeed, scrollRange); scrollObject.position = new Vector3(startPosition + newPosition, scrollObject.position.y, scrollObject.position.z); } } ``` 在这个示例中，脚本控制了一个名为 "scrollObject" 的游戏对象沿着X轴移动。 "scrollSpeed" 和 "scrollRange" 变量用于控制滚动速度和范围。 "startPosition" 变量用于保存游戏对象的起始位置。在Update函数中，使用Mathf.Repeat函数实现了循环滚动效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

龙笑~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值