QiJing
/
YooAsset
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add load all asset method. 

增加新的资源加载方法：加载资源对象所属资源包里的所有资源。
pull/9/head
hevinci 2022-05-06 23:15:03 +08:00
parent 65875b66c2
commit afc08d4e46
18 changed files with 605 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Assets/YooAsset/Runtime/AssetSystem/AssetSystem.cs
View File

@ -130,7 +130,7 @@ namespace YooAsset
/// <summary>
/// 异步加载场景
/// 加载场景
/// </summary>
public static SceneOperationHandle LoadSceneAsync(string scenePath, LoadSceneMode sceneMode, bool activateOnLoad, int priority)
{
@ -161,7 +161,7 @@ namespace YooAsset
}
/// <summary>
/// 异步加载资源对象
/// 加载资源对象
/// </summary>
public static AssetOperationHandle LoadAssetAsync(string assetPath, System.Type assetType)
{
@ -179,7 +179,7 @@ namespace YooAsset
}
/// <summary>
/// 异步加载所有子资源对象
/// 加载子资源对象
/// </summary>
public static SubAssetsOperationHandle LoadSubAssetsAsync(string assetPath, System.Type assetType)
{
@ -196,6 +196,24 @@ namespace YooAsset
return provider.CreateHandle() as SubAssetsOperationHandle;
}
/// <summary>
/// 加载资源包里的所有资源对象
/// </summary>
public static AllAssetsOperationHandle LoadAllAssetsAsync(string assetPath, System.Type assetType)
{
ProviderBase provider = TryGetProvider(assetPath);
if (provider == null)
{
if (SimulationOnEditor)
provider = new DatabaseAllAssetsProvider(assetPath, assetType);
else
provider = new BundledAllAssetsProvider(assetPath, assetType);
provider.InitSpawnDebugInfo();
_providers.Add(provider);
}
return provider.CreateHandle() as AllAssetsOperationHandle;
}
internal static void UnloadSubScene(ProviderBase provider)
{

69
Assets/YooAsset/Runtime/AssetSystem/Handles/AllAssetsOperationHandle.cs Normal file
View File

@ -0,0 +1,69 @@

namespace YooAsset
{
public sealed class AllAssetsOperationHandle : OperationHandleBase
{
private System.Action<AllAssetsOperationHandle> _callback;
internal AllAssetsOperationHandle(ProviderBase provider) : base(provider)
{
}
internal override void InvokeCallback()
{
_callback?.Invoke(this);
}
/// <summary>
/// 完成委托
/// </summary>
public event System.Action<AllAssetsOperationHandle> Completed
{
add
{
if (IsValid == false)
throw new System.Exception($"{nameof(AllAssetsOperationHandle)} is invalid");
if (Provider.IsDone)
value.Invoke(this);
else
_callback += value;
}
remove
{
if (IsValid == false)
throw new System.Exception($"{nameof(AllAssetsOperationHandle)} is invalid");
_callback -= value;
}
}
/// <summary>
/// 资源包内的资源对象集合
/// </summary>
public UnityEngine.Object[] AllAssetObjects
{
get
{
if (IsValid == false)
return null;
return Provider.AllAssetObjects;
}
}
/// <summary>
/// 等待异步执行完毕
/// </summary>
public void WaitForAsyncComplete()
{
if (IsValid == false)
return;
Provider.WaitForAsyncComplete();
}
/// <summary>
/// 释放资源句柄
/// </summary>
public void Release()
{
this.ReleaseInternal();
}
}
}

11
Assets/YooAsset/Runtime/AssetSystem/Handles/AllAssetsOperationHandle.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 05c287035a2264f469a654a6152b02c9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

116
Assets/YooAsset/Runtime/AssetSystem/Provider/BundledAllAssetsProvider.cs Normal file
View File

@ -0,0 +1,116 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace YooAsset
{
internal sealed class BundledAllAssetsProvider : BundledProvider
{
private AssetBundleRequest _cacheRequest;
public override float Progress
{
get
{
if (_cacheRequest == null)
return 0;
return _cacheRequest.progress;
}
}
public BundledAllAssetsProvider(string assetPath, System.Type assetType)
: base(assetPath, assetType)
{
}
public override void Update()
{
if (IsDone)
return;
if (Status == EStatus.None)
{
Status = EStatus.CheckBundle;
}
// 1. 检测资源包
if (Status == EStatus.CheckBundle)
{
if (IsWaitForAsyncComplete)
{
DependBundles.WaitForAsyncComplete();
OwnerBundle.WaitForAsyncComplete();
}
if (DependBundles.IsDone() == false)
return;
if (OwnerBundle.IsDone() == false)
return;
if (DependBundles.IsSucceed() == false)
{
Status = EStatus.Fail;
LastError = DependBundles.GetLastError();
InvokeCompletion();
return;
}
if (OwnerBundle.Status != AssetBundleLoaderBase.EStatus.Succeed)
{
Status = EStatus.Fail;
LastError = OwnerBundle.LastError;
InvokeCompletion();
return;
}
Status = EStatus.Loading;
}
// 2. 加载资源对象
if (Status == EStatus.Loading)
{
if (IsWaitForAsyncComplete)
{
if (AssetType == null)
AllAssetObjects = OwnerBundle.CacheBundle.LoadAllAssets();
else
AllAssetObjects = OwnerBundle.CacheBundle.LoadAllAssets(AssetType);
}
else
{
if (AssetType == null)
_cacheRequest = OwnerBundle.CacheBundle.LoadAllAssetsAsync();
else
_cacheRequest = OwnerBundle.CacheBundle.LoadAllAssetsAsync(AssetType);
}
Status = EStatus.Checking;
}
// 3. 检测加载结果
if (Status == EStatus.Checking)
{
if (_cacheRequest != null)
{
if (IsWaitForAsyncComplete)
{
// 强制挂起主线程（注意：该操作会很耗时）
YooLogger.Warning("Suspend the main thread to load unity asset.");
AllAssetObjects = _cacheRequest.allAssets;
}
else
{
if (_cacheRequest.isDone == false)
return;
AllAssetObjects = _cacheRequest.allAssets;
}
}
Status = AllAssetObjects == null ? EStatus.Fail : EStatus.Success;
if (Status == EStatus.Fail)
{
LastError = $"Failed to load all assets from bundle : {OwnerBundle.BundleFileInfo.BundleName}";
YooLogger.Error(LastError);
}
InvokeCompletion();
}
}
}
}

11
Assets/YooAsset/Runtime/AssetSystem/Provider/BundledAllAssetsProvider.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: dd972d8e33cbbaf4aa7f976d59896b0e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

127
Assets/YooAsset/Runtime/AssetSystem/Provider/DatabaseAllAssetsProvider.cs Normal file
View File

@ -0,0 +1,127 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace YooAsset
{
internal sealed class DatabaseAllAssetsProvider : ProviderBase
{
private string _bundleName;
public override float Progress
{
get
{
if (IsDone)
return 100f;
else
return 0;
}
}
public DatabaseAllAssetsProvider(string assetPath, System.Type assetType)
: base(assetPath, assetType)
{
}
public override void Update()
{
#if UNITY_EDITOR
if (IsDone)
return;
if (Status == EStatus.None)
{
// 检测资源文件是否存在
string guid = UnityEditor.AssetDatabase.AssetPathToGUID(AssetPath);
if (string.IsNullOrEmpty(guid))
{
Status = EStatus.Fail;
LastError = $"Not found asset : {AssetPath}";
YooLogger.Error(LastError);
InvokeCompletion();
return;
}
// 获取资源包名称
_bundleName = AssetSystem.BundleServices.GetBundleName(AssetPath);
if (string.IsNullOrEmpty(_bundleName))
{
Status = EStatus.Fail;
LastError = $"Not found bundle name : {AssetPath}";
YooLogger.Error(LastError);
InvokeCompletion();
return;
}
Status = EStatus.Loading;
// 注意：模拟异步加载效果提前返回
if (IsWaitForAsyncComplete == false)
return;
}
// 1. 加载资源对象
if (Status == EStatus.Loading)
{
bool loadFailed = false;
if (AssetType == null)
{
List<UnityEngine.Object> result = new List<Object>(100);
AssetInfo[] allAssetInfos = AssetSystem.BundleServices.GetAssetInfos(_bundleName);
foreach (var assetInfo in allAssetInfos)
{
var assetObject = UnityEditor.AssetDatabase.LoadMainAssetAtPath(assetInfo.AssetPath);
if (assetObject != null)
{
result.Add(assetObject);
}
else
{
YooLogger.Warning($"Failed to load main asset : {assetInfo.AssetPath}");
loadFailed = true;
break;
}
}
if (loadFailed == false)
AllAssetObjects = result.ToArray();
}
else
{
List<UnityEngine.Object> result = new List<Object>(100);
AssetInfo[] allAssetInfos = AssetSystem.BundleServices.GetAssetInfos(_bundleName);
foreach (var assetInfo in allAssetInfos)
{
var assetObject = UnityEditor.AssetDatabase.LoadAssetAtPath(assetInfo.AssetPath, AssetType);
if (assetObject != null)
{
if (AssetType.IsAssignableFrom(assetObject.GetType()))
result.Add(assetObject);
}
else
{
YooLogger.Warning($"Failed to load asset : {assetInfo.AssetPath}");
loadFailed = true;
break;
}
}
if (loadFailed == false)
AllAssetObjects = result.ToArray();
}
Status = EStatus.Checking;
}
// 2. 检测加载结果
if (Status == EStatus.Checking)
{
Status = AllAssetObjects == null ? EStatus.Fail : EStatus.Success;
if (Status == EStatus.Fail)
{
LastError = $"Failed to load all assets : {nameof(AssetType)} in bundle {_bundleName}";
YooLogger.Error(LastError);
}
InvokeCompletion();
}
#endif
}
}
}

11
Assets/YooAsset/Runtime/AssetSystem/Provider/DatabaseAllAssetsProvider.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b418b6a8da0e3d240b1566cc44fc4b2b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

7
Assets/YooAsset/Runtime/AssetSystem/Provider/DatabaseAssetProvider.cs
View File

@ -39,10 +39,8 @@ namespace YooAsset
InvokeCompletion();
return;
}
else
{
Status = EStatus.Loading;
}
// 注意：模拟异步加载效果提前返回
if (IsWaitForAsyncComplete == false)
@ -52,6 +50,9 @@ namespace YooAsset
// 1. 加载资源对象
if (Status == EStatus.Loading)
{
if (AssetType == null)
AssetObject = UnityEditor.AssetDatabase.LoadMainAssetAtPath(AssetPath);
else
AssetObject = UnityEditor.AssetDatabase.LoadAssetAtPath(AssetPath, AssetType);
Status = EStatus.Checking;
}

