简单UI框架---UIManager

最新推荐文章于 2024-06-01 22:41:01 发布
最新推荐文章于 2024-06-01 22:41:01 发布
阅读量4.2k 收藏 18
点赞数 4
分类专栏： unity3d 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36274965/article/details/83107898
版权

一、简介
1.1、UI基类—UIBase
1.2、UI第二层基类，继承自UIBase，分别为UIWindowBase（所有窗口的基类）、UISceneBase（场景UI基类）
继承自UISceneBase的类都放在UIRoot物体上，而继承自UIWindowBase的类，主要放在窗口上，例如整个登
录注册面板的父物体UIPanel物体之上，类似的。
1.3、三个基本的管理器：LayerUIMgr（UI层级管理器）、SceneUIMgr（场景管UI理器）、WindowUIMgr（窗口
UI管理器）
SceneUIMgr（场景管UI理器）：主要用于场景UI加载，即场景UIRoot预制物体的加载。
WindowUIMgr（窗口UI管理器）：主要用于例如登录窗口、注册窗口等的预制加载，关闭和销毁。
LayerUIMgr（UI层级管理器）：记录一个当前最大深度值，用于设置传入物体的深度层级值。
二、代码
2.1、UIBase

using UnityEngine;
/// <summary>
/// UI基类
/// </summary>
public class UIBase : MonoBehaviour
{
    private void Awake()
    {
        OnAwake();
    }
    void Start()
    {
        #region 给所有的UIButton绑定事件
        UIButton[] btnArr = GetComponentsInChildren<UIButton>(true);//setactive为false的也要获得
        for (int i = 0; i < btnArr.Length; i++)
        {
            UIEventListener.Get(btnArr[i].gameObject).onClick += BtnClick;
        }
        #endregion
        OnStart();
    }
    private void OnDestroy()
    {
        BeforeOnDestory();
    }
    private void BtnClick(GameObject go)
    {
        OnBtnClick(go);
    }
    protected virtual void OnAwake()
    {

    }
    protected virtual void OnStart()
    {

    }
    protected virtual void OnBtnClick(GameObject go)
    {

    }
    protected virtual void BeforeOnDestory()
    {

    }
}

2.2、UIWindowBase（所有窗口的基类）以及UISceneBase（场景UI基类）
2.2.1、UIWindowBase

using UnityEngine;
/// <summary>
/// 所有窗口的基类
/// </summary>
public class UIWindowBase : UIBase
{
    /// <summary>
    /// 挂点类型,挂在哪个容器位置下
    /// </summary>
    public WindowUIContainerType containerType = WindowUIContainerType.Center;
    /// <summary>
    /// 显示类型
    /// </summary>
    public WindowShowStyle showStyle = WindowShowStyle.Normal;
    /// <summary>
    /// 打开或者关闭动画效果持续时间
    /// </summary>
    public float duration = 0.2f;
    /// <summary>
    /// 当前窗口类型
    /// </summary>
    [HideInInspector]
    public WindowUIType CurrentUIType;
    /// <summary>
    /// 下一个要打开的窗口
    /// </summary>
    public WindowUIType m_NextOpenWindow = WindowUIType.None;
    /// <summary>
    /// 关闭当前自己
    /// </summary>
    protected virtual void Close()
    {
        WindowUIMgr.Instance.CloseWindow(CurrentUIType);
    }
    /// <summary>
    /// 销毁自身之前调用
    /// </summary>
    protected override void BeforeOnDestory()
    {
        if (m_NextOpenWindow == WindowUIType.None) return;
        WindowUIMgr.Instance.OpenWindow(m_NextOpenWindow);
    }
}

2.2.2、UISceneBase（场景UI基类）

using UnityEngine;
/// <summary>
/// 场景UI基类
/// </summary>
public class UISceneBase : UIBase
{
    /// <summary>
    /// 容器_居中
    /// </summary>
    public Transform Container_Center;
}

2.2.3、例举一些继承自这两个类的一些实现
2.2.3.1、UISceneLogonCtrl 挂载在Scene_LogOn场景的UIRoot物体上。用于显示进入场景就加载打开登录窗口

using System.Collections;
using UnityEngine;
public class UISceneLogonCtrl : UISceneBase
{

    protected override void OnStart()
    {
        base.OnStart();
        //加载登录窗口       
        StartCoroutine(OpenLogOnWindow());
    }

