Unity UI框架 EGUIFramework

最新推荐文章于 2024-08-16 09:03:01 发布
最新推荐文章于 2024-08-16 09:03:01 发布
阅读量627 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42987283/article/details/108083327
版权

EGUI框架，包括dotween，util，Editor一套完整框架

链接：https://pan.baidu.com/s/1Dq_ySDsWbdmUHmEs0Vb0lw
提取码：wtbc

框架就一个脚本 UIPage.cs，如下

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

namespace EG
{
    public class UIPage : MonoBehaviour
    {
        #region static

        private static bool isInit;
        public static GameObject root;
        public static GameObject normalNode;
        public static GameObject fixedNode;
        public static GameObject popupNode;
        public static Camera uiCamera;
        //public static AudioListener uiAudioListener;
        public static EventSystem eventSystem;
        public static Canvas canvas;
        public static CanvasScaler canvasScaler;
        public static GraphicRaycaster graphicRaycaster;
        public static float screenWidth = 1920;
        public static float screenHeight = 1080;
        private static bool isPortrait;
        public static AllPages allPages;

        #endregion

        #region member

        public string uiPath;
        public string pageName;
        public UIType uiType;
        public UIData uiData;

        #endregion


        private static void Init()
        {
            root = new GameObject("Root");
            DontDestroyOnLoad(root);
            root.transform.position = Vector3.zero;
            normalNode = new GameObject("NormalNode");
            normalNode.transform.SetParent(root.transform);
            normalNode.transform.localPosition = Vector3.zero;
            fixedNode = new GameObject("FixedNode");
            fixedNode.transform.SetParent(root.transform);
            fixedNode.transform.localPosition = Vector3.zero;
            popupNode = new GameObject("PopupNode");
            popupNode.transform.SetParent(root.transform);
            popupNode.transform.localPosition = Vector3.zero;
            uiCamera = new GameObject("UICamera").AddComponent<Camera>();
            uiCamera.transform.SetParent(root.transform);
            uiCamera.transform.localPosition = Vector3.zero;
            eventSystem = new GameObject("EventSystem").AddComponent<EventSystem>();
            eventSystem.transform.SetParent(root.transform);
            eventSystem.transform.localPosition = Vector3.zero;

            canvas = root.AddComponent<Canvas>();
            canvasScaler = root.AddComponent<CanvasScaler>();
            canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
            graphicRaycaster = root.AddComponent<GraphicRaycaster>();

            //uiAudioListener = uiCamera.gameObject.AddComponent<AudioListener>();
            uiCamera.clearFlags = CameraClearFlags.Depth;
            uiCamera.cullingMask = 1 << LayerMask.NameToLayer("UI");
            // //相机打开Defalut层
            // uiCamera.cullingMask |= (1 << 0);
            //
            uiCamera.orthographic = true;
            uiCamera.transform.localPosition = Vector3.back * 1500;
            canvas.renderMode = RenderMode.ScreenSpaceCamera;
            canvas.worldCamera = uiCamera;

            RectTransform nrf = normalNode.AddComponent<RectTransform>();
            RectTransform frf = fixedNode.AddComponent<RectTransform>();
            RectTransform prf = popupNode.AddComponent<RectTransform>();

            nrf.sizeDelta = new Vector2(screenWidth, screenHeight);
            frf.sizeDelta = new Vector2(screenWidth, screenHeight);
            prf.sizeDelta = new Vector2(screenWidth, screenHeight);

            root.layer = LayerMask.NameToLayer("UI");
            normalNode.layer = LayerMask.NameToLayer("UI");
            fixedNode.layer = LayerMask.NameToLayer("UI");
            popupNode.layer = LayerMask.NameToLayer("UI");

            eventSystem.gameObject.AddComponent<StandaloneInputModule>();

            allPages = new AllPages();

            isPortrait = screenWidth < screenHeight;

            if (isPortrait)
            {
                ChangeToPortrait();
            }
            else
            {
                ChangeToLandscape();
            }

            isInit = true;
        }

