Unity小功能——UGUI拖动到指定区域

于 2024-09-10 21:31:49 发布
阅读量1.2k 收藏 17
点赞数 24
分类专栏： Unity小功能 文章标签： unity android 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48855093/article/details/142060149
版权

Unity小功能——UGUI拖动到指定区域请添加图片描述

功能包含：
一，限定拖动区域，
1，无限制
2，屏幕内
3，父物体内
二，拖动位置
1，鼠标到指定位置
2，拖动的物品到指定区域
三，吸附物品释放等功能
四，具体功能需要自行扩展
在以下内容中添加功能
public UnityEvent onDragEntry; //进入
public UnityEvent onDragExit; //离开
public UnityEvent onDragNotExit; //未离开

脚本

DragHandle.cs

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

namespace MinorFunction
{
    public enum DragHandleMode
    {
        Free, // 自由拖拽
        WithinScreen, // 在屏幕内拖拽
        WithinParent, // 在父对象内拖拽
    }

    [RequireComponent(typeof(CanvasGroup))]
    public class DragHandle : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
    {
        public DragHandleMode dragMode = DragHandleMode.Free;
       
        // 是否偏移
        public bool isOffset = true;
        // 是否位置重叠判定
        public bool isOverlap = true;
        // 拖动置顶层级
        public bool isDragTop = false;


        // 偏移向量
        private Vector2 offset = Vector2.zero;





        public UnityEvent onBeginDrag;// 开始拖动 
        public UnityEvent onDrag;// 拖动  
        public UnityEvent onEndDrag; // 拖动结束

        [HideInInspector]
        public SlotHandle currentSlotHandle;

        public SlotHandle[] slotHandles;

        public void OnBeginDrag(PointerEventData eventData)
        {
            slotHandles = Object.FindObjectsOfType<SlotHandle>();

            offset = eventData.position - (Vector2)transform.position;
            gameObject.GetComponent<CanvasGroup>().blocksRaycasts = false;
            if (isDragTop)
            {
                transform.SetAsLastSibling();
            }

            onBeginDrag?.Invoke();
        }

        public void OnDrag(PointerEventData eventData)
        {
            switch (dragMode)
            {
                case DragHandleMode.Free:
                    SetFreeDrag(eventData);
                    break;
                case DragHandleMode.WithinScreen:
                    SetDragWithinScreen(eventData);
                    break;
                case DragHandleMode.WithinParent:
                    SetDragWithinParent(eventData);
                    break;

            }

            onDrag?.Invoke();
        }

        public void OnEndDrag(PointerEventData eventData)
        {
            gameObject.GetComponent<CanvasGroup>().blocksRaycasts = true;
            if (isOverlap)
            {

                bool overlap = false;
                int overlapIndex = 0;
                for (int i = 0; i < slotHandles.Length; i++)
                {
                    if (IsRectanglesOverlapping(GetComponent<RectTransform>(), slotHandles[i].GetComponent<RectTransform>()))
                    {
                        overlap = true;
                        overlapIndex = i;
                        break;
                    }
                }
                if (overlap)
                {
                    //Debug.Log($"{gameObject.name}  有重叠  {slotHandles[overlapIndex].gameObject.name}");

                    slotHandles[overlapIndex].ModifyDrag(this);
                }
                else
                {
                    if (currentSlotHandle)
                    {
                        RemoveSlotHandle();
                        currentSlotHandle = null;
                    }

                    //Debug.Log("无任何重叠");
                }
            }
            else
            {
                if (currentSlotHandle)
                {
                    if (!currentSlotHandle.isEnter)
                    {
                        RemoveSlotHandle();
                        currentSlotHandle = null;
                    }
                }
            }
           


            onEndDrag?.Invoke();

        }

        /// <summary>
        /// 移除SlotHandle
        /// </summary>
        public void RemoveSlotHandle()
        {
            currentSlotHandle.onDragExit?.Invoke(this);
            currentSlotHandle.currentDragHandles.Remove(this);
            currentSlotHandle = null;
        }