    private IEnumerator OpenLogOnWindow()
    {
        yield return new WaitForSeconds(0.5f);
        GameObject obj = WindowUIMgr.Instance.OpenWindow(WindowUIType.LogOn);
    }
    private void Update()
    {
    }
}

2.2.3.2、UI_PanelLogonCtrl 挂在在登录窗口面板最外层父物体上

using UnityEngine;
/// <summary>
/// 登录窗口UI控制器
/// </summary>
public class UI_PanelLogonCtrl : UIWindowBase
{
    /// <summary>
    /// 昵称
    /// </summary>
    [SerializeField]
    private UIInput m_InputNockName;
    /// <summary>
    /// 密码
    /// </summary>
    [SerializeField]
    private UIInput m_InputPwd;
    /// <summary>
    /// 提示
    /// </summary>
    [SerializeField]
    private UILabel m_libTip;
    #region OnBtnClick 重写基类OnBtnClick
    /// <summary>
    /// 重写基类OnBtnClick
    /// </summary>
    /// <param name="go"></param>
    protected override void OnBtnClick(GameObject go)
    {
        Debug.Log("登录窗口Btn调用");
        switch (go.name)
        {
            case "BtnLog":
                BtnLogOn();
                break;
            case "BtnReg":
                BtnReg();
                break;
        }
    }
    #endregion
    /// <summary>
    /// 我要注册按钮
    /// </summary>
    void BtnReg()
    {
        //this.Close();
        //m_NextOpenWindow = WindowUIType.Reg;
        WindowUIMgr.Instance.OpenWindow(WindowUIType.Reg);
    }
    /// <summary>
    /// 登录按钮
    /// </summary>
    void BtnLogOn()
    {
        string nickName = this.m_InputNockName.value.Trim();
        string pwd = m_InputPwd.value.Trim();
        string oldNickName = PlayerPrefs.GetString(GlobalInit.MMO_NICKNAME);
        string oldPwd = PlayerPrefs.GetString(GlobalInit.MMO_PWD);
        if (nickName == string.Empty || pwd == string.Empty)
        {
            m_libTip.text = "密码或者昵称不能为空";
            return;
        }
        if (oldNickName != nickName || oldPwd != pwd)
        {
            m_libTip.text = "您输入的账号或者密码错误";
            return;
        }
        GlobalInit.Instance.CurrRoleNickName = nickName;
        SceneMgr.Instance.LoadToCity();
    }
}

2.3管理类 WindowUIMgr（窗口管理类）、LayerUIMgr（UI层级管理器）、SceneUIMgr（场景管UI理器）
2.3.1、WindowUIMgr

