Before we start use it, you'd better import it to an empty project, following the ReadMe to learn this framework step by step, it may take 2 hours.
Let's see the folder structure :
It has 4 folders in the AssetBundleMaster folder:
[AssetBundleMasterExample] is Demo for leaning basical APIs, It include load assets, load scenes, and how to do unload.
[AssetBundleMasterExample2] is Demo for testing how Built-In Shader multi compiled and how AssetBundleMaster to optimize it.
[Editor] is editor scripts.
[Plugins] is runtime scripts, asset load is basic logic for a project, so we put it in Plugins.
Let's try to run API Demo scenes in Editor Mode, open AssetBundleMaster Window first :
window shows :
We need to set only 2 variables can make it runable in Editor, developer friendly, ignor other options now :
1. Editor Asset LoadMode : load mode in Editor, select AssetDataBase_Editor, it means load asset directly.
2. Build Root : It is the root folder for loading assets, click [Change Build Root...] to change the folder, set to AssetBundleMasterExample folder so that we can run API Demo scenes. The entry scene is StartScene1, you can find it in AssetBundleMasterExample/Scenes folder:
Run StartScene1, the bottom-left shows a dropdown for selecting demo scenes :
These are all the API demo scenes, select any scene, you can see the hierarchy that a GameObject has the same name with the scene, and the same named script attached on it, it is the demo script.
We must explain how the scene load process working, when we select any scene it will unload all assets loaded before, so that any asset will be loaded in the new scene will be new load, this is convenient for testing asset load and unload, you can open Profiler window to check all the time. The unload process has a padding time when you switch the scene. You can see Hierarchy select [AssetLoadManager] GameObject and the inspector will shows it :
Change the scene, then you can see [AssetLoadManager] Inspector has a count down Slider shows unload padding left time:
If you use Profiler : Memory > Detailed > Take Sample to check assets in memory, check after the unload process done.
Let's see every demo scene and how to use APIs, we set the Build Root path, so all the asset load paths are relative path from it, the assets in this folder are called main assets that commonly should be load by your script, like Scenes, and assets not in this folder called referenced assets like Meshes that will not be loaded directly by your code, so you don't need to put all assets into the Build Root. keep this in mind.
PS : when using AssetDataBase_Editor mode, it has no asynchronous loading, all asset loading will be sync load because we use AssetDataBase.LoadAssetAtPath as Editor load function. The unload logic also diferent with AssetBundle mode, while AseetBundle mode using AssetBundle.Unload() and Resources.UnloadUnusedAssets() API.
You can check what kinds of assets we have in the AssetBundleMasterExample folder.
After all we can load assets in Editor, not so much things to learn, if you want it work for your project, only to set Build Root to your asset folder.
Now you can see AssetBundleMaster generate a file in your Resources Folder, this is the basic settings of AssetBundleMaster, you can upload it for other teammates can use it :
Let's start learn how to use API by Demo scenes. How to create AssetBundle written at the end.
0. StartScene1 / StartScene2 (Script : StartScene.cs)
These are 2 entry scene for all demo testing, normally you don't need to do any thing before use AssetBundleMaster APIs, but the only one exception is Remote AssetBundle mode that you load assetbundle from a remote address(Server), you have to wait the AssetLoadManager to download basical files from server, you can see the code in StartScene.cs::Start() function :
AssetLoadManager in namespace AssetBundleMaster.AssetLoad.
You can make it as your game Entry Point, start game logic after AssetLoadManager.Instance.OnAssetLoadModuleInited() callback.
1. Example_LoadAsset (Script : Example_LoadAsset.cs)
This Demo shows how to load common assets, loading with ResourceLoadManager .
API (namespace AssetBundleMaster.ResourceLoad):
ResourceLoadManager.Instance.Load<T>(string loadPath)
ResourceLoadManager.Instance.LoadAsync<T>(string loadPath, System.Action<T> loaded)
ResourceLoadManager.Instance.LoadAll<T>(string loadPath)
This Demo will load assets in Sprites and Textures folder, the path "Sprites/Pic1" is kind of special, let's see :
It contains 3 assets have the same asset name Pic1.jpg / Pic1.png / Pic1.txt, in this situation our asset load API use no ext name path to load assets( like Resources.Load API ), so these 3 assets have the same load path, the API can load asset by limit its type, for example ResourceLoadManager.Instance.Load<TextAsset>("Sprites/Pic1").text; load the first TextAsset in the path, and ResourceLoadManager.Instance.LoadAll<Sprite>("Sprites/Pic1"); load all Sprites from this path, if you change "Sprites/Pic1" to "Sprites" that targeting the folder, it will also load asset correctly, the logic is the same as UnityEngine.Resources load API. This feature solved the problem when in Android load from StreamingAssets that has no way to load all assets from target folder.
If you load asset by path without extension, and the file name is not unique like Pic1 above, the asset loader will load assets iteratively until target asset is loaded. that's unnecessary overhead. If a load path with extension the path must be unique, so we enhanced the load APIs, support the load path with extension :
ResourceLoadManager.Instance.Load<TextAsset>("Sprites/Pic1").text;
can be rewrite to :
ResourceLoadManager.Instance.Load<TextAsset>("Sprites/Pic1.txt").text;
We don't have any load overhead now. In the Demo scripts all asset load do not use file extension is just for make it looks like Resources.Load API, you should use load path with extension when the asset name is not unique while loading a single asset for preventing the overhead ( with a good naming habit and well resource classification can make a good project ) .
Tips for AssetBunlde load mode : if you are loading asset async, and a sync requst happened while the asset is still loading, the Console will pop an error message, but the function still work correctly. see what happened:
1. Request load "Textures/Pic3" Async
2. Request load "Textures/Pic3" Sync before Async is not yet completed
Load Sync while Async loading, this code was not written in demo, just for reference.
This is because Unity has no provide any API for stop an AssetBundle async load, and load sync while async loading will pop error, the AssetBundleMaster's Low-Level API handles it to ensure all call backs and returns working correctly. you don't need to worry about it.
Other APIs can be check in ResourceLoadManager.cs, include Generic and Non-Generic version, convenient for users using Lua script.
2. Example_LoadPrefab (Script : Example_LoadPrefab.cs)
This demo shows how to load and Instantiate GameObjects. load with PrefabLoadManager. the sctips shows 2 ways to Instantiate GameObject async, with a little overhead diference.
API (namespace AssetBundleMaster.ResourceLoad):
PrefabLoadManager.Instance.Spawn(string loadPath, string poolName = null, bool active = true) // Spawn is to load and Instantiate GameObject.
PrefabLoadManager.Instance.SpawnAsync(string loadPath, System.Action<GameObject> loaded = null, string poolName = null, bool active = true) // SpawnAsync is to load Async and Instantiate GameObject.
PrefabLoadManager.Instance.LoadAssetToPoolAsync(string loadPath, System.Action<GameObject, GameObjectPool> loaded = null, string poolName = null) // LoadAssetToPoolAsync is to load prefab asset Async to target pool.
The script shows 2 Async load logic, if the prefab asset is not yet loaded, the second one is more efficiency than the first one, but is more coding work( See scope in LoadAsyncButton2.onClick ). the overhead of PrefabLoadManager.Instance.SpawnAsync is acceptable. You should always load and instantiate GameObject with PrefabLoadManager ( Character, UI, Particle Effect, Weapon...etc, all your GameObject Prefabs ), you are not only get benefit from ObjectPool, but also get auto resources control. you can also use LoadAssetToPoolAsync as a pre-load like this :
PrefabLoadManager.Instance.LoadAssetToPoolAsync("Prefabs/Cube", null, "Characters");
This is only load Cube asset to pool, as you know the asset load process causes I/O, Decompress, Deserialize, Shader Parse....ect, do pre-load while CPU is not busy can have a better game experience.
The auto resource contrl logic can be check in the appendix.
you can use file extension also.
3. Example_LoadScene (Script : Example_LoadScene.cs)
This demo shows how to load scenes, the scene load is like asset load which using relative load path. Let's see the scene Example_LoadScene.
API (namespace AssetBundleMaster.ResourceLoad):
SceneLoadManager.Instance.LoadScene(string sceneLoadPath,
AssetBundleMaster.AssetLoad.LoadThreadMode loadMode = AssetBundleMaster.AssetLoad.LoadThreadMode.Asynchronous,
UnityEngine.SceneManagement.LoadSceneMode loadSceneMode = LoadSceneMode.Single,
System.Action<int, Scene> loaded = null )
It do load scene like an asset using its relative load path, can load with async/sync mode and LoadSceneMode. Please notice it that load scene must wait for the call back UnityEngine.SceneManagement.SceneManager.sceneLoaded that means no matter load scene Sync or Async, you'd better wait for loaded call back.
It returns a HashCode as handler of this scene, and the callback [ System.Action<int, Scene> loaded = null ] is also give you the same HashCode.
4. Example_SpawnDespawn (Script : Example_SpawnDespawn.cs)
This demo shows how the objectpool do spawn and despawn GameObjects.
API (namespace AssetBundleMaster.ResourceLoad):
PrefabLoadManager.Instance.Spawn(string loadPath, string poolName = null, bool active = true);
PrefabLoadManager.Instance.Despawn(GameObject go, string poolName = null);
We do auto load and Instantiate prefab, and set active when spawn a GameObject, with the poolName parameter, you must despawn GameObject to the same poolName where it spawned from. The GameObject will be set active false while despawn to pool, and its parent will also set to the pool, if you have spacial needs, rewrite the code at AssetBundleMaster.ObjectPool.GameObjectPool.Despawn function.
PS : if you call the PrefabLoadManager.Instance.Despawn(GameObject go, string poolName = null); poolName is incorrect, it will search all pools to find the correct pool where the gameobject is spawned from, if you have many pools you'd better fill the correct poolName for less search. else if you don't fill any poolName, it will use a default pool name.
5. Example_SpawnPoolAndUnload (Script : Example_SpawnPoolAndUnload.cs)
This deom shows how to destroy spawn pool, and how's the auto unload working.
API (namespace AssetBundleMaster.ResourceLoad):
PrefabLoadManager.Instance.DestroyTargetInPool(string loadPath, string poolName = null, bool tryUnloadAsset = true);
This API is to destroy a target spawned GameObjects from target Pool by loadPath and poolName. if tryUnloadAsset is true, PrefabLoadManager will do check referenced assets, if all pools do not reference to the prefab asset, it will do unload asset process.
PS : click [Spawn Cubes] button in scene, there are 2 pools will be created, and every pool create some Cubes, see Hierarchy there are some Cubes was set no parent, it just for telling you that the connection of spawned GameObject to pool will not be break from parent changed. GameObject still controlled by pool even it is not child of the pool in Hierarchy.
click [ DestroyCubesInPool:MyCubes[1] ] button, the MyCubes[1] pool will destroy all Cubes controlled by it, we can see the pool of MyCobes[1] is alive but spawned cubes was destroied.
The asset(prefab) is still referenced by MyCubes[2] pool, so it will not trigger the unload asset process, click [DestroyCubesInPool:MyCubes[2]] button, now all GameObjects was destroied, see [AssetLoadManager] inspector, unload asset was triggered.
So that PrefabLoadManager can auto control the resources. every developer in your team can have their unique object pools by using unique pool names, every one just to control their pools to load and unload, the auto resource control will handle when to unload the assets.
PS : here we using the AssetDataBase_Editor mode, it will unload the assets depending on Resources.UnloadUnusedAssets(); while the AssetBundle mode will use AssetBundle.Unload(true); to unload assets, it is more faster ( more about it see the appendix) .
6. Example_UnloadAsset (Script : Example_UnloadAsset.cs)
This deom shows common asset unload process. the API is to unload asset :
API (namespace AssetBundleMaster.ResourceLoad):
ResourceLoadManager.Instance.UnloadAsset(UnityEngine.Object target); // recommand not use this
ResourceLoadManager.Instance.UnloadAsset(string loadPath, System.Type systemTypeInstance, bool inherit = false); // use this
ResourceLoadManager.Instance.UnloadAsset<T>(string loadPath, bool inherit = false); // use this
We have many ways to unload asset, you can call [ResourceLoadManager.Instance.UnloadAsset(UnityEngine.Object target)] like UnityEngine.Resources.UnloadAsset, or others the parameter is the load path + load type, this is because to load the same asset it may have diferent load types, for example a picture can be load as Texture2D or Object, so the unload logic is also the same. The unload type can be inherit, like the picture shows above, ResourceLoadManager.Instance.UnloadAsset<Object>("Sprites/Pic1", true); means to unload all type inherit from Object that load from path "Sprites/Pic1", and the ResourceLoadManager.Instance.UnloadAsset<Sprite>("Sprites/Pic2", false); means only to unload Sprite type load from "Sprites/Pic2". these APIs were provided for your special need. UnloadAsset with Object target is not a good use, because the "Resource" you want to unload maybe incorrcet( for example you load a GameObject and get a texture from it, UnloadAsset(texture) is incorrect, you should unload the GameObject ),
This API is privide a flexible asset unload logic that it do reduce the reference count of assets, if any asset reference count was set to 0, the unload process will be triggered. if you set all references of assets to null, the assets will be unloaded, but if not, the ResourceLoadManager holds weakreference to the assets too, and someone request the same asset next time, ResourceLoadManager will return the weakreferenced target and no need to reload asset, this is the core logic to make sure asset will not duplicated in memory.
Unload procccess will be diferent by diferent asset load mode, the AssetDataBase_Editor is totally use Resources.UnloadUnusedAssets(); and the AssetBundle mode may use AssetBundle.Unload(true) or AssetBundle.Unload(false) + Resources.UnloadUnusedAssets() it depends on the auto resource control logic.
If you do request unload asset by ResourceLoadManager, the AssetLoadManager will increase the unload counter number, if the number is greater than AssetLoadManager.Instance.unloadAssetCountGreater it will enter the unload process, finally will trigger the Resources.UnloadUnusedAssets(). you can adjust the value of it. AssetLoadManager have only 2 variables can be access, you can see StartScene.cs::Start() function :
1. AssetLoadManager.Instance.unloadAssetCountGreater : the minimal unload number to enter unload process. change this value for your needs.
2. AssetLoadManager.Instance.unloadPaddingTime : the padding time between unload process started and unload function called. The async load API's callback is a delegate, they do referencing the requested assets, logically we should wait the GC to collect them before call unload function, but when the CG will be called is unknow. In runtime the asset load / unload will happened often, so you don't have to mind it.
PS: both of them were set to a small value for editor proflier testing in StartScene.cs script.
7. Example_UnloadScene (Script : Example_UnloadScene.cs)
This demo shows unload scene features, scene loading can have both async and sync process, the scene loaded event is triggered by SceneManager.sceneLoaded, so to unload scene is a little complex( but simple for user side ) :
API (namespace AssetBundleMaster.ResourceLoad, AssetBundleMaster.AssetLoad):
AssetLoadManager.Instance.UnloadLevelAssets(int hashCode); // recommand don't use it ...
This is a Low-Level API to clear scene assets, it only works in AssetBundle mode, and only can clear AssetBundle serialized file which scene referenced, if you don't load scene again while this scene exists, and the serialized file was eat up your memory, you can call it but we recommand don't call it, it may cause asset duplicated. This example is to show if you call this function and load scene again, the assets in memory will duplicated(if you don't unload any scene).
SceneLoadManager.Instance.UnloadScene(int id, System.Action<Scene> unloaded = null);
The scene load API ( SceneLoadManager.Instance.LoadScene ) retuen a HashCode, UnloadScene is use this HashCode. and the unload asset process will triggered if any scene asset can be unload. it is also auto resource control. The scene load has async process, the unload flow chart is like this(if not AssetBundle mode, no AssetBundle step) :
The Async loading may be :
1. Async load AssetBundle
2. Async load Scene
3. Wait SceneManager.sceneLoaded called no matter load scene Async/Sync
So the UnloadScene function wrapped all situations to make sure unload request work at any loading step.
This is to test UnloadScene function, it do load scene Aync and unload after Wait Frames, change to 1,2,3...etc, can see in all step it works.
Thats all the Asset load, GameObject load, Scene load and unload logic, controlled by only 3 managers:
1. ResourceLoadManager
2. PrefabLoadManager
3. SceneLoadManager
if you run in editor mode, some tests may not work as well such as Async load and asset duplicate. Let's start build AssetBundle, and runs it in Editor and published app.
PS : StartScene1 Dropdown has a scene Example_UnloadAssetEfficiency is to explain how auto resources unload logic work with diferent LoadManagers, see appendix.
--------------------------------------- Build AssetBundles -----------------------------------------
Open the AssetBundleMaster Window
We have 6 load modes, and have 4 published asset load modes.
Editor Modes
Publish modes
1. Resoueces mode: used as default Resources load mode, if you use it, you don't have to use AssetBundleMaster.
2. AssetBundle_StreamingAssets mode: load AssetBundle from StreamingAssets.
3. AssetBundle_PersistentDataPath mode : updatable resource mode, load from PersistentDataPath, if no asset in PersistentDataPath, load from StreamingAssets. (we don't implement any update logic, but generate patch file for you)
4. AssetBundle_Remote : remote assetbundle mode, you can put your assetbunlde to any server, and load from it.
5. AssetBundle_EditorTest mode: load from temp AssetBundle folder, build AssetBundle will build to temp folde (Editor Only).
6. AssetDataBase_Editor mode: no need to build AssetBundle, load asset directly (Editor Only).
If you use the AssetBundle_Remote mode, the following options will shows up :
Remote URL is the server url, is the same as your root folder. Download FailedTimes is the retry time if assetbundle download failed, the download use the lcoal cache, the APIs are UnityWebRequestAssetBundle / UnityWebRequest / LoadFromCacheOrDownload based on the different Unity Version. if you are testing with a http server, it may have some CORS or MIME issues, check it.
Let's check all the settings on AssetBundleMaster Window :
1. Editor Asset LoadMode (EnumPop) : Asset load mode in Editor.
2. Runtime Asset LoadMode (EnumPop) : Asset load mode in Published.
3. Platform Selection (EnumPop) : AssetBundle target platform, click [Set Current Platform] can set to current platform.
4. Set Bundle Version (Text) : The version of AssetBundle.
5. BuildAssetBundleOptions (EnumFlagPop) : BuildAssetBundleOptions.
6. Build Update File (CheckBox) : Create Patch between versions, Patch file is Josn, serialized from AssetBundleMaster.AssetLoad.LocalVersion.UpdateInfo.
7. Clean TempBuildFolder (CheckBox) : Clear any file in temp folder not in this build.
8. Built-In Shader Collection (Scroll View CheckBox) : Deal with Built-In Shader, no multi compiled.
9. Build Root (Label, Button) : Root folder, asset in this folder can be load.
10. Step1 Clear Old Datas (Button) : Clear all AssetImporter.AssetBundleName.
11. Step 2 Set AssetBundle Names (Button) : Auto set AssetBundleNames, some asset auto process. see appendix.
12. Step 3 Start Build AssetBundles (Button) : Start Build AssetBundles.
That's all settings. Let's set editor load mode and runtime load mode to AssetBundle_StreamingAssets, this is the most simple publish mode. and click :
Step1...
Step2...
Step3...
It will auto build AssetBundle for you. every step shows tips :
Step1
Step2
Step3
When build finished, It will ask you to copy built AssetBundles from temp folder to StreamingAssets? Yes.
You can see StreamingAssets got built AssetBundles :
So the AssetBundle build successed, if you run in Editor, just open the StartScene1, repeat the API tutorial again. This time the Async load is working.
And the [AssetLoadManager] shows different if you noticed :
AssetDataBase_Editor no AssetBundle was loaded
AssetBundle_StreamingAssets load AssetBundles
We did successed building AssetBundles and load AssetBundle in Editor, if we want to publish it, make sure your Platform Selection correct, the next one is very important, scene and the Build Settings :
When you pubilsh your project, there is no need to add any scene to build Settings, because the scenes in Build Root folder will be built to AssetBundle, and any scene added to Build Settings will be packed to Resources too. So how to publish the app and load the StartScene1 as default scene? there are 2 ways :
1. Add entry scene to scene build as default scene
This is the most commonly used, but notice if you add StartScene1 to build settings, and the scene file [StartScene1.unity] is under the Build-Root directory, it will be duplicated after build. if you move the file out of Build-Root directory, you can't use SceneLoadManger API to load StartScene1, you must load it by UnityEngine.SceneManagement API as usual.
2. Or you can use the [UnityEngine.RuntimeInitializeOnLoadMethod] attribute to load the entry scene.
Or you are useing AssetBundle_Remote Mode :
You should add this code to any script yourself. This is pretty good to avoid scene build duplicated, but need coding. In this way your Build Settings is stay empty.
No need to add any scene, just build it and run.
Now let's look at the function 8. Built-In Shader Collection. Let's change the Build Root to AssetBundleMasterExample2 :
Click [Change Build Root] button to change it.
And chagne the version to 2.0.0, We Built 1.0.0 before, so Exists Versions shows 1.0.0 Exists, check the Build Update File, we can see Patch file will be generated later. Build Root is AssetBundleMasterExample2 now, let's see what is in this folder :
There are 44 materials were used in the Example_ShaderCollection scene, they all used the Standard Shader :
These materials may cause the issue. We need to change the entry scene to StartScene2, it will load Example_ShaderCollection, now change the entry scene :
1. Change the entry scene by Build Settings
2. Or change code
Or you are useing AssetBundle_Remote Mode :
Do build AssetBundle Steps again,
Step1...
Step2...
Step3...
This time the Step3 shows new tips :
This is because we built 1.0.0 version bundles already, and if we create 2.0.0 version it can be a incremental build, it will be faster than build a totally new version. But this build is to build AssetBundleMasterExample2, is totally diferent with AssetBundleMasterExample, no shared assets, so whatever you choose, it will build a totally new version.
So the function 7. Clean TempBuildFolder (CheckBox) is used for it, if checked, the temp folder will do clean files that not in this version.
After the build AssetBunlde finished, we build app to check what happened at the runtime. don't forget to select the [Development Build] and [Autoconnect Profiler] in Build Settings. My platform is macro soft windows 10. Screen shot from Unity2020.
Total AssetBundle size : 5.11MB(With .manifest files)
The Task Manager shows the app runtime memory : 279.8MB
Profiler Shader 113MB, Standard was compiled many times
This issue happend on Standard Shader, let's use the Shader Collection to collect Standard Shader, and build a 3.0.0 version, the shader changes will not cause the changes of referencing assets, so we must select the ForceRebuildAssetBundle on BuildAssetBundleOption, otherwise we will lost the reference of materials :
PS : the default setting of BuildAssetBundleOption is ChunkBasedCompression, it is just for building AssetBundle faster, you can change the settings by your need, and the setting serialized files is in the editor folder shows below, you can upload to SVN share to your teammate :
Do build AssetBundle Steps again,
Step1...
Step2...
Step3...
And build app to run :
Total AssetBundle size : 1.77MB
Task Manager shows runtime memory 122.0MB
Profiler : Shader 10M, Standard compiled once only.
You can see the big different between 2.0.0 and 3.0.0, in 2.0 we are wasting I/O time and runtime memory. this issue mainly caused by Built-In Shader( based on your usage, for exp the UGUI using built-in shaders but have the same built-in material, it will not cause this problem ).
All tests were tested on Unity5/Unity2017/Unity2018/Unity2019/Unity2020, nearly got the same result.
Let's take a look at AssetBundle temp folder, it is at the same layer as the Assets folder :
Assets/../AssetBundles/StandaloneWindows64/
You can see Version based AssetBundle Temp Folders and Update Patch files, patch file is Json format looks like this (Update_2.0.0_to_3.0.0.txt) :
Means if you are Version 2.0.0, update to 3.0.0 you sould download files listed in "updateList" from server or CDN, and delete files listed in "deleteList" in local. The patch file was generated between versions, serialized from AssetBundleMaster.AssetLoad.LocalVersion.UpdateInfo, json format.
Notice : we are only generate update-patch files, there is no file update system implemented in AssetBundleMaster, users must implement the file update system your self.( Based on different game requirments, the update logic is very complicated to satisfied)
Notice2 : If you just need a remote assetbundle loader, you just set AssetLoadMode to AssetBundle_Remote, it can load the newest assetbundle from cache or server.
Use AssetBundle_Remote load from a server example. what we need to do is copy the built assetbundles to the server directory :
Just Copy To Server Directory ( a IIS server path root is E:LocalServerWebGL_Raw )
.manifest file is no need to put to server.
If you are using AssetBundle_EditorTest mode, it load AssetBundles from temp folder, you can switch load between built versions easily, just change the [Platform Selection] and [Set Bundle Version] :
Temp Folder is Assets/../AssetBundles/StandaloneWindows64/x.x.x/
PS : when you start run, the asset load root path will log to console, you can check it.
Other functions in the Tools Bar:
1. Copy built AssetBundle from temp folder to StreamingAssetsfolder :
This is the same function as to the AssetBundle build finished tips.
2. Clear AssetBundleMaster serialized datas :
It will clear the generated settings files said before, AssetBundleMaster can not run without these files.
3. Open Caching Folder
Open the cache folder, if you are using AssetBundle_Remote load from a server, you can see cached files in this folder, Unity5 shows nothing even cached(Maybe cached files not in this folder), Unity2017~Unity2020 showing correctly.
These are all about AssetBundleMaster, it was designed for small or middle-class projects and provide the convenience and correctness for resource control, give you a friendly developing flow chat, and it has the potential to work for large project. Have Fun.
Appendix
Auto asset processing, the Editor code written in AssetBundleBuildWindow.cs, we do process some assets :
1. SpriteAtlas, you can not create SpriteAtlas yourself in Unity5, it can be created after Unity2017, code in AssetBundleBuildWindow::1762 line, CreateSpriteAtlasAssets function, it do set all Sprites with same Packing Tag to the same AssetBundle, avoid the SpriteAtlas duplicated(works in Unity5). The Packing Tag is the basis for packing AssetBundle, but in Unity2019 the Packing Tag do not shows up in the Inspector, but it exists in the serialize file. AssetBundleMaster overwrite the Inspector for it, Packing Tag was added, the script is TextureImporterInspector.cs :
Unity5 has the Packing Tag field
Unity2019 has no Packing Tag
Unity2019 or newer AssetBundleMaster overwrite Texture Inspector
In some cases the [Include in Build] info of SpriteAtlas may lost ( for exp AssetBundle update ), ResourceLoadManager added a callback to UnityEngine.U2D.SpriteAtlasManager.atlasRequested as a fallback to ensure the Sprites will be load correctly, if you got the issue that can not load Sprite, debug the ResourceLoadManager.RequestAtlas function(Unity2017 or newer).
SpriteAtlas will be created to Assets/AssetBundleMasterSpriteAtlas folder(Unity2017 or newer).
2. EditorConfigSettings, some of the editor settings will be set, you can take a look codes at AssetBundleBuildWindow::1679 line, EditorConfigSettings function, it did set the UnityEditor.EditorSettings.spritePackerMode for create SpriteAtlas, and change GraphicsSettings > Lightmap Modes to Custom mode, for preventing the LightMap info being stripped while build AssetBundle :
If you got some issues unexpect, check the code AssetBundleBuildWindow.EditorConfigSettings();
3. TerrainData( AssetBundleBuildWindow.AssetPostCheck ), the used textures must set to isReadable(Read/Write Enabled in AssetImport Inspector), or it will pop error message after AssetBundle built( Make your build failed ).
The logic of auto resource control in AssetBundle mode, we can see Demo : Example_UnloadAssetEfficiency. please select any AssetBundle mode and build AssetBundles, and select this scene to load assets. when we loading assets, we have only 3 Managers ( namespace AssetBundleMaster.ResourceLoad ) :
1. ResourceLoadManager not auto controlled, can't unload by AssetBundle.Unload(true);
2. PrefabLoadManager auto controlled, unload by AssetBundle.Unload(true);
3. SceneLoadManager auto controlled, unload by AssetBundle.Unload(true);
That's means commonly the PrefabLoadManager and SceneLoadManager do unload assets, it will call AssetBundle.Unload(true); but the assets loaded by ResourceLoadManager will unload by AssetBundle.Unload(false); + Resources.UnloadUnusedAssets(); it is not good efficiency but it can keep the resources unload safe, the assets will not lost by any unexcepted unload.
When these referenced assets were cross referenced, the unload logic may changed too. for example a Prefab referencing a Texture named Pic3, the GameObject was instantiated by PrefabLoadManager and destroied, the AssetBundle of Pic3 should be unload by AssetBundle.Unload(true); but before it unload, the ResourceLoadManager do load the Pic3, so the Pic3 Asset was changed to be not auto controlled, the unload call should be AssetBundle.Unload(false); ...... the logic about unload control is in AssetBundleMaster.AssetLoad.AssetBundleTarget , the variable is unloadable.
Let's run the scene Example_UnloadAssetEfficiency in any AssetBundle Mode:
Click LoadCubeButton to load GameObject, we can see AssetBundles are auto controled:
Click UnloadCubeButton, The Unload log shows AssetBundle.Unload(true); was called:
This time we do load both assets, Cube and Pic3, Click LoadCubeButton, LoadTextureButton:
We can see textures/pic3.ab was set to unloadable : False, it means Pic3 asset was set to not auto control asset, Click UnloadCubeButton, you can see the unload log:
Only 2 assets was unloaded, the AssetBundle textures/pic3.ab was kept, because it loaded by ResourceLoadManager and was referenced by it, Click UnloadTextureButton:
Finally the Pic3 was unloaded by AssetBundle.Unload(false); + Resources.UnloadUnusedAssets();
That's the basic unload logic.
Update support :
1. We are not to implement any file update system. but as we can see the update-patch file can be generated by 6. Build Update File (CheckBox) selected, no matter which version of AssetBundles you build or rebuild, all update patch files will be refresh again, so your update system can use it.
Assets/../AssetBundles/[Platform]/
How to get current assetbundle version is to get VersionInfo from LocalVersion :
It is a string, you can send it to server to quary a update patch file, and run your update system if needed.
2. If you select AssetBundle_PersistantDataPath mode, the AssetBundleMaster will try to load assetbundle from Application.persistentDataPath first, if there is no target file exists, AssetBundleMaster will try to load from Application.streamingAssetsPath. It means you can publish a basic version app such as [1.0.0] or [2.0.0] with assetbundles in StreamingAssets folder, and you can download new version files to Application.persistentDataPath, the runtime will load from this path if new version file exists. Most platforms can Read/Write to persistentDataPath, your project is updatable in this mode( but AssetBundleMaster not implement any file update system, you must make it your self ).
3. If you select AssetBundle_Remote mode, witch means you load assetbundle from remote address, you don't need to make any file update system, it will load newest assetbundle from remote or local cached.