Exemple #1
0
    public static AsssetTextureDebugNode PushAssetDebugNode(int key, ResNode resNode, Dictionary <int, AsssetTextureDebugNode> table)
    {
        AsssetTextureDebugNode node = new AsssetTextureDebugNode();

        node.AssetName = resNode.AssetName;
        node.AssetPath = resNode.AssetBundleName;
        node.RefCount  = resNode.GetRefCount();
        if (!GetTextureMemory(resNode, ref node))
        {
            return(null);
        }
        table.Add(key, node);
        return(node);
    }
Exemple #2
0
    public static bool GetTextureMemory(ResNode res, ref AsssetTextureDebugNode node)
    {
        Texture2D tex = null;
        Sprite    sp  = null;

        if (res.isAsync)
        {
            if (res.isLoadFinish)
            {
                tex = res.AllAssets[0] as Texture2D;
                //转换失败,看看是不是sprite
                if (!tex)
                {
                    sp = res.AllAssets[0] as Sprite;
                    if (sp)
                    {
                        tex = sp.texture;
                    }
                }
            }
        }
        else
        {
            tex = res.AllAssets[0] as Texture2D;
            //转换失败,看看是不是sprite
            if (!tex)
            {
                sp = res.AllAssets[0] as Sprite;
                if (sp)
                {
                    tex = sp.texture;
                }
            }
        }

        if (tex)
        {
            node.MemoryUsedInMB = GetTextureMemory(tex.width, tex.height, tex.format, tex.mipmapCount > 1);
            node.minmap         = tex.mipmapCount > 1;
            if (sp)
            {
                node.isUIPacked = sp.packed;
                node.PackedSize = node.MemoryUsedInMB;
                node.PackedName = tex.name;
            }
        }
        return(tex);
    }
Exemple #3
0
    public static void GenerateTextureNodeList()
    {
        LoadingAssetList.Clear();
        SceneAssetsDebugNodeList.Clear();
        UIAssetsDebugNodeList.Clear();
        HeroAssetsDebugNodeList.Clear();
        MonsterAssetsDebugNodeList.Clear();
        EffectAssetsDebugNodeList.Clear();
        onUnLoadingDebugNodeList.Clear();
        UIPackedCacluate.Clear();
        CommAssetsDebugNodeList.Clear();
        EffectUsedTotal      = 0.0f;
        onUnLoadingUsedTotal = 0.0f;
        MonsterUsedTotal     = 0.0f;
        HeroUsedTotal        = 0.0f;
        UIUsedTotal          = 0.0f;
        SceneUsedTotal       = 0.0f;
        UIDebugNodeCount     = 0.0f;
        CommUsedTotal        = 0.0f;

        foreach (ResNode resNode in m_TextureResTable.Values)
        {
            bool needToCacluate = true;
            if (resNode.isAsync)
            {
                needToCacluate = resNode.isLoadFinish;
            }

            if (!needToCacluate)
            {
                LoadingAssetList.Add(resNode.instanceID);
            }
            else
            {
                if (IsScenePath(resNode.AssetBundleName))
                {
                    AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, SceneAssetsDebugNodeList);
                    if (null == node)
                    {
                        continue;
                    }

                    SceneUsedTotal += node.MemoryUsedInMB;
                }
                else if (IsHeroPath(resNode.AssetBundleName))
                {
                    AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, HeroAssetsDebugNodeList);
                    if (null == node)
                    {
                        continue;
                    }
                    HeroUsedTotal += node.MemoryUsedInMB;
                }
                else if (IsMonsterPath(resNode.AssetBundleName))
                {
                    AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, MonsterAssetsDebugNodeList);
                    if (null == node)
                    {
                        continue;
                    }
                    MonsterUsedTotal += node.MemoryUsedInMB;
                }
                else if (IsEffectPath(resNode.AssetBundleName))
                {
                    AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, EffectAssetsDebugNodeList);
                    if (null == node)
                    {
                        continue;
                    }
                    EffectUsedTotal += node.MemoryUsedInMB;
                }
            }
        }

        foreach (ResNode resNode in m_TextureCacheResTable.Values)
        {
            AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, onUnLoadingDebugNodeList);
            if (null == node)
            {
                continue;
            }

            onUnLoadingUsedTotal += node.MemoryUsedInMB;
        }

        foreach (ResNode resNode in m_SpriteTable.Values)
        {
            AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, UIAssetsDebugNodeList);
            if (null == node)
            {
                continue;
            }
            if (node.isUIPacked)
            {
                if (!UIPackedCacluate.ContainsKey(node.PackedName))
                {
                    UIUsedTotal += node.PackedSize;
                    UIPackedCacluate.Add(node.PackedName, 1);
                    UIDebugNodeCount++;
                }
                else
                {
                    UIPackedCacluate[node.PackedName]++;
                }
            }
            else
            {
                UIUsedTotal += node.MemoryUsedInMB;
                UIDebugNodeCount++;
            }
        }

        foreach (ResNode resNode in m_UISpriteCacheTable.Values)
        {
            AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, UIAssetsDebugNodeList);
            if (null == node)
            {
                continue;
            }
            if (node.isUIPacked)
            {
                if (UIPackedCacluate.ContainsKey(node.PackedName))
                {
                    int cout = --UIPackedCacluate[node.PackedName];
                    if (cout <= 0)
                    {
                        onUnLoadingUsedTotal += node.PackedSize;
                        UIUsedTotal          -= node.PackedSize;
                        UIPackedCacluate.Remove(node.PackedName);
                    }
                }
            }
            else
            {
                onUnLoadingUsedTotal += node.MemoryUsedInMB;
                UIUsedTotal          -= node.PackedSize;
            }
        }

        foreach (ResNode resNode in m_CommonResNodeTable.Values)
        {
            AsssetTextureDebugNode node = PushAssetDebugNode(resNode.instanceID, resNode, CommAssetsDebugNodeList);
            if (null == node)
            {
                continue;
            }
            CommUsedTotal += node.MemoryUsedInMB;
        }
    }