2
Assets/YooAsset/Runtime/AssetSystem/Provider/DatabaseSceneProvider.cs
View File

@ -70,7 +70,7 @@ namespace YooAsset
Status = SceneObject.IsValid() ? EStatus.Success : EStatus.Fail;
if (Status == EStatus.Fail)
{
LastError = $"The load scene is invalid : {AssetPath}";
LastError = $"The loaded scene is invalid : {AssetPath}";
YooLogger.Error(LastError);
}
InvokeCompletion();

6
Assets/YooAsset/Runtime/AssetSystem/Provider/DatabaseSubAssetsProvider.cs
View File

@ -39,10 +39,8 @@ namespace YooAsset
InvokeCompletion();
return;
}
else
{
Status = EStatus.Loading;
}
// 注意：模拟异步加载效果提前返回
if (IsWaitForAsyncComplete == false)
@ -62,7 +60,7 @@ namespace YooAsset
List<UnityEngine.Object> result = new List<Object>(findAssets.Length);
foreach (var findAsset in findAssets)
{
if (findAsset.GetType() == AssetType)
if (AssetType.IsAssignableFrom(findAsset.GetType()))
result.Add(findAsset);
}
AllAssetObjects = result.ToArray();

46
Assets/YooAsset/Runtime/AssetSystem/Provider/ProviderBase.cs
View File

