Loading UXML dynamically at runtime eg: LoadAssetAtPath

Hi all,
I've followed the documentation for loading xml from c# here:
https://docs.unity3d.com/2020.1/Documentation/Manual/UIE-LoadingUXMLcsharp.html


But this doesn't work in a build, because AssetDatabase is in the UnityEditor namespace...

How do I do this for run time?

 

A runtime build.

 

I see. So a good solution would be a mono sitting somewhere that has a reference to any and all UXML that might need to be dynamically added, then reference those fields instead.

That will be annoying to maintain, so I will likely write something that automates generating those references and just run it on a function attributed with [UnityEditor.Callbacks.DidReloadScripts]
Then I can make the keys of the files their filepaths - and everything should work fine

Related question: What about using the <Template> element? Is there a way I can put a template in my uxml, then grab that with a root.Q<Template>() and CloneTree on it?

 

ok good to know.

What I'm doing is basically just developing a standardized way of importing things to a current rendered uxml doc.

Examples are:
1) A map where the "pins" are separate uxml files we clone and drop on an element and set their positions, userData, and tooltips etc based on a data source determined at run time.

2) A Generic popup dialog window that can be created at any time on any screen and filled with say a warning, a message, a small form etc...


I want the artists to be able to work on as many individual components of the ui by taking advantage of the fact that these things are put together at run time, and it means we won't run in to merge conflicts as frequently: being that individual files will be accessed rather than one giant ui doc that contains everything

 

So for others who might find this thread and or relevant - here's what I've come up with. Havne't fully tested yet, but I think this is gonna work:

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using System.IO;
4. using UnityEngine;
5. using UnityEngine.UIElements;
6. #if UNITY_EDITOR
7. using UnityEditor;
8. #endif
9.  
10. namespace UI
11. {
12.     /// <summary>
13.     /// Used to store references to all uxml files in the project for dynamic loading both in run time builds
14.     /// and editor
15.     /// </summary>
16.     public class UIDocumentCache : ScriptableObject
17.     {
18.         private static UIDocumentCache _instance;
19.  
20.         [SerializeField]
21.         [Tooltip("Loaded UXML file keys - do not manually adjust")]
22.         private string[] _keysUXML;
23.  
24.         [SerializeField]
25.         [Tooltip("Loaded UXML files - do not manually adjust")]
26.         private VisualTreeAsset[] _valuesUXML;
27.  
28.  
29.         /// <summary>
30.         /// Mapped assets against their keys
31.         /// </summary>
32.         private Dictionary<string, VisualTreeAsset> _uxmlAssetData;
33.  
34.         /// <summary>
35.         /// Get a preloaded visual tree asset for cloning to a UIDocument
36.         /// where the key is a dot syntax file path name relative to the UITK folder
37.         /// </summary>
38.         /// <param name="pKey">eg: screens.warzonescreen.warzonescreen</param>
39.         /// <returns></returns>
40.         public static VisualTreeAsset GetUXMLAsset(string pKey)
41.         {
42.             if(_instance == null)
43.             {
44.                 //Initialization should happen from within the UI.Init method
45.                 throw new System.Exception("[UIDocumentCache] The system has not been initialized");
46.             }
47.             if(string.IsNullOrEmpty(pKey) || string.IsNullOrWhiteSpace(pKey))
48.             {
49.                 throw new System.Exception("[UIDocumentCache] The key cannot be null, whitespace, or empty");
50.             }
51.             string key = pKey.ToLower();
52.             if(!_instance._uxmlAssetData.ContainsKey(key))
53.             {
54.                 throw new System.Exception("[UIDocumentCache] The key: " + key + " could not be found");
55.             }
56.  
57.             return _instance._uxmlAssetData[key];
58.         }
59.  
60.  
61.         /// <summary>
62.         /// Initializes the system - in editor, this will rebuild the mapping of all UXML files every time
63.         /// it's called.
64.         /// In a runtime build: it just loads the data
65.         /// </summary>
66.         public static void Initialize()
67.         {
68.             Object cache = Resources.Load("UIDocumentCache", typeof(UIDocumentCache));
69.             _instance = (UIDocumentCache)cache;
70.  
71. #if UNITY_EDITOR
72.             //If we are in the editor: then everytime we call init - let's scan and update the document cache
73.             _instance._keysUXML = null;
74.  
75.             //The root path of all ui files in our project
76.             string rootPath = Path.Combine(Application.dataPath, "Code/UI/UITK");
77.  
78.             List<string> _allUXML = IO.Helpers.FileSystem.GetFiles(rootPath, "*.uxml", SearchOption.AllDirectories);
79.  
80.            
81.             List<string> _uxmlKeys = new List<string>();
82.             List<VisualTreeAsset> _uxmlAssets = new List<VisualTreeAsset>();
83.  
84.             for (int i = 0; i < _allUXML.Count; i++)
85.             {
86.                 //Unity wants a path relative to the project directory - which the Application class doesn't have... for raisons...
87.                 string _relativePath = _allUXML[i].Replace(Application.dataPath,"Assets");
88.                 _uxmlAssets.Add(AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(_relativePath));
89.  
90.                 //Generate the keys: eg
91.                 //  "components.someuxmlfilename"
92.                 //  "somefilename"
93.                 string key = _allUXML[i].Replace(rootPath, "").ToLower();
94.                 key = key.Substring(1).Replace(".uxml","").Replace("\\",".");
95.  
96.                 _uxmlKeys.Add(key);
97.             }
98.            
99.             _instance._keysUXML = _uxmlKeys.ToArray();
100.             _instance._valuesUXML = _uxmlAssets.ToArray();
101. #endif      //Done in editor
102.  
103.             //Now we can just put the lists to a dictionary for use in engine
104.             _instance._uxmlAssetData = new Dictionary<string, VisualTreeAsset>();
105.             for(int i = 0; i < _instance._keysUXML.Length; i++)
106.             {
107.                 _instance._uxmlAssetData.Add(_instance._keysUXML[i], _instance._valuesUXML[i]);
108.             }
109.         }
110.     }
111. }
112.  
113.  

 

