/// <summary>
/// Will retrieve asset either from LoadedAssets or asset bundle and return it. Will load
/// asset bundle if necessary.
/// </summary>
/// <typeparam name="T">Type of asset</typeparam>
/// <param name="assetName">name of asset</param>
/// <param name="loadedBundle">had to load asset bundle</param>
/// <returns>A reference to the loaded asset or null if not found.</returns>
private T LoadAssetFromBundle <T>(string assetName, out bool loadedBundle) where T : UnityEngine.Object
{
LoadedAsset la = new LoadedAsset();
loadedBundle = false;
if (string.IsNullOrEmpty(assetName))
{
return(null);
}
try
{
assetName = ModManager.GetAssetName(assetName);
if (IsAssetLoaded(assetName))
{
la = loadedAssets[assetName];
return(la.Obj as T);
}
#if UNITY_EDITOR
if (IsVirtual)
{
la.Obj = LoadAssetFromResources <T>(assetName);
if (la.Obj != null)
{
la.T = la.Obj.GetType();
loadedAssets.Add(assetName, la);
}
return(la.Obj as T);
}
#endif
if (AssetBundle == null)
{
loadedBundle = LoadAssetBundle();
}
if (AssetBundle.Contains(assetName))
{
la.Obj = AssetBundle.LoadAsset <T>(assetName);
if (la.Obj != null)
{
la.T = la.Obj.GetType();
AddAsset(assetName, la);
}
return(la.Obj as T);
}
else
{
return(null);
}
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
return(null);
}
}
/// <summary>
/// Loads an asset without cache. In most cases <see cref="GetAsset{T}(string, bool)"/> should be used instead.
/// </summary>
/// <typeparam name="T">The asset must be assignable to this type to be accepted.</typeparam>
/// <param name="assetName">The name of the asset with or without extension.</param>
/// <remarks>
/// This method allows to load directly from bundle without mod cache to avoid references that would prevent
/// garbage collection to be performed. For example is used internally when the game seeks assets from all mods
/// and handles a global cache.
/// Shouldn't be used for prefabs because <see cref="ImportedComponentAttribute"/> is currently unsupported.
/// </remarks>
/// <returns>Returns the loaded asset if found; otherwise returns null without logging errors.</returns>
internal T LoadAsset <T>(string assetName)
where T : UnityEngine.Object
{
assetName = ModManager.GetAssetName(assetName);
T asset = null;
bool isVirtual = false;
#if UNITY_EDITOR
if (isVirtual = IsVirtual)
{
asset = LoadAssetFromResources <T>(assetName);
}
#endif
if (!isVirtual)
{
if (!AssetBundle)
{
LoadAssetBundle();
}
asset = AssetBundle.LoadAsset <T>(assetName);
}
return(asset);
}
/// <summary>
/// Used internally when the game seeks assets from all mods and handles a global cache.
/// This method allows to load directly from bundle without mod cache to avoid
/// references that would prevents garbage collection to be performed.
/// Shouldn't be used for prefabs because <see cref="ImportedComponentAttribute"/> is currently unsupported.
/// </summary>
internal T LoadAsset <T>(string assetName)
where T : UnityEngine.Object
{
assetName = ModManager.GetAssetName(assetName);
T asset = null;
bool isVirtual = false;
#if UNITY_EDITOR
if (isVirtual = IsVirtual)
{
asset = LoadAssetFromResources <T>(assetName);
}
#endif
if (!isVirtual)
{
if (!AssetBundle)
{
LoadAssetBundle();
}
asset = AssetBundle.LoadAsset <T>(assetName);
}
if (asset)
{
return(asset);
}
Debug.LogErrorFormat("Failed to load asset: {0}", assetName);
return(null);
}
/// <summary>
/// Loads all assets from asset bundle immediately.
/// Invidual assets can then be retrieved with <see cref="GetAsset{T}(string, bool)"/>.
/// Assets are permanently cached until requested once; then they benefit of memory management.
/// </summary>
/// <param name="unloadBundle">Unload asset bundle if true</param>
/// <returns>True if assetbundle has been loaded succesfully.</returns>
public bool LoadAllAssetsFromBundle(bool unloadBundle = true)
{
if (AssetNames == null)
{
return(false);
}
try
{
for (int i = 0; i < AssetNames.Length; i++)
{
string assetname = ModManager.GetAssetName(AssetNames[i]);
if (IsAssetLoaded(assetname))
{
continue;
}
if (AssetBundle == null)
{
if (!LoadAssetBundle())
{
return(false);
}
}
LoadedAsset la = new LoadedAsset();
la.Obj = AssetBundle.LoadAsset(assetname);
if (la.Obj == null)
{
Debug.LogWarning(string.Format("failed to load asset: {0} for mod: {1}", AssetNames[i], Title));
continue;
}
la.T = la.Obj.GetType();
la.TimeStamp = -1;
AddAsset(assetname, la);
}
if (unloadBundle)
{
UnloadAssetBundle(false);
}
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
return(false);
}
return(true);
}
/// <summary>
/// Load all assets from asset bundle asynchronously.
/// </summary>
/// <param name="unloadBundle">Unload asset bundle if true</param>
/// <returns></returns>
public IEnumerator LoadAllAssetsFromBundleAsync(bool unloadBundle = true)
{
if (AssetNames == null)
{
yield return(null);
}
for (int i = 0; i < AssetNames.Length; i++)
{
string assetname = ModManager.GetAssetName(AssetNames[i]);
if (IsAssetLoaded(assetname))
{
continue;
}
if (assetBundle == null)
{
yield return(LoadAssetBundleAsync());
if (assetBundle == null)
{
yield break;
}
}
AssetBundleRequest request = assetBundle.LoadAssetAsync(assetname);
yield return(request);
if (request.asset == null)
{
Debug.LogWarning(string.Format("failed to load asset: {0} for mod: {1}", AssetNames[i], Name));
continue;
}
AddAsset(assetname, request.asset);
}
if (unloadBundle)
{
UnloadAssetBundle(false);
}
yield return(null);
}
private string[] GetAllAssetNames()
{
try
{
if (assetBundle == null)
{
return(null);
}
string[] assetNames = assetBundle.GetAllAssetNames();
for (int i = 0; i < assetNames.Length; i++)
{
assetNames[i] = ModManager.GetAssetName(assetNames[i]);
}
return(assetNames);
}
catch (Exception ex)
{
Debug.Log(ex.Message);
return(null);
}
}
/// <summary>
/// Will retrieve asset either from LoadedAssets or asset bundle and return it. Will load
/// asset bundle if necessary.
/// </summary>
/// <typeparam name="T">Type of asset</typeparam>
/// <param name="assetName">name of asset</param>
/// <param name="loadedBundle">had to load asset bundle</param>
/// <returns>A reference to the loaded asset or null if not found.</returns>
private T LoadAssetFromBundle <T>(string assetName, out bool loadedBundle) where T : UnityEngine.Object
{
LoadedAsset la = new LoadedAsset();
loadedBundle = false;
if (string.IsNullOrEmpty(assetName))
{
return(null);
}
try
{
assetName = ModManager.GetAssetName(assetName);
float time = Time.realtimeSinceStartup;
if (IsAssetLoaded(assetName))
{
la = loadedAssets[assetName];
if (la.Obj)
{
// Update timestamp of last access, but only if difference is
// significant to limit the number of reassignment to dictionary.
if (la.TimeStamp < 0 || time - la.TimeStamp > 59)
{
la.TimeStamp = time;
loadedAssets[assetName] = la;
}
return(la.Obj as T);
}
loadedAssets.Remove(assetName);
Debug.LogWarningFormat("Removed asset {0} from cache of mod {1} because object is unloaded.", assetName, Title);
}
#if UNITY_EDITOR
if (IsVirtual)
{
la.Obj = LoadAssetFromResources <T>(assetName);
if (la.Obj != null)
{
la.T = la.Obj.GetType();
la.TimeStamp = time;
loadedAssets.Add(assetName, la);
}
return(la.Obj as T);
}
#endif
if (AssetBundle == null)
{
loadedBundle = LoadAssetBundle();
}
if (AssetBundle.Contains(assetName))
{
la.Obj = AssetBundle.LoadAsset <T>(assetName);
if (la.Obj != null)
{
la.T = la.Obj.GetType();
la.TimeStamp = time;
AddAsset(assetName, la);
}
return(la.Obj as T);
}
else
{
return(null);
}
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
return(null);
}
}