@ -140,6 +140,8 @@ namespace YooAsset
handle = new SceneOperationHandle(this);
else if (IsSubAssetsProvider())
handle = new SubAssetsOperationHandle(this);
else if (IsAllAssetsProvider())
handle = new AllAssetsOperationHandle(this);
else
handle = new AssetOperationHandle(this);
@ -162,28 +164,6 @@ namespace YooAsset
RefCount--;
}
/// <summary>
/// 是否为场景提供者
/// </summary>
public bool IsSceneProvider()
{
if (this is BundledSceneProvider || this is DatabaseSceneProvider)
return true;
else
return false;
}
/// <summary>
/// 是否为子资源对象提供者
/// </summary>
public bool IsSubAssetsProvider()
{
if (this is BundledSubAssetsProvider || this is DatabaseSubAssetsProvider)
return true;
else
return false;
}
/// <summary>
/// 等待异步执行完毕
/// </summary>
@ -218,6 +198,28 @@ namespace YooAsset
}
}
public bool IsSceneProvider()
{
if (this is BundledSceneProvider || this is DatabaseSceneProvider)
return true;
else
return false;
}
public bool IsSubAssetsProvider()
{
if (this is BundledSubAssetsProvider || this is DatabaseSubAssetsProvider)
return true;
else
return false;
}
public bool IsAllAssetsProvider()
{
if (this is BundledAllAssetsProvider || this is DatabaseAllAssetsProvider)
return true;
else
return false;
}
#region 异步编程相关
private TaskCompletionSource<object> _taskCompletionSource;
protected void InvokeCompletion()