        public static T ShowPage<T>(UIData data = null) where T : UIPage, new()
        {
            if (!isInit)
            {
                Init();
            }

            T t = new T();

            if (allPages.ContainsKey(typeof(T).ToString()))
            {
                T pg = (T) allPages[typeof(T).ToString()];
                pg.uiData = data;
                pg.OnShowPage();

                UIPage curPage = allPages.GetCurPage(pg.uiType);
                if (curPage != null && curPage != pg)
                {
                    curPage.OnLostFocusPage();
                }

                allPages.SetAsLastSibling(pg.pageName);
                if (!pg.gameObject.activeSelf)
                {
                    pg.OnActive();
                }

                return pg;
            }

            t.InitPage();
            GameObject prefab = Resources.Load<GameObject>(t.uiPath);
            T page = Instantiate(prefab).AddComponent<T>();
            page.InitPage();
            page.name = typeof(T).ToString();
            page.pageName = typeof(T).ToString();
            allPages.AddPage(page);
            page.uiData = data;
            
            #region MyRegion

            RectTransform rectTransform = page.GetComponent<RectTransform>();
            Vector3 anchorPos = Vector3.zero;
            
            Vector3 scale = Vector3.one;
            Vector2 sizeDel = Vector2.zero;
            if (rectTransform != null)
            {
                anchorPos = rectTransform.anchoredPosition;
                scale = rectTransform.localScale;
                sizeDel = rectTransform.sizeDelta;
            }
            else
            {
                scale = page.transform.localScale;
            }


            if (page.uiType == UIType.Normal)
            {
                page.transform.SetParent(normalNode.transform);
            }
            else if (page.uiType == UIType.Fixed)
            {
                page.transform.SetParent(fixedNode.transform);
            }
            else if (page.uiType == UIType.PopUp)
            {
                page.transform.SetParent(popupNode.transform);
            }

            if (rectTransform != null)
            {
                rectTransform.anchoredPosition = anchorPos;
                rectTransform.localScale = scale;
                rectTransform.sizeDelta = sizeDel;
            }
            else
            {
                page.transform.localScale = scale;
                page.transform.localPosition = Vector3.zero;
            }

            #endregion
            
            page.OnShowPage();

            UIPage curPage2 = allPages.GetCurPage(page.uiType);
            if (curPage2 != null && curPage2 != page)
            {
                curPage2.OnLostFocusPage();
            }

           
            

            page.OnActive();
            return page;
        }

        public static void ClosePage<T>() where T : UIPage, new()
        {
            if (!isInit)
            {
                Init();
            }

            T t = new T();
            t.InitPage();
            if (allPages.ContainsKey(typeof(T).ToString()))
            {
                T pg = (T) allPages[typeof(T).ToString()];
                pg.OnClosePage();
                if (pg.gameObject.activeSelf)
                {
                    pg.OnHide();
                }

                UIPage curPage = allPages.GetCurPage(pg.uiType);
                if (curPage != null && curPage != pg)
                {
                    curPage.OnFocusPage();
                }
            }
            else
            {
                Debug.LogWarning("no page named \"" + typeof(T) + "\"");
            }
        }

        public static void CloseCurPage(UIType uiType)
        {
            UIPage page = allPages.GetCurPage(uiType);
            if (page != null)
            {
                if (!isInit)
                {
                    Init();
                }

                page.OnClosePage();
                if (page.gameObject.activeSelf)
                {
                    page.OnHide();
                }

                UIPage curPage = allPages.GetCurPage(page.uiType);
                if (curPage != null && curPage != page)
                {
                    curPage.OnFocusPage();
                }
            }
        }

        public static void ChangeToLandscape()
        {
            if (isPortrait)
            {
                canvasScaler.referenceResolution = new Vector2(screenHeight, screenWidth);
                canvasScaler.matchWidthOrHeight = 1;
                Screen.orientation = ScreenOrientation.Landscape;
            }
            else
            {
                canvasScaler.referenceResolution = new Vector2(screenWidth, screenHeight);
                canvasScaler.matchWidthOrHeight = 1;
                Screen.orientation = ScreenOrientation.Landscape;
            }
        }

