void Start()
{
// 初始化引用关系
BundleDependencies.LoadBundleDependencies();
// 初始化资源和bundle的对应关系
BundleAsset.LoadBundleAssets();
}
private static void DestroyObject(ObjectReference or)
{
// 删除自己
if (ResourceUtil.isLog)
{
Debug.Log("UnloadAsset " + or.assetName);
}
if (!(or.obj is GameObject))
{
Resources.UnloadAsset(or.obj);
}
//else
/* GameObejct的释放方法
* 1 assetbundle.unload(true)
* 2 Resources.UnloadUnusedAsset()
*/
// 释放引用bundle
string bundleName = BundleAsset.GetBundleName(or.assetName);
if (bundleName == null)
{
return;
}
ReferenceBundle.ReleaseBundle(bundleName);
}
private IEnumerator BeginInitialize()
{
if (mStatus == LoadStatus.Done)
{
yield break;
}
else if (mStatus == LoadStatus.Loading)
{
yield return(new WaitUntil(() => mStatus == LoadStatus.Done));
}
else
{
mStatus = LoadStatus.Loading;
//初始化资源列表
yield return(AssetPath.Initialize());
if (AssetPath.mode == AssetMode.AssetBundle)
{
BundleAsset bundle = GetOrCreateBundle <BundleAsset>(AssetPath.list.manifest);
AssetLoadTask <AssetBundleManifest> task = new AssetLoadTask <AssetBundleManifest>(AssetPath.list.manifest, FinishInitialize);
task.assetName = "AssetBundleManifest";
yield return(bundle.LoadAssetAsync(task));
}
else
{
FinishInitialize(null);
}
}
}
/// <summary>
/// 异步加载资源
/// </summary>
/// <param name="assetName">资源名</param>
private static void LoadAssetAsync(LoadAssetInfo loadAssetInfo)
{
AssetBundle assetBundle = ReferenceBundle.GetAssetBundle(loadAssetInfo.bundleName);
string assetInBundleName = BundleAsset.GetAssetInBundleName(loadAssetInfo.assetName);
AssetBundleRequest request = assetBundle.LoadAssetAsync(assetInBundleName);
loadAssetInfo.request = request;
EnterLoading(loadAssetInfo);
}
/// <summary>
/// 异步加载资源
/// </summary>
/// <param name="assetName">需要加载的资源路径</param>
/// <param name="onLoadAsset">加载成功之后的回调</param>
/// <returns>请求Id</returns>
public static int LoadAssetAsync(string assetName, OnLoadAsset onLoadAsset)
{
// 回调不存在不允加载
if (onLoadAsset == null)
{
GameLogger.LogError("[资源加载错误] 加载函数回调不能为空，加载后也没有引用");
return(0);
}
// 资源对应bundle名
string abName = BundleAsset.GetBundleName(assetName);
if (abName == null)
{
GameLogger.LogError("[资源加载错误] 找不到资源 ", assetName);
return(0);
}
// 获取请求ID
int requestId = ResourceManager.GetRequestId();
LoadAssetInfo loadAssetInfo = GetTempLoadAssetInfo();
loadAssetInfo.requestId = requestId;
loadAssetInfo.assetName = assetName;
loadAssetInfo.onLoadAsset = onLoadAsset;
loadAssetInfo.bundleName = abName;
EnterLoadWait(loadAssetInfo);
// 1 asset是否已加载
if (ReferenceObject.IsObjectCreate(loadAssetInfo.assetName))
{
EnterWaitCall(loadAssetInfo);
}
// 2 bundle是否已加载
else if (!ReferenceBundle.IsAssetBundleCraete(abName))
{
PushPending(loadAssetInfo);
}
// 3 从bundle加载资源
else
{
List <LoadAssetInfo> loadingAssetList = GetLoadAssetStateList(LoadAssetStep.Loading);
if (loadingAssetList.Count < _frameLoadMaxCount)
{
LoadAssetAsync(loadAssetInfo);
}
}
_loadAssetInfoList.Add(loadAssetInfo);
return(requestId);
}
private void AddDependenceBy(BundleAsset parent)
{
if (parent == null)
{
return;
}
if (dependencesby.ContainsKey(parent.bundleName) == false)
{
dependencesby.Add(parent.bundleName, parent);
}
}
private IEnumerator LoadAssetAsync <T>(IAssetLoadTask <T> task) where T : UnityEngine.Object
{
if (mStatus != LoadStatus.Done)
{
yield return(BeginInitialize());
}
BundleAsset bundle = GetOrCreateBundle <BundleAsset>(task.bundleName);
yield return(bundle.LoadAssetAsync(task));
}
public Asset(string assetName, BundleAsset bundle, Object asset, T assetObject)
{
this.assetName = assetName;
this.bundle = bundle;
this.asset = asset;
this.assetObject = assetObject;
if (bundle != null)
{
bundle.AddReference(this);
}
}
private async Task <IList <BundleAsset> > AssestsList(string pageName, string role)
{
BundleAsset bundleAsset = new BundleAsset();
bundleAsset.Roles = role;
bundleAsset.ExcessMode = excessMode;
bundleAsset.Application = Application;
bundleAsset.UserArea = UserArea;
bundleAsset.PageName = pageName;
AssestController assestController = new AssestController();
IList <BundleAsset> bundleAssets = await assestController.GetAssets(bundleAsset);
return(bundleAssets);
}
void Start()
{
IOTools.Init();
BundleAsset.LoadAb("common" + IOTools.abSuffix);
var actor = ActorManager.Singleton.CreateActor(0, ActorType.Player, 1, 1000);
ActorManager.Singleton.SetPlayer(actor);
// CreateNavAgent();
// pathFinding = new ActorPathFinding();
//pathFinding.Init(seeker,controller,target);
MyTileHandlerHelper.Singleton.Start();
}
private void RemoveDependenceBy(BundleAsset parent)
{
if (parent == null)
{
return;
}
dependencesby.Remove(parent.bundleName);
if (dependencesby.Count == 0)
{
//检查是否可以被卸载
RemoveReference();
}
}
/// <summary>
/// 检测加载回调
/// </summary>
private static void CheckLoad()
{
List <LoadAssetInfo> loadAssetInfoList = GetLoadAssetStateList(LoadAssetStep.Loading);
if (loadAssetInfoList.Count == 0)
{
return;
}
foreach (LoadAssetInfo loadAssetInfo in loadAssetInfoList)
{
AssetBundleRequest request = loadAssetInfo.request;
if (request == null)
{
continue;
}
if (!request.isDone)
{
continue;
}
Object asset = request.asset;
if (asset == null)
{
continue;
}
// 资源加载成功 进入等待回调状态
string assetInBundleName = BundleAsset.GetAssetInBundleName(loadAssetInfo.assetName);
if (asset.name == assetInBundleName)
{
ReferenceObject.AddObject(loadAssetInfo.assetName, asset);
loadAssetInfo.asset = asset;
EnterWaitCall(loadAssetInfo);
// 加载成功一个资源之后 从等待列表中释放一个 维持每帧加载上线
List <LoadAssetInfo> loadWaitAssetList = GetLoadAssetStateList(LoadAssetStep.LoadWait);
if (loadWaitAssetList.Count > 0)
{
LoadAssetAsync(loadWaitAssetList[0]);
}
break;
}
}
}
// Use this for initialization
void Start()
{
// 初始化引用关系
BundleDependencies.LoadBundleDependencies();
// 初始化资源和bundle的对应关系
BundleAsset.LoadBundleAssets();
// 测试加载
if (createType == CreateType.Bundle)
{
CreateBundle();
}
else if (createType == CreateType.Asset)
{
CreateAsset();
}
else if (createType == CreateType.GameObejct)
{
CreateGameObject();
}
}
public async Task <IList <BundleAsset> > GetAssets(BundleAsset bundleAsset)
{
IList <BundleAsset> bundleAssets;
List <SQLParam> sQLParam = new List <SQLParam>();
sQLParam.Add(new SQLParam("@Roles", bundleAsset.Roles));
sQLParam.Add(new SQLParam("@ExcessMode", bundleAsset.ExcessMode.ToString()));
sQLParam.Add(new SQLParam("@Application", bundleAsset.Application));
sQLParam.Add(new SQLParam("@UserArea", bundleAsset.UserArea));
sQLParam.Add(new SQLParam("@PageName", bundleAsset.PageName));
SQLGetListAsync sqlhandler = new SQLGetListAsync();
try
{
bundleAssets = await sqlhandler.ExecuteAsListAsync <BundleAsset>("[dbo].[usp_webbuilder_asset_getAll]", sQLParam);
}
catch
{
throw;
}
return(bundleAssets);
}
public override IEnumerator LoadAsync()
{
#if UNITY_EDITOR
if (AssetPath.mode == AssetMode.Editor)
{
yield break;
}
#endif
string[] dependenceNames = AssetLoader.GetDirectDependencies(bundleName);
if (dependenceNames != null)
{
for (int i = 0; i < dependenceNames.Length; ++i)
{
string dependenceName = dependenceNames[i];
BundleAsset bundleObject;
if (dependences.TryGetValue(dependenceName, out bundleObject) == false)
{
bundleObject = AssetLoader.GetOrCreateBundle <BundleAsset>(dependenceName);
bundleObject.AddDependenceBy(this);
dependences.Add(dependenceName, bundleObject);
}
}
}
var it = dependences.GetEnumerator();
while (it.MoveNext())
{
BundleAsset bundleObject = it.Current.Value;
if (bundleObject.status == LoadStatus.None)
{
yield return(bundleObject.LoadAsync());
}
}
yield return(base.LoadAsync());
}
public async Task <IList <BundleAsset> > GetAssets(BundleAsset bundleAsset)
{
AssetDataprovider assetDataprovider = new AssetDataprovider();
return(await assetDataprovider.GetAssets(bundleAsset));
}
