Hi!
I want to download all available remote asset bundles when my game initialy loads. And I cannot find API for that.
DownloadDependenciesAsync() API takes keys or labels and this is not convinient in my case.
Yes I can add some fake asset to each bundle and then request to download all of them using some label but it is a hack. What is an idiomatic way to do that?
You should be able to use Addressables.LoadContentCatalogAsync to load your remote catalog and then Addressables.GetDownloadSizeAsync to check if there’s anything to download and finally Addressables.DownloadDependenciesAsync with the result from LoadContentCatalogAsync.
Here’s a quick example of what I mean:
AsyncOperationHandle<IResourceLocator> loadContentHandle = Addressables.LoadContentCatalogAsync(catalogPath);
await loadContentHandle.Task;
AsyncOperationHandle<long> downloadSizeHandle = Addressables.GetDownloadSizeAsync(loadContentHandle.Result.Keys);
long bytes = await downloadSizeHandle.Task;
if (bytes > 0)
{
foreach (object key in loadContentHandle.Result.Keys)
{
AsyncOperationHandle downloadHandle = Addressables.DownloadDependenciesAsync(key);
while (!downloadHandle.IsDone)
{
await Task.Yield();
}
//Asset download completed, do anything with the asset
Addressables.Release(downloadHandle);
}
}
Addressables.Release(downloadSizeHandle);
Addressables.Release(loadContentHandle);
I have custom loading system. I am using label to preload a set of assets. For example I have scene Bootstrap, and according label bootstrap_preload to preload assets on that scene that have that label.
@Rotary-Heart , isn’t that sufficient enough?
protected override async UniTask<bool> ExecuteAsync_Implementation(CancellationToken cancellationToken)
{
var getDownloadSizeHandle = Addressables.GetDownloadSizeAsync(_assetLabelReference);
using var getDownloadSizeReleaseHandle = getDownloadSizeHandle.ReleaseInScope();
await getDownloadSizeHandle;
if (getDownloadSizeHandle.Status == AsyncOperationStatus.Failed)
{
Debug.LogException(getDownloadSizeHandle.OperationException);
return false;
}
if (getDownloadSizeHandle.Result > 0)
{
var downloadDependenciesHandle = Addressables.DownloadDependenciesAsync(_assetLabelReference);
using var downloadDependenciesReleaseHandle = downloadDependenciesHandle.ReleaseInScope();
SetProgress01(downloadDependenciesHandle.GetDownloadStatus().Percent);
while (!downloadDependenciesHandle.IsDone)
{
await UniTask.DelayFrame(1, cancellationToken: cancellationToken);
SetProgress01(downloadDependenciesHandle.GetDownloadStatus().Percent);
}
if (downloadDependenciesHandle.Status == AsyncOperationStatus.Failed)
{
Debug.LogException(downloadDependenciesHandle.OperationException);
return false;
}
}
return true;
}
Hi.
I came to similar solution. I have marked some of assets in remote bundles with “Downloadable” label and I use this label to predownload all remote bundles then. A bit ugly but works.
Yes, if you want to download a set of assets that can be done too. Using a catalog allows you to download all without needing any specific label.
Oh, thank you @Rotary-Heart . My idea was to minimise amount of packages to download at login. And only then to download rest of them in background (if it’s possible).
But what you are saying is pretty interesting.
Why Addressables.LoadContentCatalogAsync has an argument for the catalog path (name)?
Isn’t a game has only one catalog for the current version?
That is the path to the catalog that you want to load, either local or remote path. No, you can have more than 1 catalog loaded, see the documentation: Addressables.LoadContentCatalogAsync | Addressables | 1.14.3 Which allows you to use a secondary catalog that holds all the remote assets that can be downloaded manually with the code above.
If you simply want to download ALL remote bundles, you can use Addressables.ResourceLocators to get all ResourceLocators, and use locator.Keys to get all keys. Finally use these keys to DownloadDependenciesAsync.
@Rotary-Heart , are you using multiple projects in your game?
Cause I can’t quite get why would I need several catalogs. Only found it as a solution for this Loading from Multiple Projects | Addressables | 1.19.19
I am, but you can use several catalogs for any reason. I’ve used them for separating DLC too.
If you interested or this might be helpful, I ended up with such implementation
public class DownloadAllAddressablesDependenciesTask : BaseLoadingTask
{
private readonly Progress _progress = new();
private readonly List<AsyncOperationHandle<long>> _downloadSizeOperations = new();
private readonly List<AsyncOperationHandle> _downloadOperations = new();
private const float AcquireSizeWeight = 0.1f;
private const float DownloadDependenciesWeight = 1f - AcquireSizeWeight;
public override IProgressProvider Progress
{
get
{
var acquireSizeTotalProgress = 0f;
if (_downloadSizeOperations.Count > 0)
{
for (int i = 0; i < _downloadSizeOperations.Count; i += 1)
{
acquireSizeTotalProgress += _downloadSizeOperations[i].GetDownloadStatus().Percent;
}
acquireSizeTotalProgress /= _downloadSizeOperations.Count;
}
var downloadTotalProgress = 0f;
if (_downloadOperations.Count > 0)
{
for (int i = 0; i < _downloadOperations.Count; i += 1)
{
downloadTotalProgress += _downloadOperations[i].GetDownloadStatus().Percent;
}
downloadTotalProgress /= _downloadOperations.Count;
}
Assert.IsTrue(AcquireSizeWeight + DownloadDependenciesWeight == 1f);
_progress.Progress01 = acquireSizeTotalProgress * AcquireSizeWeight + downloadTotalProgress * DownloadDependenciesWeight;
return _progress;
}
}
public override string ToString()
{
return nameof(DownloadAllAddressablesDependenciesTask);
}
protected override async UniTask<bool> ExecuteAsync_Implementation(CancellationToken cancellationToken)
{
_progress.Reset();
var resourceLocators = Addressables.ResourceLocators.ToList();
_downloadSizeOperations.Clear();
_downloadSizeOperations.EnsureSize(resourceLocators.Count);
_downloadOperations.Clear();
try
{
for (int i = 0; i < resourceLocators.Count; i += 1)
{
var resourceLocator = resourceLocators[i];
_downloadSizeOperations[i] = Addressables.GetDownloadSizeAsync(resourceLocator.Keys);
}
var downloadSizeBytesList = await UniTask.WhenAll(_downloadSizeOperations.ToUniTask()).AttachExternalCancellation(cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
var totalBytes = downloadSizeBytesList.Sum();
Log($"Acquire sizes finished. To download ~{BytesConversionUtils.ToHumanizedString(totalBytes)}({totalBytes} bytes)");
for (int i = 0; i < resourceLocators.Count; i += 1)
{
var downloadSizeBytes = downloadSizeBytesList[i];
if (downloadSizeBytes > 0)
{
var resourceLocator = resourceLocators[i];
foreach (var resourceKey in resourceLocator.Keys)
{
var downloadOperation = Addressables.DownloadDependenciesAsync(resourceKey);
_downloadOperations.Add(downloadOperation);
}
}
}
await UniTask.WhenAll(_downloadOperations.ToUniTask()).AttachExternalCancellation(cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
}
finally
{
_downloadSizeOperations.Release();
_downloadSizeOperations.Clear();
_downloadOperations.Release();
_downloadOperations.Clear();
}
return true;
}
private static void Log(string message)
{
Debug.unityLogger.Log(nameof(DownloadAllAddressablesDependenciesTask), message);
}
}
Hi @elaptop. Your code is so much interesting. Im a newbie on this addressables. Could you provide an example of this code ? isn’t this code run automatically ? or that need to be called in somewhere ?. Thanks