        public static void ChangeToPortrait()
        {
            if (isPortrait)
            {
                canvasScaler.referenceResolution = new Vector2(screenWidth, screenHeight);
                canvasScaler.matchWidthOrHeight = 0;
                Screen.orientation = ScreenOrientation.Portrait;
            }
            else
            {
                canvasScaler.referenceResolution = new Vector2(screenHeight, screenWidth);
                canvasScaler.matchWidthOrHeight = 0;
                Screen.orientation = ScreenOrientation.Portrait;
            }
        }

        public virtual void InitPage()
        {
        }

        public virtual void OnShowPage()
        {
        }

        public virtual void OnClosePage()
        {
        }

        public virtual void OnFocusPage()
        {
        }

        public virtual void OnLostFocusPage()
        {
        }

        public virtual void OnActive()
        {
            gameObject.SetActive(true);
        }

        public virtual void OnHide()
        {
            gameObject.SetActive(false);
        }

        public bool IsOnGUI
        {
            get
            {
                PointerEventData eventData = new PointerEventData(EventSystem.current);
                eventData.pressPosition = Input.mousePosition;
                eventData.position = Input.mousePosition;

                List<RaycastResult> list = new List<RaycastResult>();
                graphicRaycaster.Raycast(eventData, list);
                return list.Count > 0;
            }
        }
    }

    public enum UIType
    {
        Normal,
        Fixed,
        PopUp,
        None,
    }

    public class AllPages
    {
        private List<UIPage> allPages;

        public UIPage this[int index]
        {
            get { return allPages[index]; }
        }

        public UIPage this[string pageName]
        {
            get
            {
                foreach (var uiPage in allPages)
                {
                    if (uiPage.pageName == pageName)
                    {
                        return uiPage;
                    }
                }

                throw new KeyNotFoundException("the ui which has a name called \"" + pageName + "\" can not be found!");
            }
        }

        public void AddPage(UIPage page)
        {
            if (allPages == null)
            {
                allPages = new List<UIPage>();
            }

            foreach (var uiPage in allPages)
            {
                if (uiPage.pageName == page.pageName)
                {
                    throw new Exception("has already add a page which called \"" + page.pageName + "\"!");
                }
            }

            allPages.Add(page);
        }

        public bool ContainsKey(string pageName)
        {
            if (allPages == null)
            {
                allPages = new List<UIPage>();
            }

            foreach (var uiPage in allPages)
            {
                if (uiPage.pageName == pageName)
                {
                    return true;
                }
            }

            return false;
        }

        public void SetAsLastSibling(string pageName)
        {
            var temp = this[pageName];
            allPages.Remove(this[pageName]);
            this.AddPage(temp);
            temp.transform.SetAsLastSibling();
        }

        public UIPage GetCurPage(UIType uiType)
        {
            for (int i = allPages.Count - 1; i >= 0; i--)
            {
                if (allPages[i].gameObject.activeSelf && allPages[i].uiType == uiType)
                {
                    return allPages[i];
                }
            }

            return null;
        }
    }

    public class UIData
    {
        public object data;
        public Action cb;
    }
}

下面是代码创建工具，不需要手写QuitUI里初始化代码，只需要工具生成

1.把该工具代码放在Editor文件夹下。工具如下

EGUIScriptCreator.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEditor.Experimental.UIElements;
using UnityEngine;
using UnityEngine.UI;

public class EGUIScriptCreator : EditorWindow
{
    private List<ToggleData> _toggleDatas;
    private GameObject curSelectGo;
    private string titleTxt;

    private string[] compTypeArr = new[]
    {
        "Button", "InputField", "Toggle", "ToggleGroup", "Slider", "ScrollRect",
        "Scrollbar", "Image", "Text", "RawImage",
        "Transform", "RectTransform", "GameObject"
    };

