Basic

September 29 2019

9 comments

Unity Addressables Benefits: 3 Ways to Save Your Game

By Rubén Torres Bonet

September 29, 2019


__CONFIG_colors_palette__{"active_palette":0,"config":{"colors":{"6c4de":{"name":"Main Accent","parent":-1},"67ed2":{"name":"Accent Dark","parent":"6c4de","lock":{"saturation":1}}},"gradients":[]},"palettes":[{"name":"Default","value":{"colors":{"6c4de":{"val":"var(--tcb-skin-color-0)"},"67ed2":{"val":"rgb(59, 65, 63)","hsl_parent_dependency":{"h":160,"l":-0.05,"s":0.04}}},"gradients":[]},"original":{"colors":{"6c4de":{"val":"rgb(51, 190, 127)","hsl":{"h":152,"s":0.57,"l":0.47}},"67ed2":{"val":"rgb(59, 65, 63)","hsl_parent_dependency":{"h":160,"s":0.04,"l":0.24}}},"gradients":[]}}]}__CONFIG_colors_palette__
If you've been following me, you probably know my interest in the Unity Addressables Benefits that can be attained in your game. That is for a reason.

Unity Addressables is a powerful Unity package that upgrades the way you and I have been tackling some of the most important challenges in Game Development: efficient, pain-free content management.

When managing your game assets, it's hard to keep good standards that prevent our project from becoming a disgusting pile of mess. A big issue there is the coupling between the different responsibilities of our asset management systems.

The way we store the assets in our project has way too much to do with the method we load them, and later use them.

For instance, you may decide to store an innocent sprite in the Resources folder. This, in turn, will force Unity to build the player in a way that that sprite is put into special archive files. And the fact that it was put there, will corner you into loading it through the Resources API.

Things get messy quicker than you can realize!

One choice, multiple long-term consequences.

A good system will prevent you and me from easily making sloppy mistakes like that. A great system will also be easy to learn and use.

With Unity Addressables, we separate the asset management concerns. Our goal is to remain flexible and to keep our project maintainable.

Here are 3 proven Unity Addressables Benefits for you and your games:

1. Unity Addressables Benefit: Reduce Your Game's Memory Pressure

When you publish your game, you'll be required on most platforms to specify the minimum hardware specifications your players must meet to buy and play your game.

The math is easy here: the more hardware power you demand, the fewer players will buy your game. Or, seen from another perspective, the better memory management you do, the higher the amount of content and fun you can offer in your game.

This is the first Unity Addressables Benefit: efficient memory management.

To give you a brief idea, converting this kind of code:
public class CharacterCustomization : MonoBehaviour
{
    [SerializeField] private List<Material> _armorVariations;
    [SerializeField] private MeshRenderer _armorRenderer;

    public void ChangeArmorVariation(int variationId)
    {
        _armorRenderer.material = _armorVariations[variationId];
    }
}
Into this other one:
using UnityEngine.AddressableAssets;

public class CharacterCustomizationV2 : MonoBehaviour
{
    [SerializeField] private List<AssetReference> _armorVariations;
    [SerializeField] private MeshRenderer _armorRenderer;

    public IEnumerator ChangeArmorVariation(int variationId)
    {
        var loadProcess = _armorVariations[variationId].LoadAssetAsync();
        yield return loadProcess;
        _armorRenderer.material = loadProcess.Result;
    }
}
Will bring you these results:
Unity Addressables - Memory Gains

Unity Addressables - Memory Gains

Easy gains I'd say.

Controller

2. Unity Addressables Benefit: Sell Your Next DLC - Quick and Easy

The fact that Addressables gives you full control over how, when and where to store and load your game assets is incredibly useful for implementing and selling Downloadable Content. That is our second Unity Addressables Benefit.

Even if you are not thinking of releasing DLCs any time soon, just by using Unity Addressables in your project, you will have done already a big chunk of the work ahead.

Other approaches for selling DLCs, such as Asset Bundles, are a very deprecated way of doing the same thing but at a much higher cost. Maintaining a well-functioning Asset Bundle pipeline is painfully time-consuming and requires a high degree of expensive expertise.

There are many ways you can approach implementing DLCs in Unity, but for starters, this is a good starting point:
public class DlcManager : MonoBehaviour
{
    // ...
    public IEnumerator TryDownloadDlc()
    {
        if (_hasBoughtDlc && _dlcDownloaded == false)
        {
            var operationHandle = Addressables.DownloadDependenciesAsync("DLC-Content");
            while (operationHandle.IsDone == false)
            {
                _progressText.text = $"{operationHandle.PercentComplete * 100.0f} %";
                yield return null;
            }
        }
    }
}

You get the idea.

Why would you say no to selling more entertainment for your players at a fraction of the cost? 

3. Unity Addressables Benefit: Reduce Your Iteration Times

Using Unity Addressables will reduce the time wasted waiting in several areas.

Tell me, how frustrating is it to be blocked for half a minute after pressing the Unity play button? And it only gets worse if you deploy your build on another platform, such as mobile or WebGL. This all starts adding minutes and minutes to your iteration times. It gets old so quickly.

I don't like waiting either.

But you know what I like? Unity Addressables, my long-awaited hero. This is how Addressables will help you:

A) Reduced Build Size

Your game has a lot of content, I get it. Gamers love enjoying content. Developers love creating content.

And so you have to deliver your content to the player.

That doesn't mean, however, that every single asset you produced has to be included in the build your players will install. In fact, you should remove as much as possible.

Players want to start playing ASAP. And they're not happy when your game steals 2GB of their data plan and 30 minutes of their gaming time. They'll just keep downloading Candy Crush kind of games that install well under 50MB.

