public bool CancelAsyncLoad(ResourceObject resObj)
{
AsyncLoadResParam asyncParam = null;
//首先获取是否存在该异步加载资源
if (m_LoadingAssetDict.TryGetValue(resObj.m_Crc, out asyncParam) && m_LoadAsyncResList[(int)resObj.m_LoadPriority].Contains(asyncParam))
{
for (int i = asyncParam.callBackList.Count - 1; i >= 0; i--)
{
AsyncCallBack tempCallBack = asyncParam.callBackList[i];
//这个判断是，当有多个物体A,B都需要加载同样的资源时，如果A取消了，但是B不能取消
if (tempCallBack != null && tempCallBack.resObj == resObj)
{
tempCallBack.Reset();
m_AsyncCallBackPool.UnSpawn(tempCallBack);
asyncParam.callBackList.RemoveAt(i);
}
}
//在上层遍历完，如果异步回调列表空了，则代表不再需要异步加载该资源了，因此直接清空回收
if (asyncParam.callBackList.Count <= 0)
{
asyncParam.Reset();
m_LoadAsyncResList[(int)resObj.m_LoadPriority].Remove(asyncParam);
m_LoadingAssetDict.Remove(resObj.m_Crc);
m_AsyncLoadResPool.UnSpawn(asyncParam);
return(true);
}
}
return(false);
}
/// <summary>
/// 取消异步加载资源
/// </summary>
/// <returns>true为完全取消了，false表示可能还有其他相同操作的异步在进行，并没有取消</returns>
public bool CancleLoad(ResourceObj resObj)
{
AsyncLoadResParam para = null;
if (m_LoadingAssetDic.TryGetValue(resObj.m_Crc, out para) && m_LoadingAssetList[(int)para.m_Priority].Contains(para))
{
for (int i = para.m_CallBackList.Count - 1; i >= 0; i--)
{
AsyncCallBack tempCallBack = para.m_CallBackList[i];
if (tempCallBack != null && resObj == tempCallBack.m_ResObj)
{
tempCallBack.Reset();
m_AsyncCallBackPool.Recycle(tempCallBack);
para.m_CallBackList.Remove(tempCallBack);
}
}
if (para.m_CallBackList.Count <= 0)
{
m_LoadingAssetList[(int)para.m_Priority].Remove(para);
para.Reset();
m_AsyncLoadResParamPool.Recycle(para);
m_LoadingAssetDic.Remove(resObj.m_Crc);
return(true);
}
}
return(false);
}
public void AsyncLoadResource(string path, ResourceObj resObj, OnAsyncFinish dealfinish, LoadResPriority priority)
{
ResourceItem item = GetCacheResourceItem(resObj.m_Crc);
if (item != null)
{
resObj.m_ResItem = item;
if (dealfinish != null)
{
dealfinish(path, resObj, resObj.m_Param1, resObj.m_Param2, resObj.m_Param3);
}
return;
}
//判断是否在加载中
AsyncLoadResParam para = null;
if (!m_LoadingAssetDic.TryGetValue(resObj.m_Crc, out para) || para == null)
{
para = m_AsyncLoadResParamPool.Spwan(true);
para.m_Crc = resObj.m_Crc;
para.m_Path = path;
para.m_Priority = priority;
m_LoadingAssetDic.Add(resObj.m_Crc, para);
m_LoadingAssetList[(int)priority].Add(para);
}
//往回调列表里面加回调
AsyncCallBack callBack = m_AsyncCallBackPool.Spwan(true);
callBack.m_DealFinish = dealfinish;
callBack.m_ResObj = resObj;
para.m_CallBackList.Add(callBack);
}
/// <summary>
/// 用于ObjectManager异步加载接口
/// </summary>
public void AsyncLoadResObj(string path, ResourceObject resObj, OnAsyncResFinshCallBack resLoadCallBack)
{
ResourceItem item = GetCacheResourceItem(resObj.m_Crc);
if (item != null)
{
resObj.m_ResItem = item;
resLoadCallBack?.Invoke(path, resObj, resObj.m_Param1, resObj.m_Param2, resObj.m_Param3);
resLoadCallBack = null;
return;
}
//判断当前要加载的资源是否已存在加载列表中，不存在，则加入加载列表
AsyncLoadResParam param = null;
if (!m_LoadingAssetDict.TryGetValue(resObj.m_Crc, out param) || param == null)
{
param = m_AsyncLoadResPool.Spawn();
param.m_Crc = resObj.m_Crc;
param.m_Path = path;
param.m_Priority = resObj.m_LoadPriority;
m_LoadingAssetDict.Add(resObj.m_Crc, param);
m_LoadAsyncResList[(int)resObj.m_LoadPriority].Add(param);
}
//回调列表里添加回调
AsyncCallBack asyncCallBack = m_AsyncCallBackPool.Spawn();
asyncCallBack.resObj = resObj;
asyncCallBack.resFinshCallBack = resLoadCallBack;
param.callBackList.Add(asyncCallBack);
}
//异步资源加载-----------------------------------------------------------------------------------
/// <summary>
/// 异步加载资源
/// </summary>
/// <param name="path">资源路径</param>
/// <param name="finishCallBack">完成后回调</param>
/// <param name="loadPriority">加载优先级</param>
/// <param name="param1">回调参数1</param>
/// <param name="param2">回调参数2</param>
/// <param name="param3">回调参数3</param>
public void AsyncLoadResource(string path, OnAsyncFinishCallBack finishCallBack, LoadPriority loadPriority, bool isSprite = false,
object param1 = null, object param2 = null, object param3 = null)
{
uint crc = CRC32.GetCRC32(path);
ResourceItem item = GetCacheResourceItem(crc);
if (item != null)
{
finishCallBack?.Invoke(path, item.m_Obj, param1, param2, param3);
return;
}
//判断当前要加载的资源是否已存在加载列表中，不存在，则加入加载列表
AsyncLoadResParam param = null;
if (!m_LoadingAssetDict.TryGetValue(crc, out param) || param == null)
{
param = m_AsyncLoadResPool.Spawn();
param.m_Crc = crc;
param.m_Path = path;
param.m_Priority = loadPriority;
param.m_IsSprite = isSprite;
m_LoadAsyncResList[(int)loadPriority].Add(param);
m_LoadingAssetDict.Add(crc, param);
}
//回调列表里添加回调
AsyncCallBack asyncCallBack = m_AsyncCallBackPool.Spawn();
asyncCallBack.finishCallBack = finishCallBack;
asyncCallBack.param1 = param1;
asyncCallBack.param2 = param2;
asyncCallBack.param3 = param3;
param.callBackList.Add(asyncCallBack);
}
static void Main(string[] args)
{ /// .Net 3.5 / 4.0 only ;)
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.WriteLine("NativePayload_AsyncMEnumSystemLocalesA , Published by Damon Mohammadbagher , Mar 2021");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("NativePayload_AsyncMEnumSystemLocalesA Callback Functions Technique via (EnumSystemLocalesA + AsyncMethod) API");
Console.WriteLine();
pay = args[0];
AsyncCallBack CsharpMethod = new AsyncCallBack(EnumSystemLocalesAExecCode);
System.Threading.Thread.Sleep(5555);
bool okAgain = EnumSystemLocalesA(CsharpMethod, 0x0);
Console.ReadKey();
}
/// <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;
m_LoadingAssetDic.Add(crc, para);
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>
public void AsyncLoadResource(string path, OnAsyncObjFinish dealFinish, LoadResPriority priority, uint crc = 0, object param1 = null, object param2 = null, object param3 = null)
{
if (crc == 0)
{
crc = CRC32.GetCRC32(path);
}
ResourceItem item = GetCancheResourceItem(crc);
if (item != null)
{
if (dealFinish != null)
{
dealFinish(path, item._obj, param1, param2, param3);
}
return;
}
//判断是否在加载中
AsyncLoadResParam param = null;
if (!_loadingAssetDic.TryGetValue(crc, out param) || param == null)
{
param = _asyncLoadResParamPool.Spawn(true);
param.crc = crc;
param.path = path;
param.priority = priority;
_loadingAssetDic.Add(crc, param);
_loadingAssetList[(int)priority].Add(param);
}
//往回调列表里面加回调
AsyncCallBack callBack = _asyncCallBackPool.Spawn(true);
callBack.dealFinish = dealFinish;
callBack.param1 = param1;
callBack.param2 = param2;
callBack.param3 = param3;
param.callBackList.Add(callBack);
}
/// <summary>
/// 异步加载
/// ?一直在运行
/// </summary>
/// <returns></returns>
IEnumerator AsyncLoadCor()
{
long lastYiledTime = System.DateTime.Now.Ticks;
List <AsyncCallBack> callBacks = null;
bool hadYiled = false;
while (true)
{
//上一次yield的时间
for (int i = 0; i < (int)LoadResPriority.RES_NUM; i++)
{
List <AsyncLoadResParam> loadingList = m_LoadingAssetList[i];
if (loadingList.Count <= 0)
{
continue;
}
AsyncLoadResParam loadingItem = loadingList[0];
loadingList.RemoveAt(0);
callBacks = loadingItem.m_CallBackList;
Object obj = null;
ResourceItem item = null;
#if UNITY_EDITOR
if (!m_LoadFromAssetBundle)
{
obj = LoadAssetByEditor <Object>(loadingItem.m_Path);
//模拟异步加载
yield return(new WaitForSeconds(0.5f));
item = AssetBundleManager.Instance.FindResourceItem(loadingItem.m_Crc);
}
#endif
if (obj == null)
{
item = AssetBundleManager.Instance.LoadResourceAssetBundle(loadingItem.m_Crc);
if (item != null && item.m_AssetBundle)
{
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, callBacks.Count);
for (int j = 0; j < callBacks.Count; j++)
{
AsyncCallBack callBack = callBacks[j];
if (callBack != null && callBack.m_DealFinish != null && callBack.m_ResObj != null)
{
ResourceObj 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;
callBacks.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;
hadYiled = true;
}
}
if (hadYiled || System.DateTime.Now.Ticks - lastYiledTime > MAXLOADRESTIME)
{
lastYiledTime = System.DateTime.Now.Ticks;
yield return(null);
}
}
}
private static extern bool EnumSystemLocalesA(AsyncCallBack ops, uint dwFlags);
/// <summary>
/// 异步加载
/// </summary>
IEnumerator AsyncLoader()
{
List <AsyncCallBack> callBackList = null;
//上一次yield的时间
long lastYiledTime = System.DateTime.Now.Ticks;
while (true)
{
bool haveYield = false;
for (int i = 0; i < (int)LoadResPriority.RES_NUM; i++)
{
List <AsyncLoadResParam> loadingList = _loadingAssetList[i];
if (loadingList.Count <= 0)
{
continue;
}
AsyncLoadResParam loadingItem = loadingList[0];
loadingList.RemoveAt(0);
callBackList = loadingItem.callBackList;
Object obj = null;
ResourceItem item = null;
#if UNITY_EDITOR
if (!_loadFromAssetBundle)
{
obj = LoadAssetByEditor <Object>(loadingItem.path);
//模拟异步加载
yield return(new WaitForSeconds(0.5f));
item = ABMgr.Ins.FingResourceItem(loadingItem.crc);
}
#endif
if (obj == null)
{
item = ABMgr.Ins.LoadResAssetBundle(loadingItem.crc);
if (item != null && item._assetBundle != null)
{
AssetBundleRequest abRequest = null;
if (loadingItem.isSprite)
{
abRequest = item._assetBundle.LoadAssetAsync <Sprite>(item._assetName);
}
else
{
abRequest = item._assetBundle.LoadAssetAsync(item._assetName);
}
yield return(abRequest);
if (abRequest.isDone)
{
obj = abRequest.asset;
}
lastYiledTime = System.DateTime.Now.Ticks;
}
}
CacheResource(loadingItem.path, ref item, loadingItem.crc, obj, callBackList.Count);
for (int j = 0; j < callBackList.Count; j++)
{
AsyncCallBack callBack = callBackList[i];
if (callBack != null && callBack.dealFinish != null)
{
callBack.dealFinish(loadingItem.path, obj, callBack.param1, callBack.param2, callBack.param3);
callBack.dealFinish = null;
}
callBack.Reset();
_asyncCallBackPool.Recycle(callBack);
}
obj = null;
callBackList.Clear();
_loadingAssetDic.Remove(loadingItem.crc);
loadingItem.Reset();
_asyncLoadResParamPool.Recycle(loadingItem);
if (System.DateTime.Now.Ticks - lastYiledTime > MAX_LOAD_RES_TIME)
{
yield return(null);
lastYiledTime = System.DateTime.Now.Ticks;
haveYield = true;
}
}
if (!haveYield || System.DateTime.Now.Ticks - lastYiledTime > MAX_LOAD_RES_TIME)
{
lastYiledTime = System.DateTime.Now.Ticks;
yield return(null);
}
}
}
private static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lprcClip, AsyncCallBack ops, uint dwData);
private static extern bool EnumUILanguagesA(AsyncCallBack ops, uint dwFlags, IntPtr lParam);