    private string[] windowTypeArr = new[] {"Normal", "Fixed", "Popup"};
    private string[] AnimionTypeArr = new[] {"Drop", "LeftOut", "RightOut", "CenterScale", "None"};
    private ClassData _classData;

    private Dictionary<string, ToggleData> _dictionary;

    private List<string> tweenOptions = new List<string>();
    private int tweenIndex = 0;
    private string tweenObjectName = "";

    private Vector2 scroPos;
    private string createPath = "Assets/Script/UI";

    [MenuItem("EGTools/EGUIScriptCreator")]
    static void Init()
    {
        GetWindow<EGUIScriptCreator>().titleContent =
            new GUIContent("EGUIScriptCreator", Resources.Load<Texture>("Icon/eg"));
    }

    private void OnGUI()
    {
        scroPos = GUILayout.BeginScrollView(scroPos, GUILayout.Width(position.width),
            GUILayout.Height(position.height));
        GUILayout.Label(titleTxt);
        if (_toggleDatas != null)
        {
            ShowToggle(_toggleDatas);


            GUILayout.Label("\n================================================================\n");
            GUILayout.Label("WindowType");
            _classData.wtype =
                (WindowType) GUILayout.SelectionGrid((int) _classData.wtype, windowTypeArr, windowTypeArr.Length);


            ShowTweenPopup();


            GUILayout.Label("AnimationType");
            _classData.anim =
                (Anim) GUILayout.SelectionGrid((int) _classData.anim, AnimionTypeArr, AnimionTypeArr.Length);


            GUILayout.Label("\n================================================================\n");
            GUILayout.Label("生成位置:");
            createPath = GUILayout.TextField(createPath);
            if (GUILayout.Button("生成"))
            {
                if (!Directory.Exists(createPath))
                {
                    Directory.CreateDirectory(createPath);
                    AssetDatabase.Refresh();
                }

                GenerateCode();
            }
        }


        GUILayout.EndScrollView();
    }

    private void GenerateCode()
    {
        List<ToggleData> temp = new List<ToggleData>();
        GetToggleData(_toggleDatas, temp);
        foreach (var toggleData in temp)
        {
            if (toggleData.isSelect)
            {
                string pro = "private " + toggleData.ctype + " " + toggleData.name + ";";
                _classData.propertys.Add(pro);

                string awa = toggleData.name + " = gameObject.transform.Find(\"" + toggleData.path + "\")";
                if (toggleData.ctype != CompType.Transform && toggleData.ctype != CompType.GameObject)
                {
                    awa += ".GetComponent<" + toggleData.ctype + ">();";
                }
                else if (toggleData.ctype == CompType.GameObject)
                {
                    awa += ".gameObject;";
                }
                else
                {
                    awa += ";";
                }

                _classData.awakes.Add(awa);

                if (toggleData.ctype == CompType.Button)
                {
                    string btnAdd = toggleData.name + ".onClick.AddListener(" + toggleData.name + "Click);";
                    _classData.awakes.Add(btnAdd);

                    string btnClick = "private void " + toggleData.name + "Click()\n    {\n\n    }";
                    _classData.btnEvents.Add(btnClick);
                }
            }
        }

        string classDataStr = "using System.Collections;\n" +
                              "using System.Collections.Generic;\n" +
                              "using EG;\n" +
                              "using DG.Tweening;\n" +
                              "using UnityEngine;\n" +
                              "using UnityEngine.UI;\n\n" +
                              "public class " + curSelectGo.name + " : UIPage\n" +
                              "{\n";

        foreach (var classDataProperty in _classData.propertys)
        {
            classDataStr += "    " + classDataProperty + "\n";
        }

        classDataStr += "    public override void InitPage()\n" +
                        "    {\n" +
                        "        uiPath = \"UI/" + curSelectGo.name + "\";\n" +
                        "        uiType = UIType." + _classData.wtype + ";\n" +
                        "    }\n\n";
        classDataStr += "    public void Awake()\n" +
                        "    {\n";

        foreach (var classDataAwake in _classData.awakes)
        {
            classDataStr += "        " + classDataAwake + "\n";
        }

        classDataStr += "    }\n";

        classDataStr += "    public override void OnShowPage()\n" +
                        "    {\n\n" +
                        "    }\n\n";
        classDataStr += "    public override void OnClosePage()\n" +
                        "    {\n\n" +
                        "    }\n\n";
        classDataStr += "    public override void OnFocusPage()\n" +
                        "    {\n\n" +
                        "    }\n\n";
        classDataStr += "    public override void OnLostFocusPage()\n" +
                        "    {\n\n" +
                        "    }\n\n";

        string animData = GetAnimData(_classData.anim);

        classDataStr += animData;


        foreach (var classDataBtnEvent in _classData.btnEvents)
        {
            classDataStr += classDataBtnEvent + "\n\n";
        }

        classDataStr += "}";

        if (File.Exists(Path.Combine(createPath, curSelectGo.name + ".cs")))
        {
            Debug.LogError("文件【" + Path.Combine(createPath, curSelectGo.name) + "】已存在！无法生成！");
        }
        else
        {
            FileInfo fileInfo = new FileInfo(Path.Combine(createPath, curSelectGo.name + ".cs"));
            StreamWriter streamWriter = fileInfo.CreateText();
            streamWriter.WriteLine(classDataStr);
            streamWriter.Close();
            AssetDatabase.Refresh();
        }
    }

