Addressables are here!

Hi there! Loving this, except there's a few questions I'd like to ask.

1. What is the default location Addressable Assets are stored in in a build? I like being able to dynamically load music tracks but I keep getting nullreference errors in builds.

2. Is there a way to get a count of the files, like a xxx.Length property or something, in said directory?

 

Addressable are built into asset bundles. The local asset bundles are stored in StreamingAssets. Not sure how much sense accessing that location manually would make, you are not supposed to load the bundles manually.

 

Then I'm not 100% clear how this works, it would seem. I'm still new to the Asset Bundle thing/

 

It's fine, I got it now, thanks! Had to make a list in a textfile with my addresses to make the intended effect work and it does.

 

When using the AWSSDK library.Core.dll from this example https://docs.aws.amazon.com/mobile/sdkforunity/developerguide/what-is-unity-plugin.html

And then add the package com.unity.addressables through the package Manager.

Then the following error occurs

Library\PackageCache\com.unity.scriptablebuildpipeline@1.5.0-preview\Editor\CacheServer\Client.cs(440,35): error CS0433: The type 'InvalidDataException' exists in both 'AWSSDK.Core, Version=3.3.0.0, Culture=neutral, PublicKeyToken=null' and 'System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'

And the question is how to fix it

 

It looks to me like they have not updated the SDK since Unity migrated to a newer .NET standard. InvalidDataException was missing from Unity's .NET assemblies but is now not. You need to get rid of the implementation of InvalidDataException that the AWS SDK includes. In fact, you need to get rid of everything in here:

https://github.com/aws/aws-sdk-net/tree/master/sdk/src/Core/Amazon.MissingTypes

To be honest, you MAY be able to use the regular, non-Unity, version of the SDK nowadays. Edit: Scrub that, I don't think that's possible. You may need to check through the GitHub repo of the SDK and see if there are any pull requests or active issues for this.

 

