Unity UI系统

最新推荐文章于 2024-10-29 13:06:50 发布
原创 最新推荐文章于 2024-10-29 13:06:50 发布 · 660 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

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

namespace Framework
{
    /// <summary>
    /// UI系统
    /// </summary>
    [RequireComponent(typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster))]
    [RequireComponent(typeof(UnityEngine.EventSystems.EventSystem), typeof(StandaloneInputModule))]
    public class UISystem : MonoSingleton<UISystem>
    {
        /// <summary>
        /// 名字分隔符
        /// </summary>
        private const char SPLIT_NAME = '.';

        /// <summary>
        /// 画布对象
        /// </summary>
        public static Canvas Canvas { get; private set; }

        /// <summary>
        /// 画布缩放对象
        /// </summary>
        public static CanvasScaler CanvasScaler { get; private set; }

        /// <summary>
        /// 图像射线接收器
        /// </summary>
        public static GraphicRaycaster GraphicRaycaster { get; private set; }

        /// <summary>
        /// 引擎事件系统
        /// </summary>
        public static UnityEngine.EventSystems.EventSystem EventSystem { get; private set; }

        /// <summary>
        /// UI摄像机
        /// </summary>
        public static Camera Camera { get { return Canvas == null ? null : Canvas.worldCamera; } }

        /// <summary>
        /// 画布大小
        /// </summary>
        public static Vector2 CanvasSize { get { return (Instance.transform as RectTransform).sizeDelta; } }

        /// <summary>
        /// 屏幕到UI缩放比例
        /// </summary>
        public static Vector2 ScreenToUIScale { get { return new Vector2(CanvasSize.x / Screen.width, CanvasSize.y / Screen.height); } }

        /// <summary>
        /// UI到屏幕缩放比例
        /// </summary>
        public static Vector2 UIToScreenScale { get { return new Vector2(Screen.width / CanvasSize.x, Screen.height / CanvasSize.y); } }

        /// <summary>
        /// 世界到UI缩放比例
        /// </summary>
        public static Vector2 WorldToUIScale { get { return new Vector2(1 / Canvas.transform.localScale.x, 1 / Canvas.transform.localScale.y); } }

        /// <summary>
        /// UI到世界缩放比例
        /// </summary>
        public static Vector2 UIToWorldScale { get { return new Vector2(Canvas.transform.localScale.x, Canvas.transform.localScale.y); } }

        /// <summary>
        /// 世界到屏幕缩放比例
        /// </summary>
        public static Vector2 WorldToScreenScale { get { return new Vector2(WorldToScreenScale.x * UIToScreenScale.x, WorldToScreenScale.y * UIToScreenScale.y); } }

        /// <summary>
        /// 屏幕到世界缩放比例
        /// </summary>
        public static Vector2 ScreenToWorldScale { get { return new Vector2(ScreenToUIScale.x * UIToWorldScale.x, ScreenToUIScale.y * UIToWorldScale.y); } }

        /// <summary>
        /// 面板表[键:面板名 值:面板对象]
        /// </summary>
        private Dictionary<string, UIPanel> m_PanelMap = new Dictionary<string, UIPanel>();

        /// <summary>
        /// 面板链表
        /// </summary>
        private List<UIPanel> m_PanelList = new List<UIPanel>();

        /// <summary>
        /// 异步回调表[键:面板名 值:回调]
        /// </summary>
        private Dictionary<string, Action<UIPanel>> m_AsyncCallbackMap = new Dictionary<string, Action<UIPanel>>();

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="renderMode">渲染模式</param>
        /// <param name="camera">摄像机</param>
        /// <param name="scaleMode">缩放模式</param>
        /// <param name="resolution">自适应分辨率</param>
        /// <param name="ppu">单位参考像素</param>
        public static void Init(RenderMode renderMode,
            Camera camera,
            CanvasScaler.ScaleMode scaleMode,
            Vector2 resolution, float ppu)
        {
            Canvas = Instance.gameObject.GetComponent<Canvas>();
            CanvasScaler = Instance.gameObject.GetComponent<CanvasScaler>();
            GraphicRaycaster = Instance.gameObject.GetComponent<GraphicRaycaster>();
            EventSystem = Instance.gameObject.GetComponent<UnityEngine.EventSystems.EventSystem>();

            Canvas.planeDistance = 0;
            Canvas.renderMode = renderMode;
            Canvas.worldCamera = camera;
            CanvasScaler.uiScaleMode = scaleMode;
            CanvasScaler.referenceResolution = resolution;
            Canvas.referencePixelsPerUnit = ppu;
        }

        /// <summary>
        /// 打开面板
        /// </summary>
        /// <param name="panelName">面板名</param>
        /// <param name="type">面板类型</param>
        /// <returns></returns>
        public static UIPanel Open(string panelName, Type type)
        {
            UIPanel panel = Get(panelName);
            if (panel == null)
            {
                GameObject asset = null;
                asset = Resources.Load<GameObject>(panelName);
                GameObject gameObject = Instantiate(asset);
                gameObject.name = asset.name;
                gameObject.transform.SetParent(Instance.transform, false);

                panel = Activator.CreateInstance(type) as UIPanel;
                Instance.m_PanelMap[panelName] = panel;
                Instance.m_PanelList.Add(panel);

                panel.Init(panelName, gameObject);
            }

            panel.Enabled = true;

            return panel;
        }

        /// <summary>
        /// 异步打开面板
        /// </summary>
        /// <param name="panelName">面板名</param>
        /// <param name="type">面板类型</param>
        /// <param name="openCallback">打开回调</param>
        public static void OpenAsync(string panelName, Type type, Action<UIPanel> openCallback = null)
        {
            UIPanel panel = Get(panelName);
            if (panel == null)
            {
                Action<UIPanel> callback = null;
                if (Instance.m_AsyncCallbackMap.TryGetValue(panelName, out callback))
                {
                    callback -= openCallback;
                    callback += openCallback;
                    Instance.m_AsyncCallbackMap[panelName] = callback;
                }
                else
                {
                    Instance.m_AsyncCallbackMap[panelName] = openCallback;
                    Instance.StartCoroutine(OnLoadComplete(panelName, type));
                }
            }
            else
            {
                if (openCallback != null)
                {
                    openCallback.Invoke(panel);
                }
                panel.Enabled = true;
            }
        }

        /// <summary>
        /// 更新启用的面板
        /// </summary>
        private void Update()
        {
            if (m_PanelList != null)
            {
                for (int i =0; i < m_PanelList.Count; i ++)
                {
                    UIPanel panel = m_PanelList[i];
                    if (!panel.Enabled)
                        continue;

                    panel.OnUpdate();
                }
            }
        }

        /// <summary>
        /// 关闭面板
        /// </summary>
        /// <param name="panelName">面板名</param>
        /// <param name="destroy">是否销毁</param>
        public static void Close(string panelName, bool destroy = false)
        {
            UIPanel panel = Get(panelName);
            if (panel == null)
            {
                return;
            }

            if (destroy)
            {
                Instance.m_PanelMap.Remove(panelName);
                Instance.m_PanelList.Remove(panel);
                panel.OnDestroy();
                Destroy(panel.GameObject);
            }
            else
            {
                panel.Enabled = false;
            }
        }

        /// <summary>
        /// 获取面板
        /// </summary>
        /// <param name="panelName">面板名</param>
        /// <returns>返回面板</returns>
        public static UIPanel Get(string panelName)
        {
            UIPanel panel = null;
            Instance.m_PanelMap.TryGetValue(panelName, out panel);
            return panel;
        }

        /// <summary>
        /// 获取所有面板
        /// </summary>
        /// <returns></returns>
        public static UIPanel[] GetAll()
        {
            return Instance.m_PanelList.ToArray();
        }

        /// <summary>
        /// 销毁启用的面板
        /// </summary>
        private void OnDestroy()
        {
            if (m_PanelList != null)
            {
                foreach (var panel in m_PanelList)
                {
                    if (!panel.Enabled)
                        continue;

                    panel.OnDestroy();
                }
            }
        }

        /// <summary>
        /// 屏幕转UI坐标
        /// </summary>
        /// <param name="position">屏幕坐标</param>
        /// <returns>返回UI坐标</returns>
        public static Vector2 ScreenToUIPoint(Vector2 position)
        {
            RectTransform transform = Instance.transform as RectTransform;
            Vector2 point = new Vector2((position.x / Screen.width - 0.5f) * transform.sizeDelta.x,
                (position.y / Screen.height - 0.5f) * transform.sizeDelta.y);

            return point;
        }

        /// <summary>
        /// UI转屏幕坐标
        /// </summary>
        /// <param name="position"></param>
        /// <returns></returns>
        public static Vector2 UIToScreenPoint(Vector2 position)
        {
            RectTransform transform = Instance.transform as RectTransform;
            Vector2 point = new Vector2((position.x / transform.sizeDelta.x + 0.5f) * Screen.width,
                (position.y / transform.sizeDelta.y + 0.5f) * Screen.height);

            return point;
        }

        /// <summary>
        /// 世界转UI坐标
        /// </summary>
        /// <param name="position">世界坐标</param>
        /// <returns>返回UI坐标</returns>
        public static Vector2 WorldToUIPoint(Vector3 position)
        {
            Vector2 screenPosition = WorldToScreenPoint(position);
            return ScreenToUIPoint(screenPosition);
        }

        /// <summary>
        /// UI转世界坐标
        /// </summary>
        /// <param name="position">UI坐标</param>
        /// <returns>返回世界坐标</returns>
        public static Vector3 UIToWorldPoint(Vector2 position)
        {
            Vector2 screenPosition = UIToScreenPoint(position);
            return ScreenToWorldPoint(screenPosition);
        }

        /// <summary>
        /// 世界转屏幕坐标
        /// </summary>
        /// <param name="position">世界坐标</param>
        /// <returns>返回屏幕坐标</returns>
        public static Vector3 WorldToScreenPoint(Vector3 position)
        {
            return Camera.WorldToScreenPoint(position);
        }

        /// <summary>
        /// 屏幕转世界坐标
        /// </summary>
        /// <param name="position">屏幕坐标</param>
        /// <returns>返回世界坐标</returns>
        public static Vector3 ScreenToWorldPoint(Vector3 position)
        {
            return Camera.ScreenToWorldPoint(position);
        }

        /// <summary>
        /// 加载完成回调
        /// </summary>
        /// <param name="asset"></param>
        /// <param name="arg"></param>
        private static void OnLoadComplete(object asset, object arg)
        {
            GameObject uiAsset = asset as GameObject;
            GameObject gameObject = Instantiate(uiAsset);
            gameObject.name = uiAsset.name;
            gameObject.transform.SetParent(Instance.transform, false);

            object[] args = arg as object[];
            string panelName = args[0] as string;
            Type type = args[1] as Type;

            UIPanel panel = Activator.CreateInstance(type) as UIPanel;
            panel.Init(panelName, gameObject);
            Instance.m_PanelMap[panelName] = panel;
            Instance.m_PanelList.Add(panel);

            panel.Enabled = true;
            Action<UIPanel> openCallback = Instance.m_AsyncCallbackMap[panelName];
            if (openCallback != null)
            {
                openCallback.Invoke(panel);
                Instance.m_AsyncCallbackMap.Remove(panelName);
            }
        }

        /// <summary>
        /// 异步加载完成回调
        /// </summary>
        /// <param name="panelName"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static IEnumerator OnLoadComplete(string panelName, Type type)
        {
            ResourceRequest request = Resources.LoadAsync<GameObject>(panelName);
            yield return request;
            try
            {
                GameObject gameObject = Instantiate(request.asset as GameObject);
                gameObject.name = request.asset.name;
                gameObject.transform.SetParent(Instance.transform, false);

                UIPanel panel = Activator.CreateInstance(type) as UIPanel;
                panel.Init(panelName, gameObject);
                Instance.m_PanelMap[panelName] = panel;
                Instance.m_PanelList.Add(panel);

                panel.Enabled = true;
                Action<UIPanel> openCallback = Instance.m_AsyncCallbackMap[panelName];

                if (openCallback != null)
                {
                    openCallback.Invoke(panel);
                    Instance.m_AsyncCallbackMap.Remove(panelName);
                }
            }
            catch (Exception e)
            {
                Debug.LogError("异步打开界面错误！" + panelName + " " + e);
            }
        }
    }
}

 

