Initial ModConfigurationDataFeed implementation

.editorconfig

@@ -60,34 +60,33 @@ dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
 
 dotnet_naming_symbols.interface.applicable_kinds = interface
 dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
-dotnet_naming_symbols.interface.required_modifiers = 
+dotnet_naming_symbols.interface.required_modifiers =
 
 dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
 dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
-dotnet_naming_symbols.types.required_modifiers = 
+dotnet_naming_symbols.types.required_modifiers =
 
 dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
 dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
-dotnet_naming_symbols.non_field_members.required_modifiers = 
+dotnet_naming_symbols.non_field_members.required_modifiers =
 
 # Naming styles
 
 dotnet_naming_style.begins_with_i.required_prefix = I
-dotnet_naming_style.begins_with_i.required_suffix = 
-dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.required_suffix =
+dotnet_naming_style.begins_with_i.word_separator =
 dotnet_naming_style.begins_with_i.capitalization = pascal_case
 
-dotnet_naming_style.pascal_case.required_prefix = 
-dotnet_naming_style.pascal_case.required_suffix = 
-dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.required_prefix =
+dotnet_naming_style.pascal_case.required_suffix =
+dotnet_naming_style.pascal_case.word_separator =
 dotnet_naming_style.pascal_case.capitalization = pascal_case
 
-dotnet_naming_style.pascal_case.required_prefix = 
-dotnet_naming_style.pascal_case.required_suffix = 
-dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.required_prefix =
+dotnet_naming_style.pascal_case.required_suffix =
+dotnet_naming_style.pascal_case.word_separator =
 dotnet_naming_style.pascal_case.capitalization = pascal_case
 dotnet_style_operator_placement_when_wrapping = beginning_of_line
-tab_width = 4
 dotnet_style_coalesce_expression = true:suggestion
 dotnet_style_null_propagation = true:suggestion
 dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion

.run/Attach to Resonite.run.xml

@@ -0,0 +1,10 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Attach to Resonite" type="UnityPlayer" factoryName="UnityAttachToPlayer">
+    <option name="host" value="127.0.0.1" />
+    <option name="playerId" value="CustomPlayer(127.0.0.1:10000)" />
+    <option name="playerInstanceId" value="Custom" />
+    <option name="port" value="10000" />
+    <option name="projectName" value="Custom" />
+    <method v="2" />
+  </configuration>
+</component>

ResoniteModLoader/AssemblyHider.cs

