├── Docs └── Images │ ├── Youtube.png │ ├── build_all.png │ ├── create_asset_variant.png │ ├── enumerators_folder.png │ ├── generate_surrogate.png │ ├── getting_started.png │ ├── import_external_asset.png │ ├── instantiate_asset.png │ ├── register_external_asset.png │ ├── runtme_asset_database.png │ └── surrogates_folder.png ├── README.md └── README.pdf /Docs/Images/Youtube.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/Youtube.png -------------------------------------------------------------------------------- /Docs/Images/build_all.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/build_all.png -------------------------------------------------------------------------------- /Docs/Images/create_asset_variant.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/create_asset_variant.png -------------------------------------------------------------------------------- /Docs/Images/enumerators_folder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/enumerators_folder.png -------------------------------------------------------------------------------- /Docs/Images/generate_surrogate.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/generate_surrogate.png -------------------------------------------------------------------------------- /Docs/Images/getting_started.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/getting_started.png -------------------------------------------------------------------------------- /Docs/Images/import_external_asset.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/import_external_asset.png -------------------------------------------------------------------------------- /Docs/Images/instantiate_asset.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/instantiate_asset.png -------------------------------------------------------------------------------- /Docs/Images/register_external_asset.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/register_external_asset.png -------------------------------------------------------------------------------- /Docs/Images/runtme_asset_database.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/runtme_asset_database.png -------------------------------------------------------------------------------- /Docs/Images/surrogates_folder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/Docs/Images/surrogates_folder.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Runtime Asset Database for Unity 2 | 3 | The [**Runtime Asset Database**](https://assetstore.unity.com/packages/tools/modeling/runtime-asset-database-263289) is a library designed to simplify the implementation of a runtime save and load subsystem in your Unity application. This library replicates and extends the familiar concepts of prefabs, prefab variants, and assets found within the Unity Editor, making it easier than ever to manage and manipulate game assets at runtime and implement workflows similar to those of the Unity Editor dynamically during runtime. 4 | 5 | [![Promo Video][youtube_icon]](https://www.youtube.com/watch?v=DXWriLgrWdE) 6 | 7 | > **Note** 8 | The repository containing the project used to create the above video can be found [here](https://github.com/Battlehub0x/RuntimeAssetDatabaseGameKit) 9 | 10 | > **Code Companion** 11 | https://chat.openai.com/g/g-1UCDubUwr-your-code-companion-don-t-trust-me-blindly 12 | 13 | 14 | ## Introduction 15 | 16 | Unity developers often rely on the convenience and flexibility of the Editor's asset management system when designing their games. However, when it comes to implementing a save and load system at runtime, this process can become more complex. The Runtime Asset Database bridges this gap by bringing the essential asset management functionalities you're accustomed to into the runtime environment. 17 | 18 | ## Features 19 | - **Runtime Asset Management API:** Provides functionality to create, load, and manage assets during runtime. 20 | - **Built on Unity Editor Prefab Concepts:** Utilizes familiar concepts from the Unity Editor's prefab workflow. 21 | - **Asset and Asset Variant Support:** Supports assets and their variants. 22 | - **Extensibility with new types and components:** Allows for the extension with new serializable types. 23 | - **Pluggable External Asset Importers:** Offers the ability to integrate external asset importers seamlessly. 24 | 25 |
26 | 27 | ## Getting Started 28 | 1. Unpack **StarterKit** Unity Package 29 | 2. Click Tools > Runtime Asset Database > **Build All** 30 | 3. Click Tools > Runtime Asset Database > **Create Host** 31 | 4. Create a new C# script named **GettingStarted.cs** in your Unity project. 32 | 5. Add the Following Code to Your Script: 33 | ```C# 34 | using UnityEngine; 35 | using Battlehub.Storage; 36 | 37 | public class GettingStarted : MonoBehaviour 38 | { 39 | private IAssetDatabase m_assetDatabase; 40 | 41 | async void Start() 42 | { 43 | // Define your project path 44 | string projectPath = $"MyProject"; 45 | 46 | // Obtain a reference to the asset database 47 | IAssetDatabase m_assetDatabase = RuntimeAssetDatabase.Instance; 48 | 49 | // Load the project 50 | await m_assetDatabase.LoadProjectAsync(projectPath); 51 | } 52 | } 53 | ``` 54 | 55 |
56 | 57 | 6. Modify Your Script as Follows: 58 | 59 | ```C# 60 | using UnityEngine; 61 | using Battlehub.Storage; 62 | 63 | public class GettingStarted : MonoBehaviour 64 | { 65 | async void Start() 66 | { 67 | string projectPath = $"MyProject"; // Define your project path 68 | 69 | // Obtain a reference to the asset database 70 | IAssetDatabase m_assetDatabase = RuntimeAssetDatabase.Instance; 71 | 72 | // Load the project 73 | await m_assetDatabase.LoadProjectAsync(projectPath); 74 | 75 | // Delete the "Assets" folder if it exists 76 | if (m_assetDatabase.Exists("Assets")) 77 | await m_assetDatabase.DeleteFolderAsync("Assets"); 78 | 79 | // Create a new "Assets" folder 80 | await m_assetDatabase.CreateFolderAsync("Assets"); 81 | 82 | // Create a primitive object (capsule) and make some modifications 83 | var go = GameObject.CreatePrimitive(PrimitiveType.Capsule); 84 | var filter = go.GetComponent(); 85 | var renderer = go.GetComponent(); 86 | var mesh = filter.mesh; 87 | var material = renderer.material; 88 | material.color = new Color32(0x0, 0x74, 0xFF, 0x0); 89 | 90 | // Create a mesh asset 91 | await m_assetDatabase.CreateAssetAsync(mesh, "Assets/Mesh.asset"); 92 | 93 | // Create a material asset 94 | await m_assetDatabase.CreateAssetAsync(material, "Assets/Material.asset"); 95 | 96 | // Create a "prefab" asset 97 | await m_assetDatabase.CreateAssetAsync(go, "Assets/Capsule.prefab"); 98 | 99 | // Unload the project and destroy all assets to free up memory 100 | await m_assetDatabase.UnloadProjectAsync(destroy: true); 101 | 102 | // Load the project again 103 | await m_assetDatabase.LoadProjectAsync(projectPath); 104 | 105 | // Instantiate the prefab. 106 | await m_assetDatabase.InstantiateAssetAsync("Assets/Capsule.prefab"); 107 | } 108 | } 109 | ``` 110 | 7. Press the "Play" button in Unity. **You should now see an instance of the object loaded from the Runtime Asset Database in your Unity scene** 111 | 112 | ![Getting Started Result][getting_started_result] 113 | 114 |
115 | 116 | ## Definitions 117 | ### Folder 118 | A folder simply refers to a directory on disk within the Runtime Asset Database project directory. 119 | 120 | ### Asset 121 | An asset is any object derived from UnityEngine.Object that can be serialized and deserialized. It is represented by three files on disk: the meta file, data file, and thumbnail. Assets fall into two categories: 122 | - **Instantiable Assets**: These assets are analogous to prefabs in the Unity Editor. They can be instantiated and used directly in your project. 123 | - **Non-instantiable Assets**: Examples of non-instantiable assets include materials and meshes. 124 | 125 | Additionally, there is the concept of a Root Asset and a regular Asset. 126 | - **Root Asset**: A GameObject is an example of a Root Asset. 127 | - **Asset**: Components or meshes are examples of regular Assets. Their data is embedded in the same data file as the Root Asset. 128 | 129 | ### Asset Variant 130 | An **Asset Variant** is the equivalent of a Prefab Variant in the Unity Editor. It can only be created from an **Instantiable Asset**. 131 | Asset Variants become valuable when you need to define a set of predetermined variations of an Asset. 132 | 133 | ### External Asset 134 | An External Asset is an asset imported into the project using a specific importer, such as Addressable importers, importer that load asset from the Resources folder, GLB importer, or any other third-party importer. 135 | External Assets are read-only and contain only identifiers for parts within the data file. If you need to make edits to an External Asset, you can create an Asset Variant of it. 136 | 137 | ### Instance 138 | You can only instantiate an Asset, Asset Variant, or External Asset. The runtime asset database maintains mappings between instance parts and their corresponding asset parts 139 | 140 | ### Dirty Instance 141 | A "dirty" instance is one that has been marked to notify the runtime asset database that a change has occurred within an instance of an Asset Variant. 142 | This change needs to be saved to disk. When you load the Asset Variant next time, the asset database will read and apply this change to the base asset 143 | 144 | ### Detached Instance 145 | A detached instance is an instance that has no connection to the actual asset it originated from. 146 | You can convert an existing instance into a detached instance using the DetachAsync method, which will be discussed in more detail below. 147 | 148 | ### Meta File 149 | The Meta File contains asset metadata, which includes identifiers of dependencies, the asset's name, file ID. To get the metafile path, combine the file ID with the **.meta** extension; to get the thumbnail path, combine the file ID with the **.thumb** extension. 150 | 151 | ### Data File 152 | The Data File contains the binary serialized data of the asset. Runtime Asset Database uses protobuf-net as serializer. 153 | 154 | ### Thumbnail File 155 | The Thumbnail File contains image data of the asset's thumbnail texture. 156 | 157 | ### Surrogate 158 | Surrogates are classes with which the Serializer works. They act as intermediary classes that facilitate the reading and writing of data to the target Unity object. 159 | While these classes are often auto-generated, you have the flexibility to edit or create them from scratch. 160 | 161 | ### Enumerator 162 | Enumerators are classes used to retrieve Unity object dependencies in a structured manner. 163 | They enable the serialization of an entire object tree in a way that ensures dependencies are deserialized before dependent objects during the deserialization process. 164 | Similar to surrogates, enumerators are often auto-generated, but users also have the flexibility to create or edit them. 165 | 166 |
167 | 168 | ## Examples 169 | ### Load project 170 | ```C# 171 | using System; 172 | using UnityEngine; 173 | namespace Battlehub.Storage.Samples 174 | { 175 | public class LoadProjectExample : MonoBehaviour 176 | { 177 | private IAssetDatabase m_assetDatabase; 178 | 179 | private async void Start() 180 | { 181 | m_assetDatabase = RuntimeAssetDatabase.Instance; 182 | 183 | string fullpath = $"{Application.persistentDataPath}/Example Project"; 184 | 185 | // load the project (creates a project folder if it does not exist) 186 | await m_assetDatabase.LoadProjectAsync(fullpath); 187 | 188 | // get root folder id 189 | Guid rootID = m_assetDatabase.RootID; 190 | 191 | // get child id by root id 192 | foreach (var childID in m_assetDatabase.GetChildren(rootID, sortByName: true)) 193 | { 194 | // get asset metadata by id 195 | var meta = m_assetDatabase.GetMeta(childID); 196 | 197 | if (m_assetDatabase.IsFolder(childID)) 198 | { 199 | Debug.Log($"Folder {meta.Name} {meta.FileID}"); 200 | } 201 | else 202 | { 203 | Debug.Log($"{meta.Name} {meta.FileID}"); 204 | } 205 | } 206 | } 207 | } 208 | } 209 | ``` 210 | 211 |
212 | 213 | ### Unload project 214 | ```C# 215 | using UnityEngine; 216 | namespace Battlehub.Storage.Samples 217 | { 218 | public class UnloadProjectExample : MonoBehaviour 219 | { 220 | private IAssetDatabase m_assetDatabase; 221 | 222 | private async void Start() 223 | { 224 | m_assetDatabase = RuntimeAssetDatabase.Instance; 225 | 226 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 227 | 228 | await m_assetDatabase.LoadProjectAsync(projectPath); 229 | } 230 | 231 | private async void OnDestroy() 232 | { 233 | if (m_assetDatabase != null) 234 | { 235 | if (m_assetDatabase.IsProjectLoaded) 236 | { 237 | // unload the project and all assets 238 | 239 | // destroy: true -> destroy the corresponding objects and game objects 240 | 241 | await m_assetDatabase.UnloadProjectAsync(destroy: true); 242 | } 243 | } 244 | } 245 | } 246 | } 247 | ``` 248 | 249 |
250 | 251 | ### Import external asset 252 | ```C# 253 | using UnityEngine; 254 | namespace Battlehub.Storage.Samples 255 | { 256 | /// 257 | /// --------------------------------------------------------------------------- 258 | /// First register an external asset loader. This should only be done once, 259 | /// after that you can import multiple asses using this loader. 260 | /// --------------------------------------------------------------------------- 261 | /// In this example, I'm using the built-in ResourcesLoader for simplicity, 262 | /// but it could be any loader which implements the IExternalAssetLoader 263 | /// interface (AddressablesLoader, glTFLoader, FBXLoader, etc.) 264 | /// --------------------------------------------------------------------------- 265 | /// The loader in this example loads an asset from the Resources folder. 266 | /// In this particular example, the asset with the key "Hellephant" is in 267 | /// Assets/Battlehub/Storage.Samples.ProjectBrowser/Content/Resources 268 | /// --------------------------------------------------------------------------- 269 | /// 270 | public class ImportExternalAssetExample : MonoBehaviour 271 | { 272 | private IAssetDatabase m_assetDatabase; 273 | 274 | private async void Start() 275 | { 276 | m_assetDatabase = RuntimeAssetDatabase.Instance; 277 | 278 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 279 | await m_assetDatabase.LoadProjectAsync(projectPath); 280 | 281 | var rootID = m_assetDatabase.RootID; 282 | string key = "Hellephant"; 283 | string loaderID = nameof(ResourcesLoader); 284 | 285 | IExternalAssetLoader loader = new ResourcesLoader(); 286 | await m_assetDatabase.RegisterExternalAssetLoaderAsync(loaderID, loader); 287 | 288 | // convert externalAssetKey to unique file id 289 | var targetFileID = m_assetDatabase.GetUniqueFileID(rootID, $"{key}"); 290 | 291 | // import external asset 292 | await m_assetDatabase.ImportExternalAssetAsync(key, loaderID, targetFileID); 293 | 294 | // instantiate imported asset 295 | await m_assetDatabase.InstantiateAssetAsync(targetFileID); 296 | } 297 | } 298 | } 299 | ``` 300 | ![Import External Asset Result][import_external_asset] 301 | 302 | > **Note** 303 | To use the AddressablesLoader, make sure to import the [Addressables package](https://docs.unity3d.com/Packages/com.unity.addressables@1.18/manual/index.html) 304 | 305 | > **Note** 306 | You can also create your own external asset loader. To do this, create a new class and implement the IExternalAssetLoader interface: 307 | 308 | ```C# 309 | using System; 310 | using System.Threading.Tasks; 311 | using UnityEngine; 312 | namespace Battlehub.Storage.Samples 313 | { 314 | public class MyLoader : IExternalAssetLoader 315 | { 316 | public Task LoadAsync(string key, object root, IProgress progress) 317 | { 318 | return Task.FromResult(new GameObject(key)); 319 | } 320 | 321 | public void Release(object obj) 322 | { 323 | GameObject go = obj as GameObject; 324 | if (go != null) 325 | { 326 | UnityEngine.Object.Destroy(go); 327 | } 328 | } 329 | } 330 | } 331 | ``` 332 | 333 | 334 |
335 | 336 | ### Register external asset 337 | ```C# 338 | using System; 339 | using System.Collections.Generic; 340 | using System.IO; 341 | using UnityEngine; 342 | namespace Battlehub.Storage.Samples 343 | { 344 | /// 345 | /// ----------------------------------------------------------------------------- 346 | /// Sometimes you don't want certain assets to appear in your runtime project 347 | /// managed by the RuntimeAssetDatabase (or you can't serialize/deserialize them), 348 | /// but you still want other assets to be able to reference them. 349 | /// ----------------------------------------------------------------------------- 350 | /// A good example of an external asset is the default materials or meshes that 351 | /// exist in your Unity editor project. 352 | /// ----------------------------------------------------------------------------- 353 | /// The RegisterExternalAssetsAsync method solves this problem. 354 | /// ----------------------------------------------------------------------------- 355 | /// You should generate some guids to use them as an external asset identifiers 356 | /// https://guidgenerator.com/ 357 | /// ----------------------------------------------------------------------------- 358 | /// Assets passed to RegisterExternalAssetsAsync are never stored in data files 359 | /// and do not have a corresponding metadata file in the runtime project. 360 | /// ----------------------------------------------------------------------------- 361 | /// 362 | public class RegisterExternalAssetExample : MonoBehaviour 363 | { 364 | private IAssetDatabase m_assetDatabase; 365 | 366 | private async void Start() 367 | { 368 | m_assetDatabase = RuntimeAssetDatabase.Instance; 369 | 370 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 371 | await m_assetDatabase.LoadProjectAsync(projectPath); 372 | var rootID = m_assetDatabase.RootID; 373 | 374 | GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule); 375 | Material material = capsule.GetComponent().sharedMaterial; 376 | Mesh mesh = capsule.GetComponent().sharedMesh; 377 | 378 | /// https://guidgenerator.com/ 379 | var externalAssets = new Dictionary() 380 | { 381 | { new Guid("c872b08a-8b5e-41df-bf89-3522b8219dd6"), material }, 382 | { new Guid("3bad1a26-d851-49b5-a11c-6dfe74ee5341"), mesh } 383 | }; 384 | 385 | // ---------------------------------------------------------------------- 386 | // Comment out the following line and you will notice that the 387 | // size of the data file written to the console becomes larger. 388 | // This is because without registering as external assets, 389 | // the mesh and material are serialized into the data file. 390 | // ---------------------------------------------------------------------- 391 | await m_assetDatabase.RegisterExternalAssetsAsync(externalAssets); 392 | 393 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule"); 394 | await m_assetDatabase.CreateAssetAsync(capsule, fileID); 395 | 396 | Debug.Log($"Size of the data file: {new FileInfo(fileID).Length} bytes"); 397 | } 398 | } 399 | } 400 | ``` 401 | ![Register External Asset Result][register_external_asset] 402 | 403 |
404 | 405 | ### Create asset 406 | 407 | ```C# 408 | using Battlehub.Storage.EditorAttributes; 409 | using UnityEngine; 410 | namespace Battlehub.Storage.Samples 411 | { 412 | public class CreateAssetExample : MonoBehaviour 413 | { 414 | private IAssetDatabase m_assetDatabase; 415 | private IThumbnailUtil m_thumbnailUtil; 416 | 417 | [Layer] 418 | public LayerMask ThumbnailLayer; 419 | 420 | private void Awake() 421 | { 422 | var thumbnailUtil = gameObject.AddComponent(); 423 | thumbnailUtil.ThumbnailLayer = ThumbnailLayer; 424 | m_thumbnailUtil = thumbnailUtil; 425 | } 426 | 427 | private async void Start() 428 | { 429 | m_assetDatabase = RuntimeAssetDatabase.Instance; 430 | 431 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 432 | await m_assetDatabase.LoadProjectAsync(projectPath); 433 | var rootID = m_assetDatabase.RootID; 434 | 435 | GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube); 436 | // ---------------------------------------------------------------------- 437 | // Asset can be created with or without thumbnail. 438 | // To generate thumbnail data you can use ThumbnailUtil. 439 | // ---------------------------------------------------------------------- 440 | var thumbnailTexture = await m_thumbnailUtil.CreateThumbnailAsync(cube); 441 | var thumbnailBytes = await m_thumbnailUtil.EncodeToPngAsync(thumbnailTexture); 442 | 443 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule"); 444 | await m_assetDatabase.CreateAssetAsync(cube, fileID, thumbnailBytes); 445 | } 446 | } 447 | } 448 | ``` 449 |
450 | 451 | ### Create thumbnail 452 | 453 | ```C# 454 | using Battlehub.Storage.EditorAttributes; 455 | using UnityEngine; 456 | using UnityEngine.UI; 457 | 458 | namespace Battlehub.Storage.Samples 459 | { 460 | public class CreateAndSaveThumbnailExample : MonoBehaviour 461 | { 462 | private IAssetDatabase m_assetDatabase; 463 | private IThumbnailUtil m_thumbnailUtil; 464 | 465 | [Layer] 466 | public LayerMask ThumbnailLayer; 467 | 468 | [SerializeField] 469 | private RawImage m_thumbnailImage; 470 | 471 | private void Awake() 472 | { 473 | var thumbnailUtil = new GameObject("ThumbnailUtil").AddComponent(); 474 | 475 | // rotate thumbnail camera 476 | thumbnailUtil.transform.LookAt(-Vector3.one); 477 | 478 | // set thumbnail camera layer 479 | thumbnailUtil.ThumbnailLayer = ThumbnailLayer; 480 | 481 | // set desired thumbnail res 482 | thumbnailUtil.SnapshotTextureWidth = 512; 483 | thumbnailUtil.SnapshotTextureHeight = 512; 484 | 485 | m_thumbnailUtil = thumbnailUtil; 486 | 487 | if (m_thumbnailImage == null) 488 | { 489 | Debug.LogWarning("Set thumbnail image"); 490 | } 491 | } 492 | 493 | private async void Start() 494 | { 495 | m_assetDatabase = RuntimeAssetDatabase.Instance; 496 | 497 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 498 | await m_assetDatabase.LoadProjectAsync(projectPath); 499 | var rootID = m_assetDatabase.RootID; 500 | 501 | GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule); 502 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule"); 503 | 504 | // Create Asset (capsule becomes instance of an asset) 505 | await m_assetDatabase.CreateAssetAsync(capsule, fileID); 506 | 507 | // Create, encode and save thumbnail 508 | var thumbnailTexture = await m_thumbnailUtil.CreateThumbnailAsync(capsule); 509 | 510 | // Release asset instance 511 | await m_assetDatabase.ReleaseAsync(capsule); 512 | 513 | // Encode and save thumbnail 514 | var thumbnailBytes = await m_thumbnailUtil.EncodeToPngAsync(thumbnailTexture); 515 | await m_assetDatabase.SaveThumbnailAsync(fileID, thumbnailBytes); 516 | 517 | if (m_thumbnailImage != null) 518 | { 519 | // Show thumbnail texture 520 | m_thumbnailImage.texture = thumbnailTexture; 521 | } 522 | } 523 | } 524 | } 525 | ``` 526 |
527 | 528 | ### Load asset 529 | ```C# 530 | using System.Linq; 531 | using UnityEngine; 532 | namespace Battlehub.Storage.Samples 533 | { 534 | public class LoadAssetExample : MonoBehaviour 535 | { 536 | private IAssetDatabase m_assetDatabase; 537 | 538 | private async void Start() 539 | { 540 | m_assetDatabase = RuntimeAssetDatabase.Instance; 541 | 542 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 543 | await m_assetDatabase.LoadProjectAsync(projectPath); 544 | 545 | var rootID = m_assetDatabase.RootID; 546 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule"); 547 | 548 | // Create GameObject 549 | var capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule); 550 | 551 | // Make some changes 552 | ModifyGameObject(capsule); 553 | 554 | // Create Asset 555 | await m_assetDatabase.CreateAssetAsync(capsule, fileID); 556 | 557 | // Unload All assets and free up memory 558 | await m_assetDatabase.UnloadAllAssetsAsync(destroy: true); 559 | 560 | // Load asset by fileID 561 | await m_assetDatabase.LoadAssetAsync(fileID); 562 | 563 | // Instantiate loaded asset 564 | await m_assetDatabase.InstantiateAssetAsync(fileID); 565 | } 566 | 567 | private static void ModifyGameObject(GameObject capsule) 568 | { 569 | var meshRenderer = capsule.GetComponent(); 570 | meshRenderer.sharedMaterial = new Material(Shader.Find("Unlit/Color")); 571 | meshRenderer.sharedMaterial.color = Color.blue; 572 | 573 | var meshFilter = capsule.GetComponent(); 574 | meshFilter.sharedMesh = meshFilter.mesh; 575 | meshFilter.sharedMesh.vertices = meshFilter.sharedMesh.vertices. 576 | Zip(meshFilter.sharedMesh.normals, (v,n) => (v, n)). 577 | Select(vn => vn.v + vn.n).ToArray(); 578 | } 579 | } 580 | } 581 | ``` 582 |
583 | 584 | ### Instantiate asset 585 | ```C# 586 | using UnityEngine; 587 | namespace Battlehub.Storage.Samples 588 | { 589 | public class InstantiateAssetExample : MonoBehaviour 590 | { 591 | private IAssetDatabase m_assetDatabase; 592 | 593 | private async void Start() 594 | { 595 | m_assetDatabase = RuntimeAssetDatabase.Instance; 596 | 597 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 598 | await m_assetDatabase.LoadProjectAsync(projectPath); 599 | 600 | var rootID = m_assetDatabase.RootID; 601 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Cube"); 602 | 603 | // Create GameObject 604 | var cube = GameObject.CreatePrimitive(PrimitiveType.Cube); 605 | 606 | // Create Asset 607 | await m_assetDatabase.CreateAssetAsync(cube, fileID); 608 | 609 | // Create 100 Asset Instances 610 | for (int i = 0; i < 100; ++i) 611 | { 612 | GameObject instance = 613 | await m_assetDatabase.InstantiateAssetAsync(fileID); 614 | instance.transform.position = Random.onUnitSphere * 10; 615 | instance.transform.rotation = Random.rotation; 616 | } 617 | } 618 | } 619 | } 620 | ``` 621 | ![Instantiate Asset Result][instantiate_asset] 622 | 623 |
624 | 625 | ### Detach asset instance 626 | ```C# 627 | // Detaching an instance means breaking the links between the instance and the 628 | // corresponding asset. Once you detach an instance, you will no longer be able 629 | // to apply changes to the underlying asset or create an asset variant from that 630 | // specific instance. 631 | 632 | // the "completely" parameter set to true means that all child instances attached 633 | // to this instance as child transforms will also be detached. Otherwise, only the 634 | // instance passed as a parameter to the DetachAsync method will be detached. 635 | 636 | await m_assetDatabase.DetachAsync(instance, completely: true) 637 | ``` 638 | 639 | ### Unload asset 640 | ```C# 641 | // Unloads asset, optionally destroying attached instances (destroy: true) 642 | await UnloadAssetAsync(assetID, destroy: true); 643 | 644 | // Unloads all assets, optionally destroying attached instances (destroy: true) 645 | await UnloadAllAssetsAsync(destroy: true); 646 | ``` 647 | 648 |
649 | 650 | ### Create asset variant 651 | ```C# 652 | using UnityEngine; 653 | namespace Battlehub.Storage.Samples 654 | { 655 | public class CreateAssetVariantExample : MonoBehaviour 656 | { 657 | private IAssetDatabase m_assetDatabase; 658 | 659 | private async void Start() 660 | { 661 | m_assetDatabase = RuntimeAssetDatabase.Instance; 662 | 663 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 664 | await m_assetDatabase.LoadProjectAsync(projectPath); 665 | 666 | var rootID = m_assetDatabase.RootID; 667 | string key = "Hellephant"; 668 | string loaderID = nameof(ResourcesLoader); 669 | 670 | IExternalAssetLoader loader = new ResourcesLoader(); 671 | await m_assetDatabase.RegisterExternalAssetLoaderAsync(loaderID, loader); 672 | 673 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"{key}"); 674 | var variantFileID = m_assetDatabase.GetUniqueFileID(rootID, $"{key} Variant"); 675 | 676 | // Import external asset 677 | await m_assetDatabase.ImportExternalAssetAsync(key, loaderID, fileID); 678 | 679 | // Instantiate external asset 680 | var hellephantVar = 681 | await m_assetDatabase.InstantiateAssetAsync(fileID); 682 | 683 | // Modify its materials 684 | var renderer = hellephantVar.GetComponentInChildren(); 685 | ModifyMaterials(renderer); 686 | 687 | // Mark the rendering component as "dirty". 688 | // This will let the CreateAssetAsync method know that this component 689 | // has changed and should be stored in the data file, thus creating a variant 690 | // of the asset that differs from the base only in that component 691 | await m_assetDatabase.SetDirtyAsync(renderer); 692 | await m_assetDatabase.CreateAssetAsync(hellephantVar, variantFileID); 693 | 694 | // Instantiate base asset 695 | var hellephant = 696 | await m_assetDatabase.InstantiateAssetAsync(fileID); 697 | hellephant.transform.position = Vector3.right * 3; 698 | 699 | // Instantiate asset variant 700 | var hellephantVariant2 = 701 | await m_assetDatabase.InstantiateAssetAsync(variantFileID); 702 | hellephantVariant2.transform.position = Vector3.left * 3; 703 | } 704 | 705 | private static void ModifyMaterials(SkinnedMeshRenderer renderer) 706 | { 707 | var materials = renderer.materials; 708 | materials[0].SetColor("_EmissionColor", Color.green); 709 | materials[1].SetColor("_EmissionColor", Color.red); 710 | renderer.sharedMaterials = materials; 711 | } 712 | } 713 | } 714 | ``` 715 | 716 | ![Create Asset Variant Result][create_asset_variant] 717 | 718 |
719 | 720 | ### Modify instance and apply changes 721 | ```C# 722 | using Battlehub.Storage.EditorAttributes; 723 | using UnityEngine; 724 | using UnityEngine.UI; 725 | 726 | namespace Battlehub.Storage.Samples 727 | { 728 | public class ModifyInstanceAndApplyChangesExample : MonoBehaviour 729 | { 730 | private IAssetDatabase m_assetDatabase; 731 | private IThumbnailUtil m_thumbnailUtil; 732 | 733 | [Layer] 734 | public LayerMask ThumbnailLayer; 735 | 736 | [SerializeField] 737 | private RawImage m_thumbnailImage; 738 | 739 | private void Awake() 740 | { 741 | var thumbnailUtil = gameObject.AddComponent(); 742 | 743 | // rotate thumbnail camera 744 | thumbnailUtil.transform.LookAt(-Vector3.one); 745 | thumbnailUtil.ThumbnailLayer = ThumbnailLayer; 746 | 747 | m_thumbnailUtil = thumbnailUtil; 748 | } 749 | 750 | private async void Start() 751 | { 752 | m_assetDatabase = RuntimeAssetDatabase.Instance; 753 | 754 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 755 | await m_assetDatabase.LoadProjectAsync(projectPath); 756 | var rootID = m_assetDatabase.RootID; 757 | 758 | GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule); 759 | var rend = capsule.GetComponent(); 760 | rend.material.color = Color.red; 761 | 762 | // Create an asset (the capsule becomes an instance attached to the asset) 763 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule"); 764 | await m_assetDatabase.CreateAssetAsync(capsule, fileID); 765 | 766 | // Modify instance transform 767 | capsule.transform.Rotate(45, 0, 45); 768 | await m_assetDatabase.SetDirtyAsync(capsule.transform); 769 | 770 | // Modify instance renderer 771 | rend.sharedMaterial.color = Color.blue; 772 | await m_assetDatabase.SetDirtyAsync(rend); 773 | 774 | // Apply the changes to the asset and save it. 775 | // This method also updates the thumbnails. 776 | var ctx = new ThumbnailCreatorContext(m_thumbnailUtil); 777 | await m_assetDatabase.ApplyChangesAndSaveAsync(capsule, ctx); 778 | 779 | if (m_thumbnailImage != null) 780 | { 781 | // Load thumbnail data 782 | await m_assetDatabase.LoadThumbnailAsync(fileID); 783 | var thumbnailBytes = m_assetDatabase.GetThumbnail(fileID); 784 | 785 | // Load thumbnail texture 786 | var texture = new Texture2D(1, 1); 787 | texture.LoadImage(thumbnailBytes); 788 | 789 | m_thumbnailImage.gameObject.SetActive(true); 790 | m_thumbnailImage.texture = texture; 791 | } 792 | } 793 | } 794 | } 795 | ``` 796 | 797 |
798 | 799 | ### Modify instance and apply changes to base asset 800 | ```C# 801 | using UnityEngine; 802 | 803 | namespace Battlehub.Storage.Samples 804 | { 805 | public class ModifyInstanceAndApplyChangesToBaseExample : MonoBehaviour 806 | { 807 | private IAssetDatabase m_assetDatabase; 808 | 809 | private async void Start() 810 | { 811 | m_assetDatabase = RuntimeAssetDatabase.Instance; 812 | 813 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 814 | await m_assetDatabase.LoadProjectAsync(projectPath); 815 | var rootID = m_assetDatabase.RootID; 816 | 817 | GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule); 818 | var rend = capsule.GetComponent(); 819 | rend.material.color = Color.red; 820 | 821 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule"); 822 | var fileVariantID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule Variant"); 823 | var materialFileID = m_assetDatabase.GetUniqueFileID(rootID, "Material"); 824 | 825 | // Create an asset (the capsule becomes an instance attached to the asset) 826 | await m_assetDatabase.CreateAssetAsync(capsule, fileID); 827 | 828 | // Modify variant instance transform 829 | capsule.transform.Rotate(45, 0, 45); 830 | await m_assetDatabase.SetDirtyAsync(capsule.transform); 831 | 832 | // Modify variant instance renderer 833 | rend.sharedMaterial = Instantiate(rend.sharedMaterial); 834 | rend.sharedMaterial.color = Color.green; 835 | await m_assetDatabase.SetDirtyAsync(rend); 836 | 837 | // Create material asset 838 | await m_assetDatabase.CreateAssetAsync(rend.sharedMaterial, materialFileID); 839 | 840 | // Create variant of the asset 841 | await m_assetDatabase.CreateAssetAsync(capsule, fileVariantID); 842 | 843 | GameObject instance = await m_assetDatabase.InstantiateAssetAsync(fileID); 844 | instance.transform.position = Vector3.right * 2; 845 | 846 | // Mark the base asset instance's transformation as dirty 847 | // to prevent ApplyChangesToBase from overriding it. 848 | await m_assetDatabase.SetDirtyAsync(instance.transform); 849 | 850 | if (m_assetDatabase.CanApplyChangesToBaseAndSaveAsync(capsule)) 851 | { 852 | // Propagate the changes to the base asset and save it. 853 | await m_assetDatabase.ApplyChangesToBaseAndSaveAsync(capsule); 854 | } 855 | } 856 | } 857 | } 858 | ``` 859 | 860 |
861 | 862 | ### Revert changes to base 863 | ```C# 864 | using UnityEngine; 865 | 866 | namespace Battlehub.Storage.Samples 867 | { 868 | public class ModifyInstanceAndRevertChangesToBaseExample : MonoBehaviour 869 | { 870 | private IAssetDatabase m_assetDatabase; 871 | 872 | private async void Start() 873 | { 874 | m_assetDatabase = RuntimeAssetDatabase.Instance; 875 | 876 | string projectPath = $"{Application.persistentDataPath}/Example Project"; 877 | await m_assetDatabase.LoadProjectAsync(projectPath); 878 | var rootID = m_assetDatabase.RootID; 879 | 880 | GameObject capsule = GameObject.CreatePrimitive(PrimitiveType.Capsule); 881 | var rend = capsule.GetComponent(); 882 | rend.material.color = Color.red; 883 | 884 | var fileID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule"); 885 | var fileVariantID = m_assetDatabase.GetUniqueFileID(rootID, $"Capsule Variant"); 886 | var materialFileID = m_assetDatabase.GetUniqueFileID(rootID, "Material"); 887 | 888 | // Create an asset (the capsule becomes an instance attached to the asset) 889 | await m_assetDatabase.CreateAssetAsync(capsule, fileID); 890 | 891 | // Modify variant instance transform 892 | capsule.transform.Rotate(45, 0, 45); 893 | await m_assetDatabase.SetDirtyAsync(capsule.transform); 894 | 895 | // Modify variant instance renderer 896 | rend.sharedMaterial = Instantiate(rend.sharedMaterial); 897 | rend.sharedMaterial.color = Color.green; 898 | await m_assetDatabase.SetDirtyAsync(rend); 899 | 900 | // Create material asset 901 | await m_assetDatabase.CreateAssetAsync(rend.sharedMaterial, materialFileID); 902 | 903 | // Create variant of the asset 904 | await m_assetDatabase.CreateAssetAsync(capsule, fileVariantID); 905 | 906 | GameObject instance = await m_assetDatabase.InstantiateAssetAsync(fileID); 907 | instance.transform.position = Vector3.right * 2; 908 | 909 | // Mark the base asset instance's transformation as dirty 910 | //to prevent ApplyChangesToBase from overriding it. 911 | await m_assetDatabase.SetDirtyAsync(instance.transform); 912 | 913 | if (m_assetDatabase.CanRevertChangesToBaseAndSaveAsync(capsule)) 914 | { 915 | // Propagate the changes from the base asset and save dependent variants 916 | await m_assetDatabase.RevertChangesToBaseAndSaveAsync(capsule); 917 | } 918 | } 919 | } 920 | } 921 | ``` 922 | 923 |
924 | 925 | ## Web Storage Sample 926 | 927 | You can use the runtime asset database in conjunction with an HTTP web server, in WebGL and Standalone builds. 928 | 929 | To start the web sample, follow these steps: 930 | 931 | 1. Install the [Newtonsoft Json package]((https://docs.unity3d.com/Packages/com.unity.nuget.newtonsoft-json@3.2/manual/index.html)). In Package Manager, click on "+ Add package by name" and enter "com.unity.nuget.newtonsoft-json" 932 | 2. Unpack the `Asset/Battlehub/Storage.Web` Unity package. 933 | 3. Open the `Asset/Battlehub.Extensions/Storage.Web/WebProjectBrowser` Unity scene. 934 | 4. Extract `Asset/Battlehub.Extensions/Storage.Web/SampleHttpServer.zip` to a folder (e.g., `C:\SampleHttpWebServer`). 935 | 5. Install Node.js from [Node.js](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs). 936 | 6. Open a terminal and navigate to `C:\SampleHttpWebServer`. 937 | 7. Run the command `npm install`. 938 | 8. Run the command `node app.js`. 939 | 9. Enter play mode in Unity. 940 | 941 | 942 | ## Surrogates 943 | Surrogates are intermediary classes used by the Serializer to facilitate the reading and writing of data to Unity objects during serialization. **To enable the serialization of a specific class, you must create a surrogate for it**. These surrogates can be generated automatically or created from scratch. To generate a Surrogate class, you can use the "Create Surrogates" window. 944 | 945 | ![Generate Surrogate][generate_surrogate] 946 | 947 | Sample component: 948 | 949 | ```C# 950 | using UnityEngine; 951 | 952 | public class MyComponent : MonoBehaviour 953 | { 954 | public Material Material; 955 | 956 | public GameObject Target; 957 | 958 | public int IntValue; 959 | 960 | public string StringValue; 961 | } 962 | ``` 963 | 964 | ![Surrogates Folder][surrogates_folder] 965 | 966 | ```C# 967 | using MessagePack; 968 | using ProtoBuf; 969 | using System; 970 | using System.Threading.Tasks; 971 | 972 | namespace Battlehub.Storage.Surrogates 973 | { 974 | [ProtoContract] 975 | [MessagePackObject] 976 | [Surrogate(typeof(global::MyComponent), _PROPERTY_INDEX, _TYPE_INDEX)] 977 | public class MyComponentSurrogate : ISurrogate where TID : IEquatable 978 | { 979 | const int _PROPERTY_INDEX = 7; 980 | const int _TYPE_INDEX = 153; 981 | //_PLACEHOLDER_FOR_EXTENSIONS_DO_NOT_DELETE_OR_CHANGE_THIS_LINE_PLEASE 982 | 983 | [ProtoMember(2), Key(2)] 984 | public TID id { get; set; } 985 | 986 | [ProtoMember(3), Key(3)] 987 | public TID gameObjectId { get; set; } 988 | 989 | [ProtoMember(4), Key(4)] 990 | public global::System.Boolean enabled { get; set; } 991 | 992 | [ProtoMember(5), Key(5)] 993 | public TID Material { get; set; } 994 | 995 | [ProtoMember(6), Key(6)] 996 | public TID Target { get; set; } 997 | 998 | [ProtoMember(7), Key(7)] 999 | public global::System.Int32 IntValue { get; set; } 1000 | //_PLACEHOLDER_FOR_NEW_PROPERTIES_DO_NOT_DELETE_OR_CHANGE_THIS_LINE_PLEASE 1001 | 1002 | public ValueTask Serialize(object obj, ISerializationContext ctx) 1003 | { 1004 | var idmap = ctx.IDMap; 1005 | 1006 | var o = (global::MyComponent)obj; 1007 | id = idmap.GetOrCreateID(o); 1008 | gameObjectId = idmap.GetOrCreateID(o.gameObject); 1009 | enabled = o.enabled; 1010 | Material = idmap.GetOrCreateID(o.Material); 1011 | Target = idmap.GetOrCreateID(o.Target); 1012 | IntValue = o.IntValue; 1013 | //_PLACEHOLDER_FOR_SERIALIZE_METHOD_BODY_DO_NOT_DELETE_OR_CHANGE_THIS_LINE_PLEASE 1014 | 1015 | return default; 1016 | } 1017 | 1018 | public ValueTask Deserialize(ISerializationContext ctx) 1019 | { 1020 | var idmap = ctx.IDMap; 1021 | 1022 | var o = idmap.GetComponent(id, gameObjectId); 1023 | o.enabled = enabled; 1024 | o.Material = idmap.GetObject(Material); 1025 | o.Target = idmap.GetObject(Target); 1026 | o.IntValue = IntValue; 1027 | //_PLACEHOLDER_FOR_DESERIALIZE_METHOD_BODY_DO_NOT_DELETE_OR_CHANGE_THIS_LINE_PLEASE 1028 | 1029 | return new ValueTask(o); 1030 | } 1031 | } 1032 | } 1033 | 1034 | ``` 1035 | After successfully generating surrogates, you have the flexibility to make various customizations within your surrogate class. You can remove properties that you don't want to be serialized, add new properties, or perform other operations as needed. 1036 | 1037 | To prevent changes you make to surrogates from being tracked and displayed in the "Update Surrogates" window, you can set the enableUpdates attribute to false using the following syntax: 1038 | 1039 | ```C# 1040 | [Surrogate(typeof(global::MyComponent), _PROPERTY_INDEX, _TYPE_INDEX, enableUpdates: false)] 1041 | ``` 1042 | 1043 | For value types, make sure to set enabled to false like this: 1044 | 1045 | ```C# 1046 | [Surrogate(typeof(global::MyComponent), _PROPERTY_INDEX, _TYPE_INDEX, enabled: false)] 1047 | ``` 1048 | 1049 | Two constants, **int _PROPERTY_INDEX** and **int _TYPE_INDEX**, have following purpose: 1050 | 1051 | - int _PROPERTY_INDEX: This constant assists the surrogate updater in determining the index of the next property to be generated. 1052 | - int _TYPE_INDEX: This constant acts as a unique type index. 1053 | 1054 | **Please note that references to other types with surrogates are replaced with their identifier (TID). 1055 | You can use an "idmap" to generate unique IDs for objects and retrieve objects using their corresponding IDs.** 1056 | 1057 |
1058 | 1059 | ## Enumerators 1060 | The enumerator is created along with the surrogate. Enumerators are specialized classes used to retrieve Unity object dependencies in a structured manner. These enumerators enable the serialization of an entire object tree, ensuring that dependencies are deserialized before dependent objects during the deserialization process. 1061 | 1062 | ![Enumerators Folder][enumerators_folder] 1063 | 1064 | ```C# 1065 | namespace Battlehub.Storage.Enumerators 1066 | { 1067 | [ObjectEnumerator(typeof(global::MyComponent))] 1068 | public class MyComponentEnumerator : ObjectEnumerator 1069 | { 1070 | public override bool MoveNext() 1071 | { 1072 | do 1073 | { 1074 | switch (Index) 1075 | { 1076 | 1077 | case 0: 1078 | if (MoveNext(TypedObject.Material, 5)) 1079 | return true; 1080 | break; 1081 | case 1: 1082 | if (MoveNext(TypedObject.Target, 6)) 1083 | return true; 1084 | break; 1085 | case 2: 1086 | if (MoveNext(Object, -1)) 1087 | return true; 1088 | break; 1089 | default: 1090 | return false; 1091 | } 1092 | } 1093 | while (true); 1094 | } 1095 | } 1096 | } 1097 | ``` 1098 | 1099 | **Note that the second parameter of the MoveNext method is the property index, which should be equal to the argument of the ProtoMember attribute assigned to that property in the surrogate class.** 1100 | 1101 | You can also use the following simplified syntax when editing an enumerator: 1102 | ```C# 1103 | namespace Battlehub.Storage.Enumerators 1104 | { 1105 | [ObjectEnumerator(typeof(global::MyComponent))] 1106 | public class MyComponentEnumerator : ObjectEnumerator 1107 | { 1108 | protected override IEnumerator<(object Object, int Key)> GetNext() 1109 | { 1110 | yield return (TypedObject.Material, 5); 1111 | yield return (TypedObject.Target, 6); 1112 | yield return (TypedObject, -1); 1113 | } 1114 | } 1115 | } 1116 | ``` 1117 | 1118 |
1119 | 1120 | ## Dynamic Surrogates (Preview) 1121 | 1122 | It is possible to avoid creating surrogates by hand, instead letting the runtime asset database serialize types using reflection at runtime. This process is roughly equivalent to Unity serialization rules. It works with fields and not with properties. 1123 | 1124 | To enable Dynamic Surrogate for a type, use the following code: 1125 | 1126 | ```csharp 1127 | var assetDatabase = RuntimeAssetDatabase.Instance; 1128 | assetDatabase.RegisterDynamicTypes(typeof(MyMonoBehaviour)); 1129 | ``` 1130 | 1131 | To use field serialization, ensure that the field: 1132 | 1133 | - Is public, or has a `SerializeField` attribute. 1134 | - Isn’t static. 1135 | - Isn’t const. 1136 | - Isn’t readonly. 1137 | - Has a field type that can be serialized: 1138 | - Primitive data types (int, float, double, bool, string, etc.) 1139 | - Enum types (32 bits or smaller) 1140 | - Fixed-size buffers 1141 | - Unity built-in types, for example, Vector2, Vector3, Rect, Matrix4x4, Color. *Some types like AnimationCurve will not be serialized.* 1142 | - Custom structs with the `Serializable` attribute 1143 | - References to objects that derive from `UnityEngine.Object` 1144 | - Custom classes with the `Serializable` attribute (see Serialization of custom classes). 1145 | - An array of a field type mentioned above. 1146 | - A `List` of a field type mentioned above. 1147 | 1148 | ### Serialization of Custom Classes 1149 | 1150 | For Unity to serialize a custom class, ensure the class: 1151 | 1152 | - Has the `Serializable` attribute. 1153 | - Isn’t static. 1154 | 1155 | The `[SerializeReference]` attribute is not supported and serialization is inline. 1156 | 1157 | ### Custom Serialization 1158 | 1159 | Sometimes you might want to serialize something that the serializer doesn’t support (for example, a C# Dictionary). The best approach is to implement the `ISerializationCallbackReceiver` interface in your class. This allows you to implement callbacks that are invoked at key points during serialization and deserialization: 1160 | 1161 | - When an object is about to be serialized, Runtime Asset Database invokes the `OnBeforeSerialize()` callback. Inside this callback is where you can transform your data into something Runtime Asset Database understands. For example, to serialize a C# Dictionary, copy the data from the Dictionary into an array of keys and an array of values. 1162 | - After the `OnBeforeSerialize()` callback is complete, Unity serializes the arrays. 1163 | - Later, when the object is deserialized, Runtime Asset Database invokes the `OnAfterDeserialize()` callback. Inside this callback is where you can transform the data back into a form that’s convenient for the object in memory. For example, use the key and value arrays to repopulate the C# Dictionary. 1164 | 1165 | 1166 | ## Build All 1167 | After finishing creating or updating surrogates, make sure to click **"Tools" > "Runtime Asset Library" > "Build All"** from the main menu. This command will build the type model and serializer. 1168 | 1169 | ![Type Model][build_all] 1170 | 1171 | ## Support 1172 | 1173 | If you cannot find something in the documentation or have any questions, please feel free to send an email to [Battlehub@outlook.com](mailto:Battlehub@outlook.com) or ask directly in [this](https://t.me/battlehub) support group. Keep up the great work in your development journey! 😊 1174 | 1175 | [youtube_icon]: Docs/Images/Youtube.png 1176 | [runtime_asset_database]: Docs/Images/runtme_asset_database.png 1177 | [getting_started_result]: Docs/Images/getting_started.png 1178 | [import_external_asset]: Docs/Images/import_external_asset.png 1179 | [register_external_asset]: Docs/Images/register_external_asset.png 1180 | [instantiate_asset]: Docs/Images/instantiate_asset.png 1181 | [create_asset_variant]: Docs/Images/create_asset_variant.png 1182 | [generate_surrogate]: Docs/Images/generate_surrogate.png 1183 | [surrogates_folder]: Docs/Images/surrogates_folder.png 1184 | [enumerators_folder]: Docs/Images/enumerators_folder.png 1185 | [build_all]: Docs/Images/build_all.png 1186 | -------------------------------------------------------------------------------- /README.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/BattlehubCode/RuntimeAssetDatabase/57fb5e83b9fea4aeca2e5fd1fa32b8b5d51c44d6/README.pdf --------------------------------------------------------------------------------