unity学习（9）UI系统
qq_40338696的博客
12-26 857
作业9： 1、血条（Health Bar）的预制设计。具体要求如下 分别使用 IMGUI 和 UGUI 实现 使用 UGUI，血条是游戏对象的一个子元素，任何时候需要面对主摄像机 分析两种实现的优缺点 给出预制的使用方法 IMGUI实现 “即时模式”GUI系统（也称为IMGUI）是Unity基于游戏对象的主要UI系统的一个完全独立的功能。IMGUI是一个代码驱动的GUI系统，主要是作为程序员的工具。它由对实现它的任何脚本上的OnGUI函数的调用驱动。 代码： using System.C.
unity中的UI系统---GUI
2302_80052051的博客
01-03 840
GUI优点：简单快捷，代码控制缺点：重复工作量繁多，控件绘制相关代码很多，最大缺点是必须运行时才能去看结果，不支持分辨率自适应。
Unity的C#编程教程_56_Namespace 详解
AItrust的博客
10-09 1422
文章目录NamespacesTour of Namespaces Namespaces 命名空间使得我们可以组织和管理我们的代码库 假设我们设置一个脚本名叫 Weapon： using System.Collections; using System.Collections.Generic; using UnityEngine; public class Weapon : MonoBehaviour { // Start is called before the first frame upd
unityUi系统
qq_43283265的博客
12-26 742
UI系统3D游戏设计第九次作业前言说明IMGUI实现实现过程效果展示生成预制体UGUI实现实现过程效果展示生成预制体IMGUI与UGUI的比较IMGUIUGUI预制的使用感悟与总结项目仓库 3D游戏设计第九次作业 前言 这是中山大学2020年3D游戏设计的第九次作业，如有错误，请指正，感谢您的阅读。 说明 本次作业为：血条（Health Bar）的预制设计。具体要求如下 分别使用 IMGUI 和 UGUI 实现 使用 UGUI，血条是游戏对象的一个子元素，任何时候需要面对主摄像机 分析两种实现的优缺点
UI系统
weixin_43870219的博客
12-27 306
UI系统血条（Health Bar）的预制设计IMGUI实现UGUI实现分析两种实现的优缺点预制的使用方法 血条（Health Bar）的预制设计 要求： 分别使用 IMGUI 和 UGUI 实现 使用 UGUI，血条是游戏对象的一个子元素，任何时候需要面对主摄像机 分析两种实现的优缺点 给出预制的使用方法 首先为人物都挂在上一个Health的组件，上面记录着当前的血量和总血量，以及受到伤害和恢复的函数调用 public class Health : MonoBehaviour { public
UnityUI系统-GUI
最新发布
08-05
封装GUI的控件，使其可以直接在Unity编辑器中使用，所见即所得
Unity引擎开发：Unity基础入门-（10）.Unity UI系统基础.docxUnity引擎开发：Unity基础入门-（11）.Unity音频系统入门.docxUnity引擎开发：Unity
09-01
Unity引擎开发：Unity基础入门_（10）.Unity UI系统基础.docx Unity引擎开发：Unity基础入门_（11）.Unity音频系统入门.docx Unity引擎开发：Unity基础入门_（12）.Unity粒子系统基础.docx Unity引擎开发：Unity基础...
精选资源
Unity UI Samples（Unity的UI样例）
01-05
Unity UI Samples是Unity引擎提供的一套完整的用户界面（UI）示例集合，旨在帮助开发者深入理解和熟练运用Unity的UI系统。这个资源包包含了各种不同类型的UI元素和交互设计，覆盖了从基础到高级的各种功能，使得...
精选资源
Unity UI边缘流光特效插件
10-25
通过阅读和理解代码，开发者可以更好地掌握Unity的UI系统和Shader编程，这对于提升个人技能和未来项目开发都非常有帮助。 需要注意的是，这个插件仅供学习交流使用，不能用于商业项目。这表明虽然你可以自由地探索...
精选资源
unity日期选择插件 DatePicker for UnityUI
04-19
"DatePicker for UnityUI" 是一个专门为Unity设计的日期选择组件，它使得在Unity界面中集成日期选择功能变得更加简单易行。这个插件特别适合那些需要用户输入特定日期或基于日期进行操作的游戏或应用。 在Unity中，...
Unity基础笔记（3）—— Unity UI系统
Dukenone的博客
09-17 9435
Unity UI系统
Unity 核心系统详解 -- UI 系统
话唠扇贝的博客
02-10 4551
Unity 提供了三个 UI 系统，可以使用它们在 Unity 编辑器中创建的应用程序创建用户界面 (UI)： * UI Toolkit * Unity UI 软件包 (uGUI) * IMGUI
Unity UI
生活是一种态度，程序也需要心。
08-18 751
在创建一个新的UI父节点时候，注意y
UnityUI系统 - GUI
m0_61939767的博客
02-24 1626
region 知识点一 全局颜色//全局的着色颜色 影响背景和文本//按钮是偏红，字体全红//文本着色颜色 会和全局颜色相乘//背景元素着色 会和全局颜色相乘GUI.Button(new Rect(0, 0, 100, 30), "测试按钮");GUI.Label(new Rect(0, 50, 100, 30), "测试按钮");//style 自定义后也会被全局改变，改回白色可以变回去。
【Unity基础】Unity中的UI系统
Tealc
10-29 1289
本文介绍了Unity中的三种UI系统
unity ui 概述_新UI系统概述
culiao6493的博客
09-16 754
unity ui 概述The UI Team here at Unity has been hard at work getting the new UI system ready for release in Unity 4.6. While there’s still more work left to be done, we’ve been showing it off at recent ...
Unity中UI系统——IMGUI(GUI)
HAL2020的博客
08-24 4901
Unity中UI系统——IMGUI(GUI)
Unity中的UI系统之UGUI
K_CRACKING的博客
04-22 7501
UGUI是什么UGUI是Unity引擎内自带的UI系统官方称之为:Unity UI是目前Unity商业游戏开发中使用最广泛的UI系统开发解决方案它是基于Unity游戏对象的UI系统,只能用来做游戏UI功能不能用于开发Unity编辑器中内置的用户界面如何在Unity中使用UGUI直接在Hierarchy窗口中右键选择UIUI中所有内容都是UGUI相关控件六大基础组件1、Canvas对象上依附的:①Canvas:画布组件,主要用于渲染UI控件②。
unityUI系统
05-30
### Unity UI 系统 (uGUI) 使用指南 #### 1. 基础概念 Unity UI 系统，也称为 uGUI，是 Unity 引擎内置的一套用于创建用户界面的工具集。它基于 GameObject 和组件的设计理念，允许开发者通过拖放预置的 UI 组件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值