using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 窗口UI管理器,窗口加载等方法
/// </summary>
public class WindowUIMgr : Singleton<WindowUIMgr>
{
    /// <summary>
    /// 当前场景中的窗口存贮表
    /// </summary>
    private Dictionary<WindowUIType, UIWindowBase> m_DicWindow = new Dictionary<WindowUIType, UIWindowBase>();
    public int OpenWindowCount
    {
        get
        {
            return m_DicWindow.Count;
        }
    }
    #region LoadWindow 打开窗口
    /// <summary>
    ///  打开窗口，窗口命名书写为Panel+枚举类型名=预制体的名称
    /// </summary>
    /// <param name="type">窗口类型</param>
    public GameObject OpenWindow(WindowUIType type)
    {
        if (type == WindowUIType.None) return null;
        GameObject obj = null;
        if (!m_DicWindow.ContainsKey(type))
        {
            //枚举名要与预制体一致
            obj = ResourcesMgr.Instance.Load(ResourcesMgr.ResourcesType.UIWindows, string.Format("Panel{0}", type.ToString()), true);
            if (obj == null) return null;
            UIWindowBase windowbase = obj.GetComponent<UIWindowBase>();
            if (windowbase == null) return null;
            windowbase.CurrentUIType = type;
            m_DicWindow.Add(type, windowbase);
            Transform transParent = null;
            switch (windowbase.containerType)
            {
                case WindowUIContainerType.Center:
                    Debug.Log("????");
                    transParent = SceneUIMgr.Instance.CurrentUIScene.Container_Center;
                    break;
                case WindowUIContainerType.TL: break;
                case WindowUIContainerType.TR: break;
                case WindowUIContainerType.BL: break;
                case WindowUIContainerType.BR: break;

            }
            obj.transform.parent = transParent;
            obj.transform.localPosition = Vector3.zero;
            obj.transform.localScale = Vector3.one;
            NGUITools.SetActive(obj, false);
            StartShowWindow(windowbase, true);
        }
        else
        {
            obj = m_DicWindow[type].gameObject;
        }
        LayerUIMgr.Instance.SetLayer(obj);


        return obj;
    }
    #endregion
    #region 开始打开窗口
    private void StartShowWindow(UIWindowBase windowbase, bool isOpen)
    {
        switch (windowbase.showStyle)
        {
            case WindowShowStyle.Normal:
                ShowNormal(windowbase, isOpen);
                break;
            case WindowShowStyle.CenterToBig:
                ShowCenterToBig(windowbase, isOpen);
                break;
            case WindowShowStyle.FromDown:
                ShowFromDir(windowbase, 1, isOpen);
                break;
            case WindowShowStyle.FromLeft:
                ShowFromDir(windowbase, 2, isOpen);
                break;
            case WindowShowStyle.FromRight:
                ShowFromDir(windowbase, 3, isOpen);
                break;
            case WindowShowStyle.FromTop:
                ShowFromDir(windowbase, 0, isOpen);
                break;

        }
    }
    #endregion
    #region 关闭窗口
    /// <summary>
    /// 关闭窗口
    /// </summary>
    /// <param name="windowbase"></param>
    public void CloseWindow(WindowUIType type)
    {
        if (m_DicWindow.ContainsKey(type))
        {
            StartShowWindow(m_DicWindow[type], false);
        }
    }
    #endregion
    #region 各种打开效果
    private void ShowNormal(UIWindowBase windowbase, bool isOpen)
    {
        if (isOpen)
        {
            NGUITools.SetActive(windowbase.gameObject, true);
        }
        else
        {
            DestroyWindow(windowbase);
        }
    }
    /// <summary>
    /// 从中间变大
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="isOpen"></param>
    private void ShowCenterToBig(UIWindowBase windowbase, bool isOpen)
    {
        TweenScale ts = windowbase.gameObject.GetOrCreatComponent<TweenScale>();
        ts.animationCurve = GlobalInit.Instance.UIAnimationCurve;
        ts.from = Vector3.zero;//开始大小
        ts.to = Vector3.one;//结束大小
        ts.duration = windowbase.duration;//持续时间
        ts.SetOnFinished(() =>//动画完成之后调用事件
        {
            if (!isOpen)
            {
                DestroyWindow(windowbase);
            }
        });
        NGUITools.SetActive(windowbase.gameObject, true);
        if (!isOpen) ts.Play(isOpen);//如果isOpen=false，即我想要关闭窗口，动画运行反方向
    }
    /// <summary>
    /// 从不同的方向加载
    /// </summary>
    /// <param name="windowbase"></param>
    /// <param name="dirType">0--从上往下，1-从下往上，2--从左向右，3---从右到左</param>
    /// <param name="isOpen"></param>
    private void ShowFromDir(UIWindowBase windowbase, int dirType, bool isOpen)
    {
        TweenPosition tp = windowbase.gameObject.GetOrCreatComponent<TweenPosition>();
        tp.animationCurve = GlobalInit.Instance.UIAnimationCurve;

        Vector3 from = Vector3.zero;
        switch (dirType)
        {
            case 0:
                from = new Vector3(0, 1000, 0);
                break;
            case 1:
                from = new Vector3(0, -1000, 0);
                break;
            case 2:
                from = new Vector3(-1000, 0, 0);
                break;
            case 3:
                from = new Vector3(1000, 0, 0);
                break;

        }
        tp.from = from;//开始大小
        tp.to = Vector3.one;//结束大小

        tp.duration = windowbase.duration;//持续时间
        tp.SetOnFinished(() =>//动画完成之后调用事件
        {
            if (!isOpen)
            {
                DestroyWindow(windowbase);
            }
        });
        NGUITools.SetActive(windowbase.gameObject, true);
        if (!isOpen) tp.Play(isOpen);//如果isOpen=false，即我想要关闭窗口，动画运行反方向
    }
    #endregion
    #region 销毁窗口
    /// <summary>
    /// 销毁窗口
    /// </summary>
    /// <param name="obj"></param>
    private void DestroyWindow(UIWindowBase windowbase)
    {
        m_DicWindow.Remove(windowbase.CurrentUIType);

        GameObject.Destroy(windowbase.gameObject);

        LayerUIMgr.Instance.CheckOpenWindow();
    }
    #endregion


}