    private string GetAnimData(Anim anim)
    {
        if (anim == Anim.None)
        {
            return "";
        }

        string data = Resources.Load<TextAsset>("AnimTxt/" + anim).text;
        data = data.Replace("__obj", tweenObjectName);
        return data;
    }

    private void ShowTweenPopup()
    {
        if (_toggleDatas != null && _toggleDatas.Count > 0)
        {
            List<ToggleData> temp = new List<ToggleData>();
            tweenOptions.Clear();
            GetToggleData(_toggleDatas, temp);
            tweenOptions.Add("gameObject");
            foreach (var toggleData in temp)
            {
                tweenOptions.Add(toggleData.path);
            }


            GUILayout.Label("");
            GUILayout.Label("===================================================");
            GUILayout.Label("请选择动画作用对象");
            if (tweenIndex >= tweenOptions.Count - 1)
            {
                tweenIndex = 0;
            }

            tweenIndex = EditorGUILayout.Popup(tweenIndex, tweenOptions.ToArray());
            tweenObjectName = tweenIndex == 0 ? "gameObject" : temp[tweenIndex - 1].name;
        }
    }

    private void GetToggleData(List<ToggleData> toggleDatas, List<ToggleData> outToggleDatas)
    {
        foreach (var toggleData in toggleDatas)
        {
            outToggleDatas.Add(toggleData);
            GetToggleData(toggleData.child, outToggleDatas);
        }
    }

    private T GetCompInParent<T>(Transform tr) where T : Component
    {
        if (tr == null)
        {
            return null;
        }

        T t = tr.GetComponent<T>();
        if (t != null)
        {
            return t;
        }

        return GetCompInParent<T>(tr.parent);
    }