        #region  拖动模式
        // 自由拖动
        public void SetFreeDrag(PointerEventData eventData)
        {
            if (isOffset)
            {
                transform.position = eventData.position - offset;
            }
            else
            {
                transform.position = eventData.position;
            }
        }
        // 设置屏幕内拖动
        public void SetDragWithinScreen(PointerEventData eventData)
        {
            RectTransform rectTransform = transform as RectTransform;
            Vector2 pos = Vector2.zero;
            if (isOffset)
            {
                pos = eventData.position - offset;
            }
            else
            {
                pos = eventData.position;
            }


            // 屏幕范围
            float parentMinX = 0;
            float parentMinY = 0;
            float parentMaxX = Screen.width;
            float parentMaxY = Screen.height;

            var pivotDistance = GetPivotDistance(rectTransform);

            float pivotMinX = pivotDistance.pivotMinX;
            float pivotMinY = pivotDistance.pivotMinY;
            float pivotMaxX = pivotDistance.pivotMaxX;
            float pivotMaxY = pivotDistance.pivotMaxY;



            // 限制范围
            float minX = parentMinX + pivotMinX;
            float minY = parentMinY + pivotMinY;
            float maxX = parentMaxX - pivotMaxX;
            float maxY = parentMaxY - pivotMaxY;


            // 限制拖动范围
            pos.x = Mathf.Clamp(pos.x, minX, maxX);
            pos.y = Mathf.Clamp(pos.y, minY, maxY);


            transform.position = pos;
        }
        // 限制矩形内拖动
        public void SetDragWithinParent(PointerEventData eventData)
        {
            RectTransform rectTransform = transform as RectTransform;
            RectTransform parentRectTransform = transform.parent as RectTransform;
            Vector2 pos = Vector2.zero;
            if (isOffset)
            {
                pos = eventData.position - offset;
            }
            else
            {
                pos = eventData.position;
            }




            var parentMinMax = GetMinMax(parentRectTransform);

            float parentMinX = parentMinMax.minX;
            float parentMinY = parentMinMax.minY;
            float parentMaxX = parentMinMax.maxX;
            float parentMaxY = parentMinMax.maxY;

            var pivotDistance = GetPivotDistance(rectTransform);

            float pivotMinX = pivotDistance.pivotMinX;
            float pivotMinY = pivotDistance.pivotMinY;
            float pivotMaxX = pivotDistance.pivotMaxX;
            float pivotMaxY = pivotDistance.pivotMaxY;

            // 限制范围
            float minX = parentMinX + pivotMinX;
            float minY = parentMinY + pivotMinY;
            float maxX = parentMaxX - pivotMaxX;
            float maxY = parentMaxY - pivotMaxY;


            // 限制拖动范围
            pos.x = Mathf.Clamp(pos.x, minX, maxX);
            pos.y = Mathf.Clamp(pos.y, minY, maxY);


            transform.position = pos;
        }

        #endregion

        #region 功能
        // 计算物体中心点到四条边的距离
        public (float pivotMinX, float pivotMinY, float pivotMaxX, float pivotMaxY) GetPivotDistance(RectTransform rectTransform)
        {
            float width = rectTransform.rect.width;
            float height = rectTransform.rect.height;

            // 注：这里一定要使用全局坐标，不然计算会受到父物体缩放的影响
            float scaleX = rectTransform.lossyScale.x;
            float scaleY = rectTransform.lossyScale.y;

            Vector2 pivot = rectTransform.pivot;
            float pivotMinX = width * pivot.x * scaleX;
            float pivotMinY = height * pivot.y * scaleY;
            float pivotMaxX = width * (1 - pivot.x) * scaleX;
            float pivotMaxY = height * (1 - pivot.y) * scaleY;
            return (pivotMinX, pivotMinY, pivotMaxX, pivotMaxY);
        }