2.3.2、SceneUIMgr

using UnityEngine;
using System.Collections;
/// <summary>
/// 场景管UI理器
/// </summary>
public class SceneUIMgr : Singleton <SceneUIMgr>
{
    public UISceneBase CurrentUIScene;
    #region LoadSceneUI 加载场景UI
    /// <summary>
    /// 加载场景UI
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public GameObject LoadSceneUI(SceneUIType type)
    {
        GameObject obj = null;
        switch (type )
        {
            case SceneUIType.LogOn:
                obj = ResourcesMgr.Instance.Load(ResourcesMgr.ResourcesType.UIScene, GameConst.UIRoot_LogOnScene);
                CurrentUIScene = obj.GetComponent<UISceneLogonCtrl>();
                break;
            case SceneUIType.Loading:break;
            case SceneUIType.MainCity:
                obj = ResourcesMgr.Instance.Load(ResourcesMgr.ResourcesType.UIScene, GameConst.UIRoot_CityScene);
                CurrentUIScene = obj.GetComponent<UISceneCityCtrl>();
                break;
        }
        return obj ;
    }
    #endregion
}

2.3.3、LayerUIMgr

using UnityEngine;
using System.Collections;

/// <summary>
/// UI层级管理器
/// </summary>
public class LayerUIMgr : Singleton <LayerUIMgr> {

    /// <summary>
    /// UIPanel层级深度
    /// </summary>
    private int m_UIPanelDepth = 50;
	public void Reset()
    {
        m_UIPanelDepth = 50;
    }
    /// <summary>
    /// 检查窗口数量，如果没有打开的窗口，重置深度
    /// </summary>
    public void CheckOpenWindow()
    {
        if(WindowUIMgr.Instance .OpenWindowCount==0)
        {
            Reset();
        }
    }
    public void SetLayer(GameObject obj)
    {
        m_UIPanelDepth += 1;
        UIPanel[] panArr = obj.GetComponentsInChildren<UIPanel>();
        if(panArr .Length >0)
        {
            for (int i = 0; i < panArr .Length ; i++)
            {
                panArr[i].depth += m_UIPanelDepth;
            }
        }
    }
}

2.4、思路
每个场景有一个场景管理类，如Scene_LogOn场景具有一个类LogOnSceneCtrl.cs类，进入场景就加载场景UI的UIRoot物体。而每个UIRoot上面都挂载一个UISceneBase的子类，该子类中可以在加载时的start方法里加载一些马上显示的窗口之类的。
using UnityEngine;
using System.Collections;
public class LogOnSceneCtrl : MonoBehaviour {

private void Awake()
{
    SceneUIMgr.Instance.LoadSceneUI(SceneUIType.LogOn);
}

}
2.5、其他类
2.5.1、单例类

using UnityEngine;
using System.Collections;
using System;

public class Singleton<T>:IDisposable where T:new ()
{
    private static T instance;
    public static T Instance
    {
        get
        {
            if(instance ==null )
            {
                instance = new T();
            }
            return instance;
        }
    }

    public virtual  void Dispose()
    {
       
    }
}

2.5.2、枚举类