    private void GetToggleData(List<ToggleData> toggleDatas, GameObject root, string parentPath = "")
    {
        foreach (Transform tr in root.transform)
        {
            string tempPath = parentPath == "" ? "" : parentPath + "/";
            string thisPath = tempPath + tr.name;
            string proName = GetName(tr.name.Replace("(", "").Replace(")", "").Replace(" ", ""));
            ToggleData thisData = new ToggleData
            {
                isSelect = true,
                path = thisPath,
                child = new List<ToggleData>(),
                name = proName
            };

            if (tr.name == "Background")
            {
                Debug.Log(tr.GetComponentInParent<Toggle>());
            }

            _dictionary.Add(proName, thisData);

            if (tr.GetComponent<Button>() != null)
            {
                thisData.ctype = CompType.Button;
            }
            else if (tr.GetComponent<InputField>() != null)
            {
                thisData.ctype = CompType.InputField;
            }
            else if (tr.GetComponent<Slider>() != null)
            {
                thisData.ctype = CompType.Slider;
            }
            else if (tr.GetComponent<Toggle>() != null)
            {
                thisData.ctype = CompType.Toggle;
            }
            else if (tr.GetComponent<ToggleGroup>() != null)
            {
                thisData.ctype = CompType.ToggleGroup;
            }
            else if (tr.GetComponent<ScrollRect>() != null)
            {
                thisData.ctype = CompType.ScrollRect;
            }
            else if (tr.GetComponent<Scrollbar>() != null)
            {
                thisData.ctype = CompType.Scrollbar;
            }
            else if (tr.GetComponent<Text>() != null)
            {
                thisData.ctype = CompType.Text;
            }
            else if (tr.GetComponent<RawImage>() != null)
            {
                thisData.ctype = CompType.RawImage;
            }
            else if (tr.GetComponent<Image>() != null)
            {
                thisData.ctype = CompType.Image;
            }
            else
            {
                thisData.ctype = CompType.Transform;
            }

            if ((thisData.ctype != CompType.Button && GetCompInParent<Button>(tr) != null) ||
                (thisData.ctype != CompType.Slider && GetCompInParent<Slider>(tr) != null) ||
                (thisData.ctype != CompType.InputField && GetCompInParent<InputField>(tr) != null) ||
                (thisData.ctype != CompType.Toggle && GetCompInParent<Toggle>(tr) != null) ||
                (thisData.ctype != CompType.ScrollRect && GetCompInParent<ScrollRect>(tr) != null &&
                 tr.parent.GetComponent<Mask>() == null) ||
                (thisData.ctype != CompType.Scrollbar && GetCompInParent<Scrollbar>(tr) != null))
            {
                thisData.isSelect = false;
            }


            toggleDatas.Add(thisData);
            GetToggleData(thisData.child, tr.gameObject, thisPath);
        }
    }

    private void ShowToggle(List<ToggleData> toggleDatas)
    {
        foreach (var toggleData in toggleDatas)
        {
            toggleData.isSelect = GUILayout.Toggle(toggleData.isSelect, toggleData.path);
            toggleData.ctype =
                (CompType) GUILayout.SelectionGrid((int) toggleData.ctype, compTypeArr, compTypeArr.Length);
            ShowToggle(toggleData.child);
        }
    }

    private string GetName(string name)
    {
        string temp = name;
        int n = 1;
        while (true)
        {
            if (_dictionary.ContainsKey(temp))
            {
                temp = name + n;
                n++;
            }
            else
            {
                break;
            }
        }

        return temp;
    }

    private void OnSelectionChange()
    {
        if (curSelectGo != Selection.activeGameObject)
        {
            curSelectGo = null;
            _toggleDatas = null;
            _classData = null;
            _dictionary = null;
            tweenOptions.Clear();
        }

        if (Selection.activeGameObject != null && Selection.activeGameObject != curSelectGo)
        {
            curSelectGo = Selection.activeGameObject;
            _toggleDatas = new List<ToggleData>();
            _classData = new ClassData();
            _dictionary = new Dictionary<string, ToggleData>();
            GetToggleData(_toggleDatas, curSelectGo);
        }

        if (_toggleDatas == null)
        {
            titleTxt = "请先选择一个预制体";
        }
        else if (curSelectGo != null)
        {
            titleTxt = "以下是UI预制体" + curSelectGo.name +
                       "子物体选项\n================================================================";
        }
    }

    private void OnInspectorUpdate()
    {
        Repaint();
        OnSelectionChange();
    }
}

public class ToggleData
{
    public string name;
    public bool isSelect;
    public string path;
    public List<ToggleData> child;
    public CompType ctype;
}

public enum CompType
{
    Button,
    InputField,
    Toggle,
    ToggleGroup,
    Slider,
    ScrollRect,
    Scrollbar,
    Image,
    Text,
    RawImage,
    Transform,
    RectTransform,
    GameObject
}

