Unity 游戏开发者必备，如何实现适用于Windows与移动平台双端的轮盘交互式提示菜单？轮盘菜单技术揭秘

已于 2024-03-19 15:50:22 修改
阅读量1.3k 收藏 29
点赞数 20
分类专栏： Unity 自制工具 Unity插件 文章标签： unity 游戏 windows ui 交互 android
于 2024-03-19 15:24:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CTangZe/article/details/136841686
版权

Unity 3D 从原理到实践：打造独特的游戏提示菜单系统

效果：

请添加图片描述

介绍

在当今游戏开发领域，用户体验已经成为吸引玩家并保持他们的关键因素之一。交互式提示菜单作为游戏界面设计的一部分，正日益受到开发者们的重视。本文将探索交互式提示菜单在游戏界面设计中的创新应用和重要性，以及如何通过它们提升游戏的用户体验。我们将深入了解交互式提示菜单的设计原理、技术实现和最佳实践，并探讨它们对游戏体验的影响。无论您是游戏开发者、界面设计师还是对游戏用户体验感兴趣的读者，本文都将为您揭示交互式提示菜单的奥秘，帮助您打造出色的游戏界面设计。

源码

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

public enum WheelStateType
{
    Expand,
    Hide,
    Single,
    Close
}

public class HintWheel : MonoBehaviour, IPointerDownHandler, IPointerUpHandler, IDragHandler
{
    [Header("外圈放大系数")]
    public float enlargementFactor = 2;
    [Header("内圈取消距离")]
    public float minWheelDistance = 50;
    [Header("选中节点放大系数")]
    public float selectWheelSize = 1.2f;
    [Header("节点信息距离中心偏移量")]
    [Range(1f, 3)]
    public float iconOffset = 2.5f;
    private float lerpValue = 0;

    private WheelStateType wheelStateType;

    private Vector3 wheelChangeSizeValue;
    private Vector3 wheelOriginSize;
    private Vector3 wheelMaxSize;
    private Vector3 iconOriginSize;
    private Vector2 inputDirection = Vector2.zero;

    private bool _isLerp = false;
    private bool _isChangeSize = false;
    private bool _isChangeSelectWheelSize = false;

    private List<WheelNode> _selectInfos = new List<WheelNode>();
    private List<WheelNode> _currentAllActivateNodes = new List<WheelNode>();

    private GraphicRaycaster _ray;
    private StandaloneInputModule _input;
    private CanvasGroup _wheelAlpha;
    private Transform _defaultHintInfo;
    private WheelNode _currentSelectNode;
    private Image _wheel, _bgWheel, _cursorIcon;

    private bool IsLerp
    {
        get => _isLerp;
        set
        {
            lerpValue = 0;
            _isLerp = value;
        }
    }

    private WheelNode CurrentSelectNode
    {
        get => _currentSelectNode;
        set
        {
            if (_currentSelectNode != value)
            {
                IsChangeSelectWheelSize = true;
                _currentSelectNode = value;
            }
        }
    }

    private bool IsChangeSize
    {
        get => _isChangeSize;
        set
        {
            _isChangeSize = value;
            IsLerp = value;
        }
    }

    private bool IsChangeSelectWheelSize
    {
        get => _isChangeSelectWheelSize;
        set
        {
            _isChangeSelectWheelSize = value;
            IsLerp = value;
        }
    }

    public WheelStateType WheelStateType
    {
        get => wheelStateType;
        set
        {
            wheelStateType = value;
            switch (wheelStateType)
            {
                case WheelStateType.Expand:
                    _defaultHintInfo.gameObject.SetActive(false);
                    CurrentSelectNode = null;
                    _cursorIcon.GetComponent<RectTransform>().anchoredPosition = Vector3.zero;
                    _cursorIcon.gameObject.SetActive(true);
                    break;
                case WheelStateType.Hide:
                    _defaultHintInfo.gameObject.SetActive(true);
                    CurrentSelectNode = null;
                    _cursorIcon.GetComponent<RectTransform>().anchoredPosition = Vector3.zero;
                    _cursorIcon.gameObject.SetActive(false);
                    break;
                case WheelStateType.Single:
                    _defaultHintInfo.gameObject.SetActive(false);
                    wheelChangeSizeValue = wheelOriginSize;
                    IsChangeSize = true;
                    CurrentSelectNode = _currentAllActivateNodes[0];
                    _currentAllActivateNodes[0].wheel.fillAmount = 0;
                    _currentAllActivateNodes[0].iconPoint.localPosition = Vector3.zero;
                    _currentAllActivateNodes[0].iconPoint.localScale = iconOriginSize;
                    _cursorIcon.GetComponent<RectTransform>().anchoredPosition = Vector3.zero;
                    _cursorIcon.gameObject.SetActive(false);
                    break;
                case WheelStateType.Close:
                    wheelChangeSizeValue = Vector3.zero;
                    IsChangeSize = true;
                    CurrentSelectNode = null;
                    _cursorIcon.GetComponent<RectTransform>().anchoredPosition = Vector3.zero;
                    _cursorIcon.gameObject.SetActive(false);
                    break;
                default:
                    break;
            }
        }
    }