#region WindowUIType 窗口类型
/// <summary>
/// 窗口类型
/// </summary>
public enum WindowUIType
{
    /// <summary>
    /// 未设置
    /// </summary>
    None,
    /// <summary>
    /// 登录窗口
    /// </summary>
    LogOn,
    /// <summary>
    /// 注册窗口
    /// </summary>
    Reg,
    /// <summary>
    /// 角色信息窗口
    /// </summary>
    RoleInfo,
}
#endregion
#region WindowShowStyle 窗口打开方式
/// <summary>
/// 窗口打开方式
/// </summary>
public enum WindowShowStyle
{
    /// <summary>
    /// 正常打开
    /// </summary>
    Normal,
    /// <summary>
    /// 从中间放大
    /// </summary>
    CenterToBig,
    /// <summary>
    /// 从上往下
    /// </summary>
    FromTop,
    /// <summary>
    /// 从下往上
    /// </summary>
    FromDown,
    /// <summary>
    /// 从左往右
    /// </summary>
    FromLeft,
    /// <summary>
    /// 从右向左
    /// </summary>
    FromRight,
}
#endregion
#region  WindowUIContainerType UI容器类型
/// <summary>
/// UI容器类型
/// </summary>
public enum WindowUIContainerType
{
    /// <summary>
    /// 左上
    /// </summary>
    TL,
    //右上
    TR,
    /// <summary>
    /// 左下
    /// </summary>
    BL,
    /// <summary>
    /// 右下
    /// </summary>
    BR,
    /// <summary>
    /// 居中
    /// </summary>
    Center,
}
#endregion
#region SceneUIType 场景UI类型
/// <summary>
/// 场景UI类型
/// </summary>
public enum SceneUIType
{
    /// <summary>
    /// 登录
    /// </summary>
    LogOn,
    /// <summary>
    /// 加载
    /// </summary>
    Loading,
    /// <summary>
    /// 主城
    /// </summary>
    MainCity,
}
#endregion
#region 场景类型
/// <summary>
/// 场景类型
/// </summary>
public enum SceneType
{
    LogOn,
    City,
}
#endregion 

#region 角色类型
/// <summary>
/// 角色类型
/// </summary>
public enum RoleType
{
    /// <summary>
    /// 未设置
    /// </summary>
    None = 0,
    /// <summary>
    /// 当前玩家
    /// </summary>
    MainPlayer = 1,
    /// <summary>
    /// 怪
    /// </summary>
    Monster = 2
}
#endregion

#region 角色状态
/// <summary>
/// 角色状态
/// </summary>
public enum RoleState
{
    /// <summary>
    /// 未设置
    /// </summary>
    None = 0,
    /// <summary>
    /// 待机
    /// </summary>
    Idle = 1,
    /// <summary>
    /// 跑
    /// </summary>
    Run = 2,
    /// <summary>
    /// 攻击
    /// </summary>
    Attack = 3,
    /// <summary>
    /// 受伤
    /// </summary>
    Hurt = 4,
    /// <summary>
    /// 死亡
    /// </summary>
    Die = 5,
}
#endregion

#region  角色动画名称
/// <summary>
/// 角色动画名称
/// </summary>
public enum RoleAnimatorName
{
    Idle_Normal,
    Idle_Fight,
    Run,
    Hurt,
    Die,
    PhyAttack1,
    PhyAttack2,
    PhyAttack3
}
#endregion