Its perhaps Unity 2019.3.0.5a Related but downloading and running the addressable example here:
https://github.com/Unity-Technologies/Addressables-Sample
(Without adding other sdk's)

gave me allso an error when hitting the play button:
NullReferenceException: Object reference not set to an instance of an object
UnityEditor.Build.Pipeline.Tasks.PreviewSceneDependencyData.Run () (at Library/PackageCache/com.unity.scriptablebuildpipeline@1.5.0-preview/Editor/Tasks/PreviewSceneDependencyData.cs:100)
UnityEditor.Build.Pipeline.BuildTasksRunner.Run (System.Collections.Generic.IList`1[T] pipeline, UnityEditor.Build.Pipeline.Interfaces.IBuildContext context) (at Library/PackageCache/com.unity.scriptablebuildpipeline@1.5.0-preview/Editor/Shared/BuildTasksRunner.cs:50)
UnityEngine.GUIUtilityrocessEvent(Int32, IntPtr)

 

Samples do work in 2019.3.06a I got the error but after selecting Window->Asset management->addressables and then select (top right) Build. The error was gone.

 

Just encountered some problems regarding building the addressables. If a bundle has too much assets in it, then the build fails with a "Stream was too long" exception thrown out. It's quite a big problem, since the bundle I'm trying to build is full of small files and splitting them into many different bundles is nothing but trouble.

 

I believe this is the same problem I am facing and is (sort of) being discussed in this thread:
https://forum.unity.com/threads/1-1-4-cannot-build-player-content.700805/

The build fails after close to an hour, depending on which assets I have marked as addressables, and I can find that same error message (IOException: Stream was too long) in the build log. It is almost by accident that I left it running for long enough to get that error message, as I usually kill the process because it is essentially crashed.

I thought the same thing that it was too many assets in some of the asset groups, so I split them up and it did not solve the problem. But after completely removing the Addressables package and starting from scratch adding assets to groups in batches, I discovered that it hangs whenever I have a single asset that is larger than 22MB marked as addressable, regardless of which group it is in, or how many assets I have to pack in total.
It is unclear if it is just the size of the file or if it has something to do with the specific large-ish files I am using, which are FBX files that have a large quantity of very small meshes in them. I believe that I probably have other files, like atlased texture maps that are as big, so I will look into this.

This problem did not exist in addressables 0.5.3 or earlier, but has since.
I am planning on creating a Unity project that just has one large FBX in it to reproduce the problem and send it as a bug report, however, I think it should be easy for them to reproduce with this information.

The workaround that I am hoping to avoid doing, is even worse than splitting up bundles, it would be splitting up FBX files into thousands of mesh files and then reattaching them to the prefab objects that use them.

 

Any news on disabling the Debug.Log from Addressables? No solution for 2 months, i would still appreciate a feedback on this from anyone who knows.

TL;DR; following doesn't work as there are no defines in player preferences and it still displays (also, why are the symbols different?):

Log(String)
Debug.Log wrapper method that is contional on the LOG_ADDRESSABLES symbol definition. This can be set in the Player preferences in the 'Scripting Define Symbols'.

Declaration
[Conditional("ADDRESSABLES_LOG_ALL")]
public static void Log(string msg)

 

I have a question about content update.

Addressables choose load from remote or local automatic when you start a loading operation. This may cause that some asset will load from remote when game playing and lead to a bad experience.

So we usually downloaded all updated assetbundle and saved to local persist path at game initialization. when we load a asset, check the persist path first then streamingassets path. so we dont load any remote asset at game playing.

And the question is：How to implement this work flow with Addressables?

 

Hi everybody,

The following thread is a very urgent blocking issue:

https://forum.unity.com/threads/nul...ables-downloaddependenciesasync-label.703922/

Could someone help us find a solution?

 

A few months later and they have a 1.x version number ... but from all accounts it is still nowhere near production ready.

I think Unity should really put some more focus on this and get it in a solid usable state soon.

 

They designed Addressables so that instead of being able to easily download required assetbundles at game initializaiton .. they make it so it is easy to start the game and it will download while the player is playing the game, leaving blank sprites/meshes moving around until the download completes .. so helpful!

Actually, well I think there is Addressables.DownloadDependencies that might be helpful for you.

But beware that if you want to display download progress (of course you do), then there is a bug
https://forum.unity.com/threads/0-7...cies-percentcomplete-always-returns-0.667558/

 

Will there be some kind of an automatic way to deal with a duplicate-fbx problem? e.g. when two assets from different bundles depend on a part of an FBX file and fixing it with a provided tool will force the entire FBX to be included.

 

Is there a way to not throw InvalidKeyException when trying to load something that might not exist?
My example is that I want to Load scriptable objects that perhaps might not exist in a current moment.

 

I recently updated to Addressables version 1.1.4 in Unity 2019.1.10f1 and now for some reason Addressables.ReleaseInstance no longer seems to be destroying objects not used by Addressables.

Also I iterate over all the objects used by addressables in the editor and like to make use of the const strings in AddressableAssetEntry and AddressableAssetSettings. This wasn't as much of an issue in earlier version, but for some reason my modifications to make these strings public (I don't see why they are internal) keep getting reverted every time I launch the Unity Editor, but not the changes I made to AssetReference.

 

From the release notes:

• BREAKING CODE CHANGES
  • ReleaseInstance will now return a bool saying if it successfully destroyed the instance. If an instance is passed in that Addressables is unaware of, this will return false (as of 0.8 and earlier, it would print a log, and still destroy the instance). It will no longer destroy unknown instances.

Where are you making the modifications? Are you making them in the package cache or have you imported the package code into the packages directory on your project root? If it's the former, you really should be copying the package in if you intend on modifying it.

 

I started to use Addressables System since version 0.8.6 in Unity 2019.1. But today I have upgraded the project to Unity 2019.2 and Addressables package to 1.1.5 and now I cannot load prefabs(no runtime data found) or build player content(NullReferenceException in Addressables package).
I tried to re-import project, remove all addressables data and reinstall packages. Nothing helped.
v0.8.6 still works fine in 2019.2 but v1.1.3, v1.1.4 and v1.1.5 not.

 

Make sure your code complies with the new API (things like IAsyncOperation was replaced in favor of AsyncOperationHandle - so do make sure youre using AsyncOperationHandle - more in my post here [ignore the part where i am using a staging server]). That's all i can think of, hopefully its your use-case.

 

All scripts are compiled with new API and even player can be built.

Code (CSharp):

1. [SerializeField] private AssetReferenceGameObject _prefab; // Reference
2. ...
3. var prefab = await _prefab.LoadAssetAsync().Task; // Try to load
4.  

Meanwhile in runtime I receive the warning:
Addressables - Unable to find any catalog locations in the runtime data.
UnityEngine.ResourceManagement.AsyncOperations.AsyncOperationBase`1:<.ctor>b__26_0(AsyncOperationHandle)

and
Exception of type 'UnityEngine.AddressableAssets.InvalidKeyException' was thrown., Key=69ec75f40a151134d8bd7274080cd640
UnityEngine.ResourceManagement.ChainOperation`2:OnWrappedCompleted(AsyncOperationHandle`1)

69ec75f40a151134d8bd7274080cd640 is a correct asset GUID.

In Addressables window I have the following Exception:
NullReferenceException: Object reference not set to an instance of an object
UnityEditor.AddressableAssets.Settings.AddressableAssetEntry.CheckForEditorAssembly (System.Type& t, System.String internalId) (at Library/PackageCache/com.unity.addressables@1.1.5/Editor/Settings/AddressableAssetEntry.cs:499)

 

Any solutions available to automatically ftp-upload the generated bundles?

 

@Cascho01 I would write a script in my prefered script language, I personally have been using node.js and npm as my prefered scripting environment above python bescuase it's very easy to manage package dependencies.

I have used for ftp upload a node package called ftp-deploy

with a script as the following:

Code (JavaScript):

1. var FtpDeploy = require("ftp-deploy");
2. var ftpDeploy = new FtpDeploy();
3.  
4. var config = {
5.     user: "foo@user.com",                  
6.     password: "@@67A@{@W~",          
7.     host: "ftp.user.com",
8.     port: 21,
9.     localRoot: __dirname + '/AssetBundles',
10.     remoteRoot: '/',
11.     // include: ['*', '**/*'],      // this would upload everything except dot files
12.     include: ['*'],
13.     exclude: [''],     // e.g. exclude sourcemaps - ** exclude: [] if nothing to exclude **
14.     deleteRemote: true,              // delete ALL existing files at destination before uploading, if true
15.     forcePasv: true                 // Passive mode is forced (EPSV command is not sent)
16. }
17. // use with promises
18. ftpDeploy.deploy(config)
19.     .then(res => console.log('finished:', res))
20.     .catch(err => console.log(err));

I also usually build all my release builds with scripts to avoid human errors as much as possible. So I would write a script that call Unity3d from the command line and then builds the AssetBundles after that the same script would call the previous script to upload the assets.

Seems like you could also write it directly in Unity:

https://stackoverflow.com/questions/33627428/communicate-from-unity-to-a-filezilla-server

 

@Leoniciux Hmm, ok, that´s a bit to advanced for me.

My question should better have been:
Any solutions available to automatically ftp-upload the updated or new generated bundles?
Would like to avoid uploading already present data.
(Until now I use the "Synchronize folders" functionality of FTPVoyager which is fine, but still this needs a manual check...)

I would expect an entry in the Hosting panel of the adressables but maybe it isn´t meant for this...

 

Hello.

I need to download AssetBundle from the server at some point. I used to just download it with unitywebrequest, then put it in the temporaryCachePath and use it from there.

Now I was told to use addressable in the project. I made a group. I can't add the URL's of the assets I need there, I can only drag and drop the assettes themselves. At the same time, their path contains a local path. But they should not be locally in the project now. If I remove them from the project, they are removed from the group list. I found that I can define a loadpath in the group profile, but so far it doesn't help.

Can I get information on what steps I need to take to download AssetBundle using Addressable?

Thanks.

 

Hi!
Is there a scripting define symbol when installing Addressable Assets?
I'm working on a framework that has different ways to load assets (Resources.Load & Addressables.Load) but if AddressableAssets is not in the project it will not compile, so I would like to add it under ADDRESSABLE_ASSETS or something similar.

 

@Martin_Gonzalez We build with addressables, I can't see any related flag in the generated build report (using Build Report Tool). You might have to #ifdef your code out and ask your users to include that define manually until Unity adds one maybe. Another way maybe is to #ifdef it out by default, and setup a file watcher on the addressables directory that runs in the editor background, if it's there, you take the #ifdef out through code.

 

Not able to load addressable scene in my iOS build, but it does work on Mac Editor.

Code (CSharp):

1. using UnityEngine;
2. using UnityEngine.AddressableAssets;
3. using UnityEngine.UI;
4.  
5. public class NextScene : MonoBehaviour
6. {
7.     public string NextSceneAddress;
8.     Button m_NextButton;
9.  
10.     void Start()
11.     {
12.         Addressables.LoadSceneAsync(NextSceneAddress);
13.  
14.         m_NextButton = GetComponent<Button>();
15.         m_NextButton.onClick.AddListener(OnButtonClick);
16.     }
17.  
18.     void OnButtonClick()
19.     {
20.         Addressables.LoadSceneAsync(NextSceneAddress);
21.     }
22. }

[B]MissingMethodException: Default constructor not found for type UnityEngine.ResourceManagement.AsyncOperations.ProviderOperation`1[[UnityEngine.AddressableAssets.Initialization.ResourceManagerRuntimeData, Unity.Addressables, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null]][/B]



[B]  at System.RuntimeType.CreateInstanceMono (System.Boolean nonPublic) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at System.Activator.CreateInstance (System.Type type, System.Boolean nonPublic) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.ResourceManagement.Util.LRUCacheAllocationStrategy.New (System.Type type, System.Int32 typeHash) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.ResourceManagement.ResourceManager.CreateOperation[T] (System.Type actualType, System.Int32 typeHash, System.Int32 operationHash, System.Action`1[T] onDestroyAction) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.ResourceManagement.ResourceManager.ProvideResource (UnityEngine.ResourceManagement.ResourceLocations.IResourceLocation location, System.Type desiredType) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.ResourceManagement.ResourceManager.ProvideResource[TObject] (UnityEngine.ResourceManagement.ResourceLocations.IResourceLocation location) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.AddressableAssets.Initialization.InitializationOperation.CreateInitializationOperation (UnityEngine.AddressableAssets.AddressablesImpl aa, System.String playerSettingsLocation, System.String providerSuffix) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.AddressableAssets.AddressablesImpl.InitializeAsync (System.String runtimeDataPath, System.String providerSuffix) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.AddressableAssets.AddressablesImpl.InitializeAsync () [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.AddressableAssets.AddressablesImpl.get_InitializationOperation () [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at UnityEngine.AddressableAssets.AddressablesImpl.LoadSceneAsync (System.Object key, UnityEngine.SceneManagement.LoadSceneMode loadMode, System.Boolean activateOnLoad, System.Int32 priority) [0x00000] in <00000000000000000000000000000000>:0 [/B]



[B]  at NextScene.Start () [0x00000] in <00000000000000000000000000000000>:0 [/B]

 

Sounds like you forgot to run "build player content" for iOS.

 

Try running in packed mode in the editor (not virtual or fast mode), should simulate the same loading that you get in build.

 

Wow sad to here that But thanks anyway! I'll try with the folder watcher

 

Hi.
Probably an stupid question but i do not get it.
I have a main scene where i load 4 big adressable (LoadSceneAsync,LoadSceneMode.Additive ) scenes.

Works great.

When i build all the scenes and do an Scripting Backend switch from Mono to IL2CPP.
Do i have to rebuild the Player Content after every switch?

 

Very good question. I don’t know, could you not try it out and see if the bundles load? Out of curiosity why do you need to switch that often?

 

My IL2CPP build has some remaining build errors. So i cannot check for now. The rebuild of Player Content works for IL2CPP and Mono.

Meanwhile this question raised.

In other scenarios IL2CPP builds perform little better.
I use Mono Builds only for faster iteration because build time is shorter.
But in these scenarios i don t use Adressables.

 

I found that I can load things under Resources with Addressables too, but it's not the same behaviour as Resources.LoadAll. My use case is:
I have several Resources folders (different modules) and each module has a scriptable object call SomeConfig.asset.

If I use Resource.LoadAll<ScriptableSomeConfig>("SomeConfig") it loads all correctly.
If I use Addressables.LoadAssetsAsync<ScriptableSomeConfig>("SomeConfig") it repeats one file the amount of files I have in total. (seems to load the first alway)

With Resources.LoadAll


With Addressables.LoadAssetsAsync

 

Hello,

I upgrade the package to the 1.1.9 version and all my groups are gone from the AddressableAssetSettings.
How can this happen ?

 

Same happen to me, i delete Library folder and they are back.

 

Hello.
I am using Unity2019.1.13f and Addressables1.1.9.

I built the project with Linux Standalone (checked “” Server Build ”) and put it on Server.
And when loading Addressable content that was uploaded to another Server, the following error occurred.

Exception encountered in operation Resource<IAssetBundleResource>(gameobjectgroup_assets_all.bundle): RemoteAssetBundleProvider unable to load from url https:/hogehoge.com/ServerData%20/StandaloneLinux64/gameobjectgroup_assets_all.bundle, result='Unknown Error'.
・・・
Exception encountered in operation Dependencies: RemoteAssetBundleProvider unable to load from url https:/hogehoge.com/ServerData%20/StandaloneLinux64/gameobjectgroup_assets_all.bundle, result='Unknown Error'.
・・・
Exception encountered in operation Resource<GameObject>(MyCube.prefab): Dependency Exception
・・・
Exception encountered in operation UnityEngine.AddressableAssets.Initialization.InitializationOperation, result='', status='Succeeded' - Chain<GameObject,IResourceLocator>: ChainOperation of Type: UnityEngine.GameObject failed because dependent operation failed
Dependency Exception

The editor and Android succeed in LoadAssetAsync ().
Does Linux (Headless) support Addressables or is my configuration incorrect?

 

Looks like you have unintended space char in your LoadPath (%20 after ServerData).
You can test bundle downloading via browser.

 

Hi,

Unity 2019.2.2f1
Adressables 1.1.9
Windows 10

after BuildPlayerContent i get this DirectoryNotFoundException.
Path and data exists.
Any idea?

DirectoryNotFoundException: Could not find a part of the path "C:\Users\xxxxx\Desktop\Test\ShaderCalibrationScene2019_2_2f1_VR\ShaderCalibrationScene\Library\BuildCache\01\01c999b6c5284321487076e8b501c778\bd982ac90833c36d82cb66955b4bff81\GI\CAB-6a83973478018059502d959be7b0a3c8\0a\0a4d0ed5a054f45939dcf22e296ffafb.rpc.sse"
System.IO.FileStream..ctor (System.String path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, System.Int32 bufferSize, System.Boolean anonymous, System.IO.FileOptions options) (at <ad04dee02e7e4a85a1299c7ee81c79f6>:0)
System.IO.FileStream..ctor (System.String path, System.IO.FileMode mode, System.IO.FileAccess access, System.IO.FileShare share, System.Int32 bufferSize, System.Boolean isAsync, System.Boolean anonymous) (at <ad04dee02e7e4a85a1299c7ee81c79f6>:0)
System.IO.FileStream..ctor (System.String path, System.IO.FileMode mode, System.IO.FileAccess access) (at <ad04dee02e7e4a85a1299c7ee81c79f6>:0)
(wrapper remoting-invoke-with-check) System.IO.FileStream..ctor(string,System.IO.FileMode,System.IO.FileAccess)
UnityEditor.Build.Pipeline.Utilities.HashingMethods.CalculateFile (System.String filePath) (at Library/PackageCache/com.unity.scriptablebuildpipeline@1.5.2/Editor/Utilities/HashingMethods.cs:294)
UnityEditor.Build.Pipeline.Tasks.ArchiveAndCompressBundles.CalculateHashVersion (System.Collections.Generic.Dictionary`2[TKey,TValue] fileOffsets, UnityEditor.Build.Content.ResourceFile[] resourceFiles) (at Library/PackageCache/com.unity.scriptablebuildpipeline@1.5.2/Editor/Tasks/ArchiveAndCompressBundles.cs:81)
UnityEditor.Build.Pipeline.Tasks.ArchiveAndCompressBundles.Run () (at Library/PackageCache/com.unity.scriptablebuildpipeline@1.5.2/Editor/Tasks/ArchiveAndCompressBundles.cs:170)
UnityEditor.Build.Pipeline.BuildTasksRunner.Run (System.Collections.Generic.IList`1[T] pipeline, UnityEditor.Build.Pipeline.Interfaces.IBuildContext context) (at Library/PackageCache/com.unity.scriptablebuildpipeline@1.5.2/Editor/Shared/BuildTasksRunner.cs:50)
UnityEditor.GenericMenu:CatchMenu(Object, String[], Int32)


SBP ErrorException

 

may be https://www.howtogeek.com/266621/how-to-make-windows-10-accept-file-paths-over-260-characters/ ?

 

damn, Thanks.
I shortend to this path and it s fixed.


C:\temp\ShaderCalibrationScene2019_2_2f1_VR\ShaderCalibrationScene\Library\BuildCache\01\01c999b6c5284321487076e8b501c778\bd982ac90833c36d82cb66955b4bff81\GI\CAB-6a83973478018059502d959be7b0a3c8\0a\0a4d0ed5a054f45939dcf22e296ffafb.rpc.sse


238 chars in path length


C:\Users\xxxxxxx\Desktop\Test\ShaderCalibrationScene2019_2_2f1_VR\ShaderCalibrationScene\Library\BuildCache\01\01c999b6c5284321487076e8b501c778\bd982ac90833c36d82cb66955b4bff81\GI\CAB-6a83973478018059502d959be7b0a3c8\0a\0a4d0ed5a054f45939dcf22e296ffafb.rpc.sse


260 chars in path length



Should be probably seen as issue because

01c999b6c5284321487076e8b501c778\bd982ac90833c36d82cb66955b4bff81\GI\CAB-6a83973478018059502d959be7b0a3c8\0a\0a4d0ed5a054f45939dcf22e296ffafb

is filling up fast to the limit.

 

Thank you nik_d
I modified LoadPath, but the result was the same.

 

Did you rebuild bundles after it was modified? (did path in error changed? loadpath is stored in built settings.json)
Did you test you can download bundle by browser?
If yes to all questions - better to open separate thread: there are possibly separate problem with https (not http) downloading.

 

Im very curious what the plans are for USD and Addressables.
I know the game industry has not really adopted USD but UDS is becoming very crucial for film, vfx and architecture. Currently 10% of studios are using it and by next year it will be around 60%.

Anyone have any though or info on what Unitys plans are with USD and Addressables

 

I am using a free ftp client to manually upload the generated bundles to my webspace.
This works fine but is very unconvenient since it´s nearly impossible to find out what files changed and so I always upload all bundles.
Is there any way to automatically synchronize the local bundles with the remote ones?

EDIT: Meanwhile I found "WinSCP", a free FTP Client that supports autosync....

 

I am finding that setting BundledAssetGroupScheme compression to LZ4 increase unreported load time by a huge amount of time. by unreported I mean, none of my AsyncOperationHandle.PercentComplete will report any value change during this time.

I can see under windows task manager that the harddrive is doing reading for a long time before any asset will actually get loaded.

when I set to uncompressed, the wait time is less, but still, there is a period of time where PercentComplete is unreported,

Is this a known issue?

my AssetGroup is about 800mb uncompressed, and 400mb compressed. if size matters

 

Hey guys, thanks a lot for this tool. I'm very happy I've found a video on youtube about addressables. Now I'm thinking could I use this tool to separate HDRP and LWRP assets? Can addressables help with this task? Maybe someone has a link to the tutorial about how to do that using addressables? Thanks again for a response.