    private void Start()
    {
        _ray = GetComponentInParent<GraphicRaycaster>();
        _input = FindObjectOfType<StandaloneInputModule>();
        _wheel = transform.Find("Wheel/WheelImage").GetComponent<Image>();
        _wheelAlpha = transform.Find("Wheel").GetComponent<CanvasGroup>();
        _bgWheel = transform.Find("BGImage").GetComponent<Image>();
        _cursorIcon = transform.Find("Cursor").GetComponent<Image>();
        _defaultHintInfo = transform.Find("SelectPointer/IconInfo");
        Initialize();
    }

    void Initialize()
    {
        wheelOriginSize = transform.localScale;
        wheelMaxSize = transform.localScale * enlargementFactor;
        iconOriginSize = _defaultHintInfo.localScale;
        _wheel.gameObject.SetActive(false);
        _cursorIcon.gameObject.SetActive(false);
        _defaultHintInfo.gameObject.SetActive(false);
        transform.localScale = Vector3.zero;
        WheelStateType = WheelStateType.Close;
#if UNITY_ANDROID
        _defaultHintInfo.GetComponentInChildren<Text>().text = "按住展开";
#elif UNITY_STANDALONE || UNITY_EDITOR
        defaultHintInfo.GetComponentInChildren<Text>().text = "按E展开";
#endif
    }

    private void LateUpdate()
    {
        if (IsLerp)
        {
            lerpValue += Time.deltaTime;
            if (lerpValue > 1) lerpValue = 1;

            if (IsChangeSize)
            {
                if (lerpValue == 1) IsChangeSize = false;
                transform.localScale = Vector3.Lerp(transform.localScale, wheelChangeSizeValue, lerpValue);

                Vector3 iconChangeSizeValue = Vector3.zero;
                switch (WheelStateType)
                {
                    case WheelStateType.Single:
                        iconChangeSizeValue = iconOriginSize;
                        break;
                    case WheelStateType.Expand:
                        iconChangeSizeValue = wheelChangeSizeValue * (1 / enlargementFactor) / enlargementFactor;
                        break;
                    case WheelStateType.Hide:
                        iconChangeSizeValue = Vector3.zero;
                        break;
                }

                foreach (var item in _currentAllActivateNodes)
                {
                    item.iconPoint.localScale = Vector3.Lerp(item.iconPoint.localScale, iconChangeSizeValue, lerpValue);
                }

                _bgWheel.transform.localScale = Vector3.Lerp(_bgWheel.transform.localScale,
                    WheelStateType == WheelStateType.Expand ?
                    wheelChangeSizeValue / 2 * (1 / enlargementFactor) / enlargementFactor : wheelChangeSizeValue, lerpValue);
                _wheelAlpha.alpha = Mathf.Lerp(_wheelAlpha.alpha, WheelStateType == WheelStateType.Expand ? 1 : 0, lerpValue);
            }

            if (IsChangeSelectWheelSize)
            {
                if (lerpValue == 1) IsChangeSelectWheelSize = false;
                if (WheelStateType == WheelStateType.Expand)
                {
                    foreach (var item in _currentAllActivateNodes)
                    {
                        if (item == CurrentSelectNode)
                        {
                            item.wheel.transform.localScale = Vector3.Lerp(item.wheel.transform.localScale,
                                wheelOriginSize * selectWheelSize, lerpValue);
                            item.iconPoint.localScale = Vector3.Lerp(item.iconPoint.localScale,
                                wheelChangeSizeValue * (1 / enlargementFactor) / enlargementFactor * selectWheelSize, lerpValue);
                        }
                        else
                        {
                            item.wheel.transform.localScale = Vector3.Lerp(item.wheel.transform.localScale, wheelOriginSize, lerpValue);
                            if (wheelChangeSizeValue == wheelMaxSize)
                                item.iconPoint.localScale = Vector3.Lerp(item.iconPoint.localScale,
                                    wheelChangeSizeValue * (1 / enlargementFactor) / enlargementFactor, lerpValue);
                        }
                    }
                }
            }
        }

        if (UnityEngine.Input.GetKeyDown(KeyCode.E))
        {
            switch (WheelStateType)
            {
                case WheelStateType.Hide:
                    ChangeWheelState(true);
                    break;
                case WheelStateType.Single:
                    CurrentSelectNode?.selectInfo.selectEvent?.Invoke();
                    break;
                default:
                    break;
            }
        }

        if (UnityEngine.Input.GetKeyUp(KeyCode.E))
        {
            if (WheelStateType == WheelStateType.Expand)
            {
                CurrentSelectNode?.selectInfo.selectEvent?.Invoke();
                ChangeWheelState(false);
            }
        }

        if (UnityEngine.Input.GetKey(KeyCode.E))
        {
            CheckSelectNode(UnityEngine.Input.mousePosition);
            AnalogCursorPoint(new Vector2(UnityEngine.Input.GetAxis("Mouse X"), UnityEngine.Input.GetAxis("Mouse Y")));
        }
    }

