【Unity】Addressables下的图集（SpriteAtlas）内存优化

前言：
资源管理系统：Addressables
UI：模拟NGUI图集Sprite，在UGUI下继承Image增加UIImage组件，实现将SpriteAtlas组件拖拽到属性面板上，切换选择里面的小图
问题：在检查项目内存占用过高问题时，发现直接拖拽上去的资源不受Addressables系统的自动引用管理，导致部分资源虽然没有引用，但是未被释放，需要等待统一释放
ps.发现一个自己的“BUG”，在销毁UIImage物体时，忘记把Sprite属性置空，它经过代码控制切换的小图，在销毁后引用关系没有解除。。。

--------------------------------------------------------------------------------------------------------------------------
想法一（希望不会有二三四）：将原本拖拽图集并把引用保存到序列化信息中的操作，更改为只保存拖拽时对应资源的Addressables地址，并在UIImage初始化时，通过Addressables的加载接口去加载，这样把图集都放入它的自动管理里面，得让它干活！
开干->新建文件夹

 

public class LImage : Image
{
    /// <summary> 图集资源地址 </summary>
    [SerializeField]
    private string m_AtlasResPath;

    /// <summary> 加载到的图集 </summary>
    private SpriteAtlas m_Atlas;

    /// <summary> 当前显示小图名称 </summary>
    [SerializeField]
    private string m_SpriteName;
}

暂时先需要这些，图集资源地址和当前设置的小图名称是需要参与序列化，保存到预设中

1、初始加载图集

 public void Start()
 {
     InitAtlas();
 }

 private void InitAtlas()
 {
     Addressables.LoadAssetAsync<SpriteAtlas>(m_AtlasResPath).Completed += AtlasLoadCompleted;
 }

 private void AtlasLoadCompleted(UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationHandle<SpriteAtlas> obj)
 {
     if (!obj.IsDone || obj.Status == AsyncOperationStatus.Failed)
     {
         if (obj.OperationException != null && obj.OperationException.Message != null)
             UnityEngine.Debug.LogError("instantiate error:" + obj.OperationException.Message);
         else
             UnityEngine.Debug.LogError("instantiate error:.....");
         return;
     }

     m_Atlas = obj.Result;
 }

2、初始化Sprite

#region 初始化Sprite
private void InitSprite()
{
    if (m_Atlas != null && !string.IsNullOrEmpty(m_SpriteName))
    {
        sprite = m_Atlas.GetSprite(m_SpriteName);
    }
}
#endregion

在上面加载到图集后调用一次
3、提供SpriteName切换接口

public string SpriteName
{
    get { return m_SpriteName; }
    set
    {
        SetSpriteName(value);
    }
}

#region 初始化Sprite
private void InitSprite()
{
    SetSprite();
}

private void SetSprite()
{
    if (m_Atlas != null && !string.IsNullOrEmpty(m_SpriteName))
    {
        sprite = m_Atlas.GetSprite(m_SpriteName);
    }
}

private void SetSpriteName(string newValue)
{
    if (m_SpriteName != newValue)
    {
        m_SpriteName = newVal
ue;

        SetSprite();
    }
}
#endregion

先简单测试一遍上面的流程

 完全没有问题

 问题：在同一个图集，切换小图时，重复使用过的它也会重新复制一个出来，如果你这个用来播放序列帧，那内存就是+++++++

 有两个方案：
方案一：当时是在LImage中用缓存字典单独储存当前图集中的小图，重复使用时，可以直接用之前复制出来的缓存，避免重复生成；

private Dictionary<string, Sprite> m_CacheSpriteDic = new Dictionary<string, Sprite>();

private Sprite GetSprite(string spritename)
{
    if (!m_CacheSpriteDic.TryGetValue(spritename, out var _spriteCache))
    {
        if (m_Atlas != null)
        {
            _spriteCache = m_Atlas.GetSprite(spritename);
            m_CacheSpriteDic[spritename] = _spriteCache;
        }
    }

    return _spriteCache;
}

 多次切换，可以看出是可以解决缓存不断复制的问题，只是引用关系都还在，所以在物体销毁时，增加一个队缓存字典的释放销毁即可

方案二：在切换Sprite的时候把旧Sprite销毁掉

private void SetSprite()
{
    if (m_Atlas != null && !string.IsNullOrEmpty(m_SpriteName))
    {
        if (sprite != null)
        {
            GameObject.Destroy(sprite);
        }
        sprite = null;
        sprite = m_Atlas.GetSprite(m_SpriteName);
    }
}

 多次切换，可以看到在缓存中只有一份，它的问题在于如果是频繁切换，它会频繁销毁，缓存（不推荐）

方案三：新想的方案，之前是在单一LImage中缓存，如果创建一个图集单例管理，把正在使用的图集对应的缓存存储，不管是哪个LImage使用，都可以使用用一份Sprite缓存；
这个方案是在方案一的基础上诞生的，因为方案一尽管同一个LImage上的相同缓存只会保留一份，但如果多个LImage，还是会有多份缓存，所以我想着是不是可以在内存中，同一个图集中的同一个小图缓存只保留一份