2
Assets/YooAsset/Runtime/PatchSystem/PatchManifest.cs
View File

@ -210,7 +210,7 @@ namespace YooAsset
}
else
{
YooLogger.Warning($"Failed to mapping location to asset path : {location}");
YooLogger.Error($"Failed to mapping location to asset path : {location}");
return string.Empty;
}
}

6
Assets/YooAsset/Runtime/PatchSystem/PlayMode/EditorSimulateModeImpl.cs
View File

@ -56,9 +56,13 @@ namespace YooAsset
return bundleInfo;
}
}
AssetInfo[] IBundleServices.GetAssetInfos(string bundleName)
{
return PatchHelper.GetAssetsInfoByBundleName(_simulatePatchManifest, bundleName);
}
AssetInfo[] IBundleServices.GetAssetInfos(string[] tags)
{
return PatchHelper.GetAssetsInfoByTag(_simulatePatchManifest, tags);
return PatchHelper.GetAssetsInfoByTags(_simulatePatchManifest, tags);
}
string IBundleServices.MappingToAssetPath(string location)
{

6
Assets/YooAsset/Runtime/PatchSystem/PlayMode/HostPlayModeImpl.cs
View File

@ -322,9 +322,13 @@ namespace YooAsset
return bundleInfo;
}
}
AssetInfo[] IBundleServices.GetAssetInfos(string bundleName)
{
return PatchHelper.GetAssetsInfoByBundleName(LocalPatchManifest, bundleName);
}
AssetInfo[] IBundleServices.GetAssetInfos(string[] tags)
{
return PatchHelper.GetAssetsInfoByTag(LocalPatchManifest, tags);
return PatchHelper.GetAssetsInfoByTags(LocalPatchManifest, tags);
}
string IBundleServices.MappingToAssetPath(string location)
{

6
Assets/YooAsset/Runtime/PatchSystem/PlayMode/OfflinePlayModeImpl.cs
View File

@ -65,9 +65,13 @@ namespace YooAsset
return bundleInfo;
}
}
AssetInfo[] IBundleServices.GetAssetInfos(string bundleName)
{
return PatchHelper.GetAssetsInfoByBundleName(_appPatchManifest, bundleName);
}
AssetInfo[] IBundleServices.GetAssetInfos(string[] tags)
{
return PatchHelper.GetAssetsInfoByTag(_appPatchManifest, tags);
return PatchHelper.GetAssetsInfoByTags(_appPatchManifest, tags);
}
string IBundleServices.MappingToAssetPath(string location)
{

5
Assets/YooAsset/Runtime/Services/IBundleServices.cs
View File

@ -8,6 +8,11 @@ namespace YooAsset
/// </summary>
BundleInfo GetBundleInfo(string bundleName);
/// <summary>
/// 获取资源信息列表
/// </summary>
AssetInfo[] GetAssetInfos(string bundleName);
/// <summary>
/// 获取资源信息列表
/// </summary>

17
Assets/YooAsset/Runtime/Utility/YooHelper.cs
View File

@ -173,7 +173,7 @@ namespace YooAsset
/// <summary>
/// 获取资源信息列表
/// </summary>
public static AssetInfo[] GetAssetsInfoByTag(PatchManifest patchManifest, string[] tags)
public static AssetInfo[] GetAssetsInfoByTags(PatchManifest patchManifest, string[] tags)
{
List<AssetInfo> result = new List<AssetInfo>(100);
foreach (var patchAsset in patchManifest.AssetList)
@ -189,5 +189,20 @@ namespace YooAsset
}
return result.ToArray();
}
/// <summary>
/// 获取资源信息列表
/// </summary>
public static AssetInfo[] GetAssetsInfoByBundleName(PatchManifest patchManifest, string bundleName)
{
List<AssetInfo> result = new List<AssetInfo>(100);
foreach (var patchAsset in patchManifest.AssetList)
{
string tempName = patchManifest.GetBundleName(patchAsset.AssetPath);
if (tempName == bundleName)
result.Add(new AssetInfo(patchAsset.AssetPath));
}
return result.ToArray();
}
}
}