    public void OnPointerDown(PointerEventData eventData)
    {
        if (_ray == null || _input == null)
            return;
        switch (WheelStateType)
        {
            case WheelStateType.Hide:
                ChangeWheelState(true);
                break;
            case WheelStateType.Single:
                CurrentSelectNode?.selectInfo.selectEvent?.Invoke();
                break;
            default:
                break;
        }
    }

    public void OnPointerUp(PointerEventData eventData)
    {
        if (WheelStateType == WheelStateType.Expand)
        {
            CurrentSelectNode?.selectInfo.selectEvent?.Invoke();
            ChangeWheelState(false);
        }
    }

    public void OnDrag(PointerEventData eventData)
    {
        CheckSelectNode(eventData.position);
        AnalogCursorPoint(eventData);
    }

    private void ChangeWheelState(bool state)
    {
        if (_currentAllActivateNodes.Count > 1)
        {
            WheelStateType = state ? WheelStateType.Expand : WheelStateType.Hide;
            IsChangeSelectWheelSize = true;
            inputDirection = Vector2.zero;
            wheelChangeSizeValue = state ? wheelMaxSize : wheelOriginSize;
            _defaultHintInfo.gameObject.SetActive(!state);
            lerpValue = 0;
            IsChangeSize = true;
        }
    }

    private WheelNode CheckSelectNode(Vector2 checkPoint)
    {
        checkPoint = _cursorIcon.rectTransform.position;
        if (WheelStateType == WheelStateType.Expand)
        {
            float distance = Vector2.Distance(checkPoint, _bgWheel.rectTransform.position);
            if (distance < minWheelDistance)
            {
                CurrentSelectNode = null;
                return null;
            }
            else
            {
                WheelNode wheelNode = null;
                Vector2 localPos;
                RectTransformUtility.ScreenPointToLocalPointInRectangle(transform as RectTransform, checkPoint, _ray.eventCamera, out localPos);
                float angle = Mathf.Atan2(localPos.x, -localPos.y) * Mathf.Rad2Deg;
                angle = (angle < 0) ? angle + 360 : angle;
                float angleAreaValue = 360 / _currentAllActivateNodes.Count;
                float angleRange = 0;
                for (int i = 1; i <= _currentAllActivateNodes.Count; i++)
                {
                    if (angle > angleRange && angle < angleRange + angleAreaValue)
                    {
                        wheelNode = i == _currentAllActivateNodes.Count ? _currentAllActivateNodes[0] : _currentAllActivateNodes[i];
                        if (i == _currentAllActivateNodes.Count) break;
                    }
                    angleRange += angleAreaValue;
                }
                CurrentSelectNode = wheelNode;
                return wheelNode;
            }
        }
        else
        {
            return null;
        }
    }

