Jump to content
  • Advertisement
  • 09/02/19 12:26 AM

    Unity Addressables: It's never too big to fit

    General and Gameplay Programming

    Ruben Torres

    You are leading a team of a handful of programmers and artists to port a good-looking PS4 VR game to Oculus Quest. You have six months to complete it. Well? What's your first move? Let's bring Unity Addressables to the table.

    You do realize you have to tackle quite many challenging tasks at once. I bet some might be personally more concerning than others, depending on your expertise level in each area. If you had to pick one that robbed your sacred sleep the most, which one would it be?

    My initial guess would be this: above 70% of the readers would say CPU/GPU performance is the biggest concern when porting a title to Quest. And to that I say: you can very well be right. Performance is one of the toughest areas to improve on in a VR game. For optimizations of this kind, you require in-depth knowledge about the product, which is a time intensive process. Sometimes you even cannot just optimize further, which usually ends in dropping expensive gameplay or graphics features. And not meeting people's expectations is a dangerous place to be.

    Performance, performance, performance.. The word might let some chills go down your spine. What can you expect in this regard from the Quest platform? How does it perform? The thing is, if you have had some development experience in it, you will probably know that in spite of being mobile hardware, it is astonishingly powerful.

    But Ruben! Don't give me that crap. I tell you my phone slows down significantly the time I open a second browser tab. How dare you say mobile platforms can be so performant?

    I read your mind, didn't I? The massive difference lies on Quest's active cooling system, which gives it a huge boost on its attainable CPU/GPU hardware levels that no other mobile platform can offer. It is a powerful fan that will prevent your hair from gathering dust and avoid melting the CPU together with your face (the GoT crown scene comes to mind).

    Additionally and on the side of the Quest software, the more specialized OS is better optimized for virtual reality rendering (surprise) than the generic Android variant. Mobile hardware has been catching up with standalone platforms so quickly in the last few years.

    But, at the same time, I cannot deny that our task of constantly rendering at 72 fps will prove to be challenging, especially for VR ports coming from high-end platforms. To be more precise, when we talk about the Oculus Quest, you have to picture yourself a Snapdragon 835 with a screen, a battery, four cameras and a fan.

    What could look like a disadvantage can actually be thought of as an edge. This mobile platform is a well researched piece of s*** hardware. One can say there are a myriad of known tricks you can pull off to quickly reduce the CPU and GPU load up to an acceptable point. If it is of your interest, you will be able to read about it in upcoming posts. As of now, we will take performance out of the equation for this post.

    What might catch your attention in our challenge is that, compared to the PS4, there is a single hardware characteristic literally halved on the Quest: the RAM capacity. That's right, we go from 8 to 4GB RAM. This is an approximation since, in both platforms, the operating system does not allow you to use it all so it can keep track of a few subsystems for the ecosystem to work. On the Quest you will be able to roughly use up to 2.2 GB of RAM before things get messy.

    Ruben, what do you exactly mean by messy? The thing is, proper memory handling is crucial for your game. This is so because you have two constraints:

    • Hard memory constraint: if you go above a certain threshold, the OS will just kill your game
    • Soft memory constraint: above another certain limit, the OS might decide to kill your game when your user minimizes your game, takes the headset off or you go out of the Oculus Guardian area

    Obviously, you do not want any of the two to happen in your game. Can you picture an angry player who just lost his last two hours of gameplay? Yes, they will go to your store and nothing pretty will come out of their mouth.

    meme-angryface.jpg.69419a5aceb5cd59420c0d1ef538bf79.jpg

    Disgruntled Player - RUN!

    The thing is, the guaranteed availability of 2.2GB of RAM is not much, honestly. It's usually not a problem for new projects where you track your stats constantly from the beginning, but it definitely is an issue for a port to a severely downgraded hardware.

    If you dealt with similar ports in the past, you will quickly realize how extremely challenging it can become to decrease your game's RAM budget by half. It grandly depends on how well the game architecture was prepared for such a change, but in most cases this will temporally transform you into a tear-producing machine.

    The most popular strategies to reduce memory pressure include tweaking asset compression settings, optimizing scripts, reducing shader variants, etc.. Depending on the specifics of your project, tweaking texture import settings is your first go-to solution, but if you need to you can also resort to compressing meshes, animations and audio. The problem is that those techniques are usually complex in nature and will have a ceiling limit.

    Not all platforms support the same import settings; targeting several devices will dramatically increase your build pipeline overhead, not to mention QA, art, design and programming complexity. Does this Android device support ASTC, or just ETC2 (if at all)? Oh, we also want to build 64 bit builds, but also keep the players on the 32 bit versions. How many split-APKs should we create, and worse, manage and test, for each update we do on the game? You want to make your life easier, so you should not rely exclusively on these techniques.

    We would like to go further. As usual, we want to keep things as simple as possible (TM), especially if you are doing a port. Redesigning the entire game for performance's sake is a worse option than just not porting it. For that matter and in today’s topic, I will offer you one of the biggest gains for the buck: I will show you how to halve a project's memory budget in matter of hours. Boom!

    Wouldn't that be awesome?

    Go ahead, go ahead... ask me: is it really possible for me? The answer is: it depends on your starting point, but in my experience, YES. Unity Addressables can be of a great value here. The catch? You must be willing to put in the work and to master the process. But this workflow will earn you the title of employee of the month. 

    If you are interested, keep reading.

    In this post you and I will go through the journey of moving from a traditional asset management to an addressables-based asset management system. To illustrate the process,  we will port a simplified old-school project to the new era of Unity Addressables.

    Now, you might ask me: why don't you just show me the real-life work you did?

    In a non-competitive world I would just show you all the material I created. In the real world though, that is likely to get me canned. And worse, busted.

    What I will do instead is to offer you my guidance so you and I iterate on project that absolutely represents the difficulties you could find tomorrow in your next project. And we will do so by first welcoming Unity's Addressables to our family of suggested packages.

    In this blog post I will get you started in Addressables ASAP so you can implement your own Unity Addressables system in a matter of minutes.

     

    addressables-demo-greenskybox.png.17a01c95e7a9be96b597a7ca5ebe83f4.png

    Unity Addressables: Why?

    Time to pay attention to this very important section. Our goal is to diagnose easy memory gains and implement them fast. There are several ways to do this, but one of the most powerful yet simplest methods to pick the low-hanging fruits by loading the initial scene and opening up the profiler. Why this?

    Because an unoptimized game architecture can frequently be diagnosed at any point during gameplay, so the quickest way to check this is by profiling the initial scenes. The reason for this is the common over-usage of singleton-like scripts containing references to every single asset in the project just in case you need it.

    In order words, in many games there is usually an almighty script causing an asset reference hellThis component keeps each asset loaded at all times independently from whether it's used or not at that time point.

    How bad is this?

    It depends. If your game is likely to be constrained by memory capacity, it is a very risky solution, as your game will not scale with the amount of assets you add (e.g. think of future DLCs). If you target heterogeneous devices, such as Android, you don't have a single memory budget; each device will offer a different one, so you settle for the worst case. The OS can decide to kill your app at any point if our user decides to answer a quick message in Facebook. Then the user comes back and surprise, all their game is gone for good.

    How fun is that?

    Zero. Unless you are overworked and sleep deprived, situation which might grant you a desperation laugh.

    To complicate matters further, if later on you decide (or someone decides for you) to port your game to another less powerful platform while keeping cross-play working, good luck. You don't want to get caught in the middle of this technical challenge.

    On the other side, is there a situation where this traditional asset management solution works just fine? The answer is yes. If you are developing it for a homogeneous platform such as PS4 and most requirements are set from the beginning, the benefits of global objects can potentially outweigh the extra added complexity of a better memory management system.

    Because let's face it: a plain, good old global object containing everything you need is a simple solution, if it works well enough for you. It will simplify your code and will also preload all your referenced assets.

    In any case, the traditional memory management approach is not acceptable for developers seeking to push the boundaries of the hardware. And as you are reading this, I take you want to level up your skills. So it is time for just doing that.

    Greet Unity Addressables.

     

    Requirements for our Unity Addressables project

    If you are planning on just reading this blog entry, your screen will suffice. Otherwise, if you want to do this along with me, you will need:

    • Functional hands
    • Overclocked brain
    • Unity 2019.2.0f1 or similar
    • The level 1 project from GitHub (download zip or through command line)
    • Willingness to get your hands dirty with Unity Addressables

    The git repository will contain three commits, one per skill level-up section in the blog (unless I messed up at some point, case in which I will commit a fix).

     

    Download the project in ZIP format directly from GitHub

     

    addressables-demo-skyboxred.thumb.png.bddfe5babe964c965dea776ad9345e18.png

    Level 1 developer: Traditional asset management

    We are starting here with the simplest asset management method here. In our case, this entails having a list of direct references to skybox materials in our component.

    If you are doing this with me, the setup is a simple 3 step process:

    1. Download the project from git
    2. Open the project in Unity
    3. Hit the damn play button!

    Good, good. You can click a few buttons and change the skybox. This is so original... and boring. I take it, no Unity Addressables yet.

    In a short moment you and I will see why we need to endure this short-lasting boredom.

    To start with, how is our project structured? It pivots around two main systems. On the one side, we have our Manager game object. This component is the main script holding the references to the skybox materials and switches between them based on UI events. Easy enough.

    using UnityEngine;
    
    public class Manager : MonoBehaviour
    {
        [SerializeField] private Material[] _skyboxMaterials;
    
        public void SetSkybox(int skyboxIndex)
        {
            RenderSettings.skybox = _skyboxMaterials[skyboxIndex];
        }
    }

    The Manager offers the UI system a function to apply a specific material to the scene settings through the usage of the RenderSettings API.

    Secondly, we have our CanvasSkyboxSelector. This game object contains a canvas component, rendering a a collection of vertically-distributed buttons. Each button, when clicked, will invoke the aforementioned Manager function to swap the rendered skybox based on the button id. Put in another way, each button's OnClick event calls the SetSkybox function on the Manager. Isn't that simple?

    Unity Addressables - Scene Hierarchy

    Unity Addressables - Scene Hierarchy

    Once we're done daydreaming how immersive it was to play X2, it's time to get our hands dirty. Let's launch the multisensory experience and open the profiler (ctrl/cmd + 7; or Window - Analysis - Profiler). I take you are familiar with this tool, otherwise you know what to do with the top record button. After a few seconds of recording, stop it and see the metrics for yourself: CPU, memory, etc.. Anything of interest?

    Performance is pretty good, which is nothing surprising considering the scope of the project. You could literally turn this project into a VR experience and I assure you that your users will not fill any of the bile buckets that so many players filled when playing Eve: Valkyrie.

    In our case, we will be focusing on the memory section. The simple view mode will display something as depicted below:

    Level 1 Asset Management - Simple Memory Profiling

    Level 1 Asset Management - Simple Memory Profiling

    The numbers on the texture size look pretty oversized for just displaying a single skybox at any given time, don't you agree? Surprise incoming: this is the pattern you will find in many unoptimized projects you are likely to suffer lead. But heck, in this case it's just a collection of skyboxes. In others, it will be more about characters, planets, sounds, music. You name it, I have it.

    If dealing with many assets falls under your responsibility, well, then I am glad you are reading this article. I will help you transitioning to scalable solution.

    Time for magic. Let's switch the memory profiler to detail mode. Have a look!

    Level 1 Asset Management - Detailed Memory Profiling

    Level 1 Asset Management - Detailed Memory Profiling

    Holy crap, what happened there? All skybox textures are loaded in memory, but only one is displayed at any given time. You see what we did? This rookie architecture produced the whoooooooping figure of 400mb.

    This is definitely a no-go, considering this is just a small piece of a future game. Addressing this very problem is the foundation for our next section.

    Come with me!

    Summary:

    • Traditional asset management entails direct references
    • Therefore you keep all objects loaded at all times
    • Your project will not scale this way

     

    Level 2 developer: Unity Addressables workflow

    In video- games you start at level 1, which is great, but once you know the gameplay rules it is time to leave the safe city walls in our quest to level up. That is exactly what this section is about.

    Grab the level 2 project now.

    As we previously saw in the profiler, we have all skyboxes loaded in memory even though only one is actively used. That is not a scalable solution, as at some point you will be limited on the amount of different variations of assets you can offer to your players. An advice? Don't limit the fun of your players.

    Here, let me help you. Take my shovel so we can dig the so needed tunnel to escape the prison of traditional asset management. Let's add a new fancy tool to our toolbox: the API of Unity Addressables.

    The first thing we need to do is to install the Addressables package. For that, go to Window → Package Manager, as shown below:

    addressables-package-manager.png.fe477cb56a0c1ee82703bfe59763eb0a.png

    Unity Package Manager - Unity Addressables

    Once installed, it's time to mark the materials as addressables. Select them and activate the addressables flag in the inspector window.

    addressables-level-2-flag.png.cd4f5448d75eb21da3bceac27b330dea.png

    Level 2 Asset Management (Unity Addressables)

    What this will do is to ask Unity politely to include those materials and their texture dependencies in the addressables database. This database will be used during our builds to pack the assets in chunks that can easily be loaded at any point during in our game.

    I'll show you something cool now. Open Window → Asset Management → Addressables. Guess what's that? It's our database screaming to go live!addressables-window.png.fed630d2014cfb36da823785ed3ed29d.png

    Level 2 Asset Management (Unity Addressables) - Main Window

    My dear reader: that was the easy part. Now comes the fun part.

    I want you to pay a visit to an old friend of ours from the previous section: Sir Manager. If you check it, you will notice it is still holding direct references to our assets! We don't want that.

    We are teaching our manager to use indirect references instead - i.e. AssetReference (in Unreal Engine you might know them as soft references).

    Let us do just that, let's beautify our component:

    using UnityEngine;
    using UnityEngine.AddressableAssets;
    using UnityEngine.ResourceManagement.AsyncOperations;
    
    public class Manager : MonoBehaviour
    {
        [SerializeField] private List<AssetReference> _skyboxMaterials;
    
        private AsyncOperationHandle  _currentSkyboxMaterialOperationHandle;
    
        public void SetSkybox(int skyboxIndex)
        {
            StartCoroutine(SetSkyboxInternal(skyboxIndex));
        }
    
        private IEnumerator SetSkyboxInternal(int skyboxIndex)
        {
            if (_currentSkyboxMaterialOperationHandle.IsValid())
            {
                Addressables.Release(_currentSkyboxMaterialOperationHandle);
            }
    
            var skyboxMaterialReference = _skyboxMaterials[skyboxIndex];
            _currentSkyboxMaterialOperationHandle = skyboxMaterialReference.LoadAssetAsync();
            yield return _currentSkyboxMaterialOperationHandle;
            RenderSettings.skybox = _currentSkyboxMaterialOperationHandle.Result;
        }
    }

    What happens here is the following:

    • A major change happens in line 7, where we hold a list of indirect references (AssetReference) instead of direct material references. This change is key, because these materials will NOT be loaded automatically just by being referenced. Their loading will have to be made explicit. Afterwards, please reassign the field in the editor.
    • Line 13: since we are now in an asynchronous workflow, we favor the use of a coroutine. We simply start a new coroutine that will handle the skybox material change.
    • We check in lines 18-20 whether we have an existing handle to a skybox material and, if so, we release the skybox we were previously rendering.  Every time we do such a load operation with the Addressables API, we receive a handle we should store for future operations. A handle is just a data structure containing data relevant to the management of a specific addressable asset.
    • We resolve specific addressable reference to a skybox material in line 23 and then you call its LoadAssetAsync function, over which you can yield (line 25) so we wait for this operation to finish before proceeding further. Thanks to the usage of generics, there's no need for sucky casts. Neat!
    • Finally, once the material and its dependencies have been loaded, we proceed to change the skybox of the scene in line 26. The material will be offered in the Result field that belongs to the handle we used to load it.
    addressables-assetreference-assignment.png.bb6b57baa52800460c889271ee87d377.png

    Level 2 Asset Management (Unity Addressables) - AssetReference list

    Keep in mind: this code is not production-ready. Do not use it when programming an airplane. I decided to favor simplicity over robustness to keep the matter simple enough.

    Enough with explanations. It is time you and I saw this in action.

    If you would be so kind to perform the following steps:

    1. In the addressables window, cook the content (build player content)
    2. Then make a build on a platform of your choice
    3. Run it and connect the (memory) profiler to it.
    4. Protect your jaw from dropping.

    addressables-build-player-content.png.18afda2f5136dc67adf7c4704c0827f7.png

    Level 2 (Unity Addressables) - Build Player Content

     
    addressables-level-2-profiler-detail.png.09f99b31fc6d852d98da2d06cc0fe881.png

    Level 2 Asset Management (Unity Addressables) - Memory Profiler

     
     

    Isn't asset cooking delicious?

    I like happy profilers. And what you saw is the happiest profiler the world has ever seen. A satisfied profiler will mean several things. For one, it means happy players playing your game in a Nokia 3210. It also means happy producers. And as of you, it means a happy wallet.

    This is the power of the Addressables system.

    Addressables which comes with little overhead on the team. On the one side, programmers will have to support asynchronous workflows (easy-peasy with Coroutines). Also, designers will have to learn the possibilities of the system, e.g. addressable groups, and gather experience to make intelligent decisions. Finally, IT will be delighted to set up an infrastructure to deliver the assets over the network, if you opt to host them online.

    I have to congratulate you. Let me tell you what we have accomplished:

    • Appropriate memory management.
    • Faster initial loading times.
    • Faster install times, reduced in-store app size.
    • Higher device compatibility.
    • Asynchronous architecture.
    • Opening the door of storing this content online → decoupling data from code.

    I would be proud of such a gain. It's for sure a good return on investment.

    Oh, and make sure to mention your experience with Addressables in job interviews.

     

    INTERMEDIATE: Instancing and reference counting. Read on it my blog post for information on this topic.

    OPTIONAL: Alternative loading strategies. Read on it my blog post for information on this topic.

     

    Summary:

    • Addressables-based asset management scales just well
    • Addressables introduces asynchronous behavior
    • Do not forget to cook content on changes or you'll give your game a pinkish tint!

     

    addressables-asset-delivery.thumb.png.21c3ccc05bff550407d2ce0d15745129.png

    Level 3 Asset Management (??) - Content Network Delivery

     

    Level 3 Asset Management (??) - Content Network Delivery

    In the previous section, we achieved the biggest bang for the buck. We leveled up our skills by moving from a traditional asset management system to an addressables-based workflow. This is a huge win for your project, as a small time investment gave your project the room to better scale in assets while keeping your memory usage low. That accomplishment indeed made you step up to level 2, congrats! However, one question is yet to answer:

    Is that it?

    No. We barely scratched the surface of Addressables, there are further ways to improve your project with this game-changer package.

    Of course you do not have to memorize all the details regarding Addressables, but I highly suggest you to have an overview of them because down the road you are likely to encounter further challenges and you will be thankful to have read a bit further. That's why I prepared an extra short guide for you.

    There you will learn about the following aspects:

    • The Addressables window: the details matter
    • Addressables profiling: don't leak a (memory) leak ruin your day
    • Network delivery: reduce the time-to-play user experience
    • Build pipeline integration
    • Practical strategies: speed up your workflow, trash your 10-minute coffee breaks

     

    And more importantly, answer questions such as:

    • What is the hidden meaning behind Send Profiler Events?
    • How useful is the AddressableAssetSettings API?
    • How do I integrate this all with the BuildPlayerWindow API?
    • What's the difference between Fast ModeVirtual Mode and Packed Mode?

    In order to grab the level 3 guide check out my blog post



      Report Article


    User Feedback


    Hi, 

    Interesting article, thanks for that! Could you check the blog links? None of them works for me, I get 404 when trying to check them. Thanks

    Share this comment


    Link to comment
    Share on other sites


    Create an account or sign in to comment

    You need to be a member in order to leave a comment

    Create an account

    Sign up for a new account in our community. It's easy!

    Register a new account

    Sign in

    Already have an account? Sign in here.

    Sign In Now

  • Advertisement
  • Game Developer Survey

    completed-task.png

    We are looking for qualified game developers to participate in a 10-minute online survey. Qualified participants will be offered a $15 incentive for your time and insights. Click here to start!

    Take me to the survey!

  • Advertisement
  • Latest Featured Articles

  • Featured Blogs

  • Advertisement
  • Popular Now

  • Similar Content

    • By HDR Games
      Yesterday I've published my new game to google play!
      I'm 16 years old and I will be very happy if you check my game and tell me what you think about it.
      It takes a minute to download and you won't regret it. Please let me know what you think in the comments.
      Best android game of the year! https://play.google.com/store/apps/details?id=com.HDRGames.FishTheFun
      Swim into the depths of the sea! Jump the highest and reach the sky. Beware of enemy fish, birds and obstacles. 
      1. Discover fish as you play!
      2. Buy fish to be able to play with them!
      3. Improve your best score to beat your friends'!
      4. Complete 100 quests to win rewards!
      5. Enter every day to receive daily rewards!
      6. Enjoy the sea, and Fish The Fun.
      Link to HDRGames website: http://hdrgames.sytes.net
      Link to HDRGames Instagram: https://www.instagram.com/hdr.games
      Watch the trailer: 
       



    • By COUNTING DEMON STUDIOS
      Devlog #4 showing the most recent updates to the game I've been working on in my spare time for about 2 years now.

      Any comments or suggestions are much appreciated!
       
    • By asmit10
      Read this first to not waste time
      Hey everyone! I'm basically brand new to game dev, specifically programming which is what I care to specialize in. Currently i'm working on a 3D Tile-based tower defense game in Unity. The plan is to plan for primary monetization on mobile, but it will come to PC too. I probably lack the most skills in the art department, primarily graphics work, but it's not like my modeling is great either. That being said, my main focus is programming so if you read further below and find yourself interested in the project and have a different interest, please let me know!
       
      Game Info
      TD Game ala Bloons TD
      Differences
      Towers are based on tiles pre-placed on a grid (plan to add ability to buy tiles, so that tile scarcity can be more of a part of level design)
      No Russian dolling of enemies, different enemies following a difficulty gradient
       flying enemies that normally follow a different path
      Misc
      Branching, occasionally choice making upgrade branches for each distinctly unique tower. (thinking something like 15 unique upgrades per turret, though that would be tough to come up with)
      Initially planning for 10 distinct level layouts not including an endless survival 'leaderboard' mode
      Seems like it would be silly to not include easy / medium / hard difficulties, just need to think of a way to reward the player for doing so
      Planning to have some long-term progression system. Maybe related to # of kills with a tower. Every 500 kills = 1% fire rate or something like that.
      All current art and models are place holders, screenshots of the project can be provided if you show interest
    • By DerTroll
      Hi there,
      recently I read in one of the treads about data-oriented programming vs. object-oriented programming. While I am generally avoiding to follow such principals dogmatically, it got me thinking again about a quite common problem: Resource Managers (in OpenGL). To get a little bit more specific, let's consider a Texture Manager. I have currently implemented them in the following way:
      When starting the program, the manager creates a texture class for each texture of my game and stores them together with the name in a map or unordered map. The texture class itself has a reference counter and the OpenGL handle of the texture. The value of the handle is set to a specific "texture not loaded" texture during construction. Now if an object is loaded, that requires a certain texture, the texture is requested from the manager. It searches the textures name and returns a special reference class, that stores a reference to the texture class and increases and decreases its reference counter. Obviously, the reference counter has the purpose to initiate the loading and unloading of the texture. The problem here is, that the texture handle, which is just an integer, is not stored in a cache-friendly way, as are other managed objects that I might need during rendering  (Buffer objects for meshes, etc). All handles are stored in the texture managers memory location, which might be far away from the buffer object handles and the other object data.
      So I was thinking that I should probably simply store references to all reference classes (I know that sounds weird) in the texture class itself. The purpose of this is, that I can then simply copy the current OpenGL texture handle to the reference class. In case that the handle changes for any reason (reloading/replacing texture), I update the handle in each reference class using a loop. Sure, this is a little bit more work during an update of the texture and if a reference is added/removed, but how often does that happen? As a benefit of this method, a copy of my texture handle is now stored at the same memory location as the rest of the object's data, which should result in reduced cache miss count.
      Now I am interested in what you think about these two approaches and how you implement your resource mangers as efficient as possible?
       
      Greetings
       
    • By Joey Nigro
      How can I automatically match the color with the tag?
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!