public class ClassData
{
    public List<string> propertys;
    public List<string> awakes;
    public List<string> btnEvents;
    public WindowType wtype;
    public Anim anim;

    public ClassData()
    {
        propertys = new List<string>();
        awakes = new List<string>();
        btnEvents = new List<string>();
    }
}

public enum WindowType
{
    Normal,
    Fixed,
    PopUp
}

public enum Anim
{
    Drop,
    LeftOut,
    RightOut,
    CenterScale,
    None
}

2.使用：

选中创建好的预制体，选择EGTools/EGUIScriptCreator，勾选需要赋值的button或者Image等等。。，完毕后生成。自动生成脚本到Scripts/UI文件夹下，并且已经对预制体上的组件进行赋值。按钮也添加好了事件。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

下面是工具创建好的UI代码，打开QuitUI后在QuitUI里执行的方法

每个UI脚本调用 ,并继承UIPage， InitPage()初始化，uiPath：ui预制体的路径，uiType ：弹出形式

例如：
public override void InitPage()
{
uiPath = “UI/QuitUI”;
uiType = UIType.Normal;
}
下面完整UI界面代码：

using System.Collections;
using System.Collections.Generic;
using EG;
using DG.Tweening;
using UnityEngine;
using UnityEngine.UI;

public class QuitUI : UIPage
{
    private Button YesBtn;//定义ui的组件
    public override void InitPage()
    {
        uiPath = "UI/QuitUI";
        uiType = UIType.Normal;
    }

    public void Awake()
    {
   	 	//组件赋值
        YesBtn = gameObject.transform.Find("bg/YesBtn").GetComponent<Button>();
        YesBtn.onClick.AddListener(YesBtnClick);
    }
   
    public override void OnShowPage()
    {
     // modelObj = (GameObject) uiData.data;//在ShowPage时传的参数是什么类型，就强转什么类型
    //当显示UI时执行的方法
    }

    public override void OnClosePage()
    {
    //当关闭UI时执行的方法
    }

    public override void OnFocusPage()
    {
    //当获取焦点时调用
    }

    public override void OnLostFocusPage()
    {
     //当失去焦点时调用
    }

	// 当enable为true时调用
    public override void OnActive()
    {
        if (!gameObject.activeSelf)
        {
            base.OnActive();
        }
    }
	//当隐藏时调用
    public override void OnHide()
    {
        if (gameObject.activeSelf)
        {
        }
    }
}

UI调用案例：

打开QuitUI方法 ：

（1）打开UI不传参数： UIPage.ShowPage<QuitUI>();