    private void AnalogCursorPoint(PointerEventData ped)
    {
        if (WheelStateType == WheelStateType.Close) return;
        Vector2 position;
        RectTransformUtility.ScreenPointToLocalPointInRectangle(
            _wheel.rectTransform,
            ped.position,
            ped.pressEventCamera,
            out position);
        position = position + _wheel.rectTransform.sizeDelta / 2;
        position.x = (position.x / _wheel.rectTransform.sizeDelta.x);
        position.y = (position.y / _wheel.rectTransform.sizeDelta.y);

        float x = (_wheel.rectTransform.pivot.x == 1f) ? position.x * 2 + 1 : position.x * 2 - 1;
        float y = (_wheel.rectTransform.pivot.y == 1f) ? position.y * 2 + 1 : position.y * 2 - 1;

        inputDirection = new Vector2(x, y);
        inputDirection = (inputDirection.magnitude > 1) ? inputDirection.normalized : inputDirection;

        float newX = inputDirection.x * (_wheel.rectTransform.sizeDelta.x / 2);
        float newY = inputDirection.y * (_wheel.rectTransform.sizeDelta.y / 2);
        _cursorIcon.rectTransform.anchoredPosition = new Vector2(newX, newY);
    }

    private void AnalogCursorPoint(Vector2 mouseOffset)
    {
        if (WheelStateType == WheelStateType.Close) return;
        Vector2 newPosition = _cursorIcon.rectTransform.anchoredPosition + mouseOffset * 10;
        float distanceToCenter = newPosition.magnitude;
        if (distanceToCenter > _wheel.rectTransform.sizeDelta.x / 2)
        {
            newPosition = newPosition.normalized * _wheel.rectTransform.sizeDelta.x / 2;
        }
        _cursorIcon.rectTransform.anchoredPosition = newPosition;
    }

    public void ShowHintWheel(SelectInfo selectInfo)
    {
        WheelNode wheelNode = GetWheelNode(selectInfo);
        if (wheelNode == null)
        {
            wheelNode = AddWheelNode(selectInfo);
        }
        wheelNode.SetNodeState(true);
        UpdateAllActiveNodes();
        UpdateWheel();
    }

    public void HideHintWheel(SelectInfo selectInfo)
    {
        GetWheelNode(selectInfo).SetNodeState(false);
        UpdateAllActiveNodes();
        UpdateWheel();
    }

    private void UpdateWheel()
    {
        if (_currentAllActivateNodes.Count == 1)
        {
            WheelStateType = WheelStateType.Single;
        }
        else if (_currentAllActivateNodes.Count == 0)
        {
            WheelStateType = WheelStateType.Close;
        }
        else
            WheelStateType = WheelStateType == WheelStateType.Single ? WheelStateType.Hide : WheelStateType;
        float angle = 0;
        float iconDistance = _bgWheel.GetComponent<RectTransform>().sizeDelta.x / 2;
        iconDistance -= iconDistance / iconOffset;
        if (_currentAllActivateNodes.Count != 1)
        {
            foreach (var item in _currentAllActivateNodes)
            {
                item.wheel.transform.rotation = Quaternion.identity;
                item.wheel.transform.Rotate(0, 0, angle);

                Vector3 iconPosition = item.wheel.transform.localPosition +
                                       Quaternion.Euler(0, 0, angle - 180 - (360 / _currentAllActivateNodes.Count) / 2) * Vector3.up * iconDistance;
                item.iconPoint.localPosition = iconPosition;
                item.iconPoint.localScale = Vector3.zero;
                float value = (360f / _currentAllActivateNodes.Count) / 360f;
                item.wheel.fillAmount = value;
                angle += 360 / _currentAllActivateNodes.Count;
            }
        }
    }

    private void UpdateAllActiveNodes()
    {
        _currentAllActivateNodes.Clear();
        foreach (var item in _selectInfos)
        {
            if (item.GetNodeState())
            {
                _currentAllActivateNodes.Add(item);
            }
        }
    }

    private WheelNode GetWheelNode(SelectInfo selectInfo)
    {
        foreach (var item in _selectInfos)
        {
            if (item.selectInfo == selectInfo)
            {
                return item;
            }
        }
        return null;
    }

    private WheelNode AddWheelNode(SelectInfo selectInfo)
    {
        Image wheel = Instantiate(_wheel, _wheel.transform.parent);
        wheel.transform.SetAsFirstSibling();
        Transform iconInfo = Instantiate(_defaultHintInfo, _defaultHintInfo.parent);
        iconInfo.transform.SetAsFirstSibling();
        WheelNode wheelNode = new WheelNode(selectInfo, wheel, iconInfo, false);
        _selectInfos.Add(wheelNode);
        return wheelNode;
    }

