feat!: rework asset handling

BREAKING CHANGE: The new ResourcesAssetResolver is
now used by default. AssetDatabaseAssetResolver has been
moved to the new UIComponents.Editor assembly.

Core/IAssetLoader.cs → Core/IAssetResolver.cs

@@ -1,7 +1,9 @@
 namespace UIComponents.Core
 {
-    public interface IAssetLoader
+    public interface IAssetResolver
     {
         public T LoadAsset<T>(string assetPath) where T : UnityEngine.Object;
+
+        public bool AssetExists(string assetPath);
     }
 }

Core/PathAttribute.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using UnityEditor;
 
 namespace UIComponents.Core
@@ -14,13 +12,8 @@ public string GetAssetPathForComponent(UIComponent component)
             if (Path == null)
                 Path = string.Empty;
 
-            if (!ConfiguredPathIsComplete())
-            {
-                if (TryGetPathFromComponent(component, out var pathFromComponent))
-                    Path = pathFromComponent;
-                else if (TryGetPathFromAssembly(component, out var pathFromAssembly))
-                    Path = pathFromAssembly;
-            }
+            if (!ConfiguredPathIsComplete() && TryGetPathFromComponent(component, out var path))
+                Path = path;
 
             return Path;
         }
@@ -35,33 +28,11 @@ private bool TryGetPathFromComponent(UIComponent component, out string path)
         {
             path = "";
 
-            return TryGetValidAssetPath(component.GetAssetPaths(), out path);
-        }
-
-        private bool TryGetPathFromAssembly(UIComponent component, out string path)
-        {
-            path = "";
-
-            var assembly = component.GetType().Assembly;
-
-            var paths =
-                assembly.GetCustomAttributes(typeof(AssetPathAttribute), false)
-                    .Select(attribute => ((AssetPathAttribute)attribute).Path );
-
-            return TryGetValidAssetPath(paths, out path);
-        }
-
-        private bool TryGetValidAssetPath(
-            IEnumerable<string> paths,
-            out string path)
-        {
-            path = "";
-
-            foreach (var pathPart in paths)
+            foreach (var pathPart in component.GetAssetPaths())
             {
                 var filePath = string.Join("/", pathPart, Path);
 
-                if (string.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(filePath)))
+                if (!component.AssetResolver.AssetExists(filePath))
                     continue;
 
                 path = filePath;

Core/ResourcesAssetResolver.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+namespace UIComponents.Core
+{
+    public class ResourcesAssetResolver : IAssetResolver
+    {
+        public T LoadAsset<T>(string assetPath) where T : UnityEngine.Object
+        {
+            return Resources.Load<T>(assetPath);
+        }
+
+        public bool AssetExists(string assetPath)
+        {
+            return Resources.Load(assetPath) != null;
+        }
+    }
+}

Core/UIComponent.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using JetBrains.Annotations;
 using UnityEngine;
 using UnityEngine.UIElements;
 
 namespace UIComponents.Core
 {
-    [Dependency(typeof(IAssetLoader), provide: typeof(AssetDatabaseAssetLoader))]
+    [Dependency(typeof(IAssetResolver), provide: typeof(ResourcesAssetResolver))]
     public abstract class UIComponent : VisualElement
     {
         private static readonly Dictionary<Type, LayoutAttribute> LayoutAttributeDictionary =
@@ -18,7 +19,7 @@ public abstract class UIComponent : VisualElement
 
         internal readonly DependencyInjector DependencyInjector;
 
-        private readonly IAssetLoader _assetLoader;
+        internal readonly IAssetResolver AssetResolver;
 
         private readonly Type _componentType;
 
@@ -27,13 +28,13 @@ protected UIComponent()
             _componentType = GetType();
             DependencyInjector = DependencyInjector.GetInjector(_componentType);
 
-            _assetLoader = DependencyInjector.Provide<IAssetLoader>();
+            AssetResolver = DependencyInjector.Provide<IAssetResolver>();
 
             if (!LayoutAttributeDictionary.ContainsKey(_componentType))
                 LayoutAttributeDictionary[_componentType] = GetSingleAttribute<LayoutAttribute>();
 
             if (!AssetPathAttributesDictionary.ContainsKey(_componentType))
-                AssetPathAttributesDictionary[_componentType] = GetAttributes<AssetPathAttribute>();
+                AssetPathAttributesDictionary[_componentType] = GetAssetPathAttributes();
 
             if (!StylesheetAttributesDictionary.ContainsKey(_componentType))
                 StylesheetAttributesDictionary[_componentType] = GetAttributes<StylesheetAttribute>();
@@ -65,7 +66,7 @@ protected virtual VisualTreeAsset GetLayout()
 
             var assetPath = layoutAttribute.GetAssetPathForComponent(this);
 
-            return _assetLoader.LoadAsset<VisualTreeAsset>(assetPath);
+            return AssetResolver.LoadAsset<VisualTreeAsset>(assetPath);
         }
 
         protected virtual StyleSheet[] GetStyleSheets()
@@ -77,7 +78,7 @@ protected virtual StyleSheet[] GetStyleSheets()
             for (var i = 0; i < stylesheetAttributes.Length; i++)
             {
                 var assetPath = stylesheetAttributes[i].GetAssetPathForComponent(this);
-                var styleSheet = _assetLoader.LoadAsset<StyleSheet>(assetPath);
+                var styleSheet = AssetResolver.LoadAsset<StyleSheet>(assetPath);
 
                 if (styleSheet == null)
                 {
@@ -107,6 +108,19 @@ protected virtual StyleSheet[] GetStyleSheets()
             return (T[]) _componentType.GetCustomAttributes(typeof(T), true);
         }
 
+        private AssetPathAttribute[] GetAssetPathAttributes()
+        {
+            var assembly = _componentType.Assembly;
+
+            var assetPathAttributes =
+                GetAttributes<AssetPathAttribute>()
+                    .Concat(
+                        (AssetPathAttribute[]) assembly.GetCustomAttributes(typeof(AssetPathAttribute), false)
+                    ).ToArray();
+
+            return assetPathAttributes;
+        }
+
         private void LoadLayout()
         {
             var layoutAsset = GetLayout();
@@ -127,7 +141,8 @@ private void LoadStyles()
             }
 
             foreach (var sheet in loadedStyleSheets)
-                styleSheets.Add(sheet);
+                if (sheet != null)
+                    styleSheets.Add(sheet);
         }
     }
 }

Editor/AssetDatabaseAssetResolver.cs

@@ -0,0 +1,18 @@
+using UIComponents.Core;
+using UnityEditor;
+
+namespace UIComponents.Editor
+{
+    public class AssetDatabaseAssetResolver : IAssetResolver
+    {
+        public T LoadAsset<T>(string assetPath) where T : UnityEngine.Object
+        {
+            return AssetDatabase.LoadAssetAtPath<T>(assetPath);
+        }
+
+        public bool AssetExists(string assetPath)
+        {
+            return !string.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(assetPath));
+        }
+    }
+}

Editor/UIComponents.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "UIComponents.Editor",
+    "rootNamespace": "UIComponents",
+    "references": [
+        "GUID:d593635333b4cae48bac5b5f0b596e90"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}