        // 计算物体X，Y最大值最小值
        public (float minX, float minY, float maxX, float maxY) GetMinMax(RectTransform rectTransform)
        {

            float parentX = rectTransform.position.x;
            float parentY = rectTransform.position.y;

            var pivotDistance = GetPivotDistance(rectTransform);

            float pivotMinX = pivotDistance.pivotMinX;
            float pivotMinY = pivotDistance.pivotMinY;
            float pivotMaxX = pivotDistance.pivotMaxX;
            float pivotMaxY = pivotDistance.pivotMaxY;

            float minX = parentX - pivotMinX;
            float minY = parentY - pivotMinY;
            float maxX = parentX + pivotMaxX;
            float maxY = parentY + pivotMaxY;

            return (minX, minY, maxX, maxY);
        }

        public bool IsRectanglesOverlapping(RectTransform rect1, RectTransform rect2)
        {
            Vector2 rect1Min = rect1.anchoredPosition - (rect1.sizeDelta * rect1.pivot)*rect1.lossyScale;
            Vector2 rect1Max = rect1.anchoredPosition + (rect1.sizeDelta * (Vector2.one-rect1.pivot)) * rect1.lossyScale;

            Vector2 rect2Min = rect2.anchoredPosition - (rect2.sizeDelta * rect2.pivot) * rect2.lossyScale;
            Vector2 rect2Max = rect2.anchoredPosition + (rect2.sizeDelta * (Vector2.one - rect2.pivot)) * rect2.lossyScale;

            // 判断矩形 1 的最右边小于矩形 2 的最左边，或者矩形 2 的最右边小于矩形 1 的最左边，说明没有水平方向重叠
            if (rect1Max.x < rect2Min.x || rect2Max.x < rect1Min.x || rect1Max.y < rect2Min.y || rect2Max.y < rect1Min.y)
            {
                return false;
            }
            return true;
        }
        #endregion 
    }
}

SlotHandle.cs

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

namespace MinorFunction
{

    public class SlotHandle : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler, IDropHandler
    {
        [HideInInspector]
        public bool isEnter = false;

        [Tooltip("multipleNumber == 0 不做任何限制可以附加无限多个，multipleNumber > 0 任何限制只能附加 multipleNumber个，multipleNumber = -1 不允许附加")]
        public int multipleNumber = 0;


        private DragHandle temporaryDragHandle;
        public List<DragHandle> currentDragHandles = new List<DragHandle>();

        public UnityEvent<DragHandle> onDragEntry; //进入
        public UnityEvent<DragHandle> onDragExit;  //离开
        public UnityEvent<DragHandle> onDragNotExit;  //未离开

        public UnityEvent onPointerEnter;    //鼠标进入
        public UnityEvent onPointerExit;     //鼠标离开

        private void Awake()
        {
            SetMultipleNumber(multipleNumber);
        }

        public void OnPointerEnter(PointerEventData eventData)
        {
            isEnter = true;
            onPointerEnter?.Invoke();
        }

        public void OnPointerExit(PointerEventData eventData)
        {
            isEnter = false;
            onPointerExit?.Invoke();
        }

        public void OnDrop(PointerEventData eventData)
        {
           
            if (eventData.pointerDrag != null)
            {
                temporaryDragHandle = eventData.pointerDrag.GetComponent<DragHandle>();
                if (temporaryDragHandle.isOverlap)
                {
                    return;
                }
                ModifyDrag(temporaryDragHandle);
            }
        }

        public void ModifyDrag(DragHandle dragHandle)
        {
            temporaryDragHandle = dragHandle;
            if (!currentDragHandles.Contains(temporaryDragHandle))
            {
                if (multipleNumber == 0)  //不做任何限制
                {
                    RemoveDragHandle();
                    ShiftInDragHandle();
                }
                else if (multipleNumber > 0)
                {
                    if (currentDragHandles.Count < multipleNumber)
                    {
                        RemoveDragHandle();
                        ShiftInDragHandle();
                    }
                }
                else if (multipleNumber < 0)
                {
                    return;
                }
            }
            else
            {
                onDragNotExit?.Invoke(temporaryDragHandle);
            }
        } 

        public void RemoveDragHandle()
        {
            if (temporaryDragHandle.currentSlotHandle)
            {
                temporaryDragHandle.RemoveSlotHandle();
            }
        }