新加脚本！！！。。。。

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.U2D;

public class SpriteAtlasManager
{
    private static SpriteAtlasManager _instance;
    public static SpriteAtlasManager Instance => _instance ?? (_instance = new SpriteAtlasManager());

    private readonly Dictionary<string, AtlasInfo> _atlasCache = new Dictionary<string, AtlasInfo>();

    private AtlasInfo tempAtlasInfo;

    public AtlasInfo GetAtlasInfo(string atlasName, Action callback = null)
    {
        if (_atlasCache.TryGetValue(atlasName, out tempAtlasInfo))
        {
            tempAtlasInfo.AddCallBack(callback);
            tempAtlasInfo.AddRefCount();
            return tempAtlasInfo;
        }

        _atlasCache[atlasName] = tempAtlasInfo = new AtlasInfo(atlasName, callback);

        return tempAtlasInfo;
    }

    public Sprite GetSprite(string atlasName, string spriteName, Action callback)
    {
        tempAtlasInfo = GetAtlasInfo(atlasName, callback);
        if (tempAtlasInfo != null)
        {
            return tempAtlasInfo.GetSprite(spriteName);
        }
        return null;
    }


    public void ReleaseAtlas(string atlasName, Action callback)
    {
        if (_atlasCache.TryGetValue(atlasName, out tempAtlasInfo))
        {
            tempAtlasInfo.RemoveCallBack(callback);
            tempAtlasInfo.RemoveRefCount();
        }
    }
    internal void DestroyAtlas(string atlasName)
    {
        if (_atlasCache.TryGetValue(atlasName, out tempAtlasInfo))
        {
            tempAtlasInfo.Release();
            _atlasCache.Remove(atlasName);
        }
    }
}

public class AtlasInfo
{
    private string _atlasName;
    private SpriteAtlas _atlas;
    private Dictionary<string, Sprite> _spriteCache;
    private int refCount;


    public AsyncOperationHandle<SpriteAtlas> OperationHandle;
    private List<Action> m_LoadCompletedCallBack;

    public AtlasInfo(string atlasName, Action callback)
    {
        _atlasName = atlasName;
        m_LoadCompletedCallBack = new List<Action>();
        _spriteCache = new Dictionary<string, Sprite>();

        AddCallBack(callback);
        OperationHandle = Addressables.LoadAssetAsync<SpriteAtlas>(atlasName);
        OperationHandle.Completed += OnAtlasLoadCompleted;
    }

    public void AddCallBack(Action callback)
    {
        if (!m_LoadCompletedCallBack.Contains(callback))
        {
            m_LoadCompletedCallBack.Add(callback);
        }
    }

    public void RemoveCallBack(Action callback)
    {
        m_LoadCompletedCallBack.Remove(callback);
    }

    private void OnAtlasLoadCompleted(AsyncOperationHandle<SpriteAtlas> handle)
    {
        if (handle.Status == AsyncOperationStatus.Succeeded)
        {
            _atlas = handle.Result;
            foreach (var callback in m_LoadCompletedCallBack)
            {
                callback?.Invoke();
            }
        }
        else
        {
            Debug.LogError($"Failed to load SpriteAtlas: {_atlasName}. Error: {handle.OperationException?.Message}");
        }
    }

    public Sprite GetSprite(string spriteName)
    {
        if (string.IsNullOrEmpty(spriteName)) return null;
        if (!_spriteCache.TryGetValue(spriteName, out var sprite))
        {
            sprite = _atlas?.GetSprite(spriteName);
            if (sprite != null)
            {
                _spriteCache[spriteName] = sprite;
            }
        }

        return sprite;
    }

    internal void AddRefCount()
    {
        refCount++;
    }

    internal void RemoveRefCount()
    {
        refCount--;

        if (refCount == 0)
        {
            SpriteAtlasManager.Instance.DestroyAtlas(_atlasName);
        }
    }

    internal void Release()
    {
        _atlas = null;
        foreach (var item in _spriteCache)
        {
            GameObject.Destroy(item.Value);
        }
        _spriteCache.Clear();
        _spriteCache = null;
        if (OperationHandle.IsValid())
        {
            Addressables.Release(OperationHandle);
        }
    }
}

加载图集信息

m_Atlas = SpriteAtlasManager.Instance.GetAtlasInfo(m_AtlasResPath, InitSprite);

protected override void OnDestroy()
{base.OnDestroy();SpriteAtlasManager.Instance.ReleaseAtlas(m_AtlasResPath, InitSprite);
}

在不需要当前图集信息的时候，调用一下卸载接口，减引用数量，当引用数为0的时候就会卸载掉资源

只看资源缓存和引用方面来看，这个方案是成功的

 但是我还是担心在调用过程中，有什么临时变量等问题产生，再做一下性能对比！