/// <summary>
/// 动画切换参数变量名
/// </summary>
public enum ToAnimatorCondition
{
    ToIdleNormal,
    ToIdleFight,
    ToRun,
    ToHurt,
    ToDie,
    ToPhyAttack,
    CurrState,
}
昵称好难写
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UIManager
dongfengsi7020的博客
03-05 501
创建UIManager，管理所有UI面板 准备工作： 　　1. 创建Canvas并设置Tag为Main Canvas 　　2. 在Canvas下新建五个层级节点，因为UGUI显示层级越往下越靠前 using System; using System.Collections.Generic; using UnityEngine; public...
manager-ui:内容平台为企业网站和应用程序提供支持
03-20
您已经找到了驱动Zesty.io实例管理器的代码库。尽管此代码库可以在本地运行，但建议仅在开发时这样做。如果您想了解有关Zesty.io的更多信息，请访问ze​​sty.org上的 建筑学 manager-ui是根据Google的描述的的。每个子应用程序都有自己的捆绑包版本。然后，应用程序外壳程序会根据用户设置动态预缓存应用程序包。 依存关系 TL; DR：在项目根目录下安装所有依赖项 为了避免混淆特定于供应商捆绑包中实际包含的不同版本的子应用程序捆绑包，所有依赖项都已移至存储库根目录。通过将所有依赖项调整为顶级package.json我们可以在一个位置管理依赖项版本。 这意味着，按照npm的默认行为，通过遍历项目直到在根目录下找到node_modules目录，可以解决所有子依赖项声明。 捆扎 Webpack用作选择的捆绑器。只有一个使用惰性路由将子应用程序分成单独的捆绑包。 国家管理 R
iOS中的UIScene和UISceneDelegate
最新发布
我叫柱子哥
06-01 982
在iOS 13及之后的版本中，苹果引入了UIScene和，将应用程序的生命周期管理分成了多个场景（Scene），使得多窗口支持成为可能。和分别负责不同方面的应用程序生命周期和 UI 管理。这篇博客主要介绍UISceneDelegate以及相关API的用法。
UnityVR--UIManager--UI管理1
唐小墨同学的博客
06-15 2860
学习笔记：​UI在项目中的重要性不言而喻，并且UI控件的种类繁多，不仅需要有一个统一的工具管理器来控制各个UI节点的初始化、排列、 组件等，还需要有一个UIManager在项目中统一控制。
UnityVR--UIManager--UI管理2
唐小墨同学的博客
06-17 2060
接前篇，上一篇已经有了UITools.cs其中定义了UI面板需要使用的基本工具，如：初始化UI节点、遍历所有节点、在按键上添加EventTrigger等，以及各种类型UI面板继承UITools的个性化工具，比如MainUI.cs。本篇要实现一个简单的管理工具UIManager，并使用它的工具实现面板的初始化、显示、隐藏等。功能比较简单，如果要做复杂的项目还需要完善。
【unity】UIManager
qq_35064654的博客
01-06 679
使用List存储所有的BasePanel的Prefab----List basePanelPrefabList。使用字典存储BasePanel和其对应的Type---- Dictionary panelMap。比如获取某个已经显示的面板GetPanel,展示某个面板，隐藏某个面板隐藏全部面板等等，可以自行进行补充。BasePanel包含一些通用的方法，所有的Panel都继承自BasePanel，然后实现各自独特的功能。默认将所有panel隐藏。
unity进阶学习笔记：UI框架
Raine_Yang的博客
05-12 1210
在UI系统中，我们放弃之前消息系统中使用的广播框架，因为该方案需要专门为每一个UI组件编写发送和接受消息的方法，过于复杂。我们希望通过UIController和UI Manager可以让每一个UI组件访问到任何一个另外的UI组件。在下面程序中我们获取到该游戏物体的按钮组件control，并在control上挂载对action的监听。UI框架主要分3层：UIManager用于管理所有UI组件，UIController用于管理某一个UI面板，如角色信息面板，商店面板等。一般来说，一个游戏内具有大量的UI组件。
简单UI框架
weixin_42190550的博客
02-16 430
1.UI框架核心方法 ● BaseUI会记录UI的名字（枚举）和Controller用来将UI与具体操作方法解耦 ● UIManger利用字典记录所有的UI组件，然后提供一些打开关闭UI的方法 ● EventManager(事件系统)来实现模块与模块之间的交互,事件系统也分很多种实现方式,都是观察者设计模型的典型应用,利用一个关键字注册多个方法，然后在利用这个关键字激活调用已经住的方法。也是C#中委托的一种典型用法。广播形式、通知形式等。 2.UI框架拓展方法 ● ResourcesManager（资源管理
UI框架
SaitamaTeacher的博客
10-25 309
UI框架 解决的问题 解决找对象问题 交互事件管理 模态处理 语言本地化 解决办法 关于找对象问题 要UI的统一管理 如果有一个UI管理，当需要找的时候直接通过UI管理就能找到 交互事件 通用事件管理 解决消息管理传递 消息框架 模态 UI的层次模块管理 本地化 文本多语言管理 写UI框架前准备 配置文件 XML/JSON/数据库/表格 一般都用XML/JSON 方便管理 对象池脚本 资源管理脚本 单例管理脚本 正式开写框架 看框架时候要结合之前
playkit-js-ui:PlayKit JS Player的UI应用程序框架
04-28
通过简单CSS定义或让应用程序定义UI的整个布局，PlayKit JS UI框架提供了一种简单直观的方法来针对任何目的和设计自定义UI。 UI框架公开了处理UI生命周期的UIManager，以及用于构建UI布局的组件库，其中每个组件...
cocos_creator_framework：cocos创建者基础框架，包含资源，ui管理，网络模块
02-05
cocos creator框架-kxCreator 资源管理重建 计划2021-2-10之前完成对资源管理逐步的初步重组，重组有几大目标： 使接口兼容2.4之前和之后的cocos资源充足 为cc.Asset注入引用计数功能，使框架使用的体验与新资源能够...
UGUI分层UI框架源码
07-12
1、UIManager中加载所有UI，存到列表中，使用时实例化到场景，根据类型分层 2、各面板继承UIBase，自己进行生命周期管理 (1)面板属性定义 (2)面板属性设置 (3)系统定义（路径定义为例） 3、UI生命周期，继承mono原本...
千峰UI框架
11-14
"千峰UI框架"是一个专为用户界面设计和开发打造的框架，旨在简化前端开发者的工作流程，提高开发效率。此框架包含丰富的组件和工具，帮助设计师实现美观且响应式的页面布局。"有代码注释"的特性表明该框架在源码层面...
UIManager_Unity3DUI框架_
09-30
在这个特定的项目中，UI框架的开发是基于JSON解析来构建的，这允许我们用更灵活和数据驱动的方式定义和管理UI布局。 首先，我们来看`UIManager.cs`这个核心文件。这是一个C#脚本，它将实现整个UI框架的核心逻辑。...
JAVA中UIManager的使用
zhouysh的专栏
06-10 3234
The following is a list of all valid keys for the UIManager.getDefaults() object. Im not sure which of these is the key you need, but you may take a look at the call ColorUIResource cuir = UIManager.
033-使用UIManager设置组件外观界面，适应不同操作系统
软件之家的博客
11-23 481
Swing可通过UIManager来设置组件的外观界面，不依赖本地操作系统。 例如： Windows：Microsoft Windows 操作系统 Solaris：SUN微系统公司开发的一种网络操作系统, Java自己的风格等； Macintosh ：Apple公司开发的一种操作系统 GTK+、WindowsXP等
Unity组件开发--UI管理器
一个人的夏天
01-10 1293
5.上面这个json文件中的path，对应的就是UI预设体的名字：由于我们的UI预制体都是用AB包的方式加载的，就都放在BundleAsset文件夹中。4.所有的UI界面预设体都用一个json文本管理起来：UIPanelType。2.画布下其他节点类型：用于不同界面类型的管理归类window类型。（4）画布下挂载两个脚本：UIRoot和UIManager。7.然后所有UI类脚本必须继承的基类：BasePanel。（2）创建一个UICamera节点，管理相机。（1）渲染模式是：屏幕空间相机。
Unity UI框架
熊思雨的博客
02-21 3614
最近在各大网站看了一下 Unity3d 的 UI 框架，各种 UI 框架已经有很多的版本了，各有千秋，有的功能虽然写的完善，但用起来太复杂，有的框架功能不完善，搞个课程就上架了，还有什么 MVC 框架，绕来绕去的看的头都大了，这些根本不想用。于是我自己就写了一个 UI 框架，只有两个脚本，不用向 UI 预制体上挂载脚本，所有的组件访问都可以通过 UIManager 来控制，常用的几个方法：显示界面，关闭界面，查找子物体，就这么多。
Unity3D 开发工具系列 UI框架：UI基类UIBase
承续缘
12-03 2040
Unity UI框架，方便管理UI，减少开发难度；
// Process macro or start UI session // if ( ! ui ) { // batch mode G4String command = "/control/execute "; G4String fileName = argv[1]; UImanager->ApplyCommand(command+fileName); } else { // interactive mode UImanager->ApplyCommand("/control/execute init_vis.mac"); ui->SessionStart(); delete ui; }
06-12
这段代码是一个条件语句，用于判断是否启动用户界面（UI）会话。 首先，如果没有创建 UI 对象（即 `!ui`），则表示程序运行在批处理模式下。此时，该代码段会获取命令行参数中的文件名，并将其赋值给 `fileName` 变量。然后将字符串 `"/control/execute "` 和 `fileName` 变量拼接起来，形成一个完整的命令字符串。最后，使用 `UImanager->ApplyCommand()` 方法执行该命令，以运行用户指定的控制文件。 如果创建了 UI 对象，则表示程序运行在交互模式下。此时，该代码段会使用 `UImanager->ApplyCommand()` 方法执行字符串 `"/control/execute init_vis.mac"`，以运行名为 `init_vis.mac` 的初始化控制文件。然后，通过调用 `ui->SessionStart()` 方法启动 UI 会话，并等待用户输入命令。最后，使用 `delete ui` 语句释放 UI 对象的内存。 综上，这段代码用于处理批处理模式和交互模式下的不同操作，并提供了命令行和 UI 两种方式来控制模拟程序的运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值