@@ -48,27 +48,25 @@ internal static class AssemblyHider {
 	/// <param name="harmony">Our RML harmony instance</param>
 	/// <param name="initialAssemblies">Assemblies that were loaded when RML first started</param>
 	internal static void PatchResonite(Harmony harmony, HashSet<Assembly> initialAssemblies) {
-		//if (ModLoaderConfiguration.Get().HideModTypes) {
-			// initialize the static assembly sets that our patches will need later
-			resoniteAssemblies = GetResoniteAssemblies(initialAssemblies);
-			modAssemblies = GetModAssemblies(resoniteAssemblies);
-			dotNetAssemblies = resoniteAssemblies.Where(LooksLikeDotNetAssembly).ToHashSet();
-
-			// TypeHelper.FindType explicitly does a type search
-			MethodInfo findTypeTarget = AccessTools.DeclaredMethod(typeof(TypeHelper), nameof(TypeHelper.FindType), new Type[] { typeof(string) });
-			MethodInfo findTypePatch = AccessTools.DeclaredMethod(typeof(AssemblyHider), nameof(FindTypePostfix));
-			harmony.Patch(findTypeTarget, postfix: new HarmonyMethod(findTypePatch));
-
-			// ReflectionExtensions.IsValidGenericType checks a type for validity, and if it returns `true` it reveals that the type exists
-			MethodInfo isValidGenericTypeTarget = AccessTools.DeclaredMethod(typeof(ReflectionExtensions), nameof(ReflectionExtensions.IsValidGenericType), new Type[] { typeof(Type), typeof(bool) });
-			MethodInfo isValidGenericTypePatch = AccessTools.DeclaredMethod(typeof(AssemblyHider), nameof(IsValidTypePostfix));
-			harmony.Patch(isValidGenericTypeTarget, postfix: new HarmonyMethod(isValidGenericTypePatch));
-
-			// FrooxEngine likes to enumerate all types in all assemblies, which is prone to issues (such as crashing FrooxCode if a type isn't loadable)
-			MethodInfo getAssembliesTarget = AccessTools.DeclaredMethod(typeof(AppDomain), nameof(AppDomain.GetAssemblies), Array.Empty<Type>());
-			MethodInfo getAssembliesPatch = AccessTools.DeclaredMethod(typeof(AssemblyHider), nameof(GetAssembliesPostfix));
-			harmony.Patch(getAssembliesTarget, postfix: new HarmonyMethod(getAssembliesPatch));
-		//}
+		// initialize the static assembly sets that our patches will need later
+		resoniteAssemblies = GetResoniteAssemblies(initialAssemblies);
+		modAssemblies = GetModAssemblies(resoniteAssemblies);
+		dotNetAssemblies = resoniteAssemblies.Where(LooksLikeDotNetAssembly).ToHashSet();
+
+		// TypeHelper.FindType explicitly does a type search
+		MethodInfo findTypeTarget = AccessTools.DeclaredMethod(typeof(TypeHelper), nameof(TypeHelper.FindType), new Type[] { typeof(string) });
+		MethodInfo findTypePatch = AccessTools.DeclaredMethod(typeof(AssemblyHider), nameof(FindTypePostfix));
+		harmony.Patch(findTypeTarget, postfix: new HarmonyMethod(findTypePatch));
+
+		// ReflectionExtensions.IsValidGenericType checks a type for validity, and if it returns `true` it reveals that the type exists
+		MethodInfo isValidGenericTypeTarget = AccessTools.DeclaredMethod(typeof(ReflectionExtensions), nameof(ReflectionExtensions.IsValidGenericType), new Type[] { typeof(Type), typeof(bool) });
+		MethodInfo isValidGenericTypePatch = AccessTools.DeclaredMethod(typeof(AssemblyHider), nameof(IsValidTypePostfix));
+		harmony.Patch(isValidGenericTypeTarget, postfix: new HarmonyMethod(isValidGenericTypePatch));
+
+		// FrooxEngine likes to enumerate all types in all assemblies, which is prone to issues (such as crashing FrooxCode if a type isn't loadable)
+		MethodInfo getAssembliesTarget = AccessTools.DeclaredMethod(typeof(AppDomain), nameof(AppDomain.GetAssemblies), Array.Empty<Type>());
+		MethodInfo getAssembliesPatch = AccessTools.DeclaredMethod(typeof(AssemblyHider), nameof(GetAssembliesPostfix));
+		harmony.Patch(getAssembliesTarget, postfix: new HarmonyMethod(getAssembliesPatch));
 	}
 
 	private static HashSet<Assembly> GetResoniteAssemblies(HashSet<Assembly> initialAssemblies) {
@@ -88,6 +86,9 @@ private static HashSet<Assembly> GetModAssemblies(HashSet<Assembly> resoniteAsse
 		// remove assemblies that we know to have come with Resonite
 		assemblies.ExceptWith(resoniteAssemblies);
 
+		// remove ourselves because we technically aren't a mod
+		assemblies.Remove(Assembly.GetExecutingAssembly());
+
 		// what's left are assemblies that magically appeared during the mod loading process. So mods and their dependencies.
 		return assemblies;
 	}
@@ -104,26 +105,24 @@ private static HashSet<Assembly> GetModAssemblies(HashSet<Assembly> resoniteAsse
 	private static bool IsModAssembly(Assembly assembly, string typeOrAssembly, string name, bool log, bool forceShowLate) {
 		if (resoniteAssemblies!.Contains(assembly)) {
 			return false; // The assembly belongs to Resonite and shouldn't be hidden
+		} else if (modAssemblies!.Contains(assembly)) {
+			// The assembly belongs to a mod and should be hidden
+			if (log) {
+				Logger.DebugFuncInternal(() => $"Hid {typeOrAssembly} \"{name}\" from Resonite");
+			}
+			return true;
+		} else if (assembly == Assembly.GetExecutingAssembly()) {
+			// we don't want the data feed components getting hidden
+			return false;
 		} else {
-			if (modAssemblies!.Contains(assembly)) {
-				// The assembly belongs to a mod and should be hidden
-				if (log) {
-					Logger.DebugFuncInternal(() => $"Hid {typeOrAssembly} \"{name}\" from Resonite");
-				}
-				return true;
-			} else {
-				// an assembly was in neither resoniteAssemblies nor modAssemblies
-				// this implies someone late-loaded an assembly after RML, and it was later used in-game
-				// this is super weird, and probably shouldn't ever happen... but if it does, I want to know about it.
-				// since this is an edge case users may want to handle in different ways, the HideLateTypes rml config option allows them to choose.
-				//bool hideLate = true;// ModLoaderConfiguration.Get().HideLateTypes;
-				/*if (log) {
-					Logger.WarnInternal($"The \"{name}\" {typeOrAssembly} does not appear to part of Resonite or a mod. It is unclear whether it should be hidden or not. Due to the HideLateTypes config option being {hideLate} it will be {(hideLate ? "Hidden" : "Shown")}");
-				}*/
-				// if forceShowLate == true, then this function will always return `false` for late-loaded types
-				// if forceShowLate == false, then this function will return `true` when hideLate == true
-				return !forceShowLate;
+			// an assembly was in neither resoniteAssemblies nor modAssemblies
+			// this implies someone late-loaded an assembly after RML, and it was later used in-game
+			// this is super weird, and probably shouldn't ever happen... but if it does, I want to know about it.
+			if (log) {
+				Logger.WarnInternal($"The \"{name}\" {typeOrAssembly} does not appear to part of Resonite or a mod. It is unclear whether it should be hidden or not. forceShowLate is {forceShowLate}, so it will be {(forceShowLate ? "Shown" : "Hidden")}");
 			}
+			// if forceShowLate == true, then this function will always return `false` for late-loaded types
+			return !forceShowLate;
 		}
 	}
 

ResoniteModLoader/Attributes/AutoRegisterConfigKeyAttribute.cs

@@ -4,4 +4,25 @@ namespace ResoniteModLoader;
 /// deriving from <see cref="ResoniteMod"/> to be automatically included in that mod's configuration.
 /// </summary>
 [AttributeUsage(AttributeTargets.Field)]
-public sealed class AutoRegisterConfigKeyAttribute : Attribute { }
+public sealed class AutoRegisterConfigKeyAttribute : Attribute {
+
+	/// <summary>
+	/// Defines a group that this configuration key belongs to, used by default configuration feed builder.
+	/// </summary>
+	public string? Group => _group;
+
+	private readonly string? _group;
+
+	/// <summary>
+	/// Flag this field to be automatically registered as a configuration key for this mod that is not grouped with any other keys.
+	/// </summary>
+	public AutoRegisterConfigKeyAttribute() { }
+
+	/// <summary>
+	/// Flag this field to be automatically registered as a configuration key for this mod that is part of a group.
+	/// </summary>
+	/// <param name="group">The name of the group this configuration key belongs to.</param>
+	public AutoRegisterConfigKeyAttribute(string group) {
+		_group = group;
+	}
+}

ResoniteModLoader/DashScreenInjector.cs

@@ -0,0 +1,101 @@
+using Elements.Core;
+using FrooxEngine;
+using FrooxEngine.UIX;
+using HarmonyLib;
+using Stream = System.IO.Stream;
+
+namespace ResoniteModLoader;
+
+internal sealed class DashScreenInjector {
+	internal static RadiantDashScreen? InjectedScreen;
+
+	internal static void PatchScreenManager(Harmony harmony) {
+		MethodInfo setupDefaultMethod = AccessTools.DeclaredMethod(typeof(UserspaceScreensManager), "SetupDefaults");
+		MethodInfo onLoadingMethod = AccessTools.DeclaredMethod(typeof(UserspaceScreensManager), "OnLoading");
+		MethodInfo tryInjectScreenMethod = AccessTools.DeclaredMethod(typeof(DashScreenInjector), nameof(TryInjectScreen));
+		harmony.Patch(setupDefaultMethod, postfix: new HarmonyMethod(tryInjectScreenMethod));
+		harmony.Patch(onLoadingMethod, postfix: new HarmonyMethod(tryInjectScreenMethod));
+		Logger.DebugInternal("UserspaceScreensManager patched");
+	}
+
+	internal static async void TryInjectScreen(UserspaceScreensManager __instance) {
+		ModLoaderConfiguration config = ModLoaderConfiguration.Get();
+
+		if (config.NoDashScreen) {
+			Logger.DebugInternal("Dash screen will not be injected due to configuration file");
+			return;
+		}
+		if (__instance.World != Userspace.UserspaceWorld) {
+			Logger.WarnInternal("Dash screen will not be injected because we're somehow not in userspace (WTF?)"); // it stands for What the Froox :>
+			return;
+		}
+		if (InjectedScreen is not null && !InjectedScreen.IsRemoved) {
+			Logger.WarnInternal("Dash screen will not be injected again because it already exists");
+			return;
+		}
+
+		string? overrideTemplatePath = Directory.EnumerateFiles(ModLoaderConfiguration.GetAssemblyDirectory(), "DashScreenTemplate.*").FirstOrDefault();
+		Stream screenFileStream = File.Exists(overrideTemplatePath) ? File.OpenRead(overrideTemplatePath) : Assembly.GetExecutingAssembly().GetManifestResourceStream("Resources\\DashScreenTemplate.bson");
+
+		Logger.DebugInternal("Injecting dash screen");
+
+		RadiantDash dash = __instance.Slot.GetComponentInParents<RadiantDash>();
+		InjectedScreen = dash.AttachScreen("Mods", RadiantUI_Constants.Neutrals.LIGHT, OfficialAssets.Graphics.Icons.Dash.Tools);
+
+		InjectedScreen.Slot.OrderOffset = 128;
+		InjectedScreen.Slot.PersistentSelf = false;
+
+		try {
+			DataTreeDictionary screenDict = DataTreeConverter.LoadAuto(screenFileStream);
+			Slot DashScreenTemplate = InjectedScreen.ScreenRoot.AddSlot("DashScreenTemplate");
+			DashScreenTemplate.LoadObject(screenDict, null!);
+			Canvas DashScreenCanvas = DashScreenTemplate.GetComponentInChildren<Canvas>();
+			InjectedScreen.ScreenCanvas.Slot.AttachComponent<NestedCanvas>().TargetCanvas.Target = DashScreenCanvas;
+		}
+		catch (ArgumentNullException e) {
+			Logger.WarnInternal(
+				"Failed to load DashScreenTemplate for dash screen, falling back to platform settings.");
+			Logger.DebugInternal($"Exception message: {e.Message}");
+
+			SingleFeedView view = InjectedScreen.ScreenRoot.AttachComponent<SingleFeedView>();
+			ModConfigurationDataFeed feed = InjectedScreen.ScreenRoot.AttachComponent<ModConfigurationDataFeed>();
+
+			Slot templates = InjectedScreen.ScreenRoot.AddSlot("Template");
+			templates.ActiveSelf = false;
+
+			if (await templates.LoadObjectAsync(__instance.Cloud.Platform.GetSpawnObjectUri("Settings"), skipHolder: true)) {
+				// we do a little bit of thievery
+				RootCategoryView rootCategoryView = templates.GetComponentInChildren<RootCategoryView>();
+				rootCategoryView.Slot.GetComponentInChildren<BreadcrumbManager>().Path.Target = view.Path;
+				rootCategoryView.CategoryManager.ContainerRoot.Target.ActiveSelf = false;
+				rootCategoryView.Slot.Children.First().Parent = InjectedScreen.ScreenCanvas.Slot;
+				view.ItemsManager.TemplateMapper.Target = rootCategoryView.ItemsManager.TemplateMapper.Target;
+				view.ItemsManager.ContainerRoot.Target = rootCategoryView.ItemsManager.ContainerRoot.Target;
+				rootCategoryView.Destroy();
+				templates.GetComponentInChildren<BreadcrumbInterface>().NameConverter.Target = view.PathSegmentName;
+			}
+			else if (config.Debug) {
+				Logger.ErrorInternal("Failed to load SettingsItemMappers for dash screen, falling back to template.");
+				DataFeedItemMapper itemMapper = templates.AttachComponent<DataFeedItemMapper>();
+				Canvas tempCanvas = templates.AttachComponent<Canvas>(); // Needed for next method to work
+				itemMapper.SetupTemplate();
+				tempCanvas.Destroy();
+				view.ItemsManager.TemplateMapper.Target = itemMapper;
+				view.ItemsManager.ContainerRoot.Target = InjectedScreen.ScreenCanvas.Slot;
+				InjectedScreen.ScreenCanvas.Slot.AttachComponent<VerticalLayout>(); // just for debugging
+			}
+			else {
+				Logger.ErrorInternal("Failed to load SettingsItemMappers for dash screen, aborting and cleaning up.");
+				InjectedScreen.Slot.Destroy();
+				return;
+			}
+
+			view.Feed.Target = feed;
+			view.SetCategoryPath(["ResoniteModLoader"]);
+		}
+
+		InjectedScreen.ScreenCanvas.Slot.AttachComponent<Image>().Tint.Value = UserspaceRadiantDash.DEFAULT_BACKGROUND;
+
+		Logger.DebugInternal("Dash screen should be injected!");
+	}
+}

ResoniteModLoader/DebugInfo.cs

@@ -3,6 +3,8 @@
 namespace ResoniteModLoader;
 
 internal static class DebugInfo {
+	internal static TimeSpan InitializationTime;
+
 	internal static void Log() {
 		Logger.MsgInternal($"ResoniteModLoader v{ModLoader.VERSION} starting up!{(ModLoaderConfiguration.Get().Debug ? " Debug logs will be shown." : "")}");
 		Logger.DebugFuncInternal(() => $"Launched with args: {string.Join(" ", Environment.GetCommandLineArgs())}");

ResoniteModLoader/ExceptionHook.cs

@@ -0,0 +1,24 @@
+using FrooxEngine;
+using HarmonyLib;
+
+namespace ResoniteModLoader;
+
+internal sealed class ExceptionHook {
+	internal static void RegisterExceptionHook(Harmony harmony) {
+		MethodInfo? preprocessExceptionMethod = typeof(DebugManager).GetMethod(nameof(DebugManager.PreprocessException), BindingFlags.Static | BindingFlags.Public)?.MakeGenericMethod(typeof(Exception));
+		MethodInfo? exceptionHookMethod = typeof(ExceptionHook).GetMethod(nameof(InterceptException), BindingFlags.Static);
+
+		if (preprocessExceptionMethod == null || exceptionHookMethod == null) {
+			Logger.ErrorInternal("Could not find DebugManager.PreprocessException. Mod exceptions may not be logged.");
+			return;
+		}
+
+		harmony.Patch(preprocessExceptionMethod, prefix: new HarmonyMethod(exceptionHookMethod));
+		Logger.DebugInternal("DebugManager.PreprocessException patched");
+	}
+
+	internal static void InterceptException(Exception exception) {
+		Logger.ProcessException(exception);
+	}
+
+}

ResoniteModLoader/ExecutionHook.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using FrooxEngine;
 
 namespace ResoniteModLoader;
@@ -18,6 +19,8 @@ private static DummyConnector InstantiateConnector() {
 	static ExecutionHook() {
 		Logger.DebugInternal($"Start of ExecutionHook");
 		try {
+			Stopwatch timer = Stopwatch.StartNew();
+			Logger.RegisterExceptionHook();
 			BindingFlags flags = BindingFlags.Static | BindingFlags.NonPublic;
 			var byName = (Dictionary<string, AssemblyTypeRegistry>)typeof(GlobalTypeRegistry).GetField("_byName", flags).GetValue(null);
 
@@ -39,8 +42,12 @@ static ExecutionHook() {
 			LoadProgressIndicator.SetCustom("Initializing");
 			DebugInfo.Log();
 			HarmonyWorker.LoadModsAndHideModAssemblies(initialAssemblies);
+			timer.Stop();
 			LoadProgressIndicator.SetCustom("Loaded");
+			Logger.MsgInternal($"Initialization & mod loading completed in {timer.ElapsedMilliseconds}ms.");
+			DebugInfo.InitializationTime = timer.Elapsed;
 		} catch (Exception e) {
+			Logger.UnregisterExceptionHook();
 			// it's important that this doesn't send exceptions back to Resonite
 			Logger.ErrorInternal($"Exception in execution hook!\n{e}");
 		}

ResoniteModLoader/HarmonyWorker.cs

@@ -6,8 +6,10 @@ namespace ResoniteModLoader;
 internal sealed class HarmonyWorker {
 	internal static void LoadModsAndHideModAssemblies(HashSet<Assembly> initialAssemblies) {
 		Harmony harmony = new("com.resonitemodloader.ResoniteModLoader");
+		// ExceptionHook.RegisterExceptionHook(harmony);
 		ModLoader.LoadMods();
 		ModConfiguration.RegisterShutdownHook(harmony);
 		AssemblyHider.PatchResonite(harmony, initialAssemblies);
+		DashScreenInjector.PatchScreenManager(harmony);
 	}
 }