一.大致功能
- 以双向链表为基础的资源池
- 基础资源同步加载
- 基本资源卸载
- 基础资源异步加载
- 清空缓存
- 预加载
- 为ObjectManager提供的同步异步资源加载
使用双向链表的原因 : 资源的使用频率，如果资源频繁使用，希望其处于最顶端，不使用的慢慢放在底端去，清理缓存的时候从底端开始清理
二.双向链表
基本功能 ：
//双向链表结构节点
public class DoubleLinkedListNode<T> where T : class, new()
{
//前一个节点
public DoubleLinkedListNode<T> prev = null;
//后一个节点
public DoubleLinkedListNode<T> next = null;
//当前节点
public T t = null;
}
//双向链表结构
public class DoubleLinedList<T> where T : class, new()
{
//表头
public DoubleLinkedListNode<T> Head = null;
//表尾
public DoubleLinkedListNode<T> Tail = null;
//双向链表结构类对象池
protected ClassObjectPool<DoubleLinkedListNode<T>> m_DoubleLinkNodePool = ObjectManager.Instance.GetOrCreatClassPool<DoubleLinkedListNode<T>>(500);
//个数
protected int m_Count = 0;
public int Count
{
get { return m_Count; }
}
/// <summary>
/// 添加一个节点到头部
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public DoubleLinkedListNode<T> AddToHeader(T t)
{
DoubleLinkedListNode<T> pList = m_DoubleLinkNodePool.Spawn(true);
pList.next = null;
pList.prev = null;
pList.t = t;
return AddToHeader(pList);
}
/// <summary>
/// 添加一个节点到头部
/// </summary>
/// <param name="pNode"></param>
/// <returns></returns>
public DoubleLinkedListNode<T> AddToHeader(DoubleLinkedListNode<T> pNode)
{
if (pNode == null)
return null;
pNode.prev = null;
if (Head == null)
{
Head = Tail = pNode;
}
else
{
pNode.next = Head;
Head.prev = pNode;
Head = pNode;
}
m_Count++;
return Head;
}
/// <summary>
/// 添加节点到尾部
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public DoubleLinkedListNode<T> AddToTail(T t)
{
DoubleLinkedListNode<T> pList = m_DoubleLinkNodePool.Spawn(true);
pList.next = null;
pList.prev = null;
pList.t = t;
return AddToTail(pList);
}
/// <summary>
/// 添加节点到尾部
/// </summary>
/// <param name="pNode"></param>
/// <returns></returns>
public DoubleLinkedListNode<T> AddToTail(DoubleLinkedListNode<T> pNode)
{
if (pNode == null)
return null;
pNode.next = null;
if (Tail == null)
{
Head = Tail = pNode;
}
else
{
pNode.prev = Tail;
Tail.next = pNode;
Tail = pNode;
}
m_Count++;
return Tail;
}
/// <summary>
/// 移除某个节点
/// </summary>
/// <param name="pNode"></param>
public void RemoveNode(DoubleLinkedListNode<T> pNode)
{
if (pNode == null)
return;
if (pNode == Head)
Head = pNode.next;
if (pNode == Tail)
Tail = pNode.prev;
if (pNode.prev != null)
pNode.prev.next = pNode.next;
if (pNode.next != null)
pNode.next.prev = pNode.prev;
pNode.next = pNode.prev = null;
pNode.t = null;
m_DoubleLinkNodePool.Recycle(pNode);
m_Count--;
}
/// <summary>
/// 把某个节点移动到头部
/// </summary>
/// <param name="pNode"></param>
public void MoveToHead(DoubleLinkedListNode<T> pNode)
{
if (pNode == null || pNode == Head)
return;
if (pNode.prev == null && pNode.next == null)
return;
if (pNode == Tail)
Tail = pNode.prev;
if (pNode.prev != null)
pNode.prev.next = pNode.next;
if (pNode.next != null)
pNode.next.prev = pNode.prev;
pNode.prev = null;
pNode.next = Head;
Head.prev = pNode;
Head = pNode;
if (Tail == null)
{
Tail = Head;
}
}
}对其简单的封装（一般包括插入，查找，获取表头，获取表尾，清除，移除，获取长度等）：
//封装双向链表
public class CMapList<T> where T : class, new()
{
DoubleLinedList<T> m_DLink = new DoubleLinedList<T>();
Dictionary<T, DoubleLinkedListNode<T>> m_FindMap = new Dictionary<T, DoubleLinkedListNode<T>>();
~CMapList()
{
Clear();
}
/// <summary>
/// 清除列表
/// </summary>
public void Clear()
{
while (m_DLink.Tail != null)
{
Remove(m_DLink.Tail.t);
}
}
/// <summary>
/// 插入一个节点到表头
/// </summary>
/// <param name="t"></param>
public void InsertToHead(T t)
{
DoubleLinkedListNode<T> node = null;
if (m_FindMap.TryGetValue(t, out node) && node != null)
{
m_DLink.AddToHeader(node);
return;
}
m_DLink.AddToHeader(t);
m_FindMap.Add(t, m_DLink.Head);
}
/// <summary>
/// 从表尾弹出一个结点
/// </summary>
public void Pop()
{
if (m_DLink.Tail != null)
{
Remove(m_DLink.Tail.t);
}
}
/// <summary>
/// 删除某个节点
/// </summary>
/// <param name="t"></param>
public void Remove(T t)
{
DoubleLinkedListNode<T> node = null;
if (!m_FindMap.TryGetValue(t, out node) || node == null)
{
return;
}
m_DLink.RemoveNode(node);
m_FindMap.Remove(t);
}
/// <summary>
/// 获取到尾部节点
/// </summary>
/// <returns></returns>
public T Back()
{
return m_DLink.Tail == null ? null : m_DLink.Tail.t;
}
/// <summary>
/// 返回节点个数
/// </summary>
/// <returns></returns>
public int Size()
{
return m_FindMap.Count;
}
/// <summary>
/// 查找是否存在该节点
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public bool Find(T t)
{
DoubleLinkedListNode<T> node = null;
if (!m_FindMap.TryGetValue(t, out node) || node == null)
return false;
return true;
}
/// <summary>
/// 刷新某个节点，把节点移动到头部
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public bool Reflesh(T t)
{
DoubleLinkedListNode<T> node = null;
if (!m_FindMap.TryGetValue(t, out node) || node == null)
return false;
m_DLink.MoveToHead(node);
return true;
}
}
三.基础资源同步加载与卸载
思路 : 根据之前打包所在的路径获取CRC，根据CRC获取中间类ResouceItem（单个资源对应的中间类，哪怕prefabs依赖的资源也是单个对应一个ResouceItem）
/// <summary>
/// 同步资源加载，外部直接调用，仅加载不需要实例化的资源，例如Texture,音频，txt等等
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path"></param>
/// <returns></returns>
public T LoadResource<T>(string path) where T : UnityEngine.Object
{
if (string.IsNullOrEmpty(path)) //string判断为空尽量用这个
{
return null;
}
uint crc = Crc32.GetCrc32(path);
//从缓存池进行缓存（判断是否已经缓存）
ResouceItem item = GetCacheResouceItem(crc);
if (item != null)
{
return item.m_Obj as T;
}
T obj = null;
// //用来测试编辑器中AB包的加载
//#if UNITY_EDITOR
// if (!m_LoadFormAssetBundle)
// {
// item = AssetBundleManager.Instance.FindResourceItme(crc);
// if (item != null && item.m_AssetBundle != null)
// {
// if (item.m_Obj != null)
// {
// obj = (T)item.m_Obj;
// }
// else
// {
// obj = item.m_AssetBundle.LoadAsset<T>(item.m_AssetName);
// }
// }
// else
// {
// if (item == null)
// {
// item = new ResouceItem();
// item.m_Crc = crc;
// }
// obj = LoadAssetByEditor<T>(path);
// }
// }
//#endif
//手机上运行
if (obj == null)
{
item = AssetBundleManager.Instance.LoadResouceAssetBundle(crc);
if (item != null && item.m_AssetBundle != null)
{
if (item.m_Obj != null)
{
obj = item.m_Obj as T;
}
else
{
obj = item.m_AssetBundle.LoadAsset<T>(item.m_AssetName);
}
}
}
CacheResource(path, ref item, crc, obj);
return obj;
}
/// <summary>
/// 根据ResouceObj卸载资源
/// </summary>
/// <param name="resObj"></param>
/// <param name="destoryObj"></param>
/// <returns></returns>
public bool ReleaseResouce(ResouceObj resObj, bool destoryObj = false)
{
if (resObj == null)
return false;
ResouceItem item = null;
if (!AssetDic.TryGetValue(resObj.m_Crc, out item) || null == item)
{
Debug.LogError("AssetDic里不存在改资源：" + resObj.m_CloneObj.name + " 可能释放了多次");
}
GameObject.Destroy(resObj.m_CloneObj);
item.RefCount--;
DestoryResouceItme(item, destoryObj);
return true;
}
/// <summary>
/// 不需要实例化的资源的卸载，根据对象
/// </summary>
/// <param name="obj"></param>
/// <param name="destoryObj"></param>
/// <returns></returns>
public bool ReleaseResouce(Object obj, bool destoryObj = false)
{
if (obj == null)
{
return false;
}
//根据GUID查找资源
ResouceItem item = null;
foreach (ResouceItem res in AssetDic.Values)
{
if (res.m_Guid == obj.GetInstanceID())
{
item = res;
}
}
if (item == null)
{
Debug.LogError("AssetDic里不存在改资源：" + obj.name + " 可能释放了多次");
return false;
}
//释放减少引用计数
item.RefCount--;
DestoryResouceItme(item, destoryObj);
return true;
}
/// <summary>
/// 不需要实例化的资源卸载，根据路径
/// </summary>
/// <param name="path"></param>
/// <param name="destoryObj"></param>
/// <returns></returns>
public bool ReleaseResouce(string path, bool destoryObj = false)
{
if (string.IsNullOrEmpty(path))
{
return false;
}
uint crc = Crc32.GetCrc32(path);
ResouceItem item = null;
if (!AssetDic.TryGetValue(crc, out item) || null == item)
{
Debug.LogError("AssetDic里不存在改资源：" + path + " 可能释放了多次");
}
item.RefCount--;
DestoryResouceItme(item, destoryObj);
return true;
}
/// <summary>
/// 缓存加载的资源
/// </summary>
/// <param name="path"></param>
/// <param name="item"></param>
/// <param name="crc"></param>
/// <param name="obj"></param>
/// <param name="addrefcount"></param>
void CacheResource(string path, ref ResouceItem item, uint crc, Object obj, int addrefcount = 1)
{
//缓存太多，清除最早没有使用的资源
WashOut();
if (item == null)
{
Debug.LogError("ResouceItem is null, path: " + path);
}
if (obj == null)
{
Debug.LogError("ResouceLoad Fail : " + path);
}
item.m_Obj = obj;
item.m_Guid = obj.GetInstanceID(); //获取GUID
item.m_LastUseTime = Time.realtimeSinceStartup; //修改成自游戏开始运行的实时时间
item.RefCount += addrefcount;
ResouceItem oldItme = null;
if (AssetDic.TryGetValue(item.m_Crc, out oldItme))
{
AssetDic[item.m_Crc] = item;
}
else
{
AssetDic.Add(item.m_Crc, item);
}
}
/// <summary>
/// 缓存太多，清除最早没有使用的资源
/// </summary>
protected void WashOut()
{
//当大于缓存个数时，进行一半释放
while (m_NoRefrenceAssetMapList.Size() >= MAXCACHECOUNT)
{
for (int i = 0; i < MAXCACHECOUNT / 2; i++)
{
ResouceItem item = m_NoRefrenceAssetMapList.Back();
DestoryResouceItme(item, true);
}
}
}
/// <summary>
/// 回收一个资源
/// </summary>
/// <param name="item"></param>
/// <param name="destroyCache">是否清除AB包缓存</param>
protected void DestoryResouceItme(ResouceItem item, bool destroyCache = false)
{
if (item == null || item.RefCount > 0)
{
return;
}
if (!destroyCache)
{
m_NoRefrenceAssetMapList.InsertToHead(item);
return;
}
if (!AssetDic.Remove(item.m_Crc))
{
return;
}
m_NoRefrenceAssetMapList.Remove(item);
//释放assetbundle引用
AssetBundleManager.Instance.ReleaseAsset(item);
//清空资源对应的对象池
ObjectManager.Instance.ClearPoolObject(item.m_Crc);
if (item.m_Obj != null)
{
item.m_Obj = null;
#if UNITY_EDITOR
Resources.UnloadUnusedAssets();
#endif
}
}测试 :
Debug.Log(ResourceManager.Instance.LoadResource<AudioClip>("Assets/GameData/Sounds/menusound.mp3").name);四.基础资源异步加载
思路 : 首先判断资源是否已经加载，如果已经加载，调用加载完成函数，如果未加载，判断是否正在加载资源,
/// <summary>
/// 异步加载资源（仅仅是不需要实例化的资源，例如音频，图片等等）
/// </summary>
public void AsyncLoadResource(string path, OnAsyncObjFinish dealFinish, LoadResPriority priority, bool isSprite = false, object param1 = null, object param2 = null,object param3 =null, uint crc = 0)
{
if (crc == 0)
{
crc = Crc32.GetCrc32(path);
}
ResouceItem item = GetCacheResouceItem(crc);
if (item != null)
{
if (dealFinish != null)
{
dealFinish(path, item.m_Obj, param1, param2, param3);
}
return;
}
//判断是否在加载中
AsyncLoadResParam para = null;
//如果未在加载中
if (!m_LoadingAssetDic.TryGetValue(crc, out para) || para == null)
{
para = m_AsyncLoadResParamPool.Spawn(true);
para.m_Crc = crc;
para.m_Path = path;
para.m_Sprite = isSprite;
para.m_Priority = priority;
//放入在加载的Dic中
m_LoadingAssetDic.Add(crc, para);
//放入优先级为(int)priority的在异步加载的List中
m_LoadingAssetList[(int)priority].Add(para);
}
//如果在加载中，将回调函数更改为此次调用的回调参数
//往回调列表里面加回调
AsyncCallBack callBack = m_AsyncCallBackPool.Spawn(true);
callBack.m_DealObjFinish = dealFinish;
//添加回调参数
callBack.m_Param1 = param1;
callBack.m_Param2 = param2;
callBack.m_Param3 = param3;
para.m_CallBackList.Add(callBack);
}
/// <summary>
/// 从资源池获取缓存资源
/// </summary>
/// <param name="crc"></param>
/// <param name="addrefcount"></param>
/// <returns></returns>
ResouceItem GetCacheResouceItem(uint crc, int addrefcount = 1)
{
ResouceItem item = null;
if (AssetDic.TryGetValue(crc, out item))
{
if (item != null)
{
item.RefCount += addrefcount;
item.m_LastUseTime = Time.realtimeSinceStartup;
}
}
return item;
}
/// <summary>
/// 异步加载
/// </summary>
/// <returns></returns>
IEnumerator AsyncLoadCor()
{
List<AsyncCallBack> callBackList = null;
//上一次yield的视角，用来判断加载资源所用的时间是否超过MAXLOADRESTIME
long lastYiledTime = System.DateTime.Now.Ticks;
while (true)
{
bool haveYield = false;
//从最高优先级开始
for(int i = 0; i < (int)LoadResPriority.RES_NUM; i++)
{
//如果有优先级高的将i置换成优先级高的数值
if (m_LoadingAssetList[(int)LoadResPriority.RES_HIGHT].Count > 0)
{
i = (int)LoadResPriority.RES_HIGHT;
}
else if (m_LoadingAssetList[(int)LoadResPriority.RES_MIDDLE].Count > 0)
{
i = (int)LoadResPriority.RES_MIDDLE;
}
List<AsyncLoadResParam> loadingList = m_LoadingAssetList[i];
if (loadingList.Count <= 0)
continue;
//获取当前优先度第一个
AsyncLoadResParam loadingItem = loadingList[0];
loadingList.RemoveAt(0);
callBackList = loadingItem.m_CallBackList;
Object obj = null;
ResouceItem item = null;
//#if UNITY_EDITOR
// if (!m_LoadFormAssetBundle)
// {
// if (loadingItem.m_Sprite)
// {
// obj = LoadAssetByEditor<Sprite>(loadingItem.m_Path);
// }
// else
// {
// obj = LoadAssetByEditor<Object>(loadingItem.m_Path);
// }
// //模拟异步加载
// yield return new WaitForSeconds(0.5f);
// item = AssetBundleManager.Instance.FindResourceItme(loadingItem.m_Crc);
// if (item == null)
// {
// item = new ResouceItem();
// item.m_Crc = loadingItem.m_Crc;
// }
// }
//#endif
if (obj == null)
{
//获取ResouceItem
item = AssetBundleManager.Instance.LoadResouceAssetBundle(loadingItem.m_Crc);
if (item != null && item.m_AssetBundle != null)
{
AssetBundleRequest abRequest = null;
//异步加载资源
if (loadingItem.m_Sprite)
{
abRequest = item.m_AssetBundle.LoadAssetAsync<Sprite>(item.m_AssetName);
}
else
{
abRequest = item.m_AssetBundle.LoadAssetAsync(item.m_AssetName);
}
yield return abRequest;
if (abRequest.isDone)
{
obj = abRequest.asset;
}
lastYiledTime = System.DateTime.Now.Ticks;
}
}
CacheResource(loadingItem.m_Path, ref item, loadingItem.m_Crc, obj, callBackList.Count);
for (int j = 0; j < callBackList.Count; j++)
{
//加载完成的回调(针对ObjectManager)
AsyncCallBack callBack = callBackList[j];
if (callBack != null && callBack.m_DealFinish != null && callBack.m_ResObj != null)
{
ResouceObj tempResObj = callBack.m_ResObj;
tempResObj.m_ResItem = item;
callBack.m_DealFinish(loadingItem.m_Path, tempResObj, tempResObj.m_Param1, tempResObj.m_Param2, tempResObj.m_Param3);
callBack.m_DealFinish = null;
tempResObj = null;
}
//加载完成的回调
if (callBack != null && callBack.m_DealObjFinish != null)
{
callBack.m_DealObjFinish(loadingItem.m_Path, obj, callBack.m_Param1, callBack.m_Param2, callBack.m_Param3);
callBack.m_DealObjFinish = null;
}
//清空回调并回收
callBack.Reset();
m_AsyncCallBackPool.Recycle(callBack);
}
obj = null;
callBackList.Clear();
m_LoadingAssetDic.Remove(loadingItem.m_Crc);
loadingItem.Reset();
m_AsyncLoadResParamPool.Recycle(loadingItem);
//????
if (System.DateTime.Now.Ticks - lastYiledTime > MAXLOADRESTIME)
{
yield return null;
lastYiledTime = System.DateTime.Now.Ticks;
haveYield = true;
}
}
if (!haveYield || System.DateTime.Now.Ticks - lastYiledTime > MAXLOADRESTIME)
{
lastYiledTime = System.DateTime.Now.Ticks;
yield return null;
}
}
}
public void Init(MonoBehaviour mono)
{
for (int i = 0; i < (int)LoadResPriority.RES_NUM; i++)
{
m_LoadingAssetList[i] = new List<AsyncLoadResParam>();
}
m_Startmono = mono;
m_Startmono.StartCoroutine(AsyncLoadCor());
}测试 :
ResourceManager.Instance.AsyncLoadResource("Assets/GameData/UGUI/Test1.png", OnLoadSpriteTest1, LoadResPriority.RES_MIDDLE, true);五.清空缓存
在程序退出和跳转场景时进行调用
/// <summary>
/// 清空缓存
/// </summary>
public void ClearCache()
{
List<ResouceItem> tempList = new List<ResouceItem>();
foreach (ResouceItem item in AssetDic.Values)
{
if (item.m_Clear)
{
tempList.Add(item);
}
}
foreach (ResouceItem item in tempList)
{
DestoryResouceItme(item, true);
}
tempList.Clear();
}六.预加载
/// <summary>
/// 预加载资源
/// </summary>
/// <param name="path"></param>
public void PreloadRes(string path)
{
if (string.IsNullOrEmpty(path))
{
return;
}
uint crc = Crc32.GetCrc32(path);
//注意没有增加引用计数
ResouceItem item = GetCacheResouceItem(crc, 0);
if (item != null)
{
return;
}
Object obj = null;
//#if UNITY_EDITOR
// if (!m_LoadFormAssetBundle)
// {
// item = AssetBundleManager.Instance.FindResourceItme(crc);
// if (item != null && item.m_Obj != null)
// {
// obj = item.m_Obj as Object;
// }
// else
// {
// if (item == null)
// {
// item = new ResouceItem();
// item.m_Crc = crc;
// }
// obj = LoadAssetByEditor<Object>(path);
// }
// }
//#endif
if (obj == null)
{
item = AssetBundleManager.Instance.LoadResouceAssetBundle(crc);
if (item != null && item.m_AssetBundle != null)
{
if (item.m_Obj != null)
{
obj = item.m_Obj;
}
else
{
obj = item.m_AssetBundle.LoadAsset<Object>(item.m_AssetName);
}
}
}
//放入AssetDic中(增加了引用计数)
CacheResource(path, ref item, crc, obj);
//跳场景不清空缓存
item.m_Clear = false;
//只是为了减少引用计数
ReleaseResouce(obj, false);
}
扫一扫
5703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