        public void ShiftInDragHandle()
        {
            temporaryDragHandle.currentSlotHandle = this;
            currentDragHandles.Add(temporaryDragHandle);

            onDragEntry?.Invoke(temporaryDragHandle);
        }

        /// <summary>
        /// 设置多选数量
        /// </summary>
        /// <param name="number">number == 0 不做任何限制可以附加无限多个，number > 0 任何限制只能附加 number 个，number = -1 不允许附加</param>
        public void SetMultipleNumber(int number)
        {
            if (number < 0)
            {
                multipleNumber = -1;
                RemoveAllDragHandles();
            }
            else
            {
                multipleNumber = number;
                if (number < currentDragHandles.Count)
                {
                    for (int i = multipleNumber - 1; i < currentDragHandles.Count; i++)
                    {
                        temporaryDragHandle = currentDragHandles[i];

                        RemoveDragHandle();
                    }
                }
            }
        }

        /// <summary>
        /// 移除全部DragHandle
        /// </summary>
        public void RemoveAllDragHandles()
        {
            for (int i = 0; i < currentDragHandles.Count; i++)
            {
                temporaryDragHandle = currentDragHandles[i];

                RemoveDragHandle();
            }
        }
        /// <summary>
        /// 移除指定DragHandle
        /// </summary>
        /// <param name="index"></param>
        public void RemoveIndexDragHandles(int index)
        {
            temporaryDragHandle = currentDragHandles[index];
            RemoveDragHandle();
        }
        /// <summary>
        /// 移除指定DragHandle
        /// </summary>
        /// <param name="dragHandle"></param>
        public void RemoveIndexDragHandles(DragHandle dragHandle)
        {
            temporaryDragHandle = dragHandle;
            RemoveDragHandle();
        }


    }
}

功能扩展案例