    public class WheelNode
    {
        public SelectInfo selectInfo;
        public Transform iconPoint;
        public Image wheel;
        public Image icon;
        public Text info;
        private bool activate = false;

        public WheelNode(SelectInfo selectInfo, Image wheel, Transform iconInfo, bool activate)
        {
            this.selectInfo = selectInfo;
            this.wheel = wheel;
            this.activate = activate;
            iconPoint = iconInfo;
            icon = iconInfo.GetComponentInChildren<Image>(true);
            info = iconInfo.GetComponentInChildren<Text>(true);
            icon.sprite = selectInfo.sprite;
            info.text = selectInfo.content;
        }

        public void SetNodeState(bool state)
        {
            if (activate != state)
            {
                activate = state;
                wheel.gameObject.SetActive(state);
                iconPoint.gameObject.SetActive(state);
            }
        }

        public bool GetNodeState()
        {
            return activate;
        }
    }
}

public class SelectInfo
{
    public Sprite sprite;
    public string content;
    public string details;
    public Action selectEvent;
}

这段代码是一个用于实现提示菜单功能的脚本，主要用于在游戏中展示一个可拖拽的环形菜单，用于提供不同选项或功能的快捷访问。现在让我们逐步解释这个代码的各个部分以及它们的作用：

对外界开放的方法：

ShowHintWheel 和 HideHintWheel 方法
如需要在特定的时候展示一个按钮就调用ShowHintWheel传入参数SelectInfo类，同样关闭也是如此
SelectInfo 类：用于存储选项的相关信息，包括图标、内容、详情和自定义选择后执行的事件。

我们写一个例子来实现这个效果：

将此脚本挂载到场景中的一个物体上

using UnityEngine;
using UnityEngine.UI;

public class testSelect : MonoBehaviour
{
    public HintWheel hintWheel;
    public Sprite sprite;
    public string content = "";
    public Text text;
    public SelectInfo selectInfo = new SelectInfo();

    // Start is called before the first frame update
    void Start()
    {
        selectInfo.sprite = sprite;
        selectInfo.content = content;
        selectInfo.selectEvent = SelectFunc;
    }
    public void ChangeToggleState(bool state)
    {
        if (state)
        {
            hintWheel.ShowHintWheel(selectInfo);
        }
        else
        {
            hintWheel.HideHintWheel(selectInfo);
        }
    }
    public void SelectFunc()
    {
        if (text)
            text.text = content;
    }
}

我们使用Toggle来测试，当点击Toggle的时候便会出现按钮，按钮上显示的信息就是我们定义好的这两个字段

public Sprite sprite;
public string content = "";

在这里插入图片描述

当然，我们可以继续添加各种其他的功能，只要扩展SelectInfo类就可以了

接着我们解释一下HintWheel 的其他功能

HintWheel 类：实现了 IPointerDownHandler、IPointerUpHandler 和 IDragHandler 接口，用于处理指针事件（鼠标或触摸）。
字段和属性：
  • 包括外圈放大系数、内圈取消距离、选中节点放大系数等参数，用于控制菜单的大小和行为。
  • 一些私有字段用于跟踪菜单的状态、选中的节点等信息。

在Start方法中初始化一些变量和对象，包括获取场景中的 UI 元素，设置初始状态等。

LateUpdate 方法：在每帧更新时执行的逻辑，主要包括：
  • 处理菜单的展开、关闭、选中等逻辑。
  • 更新菜单的大小和状态。
  • 根据用户的输入更新菜单的位置和状态。
  • 检查选中的节点。

ChangeWheelState 方法：根据传入的状态展开或隐藏提示菜单，并更新菜单的状态和大小。

CheckSelectNode

此方法适应不同屏幕尺寸和分辨率： 使用了 RectTransformUtility.ScreenPointToLocalPointInRectangle 方法，可以将屏幕上的点转换为相对于 RectTransform 的本地坐标系中的点。这样可以确保在不同分辨率和屏幕尺寸下，提示菜单的交互功能仍然有效。使用了迭代方式处理多个节点的选择，使得可以轻松地添加、删除或修改提示菜单中的节点，从而实现不同需求下的菜单设计。代码使用了向量运算和角度计算等数学计算，以及简洁的迭代方式，保证了代码的执行效率和性能表现，能够在游戏中保持流畅的交互体验。