(2) 打开UI传参数:

	UIPage.ShowPage<QuitUI>(new UIData()
    {
        data= 要传的参数（任意类型） , cb = ()=> { //回调函数，可为空 }
    });

例子：
打开UI时传递参数

 private GameObject obj;
 //打开UI界面
 UIPage.ShowPage<FuncUI>(new UIData()
 	{
 		data=obj, cb = () =>{Debug.Log("这是回调函数");}
 	});

UI界面获取传过来的参数

	//UI界面的OnShowPage方法里接收参数
	public override void OnShowPage()
    {
    	//uiData.data:上级界面传递过来的参数，（这里传的是GameObject）
       GameObject modelObj = (GameObject) uiData.data;
    }
红叶920
关注
unity之EGUI
Candy_Gt的专栏
01-21 942
欢迎来到我们的狗刨网，我们今天主要讲解了EGUI，在这里我们讲了很多知识点，接下来就和大家分享一下吧。 总结:首先是导入EGUI的资源包，然后创建场景，然后在组件EGUI里面的组件里找到NGUI-->Opertions-->Reset Prefab Toolbar在这里面你也可以把摄像机给隐藏了。把这些资源都导入了以后再接着是创建label，在创建label之前要写点住UI Ro
Unity UI框架
heaventianjianke的博客
10-04 1809
使用建造者模式来构建整个结构，由UIManager统一管理UIBase、UIWidget和UISubBase，UIManager本身使用的是单例模式。
UIFrameWork 教程
最新发布
gitblog_00579的博客
08-16 354
UIFrameWork 教程 UIFrameWorkA tiny and simple UIFrameWork for Unity4.x and Unity5.x项目地址:https://gitcode.com/gh_mirrors/ui/UIFrameWork 项目介绍 UIFrameWork 是由 TinyAnt Studio 开发的一个针对 Unity 引擎的全面且基于MVC/MVP/M...
Unity的UI框架
ht_game的博客
10-03 4310
含义：UI框架用于管理场景中所有的面板，负责控制面板之间的跳转。
Unity UI 框架
NRatel的博客
11-19 9398
Unity UI 框架 组件化、树状聚合设计 提供面板创建/销毁/显隐藏接口、显示状态维护 提供控件创建/动态逻辑绑定/销毁接口 提供元素半自动收集、代码自动生成 层级管理 焦点管理 内置自动添加背景，及背景点击响应逻辑 内置自动播放打开/关闭动画、动画状态维护 内置返回键回退逻辑 其他（自定义组件、屏幕适配、多语言支持等）
一套完整的UnityUI框架、可用于实际开发
03-20
本套“Unity UI框架”就是针对这一需求，提供了一套完整的解决方案，可以用于实际的游戏开发项目。 Unity的UI系统自Unity 4.6版本起进行了重大更新，引入了所谓的Canvas系统，它将UI元素以层次结构的方式组织，并...
UI框架_unityui框架_unity_
10-01
Unity UI框架，通常被称为Unity UGUI，是Unity引擎内置的一套强大的用户界面系统。这个框架为游戏开发者提供了创建丰富的交互式2D和3D界面的能力，适用于各种游戏和应用程序。在Unity 4.x版本之前，Unity主要依赖于...
Unity UI框架
07-20
Unity UI框架是Unity引擎内置的一套用户界面系统，它为开发者提供了一整套构建游戏界面的工具和组件，包括但不限于按钮、文本、图像、滑动条、输入框等元素，使得开发者可以创建出丰富多样的交互式游戏界面。...
基于Unity3D简单UI框架
07-14
基于Unity3D和NGUI实现的简单的UI框架，实现内容如下 1.加载，显示，隐藏，关闭页面，根据标示获得相应界面实例 2.提供界面显示隐藏动画接口 3.单独界面层级，Collider，背景管理 4.根据存储的导航信息完成界面导航...
UIFramework.unity
05-20
设计一套用于管理UI的框架，各个UI的生成，销毁，切换，都是通过这个Manager单例来实现。各个UI间不直接联系。以栈发方式管理UI，每次打开一个新的UI，都将它堆入栈，关闭时出栈。这个栈是一个特殊的栈，例如它可以实现，某个不在栈顶的UI，可以“TOP”到栈顶。
unity ui框架
12-12
unity的ui框架视频教程，适合已经学会unity但是还没自己ui框架的同学学习.
unity UI框架
Roadlun的博客
05-26 987
UI管理者类：包含全部子控件信息，给外加提供接口，以访问全部子控件UIBase类：通过UI管理者给子控件添加事件监听UIBehavior：给自身添加事件监听源码：UIManger：using System.Collections.Generic; using UnityEngine; public class UIManager : MonoBehaviour { private Ga...
Unity--UI框架
qq_62947569的博客
05-19 2850
UI框架
Unity 基于UGUI的UI框架 (UIFramework)
九本才的博客
08-19 2539
文件结构 PanelInfo using System; using System.Collections.Generic; [Serializable] public class UIPanelInfo { public string panelTypeString; public string path; } [Serializable] public class UIPanelTypeJson { public List<UIPanelIn...
unity ui框架下载简易框架
09-07
Unity UI框架是一种用于创建用户界面（UI）的工具集和组件集合。它提供了丰富的UI元素和功能，可以帮助开发者轻松地构建交互性和可视化的界面。 Unity UI框架可以通过Unity Asset Store进行下载。打开Unity编辑器，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值