237
Assets/YooAsset/Runtime/YooAssets.cs
View File

@ -368,6 +368,17 @@ namespace YooAsset
return _bundleServices.GetAssetInfos(tags);
}
/// <summary>
/// 获取资源信息列表
/// </summary>
/// <param name="tags">资源标签列表</param>
/// <returns></returns>
public static AssetInfo[] GetAssetInfos(string[] tags)
{
DebugCheckInitialize();
return _bundleServices.GetAssetInfos(tags);
}
/// <summary>
/// 获取调试信息
/// </summary>
@ -436,6 +447,37 @@ namespace YooAsset
}
private static RawFileOperation GetRawFileInternal(string assetPath, string copyPath)
{
string bundleName = _bundleServices.GetBundleName(assetPath);
BundleInfo bundleInfo = _bundleServices.GetBundleInfo(bundleName);
if (_playMode == EPlayMode.EditorSimulateMode)
{
RawFileOperation operation = new EditorPlayModeRawFileOperation(bundleInfo, copyPath);
OperationSystem.ProcessOperaiton(operation);
return operation;
}
else if (_playMode == EPlayMode.OfflinePlayMode)
{
RawFileOperation operation = new OfflinePlayModeRawFileOperation(bundleInfo, copyPath);
OperationSystem.ProcessOperaiton(operation);
return operation;
}
else if (_playMode == EPlayMode.HostPlayMode)
{
RawFileOperation operation = new HostPlayModeRawFileOperation(bundleInfo, copyPath);
OperationSystem.ProcessOperaiton(operation);
return operation;
}
else
{
throw new NotImplementedException();
}
}
#endregion
#region 资源加载
/// <summary>
/// 同步加载资源对象
/// </summary>
@ -471,41 +513,6 @@ namespace YooAsset
}
/// <summary>
/// 同步加载子资源对象
/// </summary>
/// <param name="assetInfo">资源信息</param>
public static SubAssetsOperationHandle LoadSubAssetsSync(AssetInfo assetInfo)
{
DebugCheckInitialize();
return LoadSubAssetsInternal(assetInfo.AssetPath, assetInfo.AssetType, true);
}
/// <summary>
/// 同步加载子资源对象
/// </summary>
/// <typeparam name="TObject">资源类型</typeparam>
/// <param name="location">资源的定位地址</param>
public static SubAssetsOperationHandle LoadSubAssetsSync<TObject>(string location)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadSubAssetsInternal(assetPath, typeof(TObject), true);
}
/// <summary>
/// 同步加载子资源对象
/// </summary>
/// <param name="location">资源的定位地址</param>
/// <param name="type">子对象类型</param>
public static SubAssetsOperationHandle LoadSubAssetsSync(string location, System.Type type)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadSubAssetsInternal(assetPath, type, true);
}
/// <summary>
/// 异步加载资源对象
/// </summary>
@ -541,6 +548,51 @@ namespace YooAsset
}
private static AssetOperationHandle LoadAssetInternal(string assetPath, System.Type assetType, bool waitForAsyncComplete)
{
var handle = AssetSystem.LoadAssetAsync(assetPath, assetType);
if (waitForAsyncComplete)
handle.WaitForAsyncComplete();
return handle;
}
#endregion
#region 资源加载
/// <summary>
/// 同步加载子资源对象
/// </summary>
/// <param name="assetInfo">资源信息</param>
public static SubAssetsOperationHandle LoadSubAssetsSync(AssetInfo assetInfo)
{
DebugCheckInitialize();
return LoadSubAssetsInternal(assetInfo.AssetPath, assetInfo.AssetType, true);
}
/// <summary>
/// 同步加载子资源对象
/// </summary>
/// <typeparam name="TObject">资源类型</typeparam>
/// <param name="location">资源的定位地址</param>
public static SubAssetsOperationHandle LoadSubAssetsSync<TObject>(string location)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadSubAssetsInternal(assetPath, typeof(TObject), true);
}
/// <summary>
/// 同步加载子资源对象
/// </summary>
/// <param name="location">资源的定位地址</param>
/// <param name="type">子对象类型</param>
public static SubAssetsOperationHandle LoadSubAssetsSync(string location, System.Type type)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadSubAssetsInternal(assetPath, type, true);
}
/// <summary>
/// 异步加载子资源对象
/// </summary>
@ -576,44 +628,89 @@ namespace YooAsset
}
private static RawFileOperation GetRawFileInternal(string assetPath, string copyPath)
private static SubAssetsOperationHandle LoadSubAssetsInternal(string assetPath, System.Type assetType, bool waitForAsyncComplete)
{
string bundleName = _bundleServices.GetBundleName(assetPath);
BundleInfo bundleInfo = _bundleServices.GetBundleInfo(bundleName);
if (_playMode == EPlayMode.EditorSimulateMode)
{
RawFileOperation operation = new EditorPlayModeRawFileOperation(bundleInfo, copyPath);
OperationSystem.ProcessOperaiton(operation);
return operation;
}
else if (_playMode == EPlayMode.OfflinePlayMode)
{
RawFileOperation operation = new OfflinePlayModeRawFileOperation(bundleInfo, copyPath);
OperationSystem.ProcessOperaiton(operation);
return operation;
}
else if (_playMode == EPlayMode.HostPlayMode)
{
RawFileOperation operation = new HostPlayModeRawFileOperation(bundleInfo, copyPath);
OperationSystem.ProcessOperaiton(operation);
return operation;
}
else
{
throw new NotImplementedException();
}
}
private static AssetOperationHandle LoadAssetInternal(string assetPath, System.Type assetType, bool waitForAsyncComplete)
{
var handle = AssetSystem.LoadAssetAsync(assetPath, assetType);
var handle = AssetSystem.LoadSubAssetsAsync(assetPath, assetType);
if (waitForAsyncComplete)
handle.WaitForAsyncComplete();
return handle;
}
private static SubAssetsOperationHandle LoadSubAssetsInternal(string assetPath, System.Type assetType, bool waitForAsyncComplete)
#endregion
#region 资源加载
/// <summary>
/// 同步加载资源对象所属资源包里的所有资源
/// </summary>
/// <param name="assetInfo">资源信息</param>
public static AllAssetsOperationHandle LoadAllAssetsSync(AssetInfo assetInfo)
{
var handle = AssetSystem.LoadSubAssetsAsync(assetPath, assetType);
DebugCheckInitialize();
return LoadAllAssetsInternal(assetInfo.AssetPath, assetInfo.AssetType, true);
}
/// <summary>
/// 同步加载资源对象所属资源包里的所有资源
/// </summary>
/// <typeparam name="TObject">资源类型</typeparam>
/// <param name="location">资源的定位地址</param>
public static AllAssetsOperationHandle LoadAllAssetsSync<TObject>(string location)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadAllAssetsInternal(assetPath, typeof(TObject), true);
}
/// <summary>
/// 同步加载资源对象所属资源包里的所有资源
/// </summary>
/// <param name="location">资源的定位地址</param>
/// <param name="type">资源类型</param>
public static AllAssetsOperationHandle LoadAllAssetsSync(string location, System.Type type)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadAllAssetsInternal(assetPath, type, true);
}
/// <summary>
/// 异步加载资源对象所属资源包里的所有资源
/// </summary>
/// <param name="assetInfo">资源信息</param>
public static AllAssetsOperationHandle LoadAllAssetsAsync(AssetInfo assetInfo)
{
DebugCheckInitialize();
return LoadAllAssetsInternal(assetInfo.AssetPath, assetInfo.AssetType, false);
}
/// <summary>
/// 异步加载资源对象所属资源包里的所有资源
/// </summary>
/// <typeparam name="TObject">资源类型</typeparam>
/// <param name="location">资源的定位地址</param>
public static AllAssetsOperationHandle LoadAllAssetsAsync<TObject>(string location)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadAllAssetsInternal(assetPath, typeof(TObject), false);
}
/// <summary>
/// 异步加载资源对象所属资源包里的所有资源
/// </summary>
/// <param name="location">资源的定位地址</param>
/// <param name="type">资源类型</param>
public static AllAssetsOperationHandle LoadAllAssetsAsync(string location, System.Type type)
{
DebugCheckInitialize();
string assetPath = _locationServices.ConvertLocationToAssetPath(location);
return LoadAllAssetsInternal(assetPath, type, false);
}
private static AllAssetsOperationHandle LoadAllAssetsInternal(string assetPath, System.Type assetType, bool waitForAsyncComplete)
{
var handle = AssetSystem.LoadAllAssetsAsync(assetPath, assetType);
if (waitForAsyncComplete)
handle.WaitForAsyncComplete();
return handle;
@ -909,7 +1006,7 @@ namespace YooAsset
{
if (string.IsNullOrEmpty(location))
{
UnityEngine.Debug.LogError("location param is null or empty!");
YooLogger.Error("location param is null or empty!");
}
else
{
@ -918,11 +1015,11 @@ namespace YooAsset
if (index != -1)
{
if (location.Length == index + 1)
UnityEngine.Debug.LogWarning($"Found blank character in location : \"{location}\"");
YooLogger.Warning($"Found blank character in location : \"{location}\"");
}
if (location.IndexOfAny(System.IO.Path.GetInvalidPathChars()) >= 0)
UnityEngine.Debug.LogWarning($"Found illegal character in location : \"{location}\"");
YooLogger.Warning($"Found illegal character in location : \"{location}\"");
}
}
#endregion