SlotHandleFunctionExpansion.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace MinorFunction
{
    public class SlotHandleFunctionExpansion : MonoBehaviour
    {
        public SlotHandle slotHandle;


        void Start()
        {
            slotHandle = GetComponent<SlotHandle>();
            AdsorptionFunction();
        }

        /// <summary>
        /// 吸附功能
        /// </summary>
        public void AdsorptionFunction()
        {
            slotHandle.onDragEntry.AddListener(call => {
                call.gameObject.transform.position = gameObject.transform.position;
                Debug.Log($"{call.gameObject.name}进入了{gameObject.name}");
            });
            slotHandle.onDragExit.AddListener(call => {
                Debug.Log($"{call.gameObject.name}离开了{gameObject.name}");
            });
            slotHandle.onDragNotExit.AddListener(call => {
                call.gameObject.transform.position = gameObject.transform.position;
                Debug.Log($"{call.gameObject.name}未离开{gameObject.name}");
            });

        }

    }

}
帅豆豆
关注
专栏目录
Unity Canvas下鼠标拖拽UI
qq_35526525的博客
05-08 712
UI拖拽相关设置
unity 拖拽ui
weixin_41071087的博客
03-24 521
using System.Collections;using System.Collections.Generic;using UnityEngine;using UnityEngine.Events;using UnityEngine.EventSystems;public class StartDrage : MonoBehaviour, IPointerEnterHandler, IPoin...
Unity日记-移动UI
qq_43921510的博客
06-17 1378
Unity日记-移动UI 1.在需要给需要移动的UI添加一个Empty GameObject的父物体。 2.通过RectTransform找到Empty GameObject。 3.用Empty.anchredPosition来控制UI坐标。 4.以上为瞬间移动若是需要展现出移动过程可以用以下类似代码 public RectTransform mainmenu;//需要将父物体拖到这里 for (float i = 0; i < 100; i++) //i代表需要移动的次数 {
【Unity】实现拖拽3D物体并吸附到某个位置
walalilongla！
08-21 1056
实现在场景内拖拽某个物体，并在到达指定位置后松开鼠标就吸附到相应位置。
Unity常用的三种拖拽方法（内置方法 + 接口 + Event Trigger组件）
m0_63330263的博客
12-03 9126
目录内置方法OnMouseDrag【对象含有Collider组件】配对小游戏Event Trigger组件接口窗口小案例OnMOuseOver()检测鼠标是否进入到这个2D贴图经验：只会在2D场景贴图和3D场景中使用OnMouseDrag等内置方法 调整Sorting Layer渲染层顺序Event Trigger—>Add New Event Type根据不同的事件类型实现不同的交互效果 引用 using UnityEngine.EventSystems命名空间接口中方法没有方法体的，接口的成
unity中物体移动到指定位置的四种方法(精确移动、无距离计算、速度可变)
热门推荐
花言的博客
01-19 1万+
法一：使用Vector3.MoveTowards()方法 void Update(){ float step = Speed*Time.deltaTime(); gameObject.transform.localPosition = Vector3.MoveTowards(gameObject.transform.localPosition, new Vector3(0, 0, 60), step); } 法二：使用iTween iTween.MoveTo(m_UIbgCamera, i
Unity UGUI 拖拽组件
极客七
02-28 876
通过计算鼠标点 计算出 相对于图片原点的 偏移 并缓存} }
Unity_拖拽_UGUI
weixin_43970896的博客
08-25 173
//先是拖拽之后学完交换的再来个交换的 也可能不来了emm using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.EventSystems; public class TuoZhuaiYiDong : MonoBehaviour, IDragHandler, IBeginDragHandler, IEndDragHandler { public Vector3
Unity开箱即用的UGUI面板的拖拽移动功能
他在试图用代码书写这个世界，字里行间温柔尽显。勿忘初心，努力做有价值的技术文章。
07-01 782
做PC项目时常常有面板拖拽移动的需求，今天总结封装一下，做成一个随时随地可复用的拖拽面板功能。
Unity小功能——UGUI拖动功能
最新发布
m0_48855093的博客
09-08 694
脚本中一共包含五种模式：1，自由拖动，2，在屏幕内容拖动（image不会离开屏幕），3，在父物体内拖动（image不会离开父对象范围），4，在屏幕外拖动（地图功能使用，不会让地图离开屏幕），5，在父物体外拖动（这个也是地图功能使用）该脚本不受父物体以及自身的缩放、锚点位置、中心点位置影响。
unity教程，无需代码实现拖拽UI窗口
10-25
unity实现无代码拖拽UI窗口，包含视频教程和工程文件。
Unity UGUI实现简单拖拽图片功能
08-19
主要为大家详细介绍了Unity UGUI实现简单拖拽图片功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
物体缓慢移动到指定位置demo(unity3D C#)
01-08
//控制物体左右上下移动 //获取水平方向值 //获取垂直方向值 //通过Translate改变物体位置 //按上下左右即可实现简单的移动了！（注意不要忘了加刚体）
unity ugui拖拽限定范围
05-21
限制了ugui拖拽时的指定范围，确保拖拽物体时，不会超出屏幕范围。
Unity从UI拖物体到场景中以及鼠标拖动物体
08-30
当我们做一些农场游戏或者类似可编辑战场类游戏时经常会遇到从UI上拖动物体在3D场景里生成，要实现这种从UI上拖物体的效果其实挺简单，代码不复杂，主要是想法很重要，一个优秀的程序员不只是技术扎实，更重要的是要多思考，不思考的程序员只是一个码农。
Unity数字孪生开发笔记——UGUI控件篇
Lcl_huolitianji的博客
12-14 8210
Unity数字孪生开发笔记——GUI控件篇一、常见GUI控件二级目录三级目录 一、常见GUI控件 二级目录 三级目录
Unity+UGUI 圆形进度条
07-12
本教程将详细介绍如何使用Unity和UGUI来创建一个圆形进度条，并探讨其在进度指示和拖拽验证码功能上的应用。 一、UGUI基础知识 UGUI是Unity 4.6版本引入的新的UI系统，它基于Canvas进行布局，通过 RectTransform ...
Unity UGUI 官方示例 Demo
05-16
9. **Drag and Drop**：Unity UGUI支持物品拖放功能，你可以创建可拖动的UI元素，并实现拖放到特定区域的逻辑。 10. **Scroll View**：滚动视图组件允许你创建可滚动的内容区域，可以用于长列表或者页面滚动。 11....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值