I think, use static instance - bad solution. In my project, we use Zenject DI, but I can't inject to visual element class.
A good solution would be opportunity to add VisualTreeAsset link in inspector of VisualElement.

 

hmm well... It'll never change during the course of the games lifespan, and there really can be only one. I think dependency injection is overkill for this when it's point is to basically replace the already static method:
AssetDatabase.LoadAssetAtPath - no?

 

I'm talking about a big business project with dozens of assets in different folders. LoadAssetAtPath is not reliable and needs support. DI is used to eliminate Unity lifecycle problems. It himself determines who and when the injection is needed

 

I'm using the Resources system for runtime (which means a lot of careful naming!!). Of course, Unity has been discouraging the use of Resources in favor of the Addressables system, so eventually I'll have to make that work. In my case, this is an RPG with things like a list of Quests (dynamically added), and a shop with rows, and Inventory with slots, etc... in these cases, it seems best to clone a VisualTreeAsset for each line rather than include them in the tree in the first place and fill them in or style.display=DisplayStyle.None them.

 

I have tried your code and I get a null reference when calling UIDocumentCahe.Initialize(). I tried to put the file in Assets/Resources folder with no results

 

This is the most annoying problem of Unity. Serialized fields have always been a problem.
Is there a way to force Unity to include all *.uxml files in build? Can I override something? Or can asset bundles be a good solution?

 

Concerning addressables, I am just going to shamelessly put some spotlight on this issue:

• Context: https://forum.unity.com/threads/add...-types-visualtreeasset-and-stylesheet.1314237
• Bug report; https://issuetracker.unity3d.com/is...own-when-loading-uxml-file-using-addressables

Would be nice if we could use

Addressables.LoadAssetsAsync<VisualTreeAsset>

instead of loading one asset at a time.

 

I could just be misunderstanding, but it seems like with any of these methods, it becomes difficult to build reusable UI. For instance, if I want to make a custom control, I can't really make use of UXML or USS outside of C# code since there's no way to grab asset references at runtime without using Resources/Addressables. Am I missing something?

 

This is covered in the link provided by antoine-unity, see Load by Label.