One strategy is to include only the assets needed to run your game up to the main menu. Then, you can progressively download the rest of your content in the background, starting of course downloading the first level of your game.

It's also neat to realize that your deployment times during development will be much faster. You'll be able to iterate more times each day; this benefit quickly adds up in the long term.

Unity Addressables - Reduced Build Sizes

Unity Addressables - Reduced Build Sizes

B) Reduced Loading Times

We, both as game developers and as players, hate waiting. Waiting takes us out of the zone and before you realize it, it is time to go to bed.

Unity is working hard towards reducing the time it takes us to start playing our games, both in the Unity Editor and in the games we distribute.

But not hard enough.

Things look promising in the future, but not without side effects. Avoiding domain reloads in Unity 2019.3 looks promising, but as of today that's still in beta and not everyone can profit from it.

In the mean-time, we can do better than just being frustrated.

Let's say you're working on a medieval game. Several months ago, you implemented armor types for your game. You did a pretty damn good job and generated over 100MB of content ( ͡° ͜ʖ ͡°)

At some point, it was time to move on and right now you're working on something else, let's say sword fighting.

Realize that, every time you press the play button to work on your features, you are loading an insane amount of data coming from all the already developed features, and loading this data takes a massive amount of time. You press play to test your sword fighting animations, and you spend 5 seconds waiting due to loading the armor features you implemented.

The time wasted in loading is mostly spent on I/O (Input/Output), because memory bandwidth is expensive. And, on top of that, your CPU has to process it. You, as a developer, pay this time penalty while developing in the Unity Editor. But your players pay it as well in the games you are distributing.

Knowing how big of a deal this can be, let's ask ourselves: which shortcuts can we take here?

It turns out that Unity Addressables can help us here in two ways.
1.

Unity Addressables will reduce your Players' Loading Times

We can alleviate some of our players' pain.


Keeping indirect references to our assets instead of direct references will drastically improve your loading times.


By using indirect references (AssetReference), Unity will not load everything at once but only what you tell it to. And more importantly, you have direct control over when that happens.

2.

Unity Addressables will reduce your Unity Editor Iteration Times

How much do you know about the play mode script in the Unity Addressables Window? The play mode script defines how the Unity Editor should load the content marked as Addressable.


With Packed Play Mode selected, Unity will directly load your pre-built addressable assets with little to no processing overhead, effectively reducing your Unity Editor iteration times


Just do not forget to build the player content for this to work

Level 2 (Unity Addressables) - Build Player Content

Unity Addressables - Build Player Content

What if you applied these strategies to your most demanding content?

4. Extra: Are You There Yet?

It is true. Unity Addressables is very helpful. But this package will help only those who want to be helped.

After reading how Addressables will help you producing better and selling more to your players, you probably want to start with it right away. However, starting in this new unknown area may be challenging.

To make the most of your chance, answer these questions first:
  • Where are you standing right now? Are you just starting, or are your skills production-ready?
  • When to use indirect references, when to use direct references?
  • What's the bigger picture?
  • What is your next logical step?

Take this short quiz now to test your answers:

      • Thanks – good tip. Here’s the solution for anyone else needing to add/remove addressables procedurally (confirmed in 2019.3 and 2020.1.0a24):

        using UnityEditor;
        using UnityEditor.AddressableAssets;
        using UnityEditor.AddressableAssets.Settings;
        […]
        string groupName = “My Addressables Group”;
        string assetPath = “Assets/wherever/whatever.prefab”;
        string addressableId = “my.procedural.addressable”;

        AddressableAssetSettings aaSettings = AddressableAssetSettingsDefaultObject.Settings;

        AddressableAssetGroup group = aaSettings.FindGroup(groupName);
        if (group == null) group = aaSettings.DefaultGroup;

        var obj = AssetDatabase.LoadAssetAtPath(assetPath);
        if (obj != null)
        {
        string guid;
        long file;
        if (AssetDatabase.TryGetGUIDAndLocalFileIdentifier(obj, out guid, out file))
        {
        // to remove:
        aaSettings.RemoveAssetEntry(guid, false);

        // to add if it hasn’t been added yet:
        string path = AssetDatabase.GUIDToAssetPath(guid);
        AddressableAssetEntry entry = aaSettings.FindAssetEntry(guid);
        if (entry == null) entry = aaSettings.CreateOrMoveEntry(guid, group, false, false);
        if (entry != null) entry.address = addressableId;
        EditorUtility.SetDirty(aaSettings);

        Thanks again,

        Adam

  • Hello. Thank you for the article.
    By the way, this link is broken –
    “-> Read more on Unity Addressables for better memory management in
    Unity Addressables: It’s Never Too Big to Fit”

  • Its a good idea to use addressables to load scene async? i want to get a base map, with my player controler, game manager etc… and then load each sceny async as a big block with light maps instead of use the normal method, could be good in this way?

    • The big benefit from using addressables here would be that you could upload the scene somewhere and let the client download it. You can then update it as often as you want, which is pretty damn handy.
      If you don’t care about content updates, then it should offer no great advantage.

  • {"email":"Email address invalid","url":"Website address invalid","required":"Required field missing"}

    Rubén Torres Bonet

    About the author

    Born Game Developer, now ready to help you develop better games. Primary programmer on Star Trek Bridge Crew (Oculus Quest), Diamond Dash. Programmer on Time Stall, Catan Universe, Anne Frank House VR, Jelly Splash, Blackguards Definitive Edition. I also worked in minor XR experiences for HoloLens and Vive for clients such as Audi and Volkswagen.

    You might also like

    >