update

yyl

2025-05-13 6208ed5ed833142a459d0dc8ad8622ca8047a80e

 Main/UI/UIManager.cs

@@ -37,6 +37,38 @@


    #region 初始化方法

    



    #region 缓存变量

    
    // 缓存Transform查找结果

    private Dictionary<UILayer, Transform> layerTransformCache = new Dictionary<UILayer, Transform>();

    
    // 缓存层级对应的基础排序顺序

    private Dictionary<UILayer, int> layerSortingOrderCache = new Dictionary<UILayer, int>();

    
    #endregion

    
    // 初始化缓存

    private void InitCache()

    {

        // 初始化层级Transform缓存

        layerTransformCache.Clear();

        layerTransformCache[UILayer.Static] = staticTrans;

        layerTransformCache[UILayer.Bottom] = bottomTrans;

        layerTransformCache[UILayer.Mid] = midTrans;

        layerTransformCache[UILayer.Top] = topTrans;

        layerTransformCache[UILayer.System] = systemTrans;

        
        // 初始化层级排序顺序缓存

        layerSortingOrderCache.Clear();

        layerSortingOrderCache[UILayer.Static] = BASE_SORTING_ORDER;

        layerSortingOrderCache[UILayer.Bottom] = BASE_SORTING_ORDER * 10;

        layerSortingOrderCache[UILayer.Mid] = BASE_SORTING_ORDER * 100;

        layerSortingOrderCache[UILayer.Top] = BASE_SORTING_ORDER * 1000;

        layerSortingOrderCache[UILayer.System] = BASE_SORTING_ORDER * 10000;

    }





    // 初始化

    public void Init()

    {

@@ -91,41 +123,69 @@
    // 获取UI层级对应的基础排序顺序

    private int GetBaseSortingOrderForLayer(UILayer layer)

    {

        if (layerSortingOrderCache.TryGetValue(layer, out int order))

            return order;

            
        // 如果缓存中没有，使用原来的方法计算并缓存结果

        int result;

        switch (layer)

        {

            case UILayer.Static:

                return BASE_SORTING_ORDER;

                result = BASE_SORTING_ORDER;

                break;

            case UILayer.Bottom:

                return BASE_SORTING_ORDER * 10;

                result = BASE_SORTING_ORDER * 10;

                break;

            case UILayer.Mid:

                return BASE_SORTING_ORDER * 100;

                result = BASE_SORTING_ORDER * 100;

                break;

            case UILayer.Top:

                return BASE_SORTING_ORDER * 1000;

                result = BASE_SORTING_ORDER * 1000;

                break;

            case UILayer.System:

                return BASE_SORTING_ORDER * 10000;

                result = BASE_SORTING_ORDER * 10000;

                break;

            default:

                return BASE_SORTING_ORDER * 10;

                result = BASE_SORTING_ORDER * 10;

                break;

        }

        
        layerSortingOrderCache[layer] = result;

        return result;

    }



    // 获取层级对应的Transform

    private Transform GetTransForLayer(UILayer layer)

    {

        if (layerTransformCache.TryGetValue(layer, out Transform trans))

            return trans;

            
        // 如果缓存中没有，使用原来的方法获取并缓存结果

        Transform result;

        switch (layer)

        {

            case UILayer.Static:

                return staticTrans;

                result = staticTrans;

                break;

            case UILayer.Bottom:

                return bottomTrans;

                result = bottomTrans;

                break;

            case UILayer.Mid:

                return midTrans;

                result = midTrans;

                break;

            case UILayer.Top:

                return topTrans;

                result = topTrans;

                break;

            case UILayer.System:

                return systemTrans;

                result = systemTrans;

                break;

            default:

                return bottomTrans;

                result = bottomTrans;

                break;

        }

        
        layerTransformCache[layer] = result;

        return result;

    }

    

    // 获取UI实例，如果不存在则返回null