AnalogCursorPoint 方法

模拟光标在菜单上的移动，使用方法的重载处理Windows与移动平台双端的计算

UpdateWheel 和 UpdateAllActiveNodes 方法：更新菜单的显示状态和选项信息。

GetWheelNode 和 AddWheelNode 方法：根据选项信息获取或添加菜单节点。

WheelNode 类：表示提示菜单中的一个节点，包含选项信息、图标、文字等。

我们来看看UI是怎么做到像扇形一样只显示一部分的

首先我们创建一个Image
在这里插入图片描述
先在Image上添加图片，这是重点，不添加图片就不会有特定的属性
之后再调整Image的属性
在这里插入图片描述
那么调整FillAmount的值就可以了
请添加图片描述

Demo案例下载

唐沢
关注
专栏目录
【Unity造轮子】实现一个类csgo的武器轮盘功能
向宇
07-31 1438
欢迎来到这篇文章，今天我们将探讨如何使用Unity制作一个功能——武器轮盘。这个功能不仅可以为你的游戏增添新的元素，还可以用于在抽奖活动中增添趣味性。本文都将指导你如何创建一个类似于CS:GO的武器轮盘功能。在CS:GO等类似游戏中，武器轮盘是一种常见且备受喜爱的功能。它给予玩家机会从一个包含各种珍贵武器的轮盘中随机选择一个。这种机制不仅提供了一种刺激和可玩性，还帮助玩家获取稀有且强大的武器装备。我们的目标是在Unity中通过使用一些基本的编程和设计技巧，来创建一个简单而又有趣的武器轮盘功能。
【Unity 实用工具篇】| 游戏多语言解决方案，官方插件Localization 实现本地化及多种语言切换
努力前行，总会成为自己心中的那道光
12-12 5万+
Unity的多语言本地化是一个很实用的功能，它可以帮助游戏支持多种语言，让不同语言的玩家都能够更好地体验游戏。 而实现本地化的方案也有很多种，各个方案之间也各有优劣，后面也会对多个方案进行介绍学习。 本文就来介绍一个专门作用于多语言本地化的Unity官方插件：Localization 。
【Unity】实现轮盘抽奖
最新发布
希望有志同道合的的朋友可以互相学习！
05-28 626
"轮盘节点""轮盘旋转的圈数""轮盘旋转初速度""减速度""最低速度""轮盘剩余旋转多少时开始减速""轮盘中物体的数量""旋转停止的位置""精准角度"
Unity实现大转盘抽奖效果（可存储数据）
qq_44887198的博客
10-10 2257
Unity实现大转盘抽奖效果，可以存储数据
unity实现幸运大转盘（实战项目）
A_Pro_Cat的博客
04-08 2918
转盘抽奖模块在游戏日常开发中经常用到，本次就为大家分享一个实战项目中的转盘实现方式（本转盘为转盘动，中间指针不动，不过指针动也是和此demo大同小异。demo下载在文章末尾，欢迎大家下载使用）。 转盘示意图： 话不多说直接贴代码（所有的关键点在代码中都已经详细注释）： using System.Collections; using System.Collections.Generic; usin...
Unity3d实现幸运转盘
ddry47579的博客
06-15 421
　　　　　　　　　　　　　　完成效果 我说一下制作流程，然后再看后面的代码1、创建一个image，选择我们的转盘背景图，素材找我或者网上都有，不多说了哈；2、创建一个空物体，位于转盘的正中心，因为我们的转盘指针的旋转中心是根据空物体进行的中心进行旋转的，所以需要把指针作为空物体的子对象，如果想要做的漂亮，可以自己找一个好的素材或者利用PS处理一下；3、然后创建一个Butto...
Unity适用于Windows与移动平台双端的轮盘交互式提示菜单
03-19
我们将深入了解交互式提示菜单的设计原理、技术实现和最佳实践，并探讨它们对游戏体验的影响。无论您是游戏开发者、界面设计师还是对游戏用户体验感兴趣的读者，本文都将为您揭示交互式提示菜单的奥秘，帮助您打造...
Unity 编辑器篇|（二）GenericMenu自定义弹出式菜单
游戏开发小Y的博客
01-09 5万+
是 Unity 中的一个强大的类，用于创建和管理自定义上下文菜单（也称为弹出菜单）。可以使用来为编辑器中的不同场合或场景元素创建自定义右键单击菜单，以提供各种操作选项。方法描述允许菜单具有多个同名的菜单项。向菜单添加已禁用的项。AddItem向菜单添加一个项。向菜单添加一个分隔符项。DropDown在给定屏幕矩形中显示菜单。获取菜单中的项数。右键单击时在鼠标下显示菜单。回调函数，菜单项选中时调用。带有用户数据的回调函数，菜单项选中时调用。// 创建一个通用菜单。
Unity手机游戏开发：从搭建到发布上线全流程实战
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！交流学习、商务合作：https://bbs.csdn.net/topics/614347534
01-21 1万+
Unity手机游戏开发：从搭建到发布上线全流程实战
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
热门推荐
努力前行，总会成为自己心中的那道光
02-23 12万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
Unity3d 虚拟摇杆(轮盘)easy touch资源包(插件)
11-08
Unity3d手机游戏开发经常用到的插件，easy touch5插件是非常实用的，可以很容易实现手游的虚拟摇杆功能控制游戏人物的走动方向。但此插件在Asset Store中是收费的，大约20美元，在这里我为同学们奉献出来了，记得关注我就好了，O(∩_∩)O哈哈~
unity3d制作的圆形转盘
09-21
大转盘抽奖活动的功能块，使用的5.4.2版本以上可以打开，里面有个现成的转盘，还有一个脚本SpinWheelViewU3D，也可以自己阅读代码自己制作一个转动风格自己调控的转盘。
Unity实现轮盘方式的按钮滚动效果
08-26
主要为大家详细介绍了Unity实现轮盘方式的按钮滚动效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Unity轮盘滚动效果
keren2的博客
08-16 2439
这里使用平面2d来模拟一个3d转换，原理很简单，假设有一个圆形，所有的物体都平均的分布在这个圆环轨迹上面。这个圆环轨迹就是所有物体运行的轨道，是个垂直于你（摄像机）的方向，在靠近摄像机的位置（实际是居中位置），物体尺寸越大，越靠后和靠近两边，物体尺寸越小。 生成的子物体，上面挂上这个脚本。 using System; using System.Collections; using System.C...
【unity 保卫星城】--- 开发笔记08（UI轮盘）
longlin19ji的博客
05-26 926
【unity 保卫星城】--- 开发笔记一、武器轮盘1.轮盘的旋转2.选择的武器3.完成轮盘隐藏和显示 -做完前三个武器，第四个武器准备在前三个武器测试完成没问题后再添加，但再测试前，武器直接是可以切换的。 -没错，通过轮盘拨动来切换你想要的武器。 -美术素材有了，咱先来分析下轮盘都要实现的功能吧 ·1.轮盘能够向上和向下旋转 ·2.粉框里的为你想选中的武器 ·3.轮盘在不点击的时候 一、武器轮盘 1.轮盘的旋转 一开始，我是想轮盘旋转嘛，就控制transform旋转不就行了，但在看完大佬们的博客后。。。
如何创建unity的菜单栏和窗口
alayeshi的专栏
05-04 3639
如何在unity编辑器中创建编辑自己的插件的菜单和窗口
unity基础知识----unity界面菜单翻译
liang_704959721的专栏
12-30 3万+
untiy界面菜单翻译对照
unity游戏开发之原神主界面操作实现
lj820348789的专栏
11-01 2462
本文使用的开发工具为unity2018，完整项目下载地址： 一、最终效果 二、实现过程 1、罗盘的实现原理： 通过触摸点的屏幕坐标与罗盘中心点的屏幕坐标相减，得到方向向量，通过这个向量与向量(0,1)获得两向量夹角，这个夹角就是罗盘的旋转值，同时也是相机朝向在水平方向投影的偏移值，由此就可以的得到角色位移的方向，代码片段如下： //得到相对坐标 Vector2 relativePos = new Vector2(curPos.x - m_uiPosInScreen.x, curPos.y
Unity中视切角转盘UI的实现
Meytones的博客
10-29 1093
标题 目标 实现思路 代码实现 谢谢大家
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

唐沢

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

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

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

打赏作者

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

抵扣说明：

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

余额充值