Test with generated hooks

to be used with the generated assemblies from the user code.

.github/copilot-instructions.md

@@ -1,4 +0,0 @@
-# Copilot Instructions
-
-## Project Guidelines
-- In MoonTools.ECS, do not store plain references to `Entity` objects in long-lived collections outside the ECS world, because their underlying IDs can be reused or destroyed. Instead, query the ECS world to track or process entities based on their assigned components.

.gitmodules

@@ -16,6 +16,3 @@
 [submodule "Nerfed.Runtime/Libraries/ImGui.NET"]
 	path = Nerfed.Runtime/Libraries/ImGui.NET
 	url = https://github.com/ImGuiNET/ImGui.NET.git
-[submodule "Nerfed.Runtime/Libraries/MoonTools.ECS"]
-	path = Nerfed.Runtime/Libraries/MoonTools.ECS
-	url = https://github.com/MoonsideGames/MoonTools.ECS.git

.idea/.idea.Nerfed/.idea/vcs.xml

@@ -4,7 +4,6 @@
     <mapping directory="" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/FAudio" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/ImGui.NET" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/MoonTools.ECS" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/RefreshCS" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/SDL2CS" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/WellspringCS" vcs="Git" />

Nerfed.Builder/Builder/Builder.cs

@@ -1,6 +1,4 @@
 using System.Diagnostics;
-using System.Text.Json;
-using Nerfed.Builder.Meta;
 
 namespace Nerfed.Builder;
 
@@ -59,45 +57,15 @@ public class Builder : IDisposable
                     string outFile = $"{args.ResourceOutPath}/{relativeFile}{PathUtil.ImportedFileExtension}";
 
                     FileInfo inFileInfo = new FileInfo(inFile);
+                    FileInfo outFileInfo = new FileInfo(outFile);
 
-                    // =========================================================================
+                    if (!FileUtil.IsNewer(inFileInfo, outFileInfo))
-                    // STEP 1: GUID META FILE SYNC
-                    // Ensure the source file has a backing .meta file generating its Guid 
-                    // =========================================================================
-                    string metaFile = inFile + ".meta";
-                    AssetMeta metaData;
-                    
-                    if (!File.Exists(metaFile))
-                    {
-                        // Generate a brand new meta file to track this asset permanently
-                        metaData = new AssetMeta(Guid.NewGuid());
-                        string json = JsonSerializer.Serialize(metaData, new JsonSerializerOptions { WriteIndented = true });
-                        File.WriteAllText(metaFile, json);
-                        Console.WriteLine($"[Meta] Generated new tracking ID '{metaData.Id}' for {relativeFile}");
-                    }
-                    else
-                    {
-                        // Load the existing guid
-                        metaData = JsonSerializer.Deserialize<AssetMeta>(File.ReadAllText(metaFile))!;
-                    }
-
-                    // Change output file from Name.ext.bin -> /GUID.bin  to completely anonymize the actual game package!
-                    string cacheOutFile = $"{args.ResourceOutPath}/{metaData.Id}.bin";
-                    FileInfo outFileInfo = new FileInfo(cacheOutFile);
-
-                    // Rebuild if the source file changed, or if the meta file changed!
-                    FileInfo metaFileInfo = new FileInfo(metaFile);
-                    bool requiresCompile = !outFileInfo.Exists || 
-                                           FileUtil.IsNewer(inFileInfo, outFileInfo) || 
-                                           FileUtil.IsNewer(metaFileInfo, outFileInfo);
-
-                    if (!requiresCompile)
                     {
                         // File has not changed since last build, no need to build this one.
                         return;
                     }
 
-                    string outDir = Path.GetDirectoryName(cacheOutFile)!;
+                    string outDir = Path.GetDirectoryName(outFile);
                     if (!Directory.Exists(outDir))
                     {
                         Directory.CreateDirectory(outDir);
@@ -106,14 +74,14 @@ public class Builder : IDisposable
                     string ext = Path.GetExtension(inFile).ToLower();
                     if (importers.TryGetValue(ext, out IImporter importer))
                     {
-                        importer.Import(inFile, cacheOutFile); // Compile source directly to hash.bin
+                        importer.Import(inFile, outFile);
                     }
                     else
                     {
-                        rawFileImporter.Import(inFile, cacheOutFile);
+                        rawFileImporter.Import(inFile, outFile);
                     }
 
-                    Console.WriteLine($"Compiled {relativeFile} -> {metaData.Id}.bin");
+                    Console.WriteLine(relativeFile);
                 }
                 catch (Exception e)
                 {

Nerfed.Builder/Meta/AssetMeta.cs

@@ -1,30 +0,0 @@
-        using System;
-
-        namespace Nerfed.Builder.Meta
-        {
-            /// <summary>
-            /// Foundation for JSON-serialized metadata files (e.g. hero.png.meta)
-            /// </summary>
-            public class AssetMeta
-            {
-                /// <summary>
-                /// The universally unique identifier for this asset, generated on first import.
-                /// </summary>
-                public Guid Id { get; set; }
-
-                /// <summary>
-                /// The importer version. Useful to force re-imports if your engine updates how it parses textures.
-                /// </summary>
-                public int ImporterVersion { get; set; } = 1;
-
-                /// <summary>
-                /// Base constructor needed for JSON deserialization
-                /// </summary>
-                public AssetMeta() { }
-
-                public AssetMeta(Guid id)
-                {
-                    Id = id;
-                }
-            }
-        }

Nerfed.Compiler/AssemblyDefinition.cs

@@ -0,0 +1,64 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Nerfed.Compiler;
+
+public class AssemblyDefinition
+{
+    public string Name { get; set; }
+    public string Guid { get; set; }
+    //public bool IsEditor { get; set; }
+    // Add platform stuff here..?
+    // Add dll's here..?
+    // Add dependencies here..?
+
+    public static bool Create(string assemblyDefinitionFilePath, string name, out AssemblyDefinition assemblyDefinition)
+    {
+        assemblyDefinition = null;
+
+        if (File.Exists(assemblyDefinitionFilePath))
+        {
+            Console.WriteLine($"ERROR: File already exists!");
+            return false;
+        }
+
+        // Create project file.
+        assemblyDefinition = new AssemblyDefinition
+        {
+            Name = name,
+            Guid = System.Guid.NewGuid().ToString("B").ToUpper(),
+        };
+
+        Save(assemblyDefinition, assemblyDefinitionFilePath);
+
+        return true;
+    }
+
+    public static bool Save(AssemblyDefinition assemblyDefinition, string assemblyDefinitionFilePath)
+    {
+        string jsonString = JsonSerializer.Serialize(assemblyDefinition, AssemblyDefinitionContext.Default.AssemblyDefinition);
+
+        File.WriteAllText(assemblyDefinitionFilePath, jsonString);
+
+        return true;
+    }
+
+    public static bool Open(string assemblyDefinitionFilePath, out AssemblyDefinition assemblyDefinition)
+    {
+        string jsonString = File.ReadAllText(assemblyDefinitionFilePath);
+        assemblyDefinition = JsonSerializer.Deserialize(jsonString, AssemblyDefinitionContext.Default.AssemblyDefinition);
+
+        if (assemblyDefinition == null)
+        {
+            Console.WriteLine($"ERROR: Could not open {typeof(AssemblyDefinition)}.");
+            return false;
+        }
+
+        return true;
+    }
+}
+
+[JsonSerializable(typeof(AssemblyDefinition))]
+public partial class AssemblyDefinitionContext : JsonSerializerContext
+{
+}

Nerfed.Compiler/Compiler.cs

@@ -0,0 +1,82 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Nerfed.Compiler;
+
+public static class Compiler
+{
+    public static bool Compile(string projectFilePath, string configuration = "Debug")
+    {
+        string projectDirectory = Path.GetDirectoryName(projectFilePath);
+
+        if (!File.Exists(projectFilePath))
+        {
+            Console.WriteLine($"ERROR: Project file not found at {projectDirectory}.");
+            return false;
+        }
+
+        if (!Project.Open(projectFilePath, out Project project))
+        {
+            return false;
+        }
+
+        // TODO: Check project version, to make sure we can compile it or something...
+
+        // Generate solution.
+        Generator.GenerateSolution(projectDirectory, project, out string solutionFilePath);
+
+        // Compile solution.
+        ProcessStartInfo processInfo = new()
+        {
+            WorkingDirectory = Path.GetDirectoryName(solutionFilePath),
+            CreateNoWindow = true,
+            UseShellExecute = false,
+            RedirectStandardError = true,
+            RedirectStandardOutput = true,
+        };
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+        {
+            processInfo.FileName = "/bin/bash";
+            processInfo.Arguments = $"-c \"dotnet build '{Path.GetFileName(solutionFilePath)}'\"" + (string.IsNullOrWhiteSpace(configuration) ? $" --configuration {configuration}" : "");
+        }
+        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            processInfo.FileName = "cmd.exe";
+            processInfo.Arguments = $"/c dotnet build \"{Path.GetFileName(solutionFilePath)}\"" + (string.IsNullOrWhiteSpace(configuration) ? $" --configuration {configuration}" : "");
+        }
+        else
+        {
+            Console.WriteLine($"ERROR: Platform not supported!");
+            return false;
+        }
+
+        Process process = Process.Start(processInfo) ?? throw new Exception();
+        process.OutputDataReceived += (sender, dataArgs) => {
+            string data = dataArgs.Data;
+
+            if (data is null)
+            {
+                return;
+            }
+
+            Console.WriteLine(data);
+        };
+
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
+        process.ErrorDataReceived += (sender, dataArgs) => {
+            if (dataArgs.Data is not null)
+            {
+                Console.WriteLine(dataArgs.Data);
+            }
+        };
+
+        process.WaitForExit();
+
+        int exitCode = process.ExitCode;
+        process.Close();
+
+        return true;
+    }
+}

Nerfed.Compiler/Generator.cs

@@ -0,0 +1,161 @@
+using System.Reflection;
+using System.Text;
+using System.Text.Json;
+
+namespace Nerfed.Compiler;
+
+public static class Generator
+{
+    public const string AssemblyDefinitionExtensionName = ".asmdef";
+    public const string CSProjectExtensionName = ".csproj";
+    public const string SolutionExtensionName = ".sln";
+
+    public static void GenerateSolution(string projectDirectory, Project project, out string solutionFilePath)
+    {
+        // Clear files.
+        ClearCSProjectFiles(projectDirectory);
+
+        // Generate projects.
+        string[] assemblyDefinitionFilePaths = Directory.GetFiles(projectDirectory, AssemblyDefinitionExtensionName, SearchOption.AllDirectories);
+        foreach (string assemblyDefinitionFilePath in assemblyDefinitionFilePaths)
+        {
+            GenerateCSProject(assemblyDefinitionFilePath, projectDirectory, out string csProjectFilePath);
+        }
+
+        // Generate solution.
+        string[] csProjectPaths = Directory.GetFiles(projectDirectory, $"*{CSProjectExtensionName}", SearchOption.TopDirectoryOnly);
+        string[] csProjectGuids = new string[csProjectPaths.Length];
+        for (int i = 0; i < csProjectPaths.Length; i++)
+        {
+            csProjectGuids[i] = Guid.NewGuid().ToString("B").ToUpper();
+        }
+
+        StringBuilder content = new StringBuilder();
+
+        // Write the solution file header
+        content.AppendLine("Microsoft Visual Studio Solution File, Format Version 12.00");
+        content.AppendLine("# Visual Studio Version 17");
+        content.AppendLine("VisualStudioVersion = 17.10.35013.160");
+        content.AppendLine("MinimumVisualStudioVersion = 10.0.40219.1");
+
+        // Add each project to the solution file
+        for (int i = 0; i < csProjectPaths.Length; i++)
+        {
+            string csProjectPath = csProjectPaths[i];
+            string csProjectGuid = csProjectGuids[i];
+            string csProjectName = Path.GetFileNameWithoutExtension(csProjectPath);
+            string csProjectRelativePath = Path.GetRelativePath(projectDirectory, csProjectPath);
+            // FAE04EC0-301F-11D3-BF4B-00C04F79EFBC for C# projects.
+            content.AppendLine($"Project(\"{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}\") = \"{csProjectName}\", \"{csProjectRelativePath}\", \"{csProjectGuid}\"");
+            content.AppendLine("EndProject");
+        }
+
+        // Add global sections (these can be extended as needed)
+        content.AppendLine("Global");
+        content.AppendLine("	GlobalSection(SolutionConfigurationPlatforms) = preSolution");
+        content.AppendLine("		Test|x64 = Test|x64");
+        content.AppendLine("		Release|x64 = Release|x64");
+        content.AppendLine("		Debug|x64 = Debug|x64");
+        content.AppendLine("	EndGlobalSection");
+        content.AppendLine("	GlobalSection(ProjectConfigurationPlatforms) = postSolution");
+
+        for (int i = 0; i < csProjectPaths.Length; i++)
+        {
+            string projectGuid = csProjectGuids[i];
+            content.AppendLine($"		{projectGuid}.Test|x64.ActiveCfg = Test|x64");
+            content.AppendLine($"		{projectGuid}.Test|x64.Build.0 = Test|x64");
+            content.AppendLine($"		{projectGuid}.Release|x64.ActiveCfg = Release|x64");
+            content.AppendLine($"		{projectGuid}.Release|x64.Build.0 = Release|x64");
+            content.AppendLine($"		{projectGuid}.Debug|x64.ActiveCfg = Debug|x64");
+            content.AppendLine($"		{projectGuid}.Debug|x64.Build.0 = Debug|x64");
+        }
+
+        content.AppendLine("	EndGlobalSection");
+        content.AppendLine("	GlobalSection(SolutionProperties) = preSolution");
+        content.AppendLine("		HideSolutionNode = FALSE");
+        content.AppendLine("	EndGlobalSection");
+        content.AppendLine("EndGlobal");
+
+        // Write the solution file content to disk
+        string solutionName = project.Name + SolutionExtensionName;
+        solutionFilePath = Path.Combine(projectDirectory, solutionName);
+        File.WriteAllText(solutionFilePath, content.ToString());
+    }
+
+    private static bool GenerateCSProject(string assemblyDefinitionFilePath, string projectPath, out string csProjectFilePath)
+    {
+        if (!File.Exists(assemblyDefinitionFilePath))
+        {
+            csProjectFilePath = string.Empty;
+            return false;
+        }
+
+        string jsonString = File.ReadAllText(assemblyDefinitionFilePath);
+        AssemblyDefinition assemblyDefinition = JsonSerializer.Deserialize(jsonString, AssemblyDefinitionContext.Default.AssemblyDefinition);
+
+        Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+        Assembly runtimeAssembly = loadedAssemblies.FirstOrDefault(assembly => assembly.GetName().Name == "Nerfed.Runtime") ?? throw new Exception("Failed to find Runtime Assembly!");
+
+        // TODO: get all dependencies.
+        // TODO: properly get assemblies.
+
+        StringBuilder content = new StringBuilder();
+
+        content.AppendLine("<Project Sdk=\"Microsoft.NET.Sdk\">");
+
+        content.AppendLine(" <PropertyGroup>");
+        content.AppendLine("     <TargetFramework>net8.0</TargetFramework>");
+        content.AppendLine("     <ImplicitUsings>enable</ImplicitUsings>");
+        content.AppendLine("     <Nullable>disable</Nullable>");
+        content.AppendLine("     <PublishAot>true</PublishAot>");
+        content.AppendLine("     <InvariantGlobalization>true</InvariantGlobalization>");
+        content.AppendLine("     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>");
+        content.AppendLine("     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>");
+        content.AppendLine("     <IsPackable>false</IsPackable>");
+        content.AppendLine("     <Configurations>Debug;Test;Release</Configurations>");
+        content.AppendLine("     <Platforms>x64</Platforms>");
+        content.AppendLine(" </PropertyGroup>");
+
+        content.AppendLine(" <PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Debug|x64' \">");
+        content.AppendLine("     <DefineConstants>TRACE;LOG_INFO;PROFILING</DefineConstants>");
+        content.AppendLine(" </PropertyGroup>");
+
+        content.AppendLine(" <PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Test|x64' \">");
+        content.AppendLine("     <DefineConstants>TRACE;LOG_ERROR;PROFILING</DefineConstants>");
+        content.AppendLine("     <Optimize>true</Optimize>");
+        content.AppendLine(" </PropertyGroup>");
+
+        content.AppendLine(" <PropertyGroup Condition=\" '$(Configuration)|$(Platform)' == 'Release|x64' \">");
+        content.AppendLine("     <DefineConstants>TRACE;LOG_ERROR</DefineConstants>");
+        content.AppendLine("     <Optimize>true</Optimize>");
+        content.AppendLine(" </PropertyGroup>");
+
+        content.AppendLine(" <ItemGroup>");
+        content.AppendLine($"     <Compile Include=\"{assemblyDefinitionFilePath}/**/*.cs\"/>");
+        content.AppendLine(" </ItemGroup>");
+
+        content.AppendLine(" <ItemGroup>");
+        content.AppendLine("     <Reference Include=\"Nerfed.Runtime\">");
+        content.AppendLine($"         <HintPath>{runtimeAssembly.Location}</HintPath>");
+        content.AppendLine("         <Private>false</Private>");
+        content.AppendLine("     </Reference>");
+        content.AppendLine(" </ItemGroup>");
+
+        content.AppendLine("</Project>");
+
+        string csProjectName = assemblyDefinition.Name + CSProjectExtensionName;
+        csProjectFilePath = Path.Combine(projectPath, csProjectName);
+        File.WriteAllText(csProjectFilePath, content.ToString());
+
+        return true;
+    }
+
+    private static void ClearCSProjectFiles(string projectPath)
+    {
+        string[] csProjectFiles = Directory.GetFiles(projectPath, $"*{CSProjectExtensionName}", SearchOption.TopDirectoryOnly);
+        foreach (string csProjectFile in csProjectFiles)
+        {
+            File.Delete(csProjectFile);
+        }
+    }
+}

Nerfed.Compiler/Nerfed.Compiler.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	
+	<PropertyGroup>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>net8.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>disable</Nullable>
+		<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+		<IsPackable>false</IsPackable>
+		<Configurations>Debug;Test;Release</Configurations>
+		<Platforms>x64</Platforms>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+		<Optimize>false</Optimize>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Test|x64' ">
+		<Optimize>true</Optimize>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+		<Optimize>true</Optimize>
+	</PropertyGroup>
+	
+</Project>

Nerfed.Compiler/Program.cs

@@ -0,0 +1,15 @@
+namespace Nerfed.Compiler;
+
+public class Program
+{
+    internal static void Main(string[] args)
+    {
+        if (args.Length != 2)
+        {
+            Console.WriteLine("projectFilePath, configuration (Debug, Test, Release)");
+            return;
+        }
+
+        Compiler.Compile(args[0], args[1]);
+    }
+}

Nerfed.Compiler/Project.cs

@@ -0,0 +1,50 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Nerfed.Compiler;
+
+public class Project
+{
+    public string Name { get; set; }
+
+    public static bool Create(string path, string name, out Project project)
+    {
+        // Create project file.
+        project = new Project
+        {
+            Name = name,
+        };
+
+        Save(project, path);
+
+        return true;
+    }
+
+    public static bool Save(Project project, string projectFilePath)
+    {
+        string jsonString = JsonSerializer.Serialize(project, ProjectContext.Default.Project);
+
+        File.WriteAllText(projectFilePath, jsonString);
+
+        return true;
+    }
+
+    public static bool Open(string path, out Project project)
+    {
+        string jsonString = File.ReadAllText(path);
+        project = JsonSerializer.Deserialize(jsonString, ProjectContext.Default.Project);
+
+        if (project == null)
+        {
+            Console.WriteLine($"ERROR: Could not open {typeof(Project)}.");
+            return false;
+        }
+
+        return true;
+    }
+}
+
+[JsonSerializable(typeof(Project))]
+public partial class ProjectContext : JsonSerializerContext
+{
+}

Nerfed.Editor/Components/HierachyComponents.cs

@@ -1,4 +0,0 @@
-namespace Nerfed.Editor.Components;
-
-public readonly record struct SelectedInHierachy;
-public readonly record struct ClickedInHierachy;

Nerfed.Editor/Editor/EditorGui.cs

@@ -1,4 +1,5 @@
 using ImGuiNET;
+using Nerfed.Editor.Project;
 using Nerfed.Runtime;
 using Nerfed.Runtime.Graphics;
 using Nerfed.Runtime.Gui;
@@ -56,6 +57,7 @@ namespace Nerfed.Editor
                     }
                     ImGui.EndMenu();
                 }
+
                 ImGui.EndMainMenuBar();
             }
         }
@@ -67,11 +69,7 @@ namespace Nerfed.Editor
 
             ImGui.ShowDemoWindow();
 
-            foreach (MoonTools.ECS.System system in Program.editorSystems)
+            EditorProjectGui.OnGui();
-            {
-                using ProfilerScope scope = new(system.GetType().Name);
-                system.Update(Engine.Timestep);
-            }
         }
     }
 }

Nerfed.Editor/Nerfed.Editor.csproj

@@ -9,7 +9,6 @@
         <IsPackable>false</IsPackable>
         <Configurations>Debug;Test;Release</Configurations>
         <Platforms>x64</Platforms>
-        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
     <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
@@ -24,6 +23,7 @@
     </PropertyGroup>
     
     <ItemGroup>
+        <ProjectReference Include="..\Nerfed.Compiler\Nerfed.Compiler.csproj" />
         <ProjectReference Include="..\Nerfed.Runtime\Nerfed.Runtime.csproj" />
     </ItemGroup>
 

Nerfed.Editor/Program.cs

@@ -1,19 +1,9 @@
-using MoonTools.ECS;
+using Nerfed.Runtime;
-using Nerfed.Editor.Systems;
-using Nerfed.Runtime;
-using Nerfed.Runtime.Components;
-using Nerfed.Runtime.Systems;
-using Nerfed.Runtime.Util;
-using System.Numerics;
 
 namespace Nerfed.Editor;
 
 internal class Program
 {
-    private static readonly World world = new World();
-    private static List<MoonTools.ECS.System> systems = new List<MoonTools.ECS.System>();
-    public static List<MoonTools.ECS.System> editorSystems = new List<MoonTools.ECS.System>();
-
     private static void Main(string[] args)
     {
         Engine.OnInitialize += HandleOnInitialize;
@@ -26,79 +16,24 @@ internal class Program
 
     private static void HandleOnInitialize()
     {
-        //systems.Add(new ParentSystem(world));
-        systems.Add(new LocalToWorldSystem(world));
-        editorSystems.Add(new EditorProfilerWindow(world));
-        // editorSystems.Add(new EditorHierarchyWindow(world));
-#if DEBUG
-        editorSystems.Add(new EditorInspectorWindow(world));
-#endif
-
-        // Entity ent1 = world.CreateEntity("parent");
-        // world.Set(ent1, new Root());
-        // world.Set(ent1, new LocalTransform(new Vector3(1, 0, 0), Quaternion.Identity, Vector3.One));
-        //
-        // Entity ent2 = world.CreateEntity("child");
-        // world.Set(ent2, new LocalTransform(new Vector3(0, 1, 0), Quaternion.Identity, Vector3.One));
-        // Transform.SetParent(world, ent2, ent1);
-        //
-        // Entity ent3 = world.CreateEntity("entity3");
-        // world.Set(ent3, new Root());
-        // Transform.SetParent(world, ent3, ent2);
-        //
-        // Entity ent4 = world.CreateEntity("entity4");
-        // world.Set(ent4, new Root());
-        //
-        // Entity ent5 = world.CreateBaseEntity("entity5");
-
-        for (int i = 0; i < 1000000; i++)
-        {
-            Entity newEnt = world.CreateBaseEntity();
-            world.Set(newEnt, new LocalTransform(new Vector3(i, i, i), Quaternion.Identity, Vector3.One));
-
-            // Entity parent = newEnt;
-            // for (int j = 0; j < 2; j++) {
-            //     Entity newChildEnt = world.CreateEntity();
-            //     world.Set(newChildEnt, new LocalTransform(new Vector3(i + j * i, i - j * i, j - i * i), Quaternion.Identity, Vector3.One));
-            //     Transform.SetParent(world, newChildEnt, parent);
-            //     parent = newChildEnt;
-            // }
-        }
-
         // Open project.
         // Setip EditorGui.
         EditorGui.Initialize();
     }
 
     private static void HandleOnUpdate()
-    {
-        foreach (MoonTools.ECS.System system in systems)
-        {
-            using ProfilerScope scope = new(system.GetType().Name);
-            system.Update(Engine.Timestep);
-        }
-
-        using (new ProfilerScope("EditorGui.Update"))
     {
         // Editor Update.
         EditorGui.Update();
-        }
+
 
         // Try Catch UserCode Update.
-
-        using (new ProfilerScope("world.FinishUpdate"))
-        {
-            world.FinishUpdate();
-        }
     }
 
     private static void HandleOnRender()
-    {
-        using (new ProfilerScope("EditorGui.Render"))
     {
         EditorGui.Render();
     }
-    }
 
     private static void HandleOnQuit()
     {

Nerfed.Editor/Project/EditorAssemblyLoadContext.cs

@@ -0,0 +1,8 @@
+using System.Runtime.Loader;
+
+namespace Nerfed.Editor.Project;
+
+internal class EditorAssemblyLoadContext : AssemblyLoadContext
+{
+    public EditorAssemblyLoadContext() : base(isCollectible: true) { }
+}

Nerfed.Editor/Project/EditorAssemblyLoader.cs

@@ -0,0 +1,124 @@
+using Nerfed.Runtime;
+using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace Nerfed.Editor.Project;
+
+// https://github.com/godotengine/godot/blob/master/modules/mono/glue/GodotSharp/GodotPlugins/Main.c
+// https://gitlab.com/robertk92/assemblyreloadtest/-/blob/main/AppContextTest/Program.cs
+
+internal static class EditorAssemblyLoader
+{
+    internal sealed class EditorAssemblyLoadContextWrapper
+    {
+        private EditorAssemblyLoadContext assemblyLoadContext;
+        private readonly WeakReference weakReference;
+
+        private EditorAssemblyLoadContextWrapper(EditorAssemblyLoadContext assemblyLoadContext, WeakReference weakReference)
+        {
+            this.assemblyLoadContext = assemblyLoadContext;
+            this.weakReference = weakReference;
+        }
+
+        public bool IsCollectible
+        {
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            // If assemblyLoadContext is null we already started unloading, so it was collectible.
+            get => assemblyLoadContext?.IsCollectible ?? true;
+        }
+
+        public bool IsAlive
+        {
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            get => weakReference.IsAlive;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static (Assembly, EditorAssemblyLoadContextWrapper) CreateAndLoad(AssemblyName assemblyName)
+        {
+            EditorAssemblyLoadContext context = new EditorAssemblyLoadContext();
+            WeakReference reference = new WeakReference(context, trackResurrection: true);
+            EditorAssemblyLoadContextWrapper wrapper = new EditorAssemblyLoadContextWrapper(context, reference);
+            Assembly assembly = context.LoadFromAssemblyName(assemblyName);
+            return (assembly, wrapper);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static (Assembly, EditorAssemblyLoadContextWrapper) CreateAndLoad(string assemblyPath)
+        {
+            EditorAssemblyLoadContext context = new EditorAssemblyLoadContext();
+            WeakReference reference = new WeakReference(context, trackResurrection: true);
+            EditorAssemblyLoadContextWrapper wrapper = new EditorAssemblyLoadContextWrapper(context, reference);
+            Assembly assembly = context.LoadFromAssemblyPath(assemblyPath);
+            return (assembly, wrapper);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        internal void Unload()
+        {
+            assemblyLoadContext?.Unload();
+            assemblyLoadContext = null;
+        }
+    }
+
+    internal static (Assembly, EditorAssemblyLoadContextWrapper) Load(string assemblyFilePath)
+    {
+        string assemblyFileName = Path.GetFileNameWithoutExtension(assemblyFilePath);
+
+        AssemblyName assemblyName = new AssemblyName(assemblyFileName);
+
+        return EditorAssemblyLoadContextWrapper.CreateAndLoad(assemblyName);
+    }
+
+    internal static (Assembly, EditorAssemblyLoadContextWrapper) LoadFromPath(string assemblyFilePath)
+    {
+        return EditorAssemblyLoadContextWrapper.CreateAndLoad(assemblyFilePath);
+    }
+
+    internal static bool Unload(EditorAssemblyLoadContextWrapper assemblyLoadContextWrapper)
+    {
+        if (assemblyLoadContextWrapper == null)
+        {
+            return true;
+        }
+
+        if (!assemblyLoadContextWrapper.IsCollectible) 
+        {
+            Log.Error($"{assemblyLoadContextWrapper} is not collectable!");
+            return false;
+        }
+
+        assemblyLoadContextWrapper.Unload();
+
+        GC.Collect();
+        GC.WaitForPendingFinalizers();
+
+        TimeSpan timeout = TimeSpan.FromSeconds(30);
+        Stopwatch stopwatch = Stopwatch.StartNew();
+
+        while (assemblyLoadContextWrapper.IsAlive) 
+        {
+            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
+            GC.WaitForPendingFinalizers();
+
+            if (!assemblyLoadContextWrapper.IsAlive)
+            {
+                break;
+            }
+
+            if (stopwatch.Elapsed.TotalSeconds % 10 == 0)
+            {
+                Log.Info("Tring to unload assembly...");
+            }
+
+            if (stopwatch.Elapsed >= timeout)
+            {
+                Log.Error("Failed to unload assembly!");
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

Nerfed.Editor/Project/EditorProject.cs

@@ -0,0 +1,173 @@
+using Nerfed.Runtime;
+
+namespace Nerfed.Editor.Project;
+
+internal static class EditorProject
+{
+    internal static Compiler.Project Project { get; private set; } = null;
+    internal static string ProjectFilePath { get; private set; } = string.Empty;
+    internal static string ProjectSolutionFilePath { get; private set; } = string.Empty;
+    internal static string ProjectDirectory { get; private set; } = string.Empty;
+    internal static string ProjectContentDirectory { get; private set; } = string.Empty;
+    internal static string ProjectTempDirectory { get; private set; } = string.Empty;
+
+    private static readonly List<(string, EditorAssemblyLoader.EditorAssemblyLoadContextWrapper)> editorAssemblyLoadContextWrappers = [];
+
+    internal static bool Create(string projectFilePath, string projectName)
+    {
+        Close();
+
+        if (!Compiler.Project.Create(projectFilePath, projectName, out Compiler.Project project))
+        {
+            return false;
+        }
+
+        Open(projectFilePath);
+
+        Log.Info($"Succesfully created project.");
+        return true;
+    }
+
+    internal static bool Open(string projectFilePath)
+    {
+        Close();
+
+        if(!Compiler.Project.Open(projectFilePath, out Compiler.Project project))
+        {
+            return false;
+        }
+
+        Project = project;
+        ProjectFilePath = projectFilePath;
+        ProjectDirectory = Path.GetDirectoryName(projectFilePath);
+
+        string projectSolutionFilePath = Path.Combine(ProjectDirectory, Project.Name + Compiler.Generator.SolutionExtensionName);
+        if (File.Exists(projectSolutionFilePath))
+        {
+            ProjectSolutionFilePath = projectSolutionFilePath;
+        }
+        
+        SetupDefaultFolders();
+        Compile();
+
+        Log.Info($"Opened project: {project.Name}");
+
+        return true;
+    }
+
+    internal static void Close()
+    {
+        Project = null;
+        ProjectFilePath = string.Empty;
+        ProjectSolutionFilePath = string.Empty;
+        ProjectDirectory = string.Empty;
+        ProjectContentDirectory = string.Empty;
+        ProjectTempDirectory = string.Empty;
+    }
+
+    internal static bool Save()
+    {
+        if(Project == null)
+        {
+            return false;
+        }
+
+        return Compiler.Project.Save(Project, ProjectFilePath);
+    }
+
+    internal static void Compile()
+    {
+        if(Project == null)
+        {
+            return;
+        }
+
+        UnloadAssemblies();
+
+        Compiler.Compiler.Compile(ProjectFilePath, "Debug");
+
+        LoadAssemblies();
+    }
+
+    internal static void GenerateSolution()
+    {
+        if(Project == null)
+        {
+            return;
+        }
+
+        Compiler.Generator.GenerateSolution(ProjectDirectory, Project, out string solutionFilePath);
+        ProjectSolutionFilePath = solutionFilePath;
+    }
+
+    private static void SetupDefaultFolders()
+    {
+        if (Project == null || ProjectDirectory == null)
+        {
+            return;
+        }
+
+        string contentDirectory = Path.Combine(ProjectDirectory, "Content");
+        if (!Directory.Exists(contentDirectory))
+        {
+            Directory.CreateDirectory(contentDirectory);
+        }
+        ProjectContentDirectory = contentDirectory;
+        string scriptsDirectory = Path.Combine(ProjectContentDirectory, "Scripts");
+        if (!Directory.Exists(scriptsDirectory))
+        {
+            Directory.CreateDirectory(scriptsDirectory);
+        }
+        string scriptsRuntimePath = Path.Combine(scriptsDirectory, "Runtime");
+        if (!Directory.Exists(scriptsRuntimePath))
+        {
+            Directory.CreateDirectory(scriptsRuntimePath);
+        }
+
+        // Test create csproject.
+        string gameplayRuntimeFilePath = Path.Combine(scriptsRuntimePath, Compiler.Generator.AssemblyDefinitionExtensionName);
+        if (!File.Exists(gameplayRuntimeFilePath))
+        {
+            Compiler.AssemblyDefinition.Create(gameplayRuntimeFilePath, "Gameplay", out Compiler.AssemblyDefinition project);
+        }
+
+        string tempDirectory = Path.Combine(ProjectDirectory, "Temp");
+        if (!Directory.Exists(tempDirectory))
+        {
+            Directory.CreateDirectory(tempDirectory);
+        }
+        ProjectTempDirectory = tempDirectory;
+    }
+
+    private static void LoadAssemblies()
+    {
+        string[] assemblies = Directory.GetFiles(Path.Combine(ProjectDirectory, "bin"), "*.dll", SearchOption.AllDirectories);
+
+        foreach (string assembly in assemblies)
+        {
+            (System.Reflection.Assembly, EditorAssemblyLoader.EditorAssemblyLoadContextWrapper) a = EditorAssemblyLoader.LoadFromPath(assembly);
+            string name = a.Item1.GetName().Name;
+            editorAssemblyLoadContextWrappers.Add((name, a.Item2));
+            Log.Info($"loaded {name}");
+        }
+
+        Nerfed.Runtime.Generator.Hook.InvokeHooks();
+    }
+
+    private static void UnloadAssemblies()
+    {
+        for (int i = editorAssemblyLoadContextWrappers.Count - 1; i >= 0; i--)
+        {
+            (string, EditorAssemblyLoader.EditorAssemblyLoadContextWrapper) a = editorAssemblyLoadContextWrappers[i];
+            if (EditorAssemblyLoader.Unload(a.Item2))
+            {
+                Log.Info($"Unloaded {a.Item1}");
+                editorAssemblyLoadContextWrappers.RemoveAt(i);
+            }
+            else
+            {
+                Log.Error($"Could not unload {a.Item1}");
+            }
+        }
+    }
+}

Nerfed.Editor/Project/EditorProjectGui.cs

@@ -0,0 +1,67 @@
+using ImGuiNET;
+
+namespace Nerfed.Editor.Project;
+
+internal static class EditorProjectGui
+{
+    private static string projectDirectory = string.Empty;
+    private static string projectName = string.Empty;
+    private static string projectFilePath = string.Empty;
+
+    internal static void OnGui()
+    {
+        ImGui.Begin("Project");
+        ImGui.BeginGroup();
+
+        ImGui.InputText("Project Directory", ref projectDirectory, 512);
+        ImGui.InputText("Project Name", ref projectName, 512);
+
+        string newProjectFilePath = Path.Combine(projectDirectory, ".project");
+        ImGui.Text(newProjectFilePath);
+
+        if (ImGui.Button("Create Project"))
+        {
+            EditorProject.Create(newProjectFilePath, projectName);
+        }
+
+        ImGui.EndGroup();
+        ImGui.BeginGroup();
+
+        ImGui.InputText("Project File Path", ref projectFilePath, 512);
+        if (ImGui.Button("Open Project"))
+        {
+            EditorProject.Open(projectFilePath);
+        }
+
+        ImGui.Text("Loaded project: ");
+        if(EditorProject.Project != null)
+        {
+            ImGui.Text(EditorProject.Project.Name);
+            ImGui.Text(EditorProject.ProjectFilePath);
+            ImGui.Text(EditorProject.ProjectSolutionFilePath);
+            ImGui.Text(EditorProject.ProjectDirectory);
+            ImGui.Text(EditorProject.ProjectContentDirectory);
+            ImGui.Text(EditorProject.ProjectTempDirectory);
+        }
+        else
+        {
+            ImGui.Text("None");
+        }
+
+        ImGui.EndGroup();
+        ImGui.BeginGroup();
+
+        if (ImGui.Button("Generate Solution"))
+        {
+            EditorProject.GenerateSolution();
+        }
+
+        if (ImGui.Button("Compile"))
+        {
+            EditorProject.Compile();
+        }
+
+        ImGui.EndGroup();
+        ImGui.End();
+    }
+}

Nerfed.Editor/Systems/EditorHierarchyWindow.cs

@@ -1,190 +0,0 @@
-using ImGuiNET;
-using MoonTools.ECS;
-using Nerfed.Editor.Components;
-using Nerfed.Runtime;
-using Nerfed.Runtime.Components;
-using Nerfed.Runtime.Util;
-
-namespace Nerfed.Editor.Systems
-{
-    // Window that draws entities.
-    internal class EditorHierarchyWindow : MoonTools.ECS.System
-    {
-        private const ImGuiTreeNodeFlags baseFlags = ImGuiTreeNodeFlags.OpenOnArrow | ImGuiTreeNodeFlags.OpenOnDoubleClick | ImGuiTreeNodeFlags.SpanAvailWidth;
-
-        //private readonly Filter rootEntitiesWithTransformFilter;
-        //private readonly Filter rootEntitiesFilterBroken;
-        private readonly Filter rootEntitiesFilter;
-
-        private readonly EditorHierachySelectionSystem hierachySelectionSystem;
-
-        public EditorHierarchyWindow(World world) : base(world)
-        {
-            //rootEntitiesWithTransformFilter = FilterBuilder.Include<LocalTransform>().Exclude<Child>().Build();
-
-            // TODO: this doesn't work.
-            //rootEntitiesFilterBroken = FilterBuilder.Exclude<Child>().Build();
-
-            // Maybe the parent/child functions should add a root component when not being a child.
-            rootEntitiesFilter = FilterBuilder.Include<Root>().Build();
-
-            // Maybe instead of a root, if we need a component that is always on an entity and has some use we could create something like a VersionComponent which only hold an int.
-            // The version would update each time something changes on the entity.
-            // Or a EditorComponent, just a component that always gets added when in editor mode.
-
-            hierachySelectionSystem = new EditorHierachySelectionSystem(world);
-        }
-
-        public override void Update(TimeSpan delta)
-        {
-            ImGui.Begin("Hierarchy");
-
-            ImGuiTreeNodeFlags flags = baseFlags;
-            flags |= ImGuiTreeNodeFlags.DefaultOpen;
-
-            if (ImGui.TreeNodeEx("World", flags))
-            {
-                if (ImGui.BeginDragDropTarget())
-                {
-                    unsafe
-                    {
-                        ImGuiPayloadPtr payload = ImGui.AcceptDragDropPayload($"{nameof(EditorHierarchyWindow)}");
-                        if (payload.NativePtr != null)
-                        {
-                            Entity* data = (Entity*)payload.Data;
-                            Entity child = data[0];
-
-                            Log.Info($"Dropped {child.ID}");
-
-                            Transform.RemoveParent(World, child);
-                        }
-                    }
-                    ImGui.EndDragDropTarget();
-                }
-
-                //foreach (Entity entity in rootEntitiesWithTransformFilter.Entities)
-                //{
-                //    DrawEntityAndChildren(entity);
-                //}
-
-                foreach (Entity entity in rootEntitiesFilter.Entities)
-                {
-                    DrawEntityAndChildren(entity);
-                }
-
-                ImGui.TreePop();
-            }
-
-            ImGui.End();
-
-            hierachySelectionSystem.Update(delta);
-        }
-
-        private void DrawEntityAndChildren(in Entity entity)
-        {
-            ImGuiTreeNodeFlags flags = baseFlags;
-
-            if (!World.HasInRelation<ChildParentRelation>(entity))
-            {
-                flags |= ImGuiTreeNodeFlags.Leaf;
-            }
-
-            if (World.Has<SelectedInHierachy>(entity))
-            {
-                flags |= ImGuiTreeNodeFlags.Selected;
-            }
-
-            if (ImGui.TreeNodeEx($"{entity.ID} | {GetTag(entity)}", flags))
-            {
-                // TODO: fix selection, look at ImGui 1.91, https://github.com/ocornut/imgui/wiki/Multi-Select
-                // Selection.
-                if (ImGui.IsItemClicked() && !ImGui.IsItemToggledOpen())
-                {
-                    World.Set(entity, new ClickedInHierachy());
-                }
-
-                // Drag and drop.
-                if (ImGui.BeginDragDropSource())
-                {
-                    unsafe
-                    {
-                        fixed (Entity* payload = &entity)
-                        {
-                            ImGui.SetDragDropPayload($"{nameof(EditorHierarchyWindow)}", (IntPtr)payload, (uint)sizeof(Entity));
-                        }
-                    }
-
-                    ImGui.EndDragDropSource();
-                }
-
-                if (ImGui.BeginDragDropTarget())
-                {
-                    unsafe
-                    {
-                        ImGuiPayloadPtr payload = ImGui.AcceptDragDropPayload($"{nameof(EditorHierarchyWindow)}");
-                        if (payload.NativePtr != null)
-                        {
-                            Entity ent = *(Entity*)payload.Data;
-
-                            Log.Info($"Dropped {ent.ID}");
-
-                            Transform.SetParent(World, ent, entity);
-                        }
-                    }
-                    ImGui.EndDragDropTarget();
-                }
-
-                // Draw children.
-                ReverseSpanEnumerator<Entity> childEntities = World.InRelations<ChildParentRelation>(entity);
-                foreach (Entity childEntity in childEntities)
-                {
-                    DrawEntityAndChildren(childEntity);
-                }
-
-                ImGui.TreePop();
-            }
-        }
-
-        // System for handling the selected entities in the hierachy.
-        private class EditorHierachySelectionSystem : MoonTools.ECS.System
-        {
-            private readonly Filter selectedEntities;
-            private readonly Filter clickedEntities;
-
-            public EditorHierachySelectionSystem(World world) : base(world)
-            {
-                selectedEntities = FilterBuilder.Include<SelectedInHierachy>().Build();
-                clickedEntities = FilterBuilder.Include<ClickedInHierachy>().Build();
-            }
-
-            public override void Update(TimeSpan delta)
-            {
-                ImGuiIOPtr io = ImGui.GetIO();
-
-                if (!clickedEntities.Empty && !io.KeyCtrl)
-                {
-                    foreach (Entity entity in selectedEntities.Entities)
-                    {
-                        Remove<SelectedInHierachy>(entity);
-                    }
-                }
-
-                foreach (Entity entity in clickedEntities.Entities)
-                {
-                    // Unselect.
-                    if (Has<SelectedInHierachy>(entity))
-                    {
-                        Remove<SelectedInHierachy>(entity);
-                    }
-                    // Select.
-                    else
-                    {
-                        Set(entity, new SelectedInHierachy());
-                    }
-
-                    Remove<ClickedInHierachy>(entity);
-                }
-            }
-        }
-    }
-}

Nerfed.Editor/Systems/EditorInspectorWindow.cs

@@ -1,100 +0,0 @@
-using System.Numerics;
-using ImGuiNET;
-using MoonTools.ECS;
-using Nerfed.Editor.Components;
-using Nerfed.Runtime.Serialization;
-
-#if DEBUG
-namespace Nerfed.Editor.Systems
-{
-    // Window that draws entities.
-    internal class EditorInspectorWindow : MoonTools.ECS.DebugSystem
-    {
-        private readonly Filter selectedEntityFilter;
-
-        public EditorInspectorWindow(World world) : base(world)
-        {
-            selectedEntityFilter = FilterBuilder.Include<SelectedInHierachy>().Build();
-        }
-
-        public override void Update(TimeSpan delta)
-        {
-            ImGui.Begin("Inspector");
-
-            foreach (Entity entity in selectedEntityFilter.Entities)
-            {
-                DrawEntityComponents(entity);
-            }
-
-            ImGui.End();
-        }
-
-        private void DrawEntityComponents(Entity entity)
-        {
-            World.ComponentTypeEnumerator componentTypes = World.Debug_GetAllComponentTypes(entity);
-            
-            // Add button of all types that we can add. Also filter out types we already have.
-            List<Type> componentTypesToAdd = ComponentHelper.AddComponentByType.Keys.ToList();
-            foreach (Type componentType in componentTypes)
-            {
-                componentTypesToAdd.Remove(componentType);
-            }
-
-            const string popupId = "AddComponentPopup";
-            if (ImGui.Button("Add Component"))
-            {
-                ImGui.OpenPopup(popupId);
-            }
-
-            if (ImGui.BeginPopup(popupId))
-            {
-                foreach (Type componentType in componentTypesToAdd)
-                {
-                    if (ImGui.Selectable(componentType.Name))
-                    {
-                        if (ComponentHelper.AddComponentByType.TryGetValue(componentType, out Action<World, Entity> componentSetter))
-                        {
-                            componentSetter.Invoke(World, entity);
-                        }
-                    }
-                }
-                ImGui.EndPopup();
-            }
-
-            ImGui.Dummy(new Vector2(16, 16));
-            
-            ImGui.Text("ComponentInspectorByType");
-            foreach (Type componentType in componentTypes)
-            {
-                if (ComponentHelper.ComponentInspectorByType.TryGetValue(componentType, out Action<World, Entity> componentInspector))
-                {
-                    componentInspector(World, entity);
-                }
-                else if (ComponentHelper.GetComponentByType.TryGetValue(componentType, out Func<World, Entity, ValueType> componentGetter))
-                {
-                    ValueType component = componentGetter.Invoke(World, entity);
-                    ImGui.Text(component.ToString());
-                }
-                else
-                {
-                    ImGui.Text(componentType.Name);
-                }
-                ImGui.Separator();
-            }
-            
-            ImGui.Dummy(new Vector2(16, 16));
-
-            // ImGui.Text("Reflection");
-            // foreach (Type component in componentTypes)
-            // {
-            //     System.Reflection.MethodInfo getMethodInfo = typeof(World).GetMethod("Get");
-            //     System.Reflection.MethodInfo getComponentMethod = getMethodInfo.MakeGenericMethod(component);
-            //     object result = getComponentMethod.Invoke(World, [entity]);
-            //
-            //     // process here
-            //     ImGui.Text(result.ToString());
-            // }
-        }
-    }
-}
-#endif

Nerfed.Editor/Systems/EditorProfilerWindow.cs

@@ -1,204 +0,0 @@
-using ImGuiNET;
-using MoonTools.ECS;
-using Nerfed.Runtime;
-
-namespace Nerfed.Editor.Systems
-{
-    internal class EditorProfilerWindow : MoonTools.ECS.System
-    {
-        const ImGuiTableFlags tableFlags = ImGuiTableFlags.Resizable | ImGuiTableFlags.BordersOuter | ImGuiTableFlags.NoBordersInBody | ImGuiTableFlags.ScrollY | ImGuiTableFlags.ScrollX;
-        const ImGuiTreeNodeFlags treeNodeFlags = ImGuiTreeNodeFlags.SpanAllColumns;
-        const ImGuiTreeNodeFlags treeNodeLeafFlags = ImGuiTreeNodeFlags.SpanAllColumns | ImGuiTreeNodeFlags.Leaf | ImGuiTreeNodeFlags.NoTreePushOnOpen;
-
-        private int selectedFrame = 0;
-        private int previousSelectedFrame = -1;
-        private IOrderedEnumerable<KeyValuePair<string, (double ms, uint calls)>> orderedCombinedData = null;
-
-        public EditorProfilerWindow(World world) : base(world)
-        {
-        }
-
-        public override void Update(TimeSpan delta)
-        {
-            if (Profiler.Frames.Count <= 0)
-            {
-                return;
-            }
-
-            ImGui.Begin("Profiler");
-
-            ImGui.BeginChild("Toolbar", new System.Numerics.Vector2(0, 0), ImGuiChildFlags.AutoResizeY);
-            if (ImGui.RadioButton("Recording", Profiler.IsRecording))
-            {
-                Profiler.SetActive(!Profiler.IsRecording);
-            }
-
-            ImGui.SameLine();
-
-            if (Profiler.IsRecording)
-            {
-                // Select last frame when recording to see latest frame data.
-                selectedFrame = Profiler.Frames.Count - 1;
-            }
-            if (ImGui.SliderInt(string.Empty, ref selectedFrame, 0, Profiler.Frames.Count - 1))
-            {
-                // Stop recording when browsing frames.
-                Profiler.SetActive(false);
-            }
-
-            Profiler.Frame frame = Profiler.Frames.ElementAt(selectedFrame);
-            double ms = frame.ElapsedMilliseconds();
-            double s = 1000;
-            ImGui.Text($"Frame: {frame.FrameCount} ({ms:0.000} ms | {(s / ms):0} fps)");
-            ImGui.EndChild();
-
-            if (!Profiler.IsRecording) {
-                if (previousSelectedFrame != selectedFrame)
-                {
-                    previousSelectedFrame = selectedFrame;
-                    orderedCombinedData = CalculateCombinedData(frame);
-                }
-
-                DrawFlameGraph(frame);
-
-                DrawHierachy(frame);
-
-                ImGui.SameLine();
-
-                DrawCombined(orderedCombinedData);
-            }
-
-            ImGui.End();
-        }
-
-        private static void DrawHierachy(Profiler.Frame frame)
-        {
-            if(frame == null)
-            {
-                return;
-            }
-
-            ImGui.BeginChild("Hierachy", new System.Numerics.Vector2(150, 0), ImGuiChildFlags.ResizeX);
-
-            if (ImGui.BeginTable("ProfilerData", 3, tableFlags, new System.Numerics.Vector2(0, 0)))
-            {
-                ImGui.TableSetupColumn("name", ImGuiTableColumnFlags.WidthStretch, 0.8f, 0);
-                ImGui.TableSetupColumn("thread", ImGuiTableColumnFlags.WidthStretch, 0.2f, 1);
-                ImGui.TableSetupColumn("ms", ImGuiTableColumnFlags.WidthStretch, 0.2f, 1);
-                ImGui.TableSetupScrollFreeze(0, 1); // Make row always visible
-                ImGui.TableHeadersRow();
-
-                foreach (Profiler.ScopeNode node in frame.RootNodes)
-                {
-                    DrawHierachyNode(node);
-                }
-
-                ImGui.EndTable();
-            }
-
-            ImGui.EndChild();
-        }
-
-        private static void DrawHierachyNode(Profiler.ScopeNode node)
-        {
-            ImGui.TableNextRow();
-            ImGui.TableNextColumn();
-
-            bool isOpen = false;
-            bool isLeaf = node.Children.Count == 0;
-
-            if (isLeaf) {
-                ImGui.TreeNodeEx(node.Label, treeNodeLeafFlags);
-            }
-            else
-            {
-                isOpen = ImGui.TreeNodeEx(node.Label, treeNodeFlags);
-            }
-
-            ImGui.TableNextColumn();
-            ImGui.Text($"{node.ManagedThreadId}");
-            ImGui.TableNextColumn();
-            ImGui.Text($"{node.ElapsedMilliseconds():0.000}");
-
-            if (isOpen)
-            {
-                for (int i = 0; i < node.Children.Count; i++)
-                {
-                    DrawHierachyNode(node.Children[i]);
-                }
-                ImGui.TreePop();
-            }
-        }
-
-        private static void DrawCombined(in IOrderedEnumerable<KeyValuePair<string, (double ms, uint calls)>> orderedCombinedData)
-        {
-            if(orderedCombinedData == null)
-            {
-                return;
-            }
-
-            ImGui.BeginChild("Combined", new System.Numerics.Vector2(0, 0));
-
-            if (ImGui.BeginTable("ProfilerCombinedData", 3, tableFlags, new System.Numerics.Vector2(0, 0)))
-            {
-                ImGui.TableSetupColumn("name", ImGuiTableColumnFlags.WidthStretch, 0.6f, 0);
-                ImGui.TableSetupColumn("ms", ImGuiTableColumnFlags.WidthStretch, 0.2f, 1);
-                ImGui.TableSetupColumn("calls", ImGuiTableColumnFlags.WidthStretch, 0.2f, 2);
-                ImGui.TableSetupScrollFreeze(0, 1); // Make row always visible
-                ImGui.TableHeadersRow();
-
-                foreach (KeyValuePair<string, (double ms, uint calls)> combinedData in orderedCombinedData)
-                {
-                    ImGui.TableNextRow();
-                    ImGui.TableNextColumn();
-                    ImGui.Text($"{combinedData.Key}");
-                    ImGui.TableNextColumn();
-                    ImGui.Text($"{combinedData.Value.ms:0.000}");
-                    ImGui.TableNextColumn();
-                    ImGui.Text($"{combinedData.Value.calls}");
-                }
-
-                ImGui.EndTable();
-            }
-
-            ImGui.EndChild();
-        }
-
-        private static IOrderedEnumerable<KeyValuePair<string, (double ms, uint calls)>> CalculateCombinedData(Profiler.Frame frame)
-        {
-            Dictionary<string, (double ms, uint calls)> combinedRecordData = new Dictionary<string, (double ms, uint calls)>(128);
-            foreach (Profiler.ScopeNode node in frame.RootNodes)
-            {
-                CalculateCombinedData(node, in combinedRecordData);
-            }
-            return combinedRecordData.OrderByDescending(x => x.Value.ms);
-        }
-
-        private static void CalculateCombinedData(Profiler.ScopeNode node, in Dictionary<string, (double ms, uint calls)> combinedRecordData)
-        {
-            if (combinedRecordData.TryGetValue(node.Label, out (double ms, uint calls) combined))
-            {
-                combinedRecordData[node.Label] = (combined.ms + node.ElapsedMilliseconds(), combined.calls + 1);
-            }
-            else
-            {
-                combinedRecordData.Add(node.Label, (node.ElapsedMilliseconds(), 1));
-            }
-
-            for (int i = 0; i < node.Children.Count; i++)
-            {
-                CalculateCombinedData(node.Children[i], combinedRecordData);
-            }
-        }
-
-        private static void DrawFlameGraph(Profiler.Frame frame)
-        {
-            if (frame == null)
-            {
-                return;
-            }
-
-            ProfilerVisualizer.RenderFlameGraph(frame);
-        }
-    }
-}

Nerfed.Runtime.Generator/HookSourceGenerator.cs

@@ -0,0 +1,91 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nerfed.Runtime.Generator
+{
+    [Generator]
+    public class HookSourceGenerator : ISourceGenerator
+    {
+        public void Execute(GeneratorExecutionContext context)
+        {
+            // Ensure the syntax receiver is not null and is of the expected type
+            if (context.SyntaxReceiver is not HookSyntaxReceiver syntaxReceiver)
+                return;
+
+            // Check if we have collected any hook methods
+            List<MethodDeclarationSyntax> hookMethods = syntaxReceiver.HookMethods;
+            if (hookMethods == null || !hookMethods.Any())
+                return;
+
+            StringBuilder codeBuilder = new StringBuilder();
+
+            codeBuilder.AppendLine("using System;");
+            codeBuilder.AppendLine("");
+            codeBuilder.AppendLine("namespace Nerfed.Runtime.Generator;");
+            codeBuilder.AppendLine("");
+            codeBuilder.AppendLine($"// Generated by {typeof(HookSourceGenerator)}");
+            codeBuilder.AppendLine("public static class Hook");
+            codeBuilder.AppendLine("{");
+            codeBuilder.AppendLine("    public static void InvokeHooks()");
+            codeBuilder.AppendLine("    {");
+
+            foreach (MethodDeclarationSyntax method in hookMethods)
+            {
+                SemanticModel model = context.Compilation.GetSemanticModel(method.SyntaxTree);
+
+                if (model.GetDeclaredSymbol(method) is not IMethodSymbol methodSymbol)
+                {
+                    continue;
+                }
+
+                if (methodSymbol.DeclaredAccessibility != Accessibility.Public || !methodSymbol.IsStatic)
+                {
+                    continue;
+                }
+
+                codeBuilder.AppendLine($"        {methodSymbol.ContainingType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}.{methodSymbol.Name}();");
+            }
+
+            codeBuilder.AppendLine("    }");
+            codeBuilder.AppendLine("}");
+
+            // Add the generated code to the compilation
+            context.AddSource("Hook.g.cs", codeBuilder.ToString());
+        }
+
+
+        public void Initialize(GeneratorInitializationContext context)
+        {
+            context.RegisterForSyntaxNotifications(() => new HookSyntaxReceiver());
+        }
+
+        public class HookSyntaxReceiver : ISyntaxReceiver
+        {
+            public List<MethodDeclarationSyntax> HookMethods { get; } = new List<MethodDeclarationSyntax>();
+
+            public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
+            {
+                // Check if the node is a method declaration
+                if (syntaxNode is MethodDeclarationSyntax methodDeclaration)
+                {
+                    // Ensure the method declaration has attribute lists
+                    if (methodDeclaration.AttributeLists.Count == 0)
+                        return;
+
+                    // Check if the method has the Hook attribute
+                    bool hasHookAttribute = methodDeclaration.AttributeLists
+                        .SelectMany(attrList => attrList.Attributes)
+                        .Any(attr => attr.Name.ToString() == "Hook");
+
+                    if (hasHookAttribute)
+                    {
+                        HookMethods.Add(methodDeclaration);
+                    }
+                }
+            }
+        }
+    }
+}

Nerfed.Runtime.Generator/Nerfed.Runtime.Generator.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>netstandard2.0</TargetFramework>
+		<LangVersion>latest</LangVersion>
+		<EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+		<Configurations>Debug;Test;Release</Configurations>
+		<Platforms>x64</Platforms>
+	</PropertyGroup>
+
+	<ItemGroup>
+	  <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	  <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.11.0"/>
+	</ItemGroup>
+
+	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+		<DefineConstants>TRACE;LOG_INFO;PROFILING</DefineConstants>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Test|x64' ">
+		<DefineConstants>TRACE;LOG_ERROR;PROFILING</DefineConstants>
+		<Optimize>true</Optimize>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+		<DefineConstants>TRACE;LOG_ERROR</DefineConstants>
+		<Optimize>true</Optimize>
+	</PropertyGroup>
+	
+</Project>

Nerfed.Runtime/Components/LocalToWorld.cs

@@ -1,6 +0,0 @@
-using System.Numerics;
-
-namespace Nerfed.Runtime.Components
-{
-    public readonly record struct LocalToWorld(Matrix4x4 localToWorldMatrix);
-}

Nerfed.Runtime/Components/LocalTransform.cs

@@ -1,11 +0,0 @@
-using System.Numerics;
-using Nerfed.Runtime.Scene;
-
-namespace Nerfed.Runtime.Components
-{
-    [SceneComponent]
-    public readonly record struct LocalTransform(Vector3 position, Quaternion rotation, Vector3 scale)
-    {
-        public static readonly LocalTransform Identity = new(Vector3.Zero, Quaternion.Identity, Vector3.One);
-    }
-}

Nerfed.Runtime/Components/Parent.cs

@@ -1,11 +0,0 @@
-using MoonTools.ECS;
-
-namespace Nerfed.Runtime.Components
-{
-    public readonly record struct Root;
-    //public readonly record struct Parent;
-    //public readonly record struct PreviousParent;
-    public readonly record struct Child;
-    // Describes a relation from the child to the parent.
-    public readonly record struct ChildParentRelation;
-}

Nerfed.Runtime/Components/Test.cs

@@ -1,7 +0,0 @@
-using Nerfed.Runtime.Scene;
-
-namespace Nerfed.Runtime.Components
-{
-    [SceneComponent]
-    public readonly record struct Test();
-}

Nerfed.Runtime/Engine.cs

@@ -16,7 +16,7 @@ public static class Engine
     public static bool VSync { get; set; }
 
     public static GraphicsDevice GraphicsDevice { get; private set; }
-    //public static AudioDevice AudioDevice { get; private set; }
+    public static AudioDevice AudioDevice { get; private set; }
     public static Window MainWindow { get; private set; }
     public static TimeSpan Timestep { get; private set; }
 
@@ -44,16 +44,19 @@ public static class Engine
     private const string WindowTitle = "Nerfed";
     //..
 
-    public static void Run(string[] args) {
+    public static void Run(string[] args)
+    {
         Timestep = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / TargetTimestep);
         gameTimer = Stopwatch.StartNew();
         SetFrameLimiter(new FrameLimiterSettings(FrameLimiterMode.Capped, MaxFps));
 
-        for(int i = 0; i < previousSleepTimes.Length; i += 1) {
+        for (int i = 0; i < previousSleepTimes.Length; i += 1)
+        {
             previousSleepTimes[i] = TimeSpan.FromMilliseconds(1);
         }
 
-        if(SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_TIMER | SDL.SDL_INIT_GAMECONTROLLER) < 0) {
+        if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_TIMER | SDL.SDL_INIT_GAMECONTROLLER) < 0)
+        {
             throw new Exception("Failed to init SDL");
         }
         
@@ -61,15 +64,18 @@ public static class Engine
         GraphicsDevice.LoadDefaultPipelines();
 
         MainWindow = new Window(GraphicsDevice, new WindowCreateInfo(WindowTitle, WindowWidth, WindowHeight, ScreenMode.Windowed));
-        if(!GraphicsDevice.ClaimWindow(MainWindow, SwapchainComposition.SDR, VSync ? PresentMode.VSync : PresentMode.Mailbox)) {
+        if (!GraphicsDevice.ClaimWindow(MainWindow, SwapchainComposition.SDR, VSync ? PresentMode.VSync : PresentMode.Mailbox))
+        {
             throw new Exception("Failed to claim window");
         }
 
-        //AudioDevice = new AudioDevice();
+        AudioDevice = new AudioDevice();
 
         OnInitialize?.Invoke();
+        Nerfed.Runtime.Generator.Hook.InvokeHooks();
 
-        while(!quit) {
+        while (!quit)
+        {
             Tick();
         }
 
@@ -78,41 +84,45 @@ public static class Engine
         GraphicsDevice.UnclaimWindow(MainWindow);
         MainWindow.Dispose();
         GraphicsDevice.Dispose();
-        //AudioDevice.Dispose();
+        AudioDevice.Dispose();
         SDL.SDL_Quit();
     }
 
     /// <summary>
     /// Updates the frame limiter settings.
     /// </summary>
-    public static void SetFrameLimiter(FrameLimiterSettings settings) {
+    public static void SetFrameLimiter(FrameLimiterSettings settings)
+    {
         framerateCapped = settings.Mode == FrameLimiterMode.Capped;
 
-        if(framerateCapped) {
+        if (framerateCapped)
+        {
             framerateCapTimeSpan = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / settings.Cap);
-        } else {
+        }
+        else
+        {
             framerateCapTimeSpan = TimeSpan.Zero;
         }
     }
 
-    public static void Quit() {
+    public static void Quit()
+    {
         quit = true;
     }
 
-    private static void Tick() {
+    private static void Tick()
-        Profiler.BeginFrame();
+    {
-
         AdvanceElapsedTime();
 
-        if(framerateCapped) {
+        if (framerateCapped)
-            Profiler.BeginSample("framerateCapped");
+        {
-
             /* We want to wait until the framerate cap,
              * but we don't want to oversleep. Requesting repeated 1ms sleeps and
              * seeing how long we actually slept for lets us estimate the worst case
              * sleep precision so we don't oversleep the next frame.
              */
-            while(accumulatedDrawTime + worstCaseSleepPrecision < framerateCapTimeSpan) {
+            while (accumulatedDrawTime + worstCaseSleepPrecision < framerateCapTimeSpan)
+            {
                 Thread.Sleep(1);
                 TimeSpan timeAdvancedSinceSleeping = AdvanceElapsedTime();
                 UpdateEstimatedSleepPrecision(timeAdvancedSinceSleeping);
@@ -123,22 +133,23 @@ public static class Engine
              * SpinWait(1) works by pausing the thread for very short intervals, so it is
              * an efficient and time-accurate way to wait out the rest of the time.
              */
-            while(accumulatedDrawTime < framerateCapTimeSpan) {
+            while (accumulatedDrawTime < framerateCapTimeSpan)
+            {
                 Thread.SpinWait(1);
                 AdvanceElapsedTime();
             }
-
-            Profiler.EndSample();
         }
 
         // Do not let any step take longer than our maximum.
-        if(accumulatedUpdateTime > MaxDeltaTime) {
+        if (accumulatedUpdateTime > MaxDeltaTime)
+        {
             accumulatedUpdateTime = MaxDeltaTime;
         }
 
-        if(!quit) {
+        if (!quit)
-            while(accumulatedUpdateTime >= Timestep) {
+        {
-                Profiler.BeginSample("Update");
+            while (accumulatedUpdateTime >= Timestep)
+            {
                 Keyboard.Update();
                 Mouse.Update();
                 GamePad.Update();
@@ -146,29 +157,23 @@ public static class Engine
                 ProcessSDLEvents();
 
                 // Tick game here...
-                Profiler.BeginSample("OnUpdate");
                 OnUpdate?.Invoke();
-                Profiler.EndSample();
 
-                //AudioDevice.WakeThread();
+                AudioDevice.WakeThread();
                 accumulatedUpdateTime -= Timestep;
-                Profiler.EndSample();
             }
 
             double alpha = accumulatedUpdateTime / Timestep;
 
             // Render here..
-            Profiler.BeginSample("OnRender");
             OnRender?.Invoke();
-            Profiler.EndSample();
 
             accumulatedDrawTime -= framerateCapTimeSpan;
         }
-
-        Profiler.EndFrame();
     }
 
-    private static TimeSpan AdvanceElapsedTime() {
+    private static TimeSpan AdvanceElapsedTime()
+    {
         long currentTicks = gameTimer.Elapsed.Ticks;
         TimeSpan timeAdvanced = TimeSpan.FromTicks(currentTicks - previousTicks);
         accumulatedUpdateTime += timeAdvanced;
@@ -177,9 +182,12 @@ public static class Engine
         return timeAdvanced;
     }
 
-    private static void ProcessSDLEvents() {
+    private static void ProcessSDLEvents()
-        while(SDL.SDL_PollEvent(out SDL.SDL_Event ev) == 1) {
+    {
-            switch(ev.type) {
+        while (SDL.SDL_PollEvent(out SDL.SDL_Event ev) == 1)
+        {
+            switch (ev.type)
+            {
                 case SDL.SDL_EventType.SDL_QUIT:
                     Quit();
                     break;
@@ -215,14 +223,16 @@ public static class Engine
     /* To calculate the sleep precision of the OS, we take the worst case
      * time spent sleeping over the results of previous requests to sleep 1ms.
      */
-    private static void UpdateEstimatedSleepPrecision(TimeSpan timeSpentSleeping) {
+    private static void UpdateEstimatedSleepPrecision(TimeSpan timeSpentSleeping)
+    {
         /* It is unlikely that the scheduler will actually be more imprecise than
          * 4ms and we don't want to get wrecked by a single long sleep so we cap this
          * value at 4ms for sanity.
          */
         TimeSpan upperTimeBound = TimeSpan.FromMilliseconds(4);
 
-        if(timeSpentSleeping > upperTimeBound) {
+        if (timeSpentSleeping > upperTimeBound)
+        {
             timeSpentSleeping = upperTimeBound;
         }
 
@@ -231,12 +241,17 @@ public static class Engine
          * is if we either 1) just got a new worst case, or 2) the worst case was
          * the oldest entry on the list.
          */
-        if(timeSpentSleeping >= worstCaseSleepPrecision) {
+        if (timeSpentSleeping >= worstCaseSleepPrecision)
+        {
             worstCaseSleepPrecision = timeSpentSleeping;
-        } else if(previousSleepTimes[sleepTimeIndex] == worstCaseSleepPrecision) {
+        }
+        else if (previousSleepTimes[sleepTimeIndex] == worstCaseSleepPrecision)
+        {
             TimeSpan maxSleepTime = TimeSpan.MinValue;
-            for(int i = 0; i < previousSleepTimes.Length; i++) {
+            for (int i = 0; i < previousSleepTimes.Length; i++)
-                if(previousSleepTimes[i] > maxSleepTime) {
+            {
+                if (previousSleepTimes[i] > maxSleepTime)
+                {
                     maxSleepTime = previousSleepTimes[i];
                 }
             }

Nerfed.Runtime/Graphics/GraphicsDevice.cs

@@ -68,10 +68,10 @@ public class GraphicsDevice : IDisposable
 
     internal void LoadDefaultPipelines()
     {
-        FullscreenVertexShader = ResourceManager.Retain<Shader>("Shaders/Fullscreen.vert");
+        FullscreenVertexShader = ResourceManager.Load<Shader>("Shaders/Fullscreen.vert");
-        VideoFragmentShader = ResourceManager.Retain<Shader>("Shaders/Video.frag");
+        VideoFragmentShader = ResourceManager.Load<Shader>("Shaders/Video.frag");
-        TextVertexShader = ResourceManager.Retain<Shader>("Shaders/Text.vert");
+        TextVertexShader = ResourceManager.Load<Shader>("Shaders/Text.vert");
-        TextFragmentShader = ResourceManager.Retain<Shader>("Shaders/Text.frag");
+        TextFragmentShader = ResourceManager.Load<Shader>("Shaders/Text.frag");
 
         VideoPipeline = new GraphicsPipeline(
             this,
@@ -373,10 +373,10 @@ public class GraphicsDevice : IDisposable
                     resources.Clear();
                 }
 
-                ResourceManager.Release(FullscreenVertexShader);
+                ResourceManager.Unload(FullscreenVertexShader);
-                ResourceManager.Release(TextFragmentShader);
+                ResourceManager.Unload(TextFragmentShader);
-                ResourceManager.Release(TextVertexShader);
+                ResourceManager.Unload(TextVertexShader);
-                ResourceManager.Release(VideoFragmentShader);
+                ResourceManager.Unload(VideoFragmentShader);
             }
 
             Refresh.Refresh_DestroyDevice(Handle);

Nerfed.Runtime/Gui/GuiController.cs

@@ -60,8 +60,8 @@ public class GuiController : IDisposable
         io.DisplaySize = new Vector2(mainWindow.Width, mainWindow.Height);
         io.DisplayFramebufferScale = Vector2.One;
 
-        imGuiVertexShader = ResourceManager.Retain<Shader>("Shaders/ImGui.vert");
+        imGuiVertexShader = ResourceManager.Load<Shader>("Shaders/ImGui.vert");
-        imGuiFragmentShader = ResourceManager.Retain<Shader>("Shaders/ImGui.frag");
+        imGuiFragmentShader = ResourceManager.Load<Shader>("Shaders/ImGui.frag");
 
         imGuiSampler = new Sampler(graphicsDevice, SamplerCreateInfo.LinearClamp);
 
@@ -630,8 +630,8 @@ public class GuiController : IDisposable
         fontTexture?.Dispose();
         imGuiVertexBuffer?.Dispose();
         imGuiIndexBuffer?.Dispose();
-        ResourceManager.Release(imGuiVertexShader);
+        ResourceManager.Unload(imGuiVertexShader);
-        ResourceManager.Release(imGuiFragmentShader);
+        ResourceManager.Unload(imGuiFragmentShader);
         imGuiPipeline?.Dispose();
         imGuiSampler?.Dispose();
         resourceUploader?.Dispose();

Nerfed.Runtime/Hook/HookAttribute.cs

@@ -0,0 +1,7 @@
+namespace Nerfed.Runtime.Hook
+{
+    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
+    public class HookAttribute : Attribute
+    {
+    }
+}

Nerfed.Runtime/Hook/HookTest.cs

@@ -0,0 +1,11 @@
+namespace Nerfed.Runtime.Hook
+{
+    public static class HookTest
+    {
+        [Hook]
+        public static void Test()
+        {
+            Log.Info("Hook!");
+        }
+    }
+}

Nerfed.Runtime/Nerfed.Runtime.csproj

@@ -11,6 +11,7 @@
         <IsPackable>false</IsPackable>
         <Configurations>Debug;Test;Release</Configurations>
         <Platforms>x64</Platforms>
+		<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     </PropertyGroup>
 
     <PropertyGroup>
@@ -32,13 +33,18 @@
     </PropertyGroup>
     
     <ItemGroup>
-        <Compile Include="Libraries\FAudio\csharp\FAudio.cs" />
-        <Compile Include="Libraries\ImGui.NET\src\ImGui.NET\**\*.cs" />
-        <Compile Include="Libraries\MoonTools.ECS\src\**\*.cs" />
-        <Compile Include="Libraries\RefreshCS\RefreshCS.cs" />
         <Compile Include="Libraries\SDL2CS\src\SDL2.cs" />
+        <Compile Include="Libraries\RefreshCS\RefreshCS.cs" />
+        <Compile Include="Libraries\FAudio\csharp\FAudio.cs" />
         <Compile Include="Libraries\WellspringCS\WellspringCS.cs" />
         <Compile Include="Libraries\dav1dfile\csharp\dav1dfile.cs" />
+        <Compile Include="Libraries\ImGui.NET\src\ImGui.NET\**\*.cs" />
+    </ItemGroup>
+    
+    <ItemGroup>
+      <ProjectReference Include="..\Nerfed.Runtime.Generator\Nerfed.Runtime.Generator.csproj"
+						OutputItemType="Analyzer"
+						ReferenceOutputAssembly="false" />
     </ItemGroup>
     
 </Project>

Nerfed.Runtime/Profiler.cs

@@ -1,166 +1,29 @@
-using System.Collections.Concurrent;
+using System.Diagnostics;
-using System.Diagnostics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
 
 namespace Nerfed.Runtime;
 
 public struct ProfilerScope : IDisposable
 {
-    public ProfilerScope(string label)
+    public ProfilerScope(string label) {
-    {
         Profiler.BeginSample(label);
     }
 
-    public void Dispose()
+    public void Dispose() {
-    {
         Profiler.EndSample();
     }
 }
 
 public static class Profiler
 {
-    public class Frame(uint frameCount)
+    [Conditional("PROFILING")]
-    {
+    public static void BeginSample(string label) {
-        public uint FrameCount { get; } = frameCount;
-        public long StartTime { get; } = Stopwatch.GetTimestamp();
-        public long EndTime { get; private set; }
 
-        // Use a concurrent list to collect all thread root nodes per frame.
-        public ConcurrentBag<ScopeNode> RootNodes = new ConcurrentBag<ScopeNode>();
-
-        internal void End()
-        {
-            EndTime = Stopwatch.GetTimestamp();
-        }
-
-        public double ElapsedMilliseconds()
-        {
-            long elapsedTicks = EndTime - StartTime;
-            return ((double)(elapsedTicks * 1000)) / Stopwatch.Frequency;
-        }
-    }
-
-    public class ScopeNode(string label)
-    {
-        public string Label { get; } = label;
-        public long StartTime { get; private set; } = Stopwatch.GetTimestamp();  // Start time in ticks
-        public long EndTime { get; private set; }
-        public int ManagedThreadId { get; } = Environment.CurrentManagedThreadId;
-        public List<ScopeNode> Children { get; } = new List<ScopeNode>();
-
-        internal void End()
-        {
-            EndTime = Stopwatch.GetTimestamp();  // End time in ticks
-        }
-
-        public double ElapsedMilliseconds()
-        {
-            return ((double)(EndTime - StartTime)) * 1000 / Stopwatch.Frequency;  // Convert ticks to ms
-        }
-
-        // Add a child node (used for nested scopes)
-        internal ScopeNode AddChild(string label)
-        {
-            ScopeNode child = new ScopeNode(label);
-            Children.Add(child);
-            return child;
-        }
-    }
-
-    private const int maxFrames = 128;
-
-    public static bool IsRecording { get; private set; } = true;
-
-    // Store only the last x amount of frames in memory.
-    public static readonly BoundedQueue<Frame> Frames = new(maxFrames);
-
-    // Use ThreadLocal to store a stack of ScopeNodes per thread and enable tracking of thread-local values.
-    private static readonly ThreadLocal<Stack<ScopeNode>> threadLocalScopes = new ThreadLocal<Stack<ScopeNode>>(() => new Stack<ScopeNode>(), true);
-
-    private static Frame currentFrame = null;
-    private static uint frameCount = 0;
-
-    public static void SetActive(bool isRecording)
-    {
-        IsRecording = isRecording;
     }
 
     [Conditional("PROFILING")]
-    public static void BeginFrame()
+    public static void EndSample() {
-    {
-        if (!IsRecording)
-        {
-            return;
-        }
 
-        currentFrame = new Frame(frameCount);
-    }
-
-    [Conditional("PROFILING")]
-    public static void EndFrame()
-    {
-        if (!IsRecording)
-        {
-            return;
-        }
-
-        foreach (Stack<ScopeNode> scopes in threadLocalScopes.Values)
-        {
-            if (scopes.Count > 0)
-            {
-                // Pop the left over root nodes.
-                ScopeNode currentScope = scopes.Pop();
-                currentScope.End();
-            }
-
-            // Clean up the thread-local stack to ensure it's empty for the next frame.
-            scopes.Clear();
-        }
-
-        currentFrame.End();
-        Frames.Enqueue(currentFrame);
-        frameCount++;
-    }
-
-    [Conditional("PROFILING")]
-    public static void BeginSample(string label)
-    {
-        if (!IsRecording)
-        {
-            return;
-        }
-
-        Stack<ScopeNode> scopes = threadLocalScopes.Value;  // Get the stack for the current thread
-
-        if (scopes.Count == 0)
-        {
-            // First scope for this thread (new root for this thread)
-            ScopeNode rootScopeNode = new ScopeNode($"Thread-{Environment.CurrentManagedThreadId}");
-            scopes.Push(rootScopeNode);
-            currentFrame.RootNodes.Add(rootScopeNode);  // Add root node to the frame list
-        }
-
-        // Create a new child under the current top of the stack
-        ScopeNode newScope = scopes.Peek().AddChild(label);
-
-        scopes.Push(newScope);  // Push new scope to the thread's stack
-    }
-
-    [Conditional("PROFILING")]
-    public static void EndSample()
-    {
-        if (!IsRecording)
-        {
-            return;
-        }
-
-        Stack<ScopeNode> scopes = threadLocalScopes.Value;
-
-        if (scopes.Count > 0)
-        {
-            // Only pop if this is not the root node.
-            //ScopeNode currentScope = scopes.Count > 1 ? scopes.Pop() : scopes.Peek();
-            ScopeNode currentScope = scopes.Pop();
-            currentScope.End();
-        }
     }
 }

Nerfed.Runtime/ProfilerVisualizer.cs

@@ -1,156 +0,0 @@
-using ImGuiNET;
-using System.Numerics;
-
-namespace Nerfed.Runtime;
-
-public static class ProfilerVisualizer
-{
-    private const float barHeight = 20f;
-    private const float barPadding = 2f;
-
-    // Render the flame graph across multiple threads
-    public static void RenderFlameGraph(Profiler.Frame frame)
-    {
-        if (frame == null) return;
-        if (frame.RootNodes == null) return;
-
-        // Calculate the total timeline duration (max end time across all nodes)
-        double totalDuration = frame.EndTime - frame.StartTime;
-        double startTime = frame.StartTime;
-
-        // Precompute the maximum depth for each thread's call stack
-        Dictionary<int, int> threadMaxDepths = new Dictionary<int, int>();
-        foreach (IGrouping<int, Profiler.ScopeNode> threadGroup in frame.RootNodes.GroupBy(node => node.ManagedThreadId))
-        {
-            int maxDepth = 0;
-            foreach (Profiler.ScopeNode rootNode in threadGroup)
-            {
-                maxDepth = Math.Max(maxDepth, GetMaxDepth(rootNode, 0));
-            }
-            threadMaxDepths[threadGroup.Key] = maxDepth;
-        }
-
-        // Start a child window to support scrolling
-        ImGui.BeginChild("FlameGraph", new Vector2(0, 64), ImGuiChildFlags.Border | ImGuiChildFlags.ResizeY, ImGuiWindowFlags.HorizontalScrollbar | ImGuiWindowFlags.AlwaysVerticalScrollbar);
-
-        ImDrawListPtr drawList = ImGui.GetWindowDrawList();
-        Vector2 windowPos = ImGui.GetCursorScreenPos();
-
-        // Sort nodes by ThreadID, ensuring main thread (Thread ID 1) is on top
-        IOrderedEnumerable<IGrouping<int, Profiler.ScopeNode>> threadGroups = frame.RootNodes.GroupBy(node => node.ManagedThreadId).OrderBy(g => g.Key);
-
-        // Initial Y position for drawing
-        float baseY = windowPos.Y;
-        bool alternate = false;
-        float contentWidth = ImGui.GetContentRegionAvail().X;
-
-        // Draw each thread's flame graph row by row
-        foreach (IGrouping<int, Profiler.ScopeNode> threadGroup in threadGroups)
-        {
-            int threadId = threadGroup.Key;
-
-            // Compute the base Y position for this thread
-            float threadBaseY = baseY;
-
-            // Calculate the maximum height for this thread's flame graph
-            float threadHeight = (threadMaxDepths[threadId] + 1) * (barHeight + barPadding);
-
-            // Draw the alternating background for each thread row
-            uint backgroundColor = ImGui.ColorConvertFloat4ToU32(alternate ? new Vector4(0.2f, 0.2f, 0.2f, 1f) : new Vector4(0.1f, 0.1f, 0.1f, 1f));
-            drawList.AddRectFilled(new Vector2(windowPos.X, threadBaseY), new Vector2(windowPos.X + contentWidth, threadBaseY + threadHeight), backgroundColor);
-
-            alternate = !alternate;
-
-            // Draw each root node in the group (one per thread)
-            foreach (Profiler.ScopeNode rootNode in threadGroup)
-            {
-                RenderNode(drawList, rootNode, startTime, totalDuration, windowPos.X, threadBaseY, 0, contentWidth, false);
-            }
-
-            // Move to the next thread's row (max depth * height per level)
-            baseY += (threadMaxDepths[threadId] + 1) * (barHeight + barPadding);
-        }
-
-        // Ensure that ImGui knows the size of the content.
-        ImGui.Dummy(new Vector2(contentWidth, baseY));
-
-        ImGui.EndChild();
-    }
-
-    private static void RenderNode(ImDrawListPtr drawList, Profiler.ScopeNode node, double startTime, double totalDuration, float startX, float baseY, int depth, float contentWidth, bool alternate)
-    {
-        if (node == null) return;
-
-        double nodeStartTime = node.StartTime - startTime;
-        double nodeEndTime = node.EndTime - startTime;
-        double nodeDuration = nodeEndTime - nodeStartTime;
-
-        // Calculate the position and width of the bar based on time
-        float xPos = (float)(startX + (nodeStartTime / totalDuration) * contentWidth);
-        float width = (float)((nodeDuration / totalDuration) * contentWidth);
-
-        // Calculate the Y position based on depth
-        float yPos = baseY + (depth * (barHeight + barPadding)) + (barPadding * 0.5f);
-
-        // Define the rectangle bounds for the node
-        Vector2 min = new Vector2(xPos, yPos);
-        Vector2 max = new Vector2(xPos + width, yPos + barHeight);
-
-        // Define color.
-        Vector4 barColor = alternate ? new Vector4(0.4f, 0.6f, 0.9f, 1f) : new Vector4(0.4f, 0.5f, 0.8f, 1f);
-        Vector4 textColor = new Vector4(1f, 1f, 1f, 1f);
-
-        if (depth != 0)
-        {
-            // Draw the bar for the node (colored based on thread depth)
-            drawList.AddRectFilled(min, max, ImGui.ColorConvertFloat4ToU32(barColor));
-
-            // Draw the label if it fits inside the bar
-            string label = $"{node.Label} ({node.ElapsedMilliseconds():0.000} ms)";
-            if (width > ImGui.CalcTextSize(label).X)
-            {
-                drawList.AddText(new Vector2(xPos + barPadding, yPos + barPadding), ImGui.ColorConvertFloat4ToU32(textColor), label);
-            }
-
-            // Add tooltip on hover
-            if (ImGui.IsMouseHoveringRect(min, max))
-            {
-                // Show tooltip when hovering over the node
-                ImGui.BeginTooltip();
-                ImGui.Text($"{node.Label}");
-                ImGui.Text($"{node.ElapsedMilliseconds():0.000} ms");
-                ImGui.Text($"{node.ManagedThreadId}");
-                ImGui.EndTooltip();
-            }
-        }
-        else
-        {
-            // Aka root node.
-            string label = $"{node.Label}";
-            drawList.AddText(new Vector2(startX + barPadding, yPos + barPadding), ImGui.ColorConvertFloat4ToU32(textColor), label);
-        }
-
-        // Draw each child node under this node
-        foreach (Profiler.ScopeNode child in node.Children)
-        {
-            alternate = !alternate;
-            RenderNode(drawList, child, startTime, totalDuration, startX, baseY, depth + 1, contentWidth, alternate);
-        }
-    }
-
-    // Recursive function to calculate the maximum depth of the node tree
-    private static int GetMaxDepth(Profiler.ScopeNode node, int currentDepth)
-    {
-        if (node.Children == null || node.Children.Count == 0)
-        {
-            return currentDepth;
-        }
-
-        int maxDepth = currentDepth;
-        foreach (Profiler.ScopeNode child in node.Children)
-        {
-            maxDepth = Math.Max(maxDepth, GetMaxDepth(child, currentDepth + 1));
-        }
-        return maxDepth;
-    }
-}

Nerfed.Runtime/Resource/Resource.cs

@@ -1,31 +1,9 @@
-using System;
 namespace Nerfed.Runtime;
 
-public enum ResourceState
-{
-    Unloaded,
-    Queued,
-    Loading,
-    Loaded,
-    Failed
-}
-
 public abstract class Resource
 {
-    public Guid Id { get; internal set; }
     public string Path { get; internal set; }
 
-    /// <summary>
-    /// Natively tracks if the resource is currently in RAM/VRAM.
-    /// </summary>
-    public ResourceState State { get; internal set; } = ResourceState.Unloaded;
-
-    /// <summary>
-    /// Tracks how many entities or systems currently need this loaded.
-    /// When it hits 0, the ResourceManager handles unloading natively.
-    /// </summary>
-    public int ReferenceCount { get; internal set; } = 0;
-
     internal abstract void Load(Stream stream);
     internal abstract void Unload();
 }

Nerfed.Runtime/Resource/ResourceComponents.cs

@@ -1,19 +0,0 @@
-namespace Nerfed.Runtime;
-
-/// <summary>
-/// Attach this component to an entity mapped to raw source-path strings.
-/// Useful for testing, hardcoded assets, or before full editor-guided GUID injection.
-/// </summary>
-public readonly record struct AssetReferenceComponent(Guid AssetId);
-
-/// <summary>
-/// A strongly-typed version of an asset reference, preventing the user from accidentally
-/// assigning a Shader GUID to a Texture component in the Editor.
-/// </summary>
-public readonly record struct TypedAssetReference<TRes>(Guid AssetId) where TRes : Resource;
-
-/// <summary>
-/// Added to an entity by the AssetStreamingSystem when the physical resource is fully 
-/// loaded in memory and ready to be used by the renderer or physics engine.
-/// </summary>
-public struct AssetLoadedTag { }

Nerfed.Runtime/Resource/ResourceManager.cs

@@ -1,209 +1,43 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-
 namespace Nerfed.Runtime;
 
-/// <summary>
-/// A highly scalable, multithreaded resource manager that handles asynchronous asset 
-/// loading and automatic reference-counted memory management.
-/// </summary>
 public static class ResourceManager
 {
-    private const string RootName = "Resources";
+    private const string rootName = "Resources";
+    private static readonly Dictionary<string, Resource> loadedResources = new Dictionary<string, Resource>();
 
-    // Track resources by their Guid ID instead of simple strings.
+    public static T Load<T>(string resourcePath) where T : Resource
-    private static readonly ConcurrentDictionary<Guid, Resource> _resourceCache = new();
-
-    // Mapping a string path to its runtime Guid identifier
-    private static readonly ConcurrentDictionary<string, Guid> _pathToGuid = new();
-
-    // Queues for background processing
-    private static readonly ConcurrentQueue<Resource> _loadQueue = new();
-
-    // Loader threads
-    private static readonly Thread _loaderThread;
-    private static bool _isRunning = true;
-
-    // A registry of how to create concrete Resource instances from a generic type without massive switch statements.
-    private static readonly Dictionary<Type, Func<Resource>> _resourceFactories = new()
     {
-        { typeof(Shader), () => new Shader() }
+        if (loadedResources.TryGetValue(resourcePath, out Resource resource))
-    };
-
-    static ResourceManager()
         {
-        _loaderThread = new Thread(LoaderWorkerLoop)
-        {
-            Name = "Nerfed Asset Loader",
-            IsBackground = true,
-            Priority = ThreadPriority.BelowNormal // Keeps CPU time focused on the main game loop
-        };
-        _loaderThread.Start();
-    }
-
-    /// <summary>
-    /// Synchronously shuts down the loader thread when the engine closes.
-    /// </summary>
-    public static void Shutdown()
-    {
-        _isRunning = false;
-        _loaderThread.Join();
-    }
-
-    /// <summary>
-    /// Registers a new resource type factory so the manager knows how to instantiate it.
-    /// Example: RegisterResourceType<Texture>(() => new Texture());
-    /// </summary>
-    public static void RegisterResourceType<T>(Func<T> factory) where T : Resource
-    {
-        _resourceFactories[typeof(T)] = factory;
-    }
-
-    /// <summary>
-    /// Gets the Guid associated with a specific asset path, making an initial id pass if required.
-    /// In a fully baked engine, the Guid is known at compile time or baked in the map data.
-    /// </summary>
-    public static Guid GetId(string resourcePath)
-    {
-        return _pathToGuid.GetOrAdd(resourcePath, _ => Guid.NewGuid());
-    }
-
-    /// <summary>
-    /// Begins an asynchronous load for a resource by its Guid.
-    /// In ECS systems, Entities should strictly prefer this overload over the string one.
-    /// </summary>
-    public static T Retain<T>(Guid id, string expectedPath) where T : Resource
-    {
-        var resource = _resourceCache.GetOrAdd(id, (assetId) =>
-        {
-            if (!_resourceFactories.TryGetValue(typeof(T), out var factory))
-            {
-                throw new Exception($"Failed to create resource. No factory registered for {typeof(T).Name}");
-            }
-
-            var newResource = factory();
-            newResource.Id = assetId;
-            // The path is still required so the background thread knows which file to open from disk.
-            newResource.Path = expectedPath; 
-            newResource.State = ResourceState.Unloaded;
-            
-            return newResource;
-        });
-
-        lock (resource)
-        {
-            resource.ReferenceCount++;
-            
-            if (resource.State == ResourceState.Unloaded)
-            {
-                resource.State = ResourceState.Queued;
-                _loadQueue.Enqueue(resource);
-            }
-        }
-
             return (T)resource;
         }
 
-    /// <summary>
+        if (typeof(T) == typeof(Shader))
-    /// Begins an asynchronous load utilizing the string path to find the matching Guid. 
-    /// This should generally be avoided in tight ECS loops.
-    /// </summary>
-    public static T Retain<T>(string resourcePath) where T : Resource
         {
-        Guid id = GetId(resourcePath);
+            resource = new Shader();
-        return Retain<T>(id, resourcePath);
-    }
-
-    /// <summary>
-    /// Gets the current loading state of a resource by its Guid without altering its reference count.
-    /// </summary>
-    public static ResourceState GetState(Guid id)
-    {
-        if (_resourceCache.TryGetValue(id, out var resource))
-        {
-            return resource.State;
-        }
-        return ResourceState.Unloaded;
-    }
-
-    /// <summary>
-    /// Decrements the reference count of a resource by its Guid.
-    /// </summary>
-    public static void Release(Guid id)
-    {
-        if (_resourceCache.TryGetValue(id, out var resource))
-        {
-            Release(resource);
-        }
-    }
-
-    /// <summary>
-    /// Decrements the reference count of a resource. 
-    /// If the count reaches 0, the asset is automatically unloaded from memory.
-    /// </summary>
-    public static void Release(Resource resource)
-    {
-        if (resource == null) return;
-
-        lock (resource)
-        {
-            resource.ReferenceCount--;
-
-            if (resource.ReferenceCount <= 0)
-            {
-                // Fully unused! We should unload it safely.
-                if (resource.State == ResourceState.Loaded)
-                {
-                    resource.Unload();
-                }
-
-                resource.State = ResourceState.Unloaded;
-                _resourceCache.TryRemove(resource.Id, out _);
-            }
-        }
-    }
-
-    /// <summary>
-    /// Background thread loop that pulls from the queue and does the slow file I/O operations.
-    /// </summary>
-    private static void LoaderWorkerLoop()
-    {
-        while (_isRunning)
-        {
-            if (_loadQueue.TryDequeue(out var resource))
-            {
-                // Safety check: Was the resource released before we even got around to loading it?
-                if (resource.ReferenceCount <= 0)
-                {
-                    resource.State = ResourceState.Unloaded;
-                    continue;
-                }
-
-                try
-                {
-                    resource.State = ResourceState.Loading;
-                    string fullPath = Path.Combine(AppContext.BaseDirectory, RootName, resource.Id.ToString()) + ".bin";
-                    
-                    // Do the slow synchronous disk read
-                    using var stream = StorageContainer.OpenStream(fullPath);
-                    resource.Load(stream);
-
-                    resource.State = ResourceState.Loaded;
-                }
-                catch (Exception e)
-                {
-                    Log.Error($"Failed to background load asset '{resource.Path}': {e.Message}");
-                    resource.State = ResourceState.Failed;
-                }
         }
         else
         {
-                // Sleep cleanly if queue is empty to avoid burning total CPU usage on an infinite while-loop
+            throw new Exception("Failed to create resource");
-                Thread.Sleep(10);
+        }
-            }
+
-        }
+        Assert.Always(resource != null);
+        resource.Path = resourcePath;
+        resource.Load(StorageContainer.OpenStream(Path.Combine(AppContext.BaseDirectory, rootName, resourcePath) + ".bin"));
+
+        loadedResources.Add(resourcePath, resource);
+        return (T)resource;
+    }
+
+    public static void Unload(Resource resource)
+    {
+        if (!loadedResources.ContainsKey(resource.Path))
+        {
+            return;
+        }
+
+        resource.Unload();
+        resource.Path = string.Empty;
+        loadedResources.Remove(resource.Path);
     }
 }

Nerfed.Runtime/Resource/SampleMeshVisualComponent.cs

@@ -1,19 +0,0 @@
-namespace Nerfed.Runtime.Resources;
-
-/// <summary>
-/// A sample component demonstrating how to use strongly-typed asset references
-/// in a realistic scenario where an entity requires multiple distinct resources.
-/// </summary>
-public struct SampleMeshVisualComponent
-{
-    // The user safely assigns a Mesh GUID in the Editor inspector.
-    public TypedAssetReference<Shader> VertexShader;
-
-    // The user safely assigns a Material GUID in the Editor inspector.
-    public TypedAssetReference<Shader> FragmentShader;
-
-    public SampleMeshVisualComponent(Guid vertexId, Guid fragId) {
-        VertexShader = new TypedAssetReference<Shader>(vertexId);
-        FragmentShader = new TypedAssetReference<Shader>(fragId);
-    }
-}

Nerfed.Runtime/Resource/SampleRenderSystem.cs

@@ -1,53 +0,0 @@
-using MoonTools.ECS;
-using Nerfed.Runtime.Scene.Streaming;
-using System;
-
-namespace Nerfed.Runtime.Resources;
-
-/// <summary>
-/// A typical rendering preparation system that natively resolves and requests
-/// asynchronous background loading for its own required assets, removing the 
-/// need for a monolithic generic AssetStreaming manager.
-/// </summary>
-public class SampleRenderSystem : MoonTools.ECS.System
-{
-    private readonly Filter _meshVisualsFilter;
-
-    public SampleRenderSystem(World world) : base(world) {
-        _meshVisualsFilter = FilterBuilder
-            .Include<SampleMeshVisualComponent>()
-            // Always ignore chunk entities technically "unloading" from RAM
-            .Exclude<ChunkUnloadPendingTag>()
-            .Build();
-    }
-
-    public override void Update(TimeSpan delta) {
-        foreach(Entity entity in _meshVisualsFilter.Entities) {
-            SampleMeshVisualComponent visualComp = Get<SampleMeshVisualComponent>(entity);
-
-            // 1. Resolve State
-            ResourceState vertState = ResourceManager.GetState(visualComp.VertexShader.AssetId);
-            ResourceState fragState = ResourceManager.GetState(visualComp.FragmentShader.AssetId);
-
-            // 2. Asynchronously request assets if they don't exist in memory yet
-            if(vertState == ResourceState.Unloaded) {
-                ResourceManager.Retain<Shader>(visualComp.VertexShader.AssetId, "Unknown/Path");
-            }
-            if(fragState == ResourceState.Unloaded) {
-                ResourceManager.Retain<Shader>(visualComp.FragmentShader.AssetId, "Unknown/Path");
-            }
-
-            // 3. Prevent rendering logic unless ALL strictly required assets are fully mapped
-            bool isReadyToDraw = vertState == ResourceState.Loaded && fragState == ResourceState.Loaded;
-
-            if(isReadyToDraw) {
-                // At this exact point, you can safely assume:
-                // 1) The background loading threads are 100% finished processing these shaders.
-                // 2) The GraphicsDevice can safely extract the native handle.
-
-                // e.g. GraphicsDevice.BindShader(visualComp.VertexShader.AssetId);
-                // e.g. GraphicsDevice.DrawPolygons(...);
-            }
-        }
-    }
-}

Nerfed.Runtime/Scene/ISceneSerializer.cs

@@ -1,13 +0,0 @@
-namespace Nerfed.Runtime.Scene;
-
-/// <summary>
-/// Abstraction over a concrete scene format (JSON, binary, …).
-/// Implementations read and write <see cref="SceneData"/> to a <see cref="Stream"/>,
-/// making it straightforward to add a compact binary format later without
-/// changing any of the surrounding scene infrastructure.
-/// </summary>
-public interface ISceneSerializer
-{
-    void Serialize(SceneData scene, Stream stream);
-    SceneData Deserialize(Stream stream);
-}

Nerfed.Runtime/Scene/JsonSceneSerializer.cs

@@ -1,189 +0,0 @@
-using System.Numerics;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-
-namespace Nerfed.Runtime.Scene;
-
-/// <summary>
-/// Human-readable JSON scene serializer.
-///
-/// Example output:
-/// <code>
-/// {
-///   "version": 1,
-///   "name": "MyScene",
-///   "entities": [
-///     {
-///       "id": "a1b2c3d4-...",
-///       "tag": "Player",
-///       "parentId": null,
-///       "components": [
-///         {
-///           "type": "Nerfed.Runtime.Components.LocalTransform",
-///           "data": {
-///             "position": { "x": 0.0, "y": 0.0, "z": 0.0 },
-///             "rotation": { "x": 0.0, "y": 0.0, "z": 0.0, "w": 1.0 },
-///             "scale":    { "x": 1.0, "y": 1.0, "z": 1.0 }
-///           }
-///         }
-///       ]
-///     }
-///   ],
-///   "relations": [
-///     {
-///       "type": "Nerfed.Runtime.Components.OwnerRelation",
-///       "entityA": "a1b2c3d4-...",
-///       "entityB": "e5f6a7b8-...",
-///       "data": {}
-///     }
-///   ]
-/// }
-/// </code>
-/// </summary>
-public sealed class JsonSceneSerializer : ISceneSerializer
-{
-    private static readonly JsonSerializerOptions Options = new() {
-        WriteIndented = true,
-        Converters =
-        {
-            new Vector3JsonConverter(),
-            new QuaternionJsonConverter(),
-            new SceneComponentDataJsonConverter(),
-            new SceneRelationDataJsonConverter(),
-        },
-    };
-
-    public void Serialize(SceneData scene, Stream stream) {
-        JsonSerializer.Serialize(stream, scene, Options);
-    }
-
-    public SceneData Deserialize(Stream stream) {
-        return JsonSerializer.Deserialize<SceneData>(stream, Options)
-            ?? throw new InvalidOperationException("Failed to deserialize scene: root element was null.");
-    }
-
-    // -------------------------------------------------------------------------
-    // Converters
-    // -------------------------------------------------------------------------
-
-    private sealed class Vector3JsonConverter : JsonConverter<Vector3>
-    {
-        public override Vector3 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
-            float x = 0f, y = 0f, z = 0f;
-            reader.Read(); // StartObject
-            while(reader.Read() && reader.TokenType != JsonTokenType.EndObject) {
-                string name = reader.GetString()!;
-                reader.Read();
-                switch(name) {
-                    case "x": x = reader.GetSingle(); break;
-                    case "y": y = reader.GetSingle(); break;
-                    case "z": z = reader.GetSingle(); break;
-                }
-            }
-            return new Vector3(x, y, z);
-        }
-
-        public override void Write(Utf8JsonWriter writer, Vector3 value, JsonSerializerOptions options) {
-            writer.WriteStartObject();
-            writer.WriteNumber("x", value.X);
-            writer.WriteNumber("y", value.Y);
-            writer.WriteNumber("z", value.Z);
-            writer.WriteEndObject();
-        }
-    }
-
-    private sealed class QuaternionJsonConverter : JsonConverter<Quaternion>
-    {
-        public override Quaternion Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
-            float x = 0f, y = 0f, z = 0f, w = 1f;
-            reader.Read(); // StartObject
-            while(reader.Read() && reader.TokenType != JsonTokenType.EndObject) {
-                string name = reader.GetString()!;
-                reader.Read();
-                switch(name) {
-                    case "x": x = reader.GetSingle(); break;
-                    case "y": y = reader.GetSingle(); break;
-                    case "z": z = reader.GetSingle(); break;
-                    case "w": w = reader.GetSingle(); break;
-                }
-            }
-            return new Quaternion(x, y, z, w);
-        }
-
-        public override void Write(Utf8JsonWriter writer, Quaternion value, JsonSerializerOptions options) {
-            writer.WriteStartObject();
-            writer.WriteNumber("x", value.X);
-            writer.WriteNumber("y", value.Y);
-            writer.WriteNumber("z", value.Z);
-            writer.WriteNumber("w", value.W);
-            writer.WriteEndObject();
-        }
-    }
-
-    /// <summary>
-    /// Buffers the full JSON object, resolves the CLR component type from the "type" field,
-    /// then deserializes "data" using that concrete type.
-    /// </summary>
-    private sealed class SceneComponentDataJsonConverter : JsonConverter<SceneComponentData>
-    {
-        public override SceneComponentData Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
-            using JsonDocument doc = JsonDocument.ParseValue(ref reader);
-            JsonElement root = doc.RootElement;
-
-            string typeName = root.GetProperty("type").GetString()
-                ?? throw new JsonException("Missing or null 'type' field in component data.");
-
-            Type componentType = SceneManager.GetComponentType(typeName)
-                ?? throw new JsonException($"Unknown component type '{typeName}'. Ensure the struct is marked with [SceneComponent].");
-
-            string rawData = root.GetProperty("data").GetRawText();
-            ValueType value = (ValueType)JsonSerializer.Deserialize(rawData, componentType, options)!;
-
-            return new SceneComponentData { Type = typeName, Value = value };
-        }
-
-        public override void Write(Utf8JsonWriter writer, SceneComponentData value, JsonSerializerOptions options) {
-            writer.WriteStartObject();
-            writer.WriteString("type", value.Type);
-            writer.WritePropertyName("data");
-            JsonSerializer.Serialize(writer, value.Value, value.Value.GetType(), options);
-            writer.WriteEndObject();
-        }
-    }
-
-    /// <summary>
-    /// Same pattern as <see cref="SceneComponentDataJsonConverter"/> but for relation data.
-    /// Resolves the type via <see cref="SceneManager.GetRelationType"/>.
-    /// </summary>
-    private sealed class SceneRelationDataJsonConverter : JsonConverter<SceneRelationData>
-    {
-        public override SceneRelationData Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
-            using JsonDocument doc = JsonDocument.ParseValue(ref reader);
-            JsonElement root = doc.RootElement;
-
-            string typeName = root.GetProperty("type").GetString()
-                ?? throw new JsonException("Missing or null 'type' field in relation data.");
-
-            Type relationType = SceneManager.GetRelationType(typeName)
-                ?? throw new JsonException($"Unknown relation type '{typeName}'. Ensure the struct is marked with [SceneRelation].");
-
-            Guid entityA = root.GetProperty("entityA").GetGuid();
-            Guid entityB = root.GetProperty("entityB").GetGuid();
-
-            string rawData = root.GetProperty("data").GetRawText();
-            ValueType value = (ValueType)JsonSerializer.Deserialize(rawData, relationType, options)!;
-
-            return new SceneRelationData { Type = typeName, EntityA = entityA, EntityB = entityB, Value = value };
-        }
-
-        public override void Write(Utf8JsonWriter writer, SceneRelationData value, JsonSerializerOptions options) {
-            writer.WriteStartObject();
-            writer.WriteString("type", value.Type);
-            writer.WriteString("entityA", value.EntityA);
-            writer.WriteString("entityB", value.EntityB);
-            writer.WritePropertyName("data");
-            JsonSerializer.Serialize(writer, value.Value, value.Value.GetType(), options);
-            writer.WriteEndObject();
-        }
-    }
-}

Nerfed.Runtime/Scene/SceneComponentAttribute.cs

@@ -1,8 +0,0 @@
-namespace Nerfed.Runtime.Scene;
-
-/// <summary>
-/// Marks an unmanaged struct as a serializable scene component.
-/// Only types with this attribute will be saved/loaded by the scene system.
-/// </summary>
-[AttributeUsage(AttributeTargets.Struct, Inherited = false)]
-public sealed class SceneComponentAttribute : Attribute { }

Nerfed.Runtime/Scene/SceneData.cs

@@ -1,65 +0,0 @@
-namespace Nerfed.Runtime.Scene;
-
-/// <summary>
-/// Root data model for a scene. A scene and a prefab are the same thing —
-/// there is no distinction between the two, mirroring Godot's design.
-/// </summary>
-public sealed class SceneData
-{
-    /// <summary>Incremented when the file format changes in a breaking way.</summary>
-    public int Version { get; set; } = SceneData.CurrentVersion;
-    public string Name { get; set; } = string.Empty;
-    public List<SceneEntityData> Entities { get; set; } = new();
-    /// <summary>All user-defined relations between entities in this scene.</summary>
-    public List<SceneRelationData> Relations { get; set; } = new();
-
-    public const int CurrentVersion = 1;
-}
-
-/// <summary>
-/// Serialized representation of a single entity.
-/// The <see cref="Id"/> is a scene-local identifier that only exists in the
-/// serialized data and is used to reconstruct parent–child and relation references.
-/// It is never stored as a component on a live entity.
-/// An entity is included if it owns at least one <see cref="SceneComponentAttribute"/> component
-/// OR participates in at least one <see cref="SceneRelationAttribute"/> relation.
-/// </summary>
-public sealed class SceneEntityData
-{
-    public Guid Id { get; set; } = Guid.NewGuid();
-    public string Tag { get; set; } = string.Empty;
-
-    /// <summary>
-    /// Scene-local <see cref="Id"/> of this entity's <see cref="Components.ChildParentRelation"/>
-    /// parent, or <c>null</c> if this is a root entity.
-    /// </summary>
-    public Guid? ParentId { get; set; }
-
-    public List<SceneComponentData> Components { get; set; } = new();
-}
-
-/// <summary>
-/// Serialized representation of a single component value on an entity.
-/// <see cref="Type"/> is the fully-qualified CLR type name used to resolve the component on load.
-/// <see cref="Value"/> is the boxed runtime value; each <see cref="ISceneSerializer"/> is
-/// responsible for converting it to/from its wire format.
-/// </summary>
-public sealed class SceneComponentData
-{
-    public string Type { get; set; } = string.Empty;
-    public ValueType Value { get; set; } = default!;
-}
-
-/// <summary>
-/// Serialized representation of a relation between two entities.
-/// <see cref="EntityA"/> and <see cref="EntityB"/> reference scene-local <see cref="SceneEntityData.Id"/> values.
-/// <see cref="Type"/> identifies the relation kind (must be marked with <see cref="SceneRelationAttribute"/>).
-/// <see cref="Value"/> holds the relation data payload (may be an empty struct).
-/// </summary>
-public sealed class SceneRelationData
-{
-    public string Type { get; set; } = string.Empty;
-    public Guid EntityA { get; set; }
-    public Guid EntityB { get; set; }
-    public ValueType Value { get; set; } = default!;
-}

Nerfed.Runtime/Scene/SceneManager.cs

@@ -1,345 +0,0 @@
-using System.Reflection;
-using MoonTools.ECS;
-using Nerfed.Runtime.Components;
-
-namespace Nerfed.Runtime.Scene;
-
-/// <summary>
-/// Central hub for scene serialization and deserialization.
-///
-/// On first use the static constructor scans all loaded assemblies for:
-///   • Structs annotated with <see cref="SceneComponentAttribute"/>  — serialized as per-entity component data.
-///   • Structs annotated with <see cref="SceneRelationAttribute"/>   — serialized as cross-entity relation data.
-///
-/// The <see cref="Components.ChildParentRelation"/> hierarchy is handled separately via
-/// <see cref="SceneEntityData.ParentId"/> and does NOT need a <see cref="SceneRelationAttribute"/>.
-///
-/// Usage:
-/// <code>
-/// var serializer = new JsonSceneSerializer();
-/// SceneManager.Save(world, "Assets/level1.scene", serializer, "Level 1");
-/// SceneManager.Load(world, "Assets/level1.scene", serializer);
-/// </code>
-/// </summary>
-public static class SceneManager
-{
-    // Full CLR type name  →  Type
-    private static readonly Dictionary<string, Type> ComponentRegistry = new();
-    private static readonly Dictionary<string, Type> RelationRegistry = new();
-
-    // Reflection cache so we only build the delegates once per type.
-    private static readonly Dictionary<Type, Func<World, Entity, bool>> HasComponentCache = new();
-    private static readonly Dictionary<Type, Func<World, Entity, ValueType>> GetComponentCache = new();
-    private static readonly Dictionary<Type, Action<World, Entity, ValueType>> SetComponentCache = new();
-    private static readonly Dictionary<Type, Func<World, Entity, bool>> HasOutRelationCache = new();
-    private static readonly Dictionary<Type, Func<World, Entity, Entity[]>> OutRelationsCache = new();
-    private static readonly Dictionary<Type, Func<World, Entity, Entity, ValueType>> GetRelationDataCache = new();
-    private static readonly Dictionary<Type, Action<World, Entity, Entity, ValueType>> RelateCache = new();
-
-    static SceneManager() {
-        foreach(Assembly assembly in AppDomain.CurrentDomain.GetAssemblies()) {
-            Type[] types;
-            try { types = assembly.GetTypes(); } catch(ReflectionTypeLoadException ex) { types = ex.Types.Where(t => t is not null).ToArray()!; }
-
-            foreach(Type type in types) {
-                if(type.FullName is null) continue;
-
-                if(type.GetCustomAttribute<SceneComponentAttribute>() is not null)
-                    ComponentRegistry[type.FullName] = type;
-
-                if(type.GetCustomAttribute<SceneRelationAttribute>() is not null)
-                    RelationRegistry[type.FullName] = type;
-            }
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Public registry accessors
-    // -------------------------------------------------------------------------
-
-    public static Type? GetComponentType(string fullName) {
-        ComponentRegistry.TryGetValue(fullName, out Type? type);
-        return type;
-    }
-
-    public static Type? GetRelationType(string fullName) {
-        RelationRegistry.TryGetValue(fullName, out Type? type);
-        return type;
-    }
-
-    public static IReadOnlyDictionary<string, Type> RegisteredComponentTypes => ComponentRegistry;
-    public static IReadOnlyDictionary<string, Type> RegisteredRelationTypes => RelationRegistry;
-
-    // -------------------------------------------------------------------------
-    // High-level Save / Load
-    // -------------------------------------------------------------------------
-
-    public static void Save(World world, string path, ISceneSerializer serializer, string sceneName = "") {
-        SceneData scene = Extract(world, sceneName);
-        string? directory = Path.GetDirectoryName(path);
-        if(!string.IsNullOrEmpty(directory))
-            Directory.CreateDirectory(directory);
-        using FileStream stream = File.Open(path, FileMode.Create, FileAccess.Write);
-        serializer.Serialize(scene, stream);
-    }
-
-    public static Dictionary<Guid, Entity> Load(World world, string path, ISceneSerializer serializer) {
-        using FileStream stream = File.Open(path, FileMode.Open, FileAccess.Read);
-        SceneData scene = serializer.Deserialize(stream);
-        return Instantiate(world, scene);
-    }
-
-    // -------------------------------------------------------------------------
-    // Extract  (world → SceneData)
-    // -------------------------------------------------------------------------
-
-    public static SceneData Extract(World world, string name = "") {
-        SceneData scene = new() { Name = name };
-
-        // ── 1. Collect entities ──────────────────────────────────────────────
-        // Include an entity if it has at least one scene component OR if it
-        // appears as an endpoint of at least one scene relation.  This ensures
-        // pure grouping nodes and relation-only entities are not dropped.
-
-        Dictionary<uint, Guid> entityToGuid = new();
-
-        void EnsureEntity(Entity e) {
-            if(!entityToGuid.ContainsKey(e.ID))
-                entityToGuid[e.ID] = Guid.NewGuid();
-        }
-
-        foreach(Entity entity in world.GetAllEntities()) {
-            if(HasAnySceneComponent(world, entity))
-                EnsureEntity(entity);
-        }
-
-        // Walk all registered relation types and pull in both endpoints.
-        foreach(Type relationType in RelationRegistry.Values) {
-            foreach((Entity a, Entity b) in WorldAllRelations(world, relationType)) {
-                EnsureEntity(a);
-                EnsureEntity(b);
-            }
-        }
-
-        // Also include entities that are part of the ChildParentRelation hierarchy
-        // even if they carry no scene components and no user-defined relations.
-        foreach((Entity child, Entity parent) in world.Relations<ChildParentRelation>()) {
-            EnsureEntity(child);
-            EnsureEntity(parent);
-        }
-
-        // ── 2. Build entity records (parents must be known before children so
-        //       we sort parents-before-children for readable output) ───────────
-        List<SceneEntityData> ordered = BuildSortedEntityList(world, entityToGuid);
-        scene.Entities.AddRange(ordered);
-
-        // ── 3. Build relation records ────────────────────────────────────────
-        foreach((string typeName, Type relationType) in RelationRegistry) {
-            foreach((Entity a, Entity b) in WorldAllRelations(world, relationType)) {
-                if(!entityToGuid.TryGetValue(a.ID, out Guid guidA) ||
-                    !entityToGuid.TryGetValue(b.ID, out Guid guidB))
-                    continue;
-
-                ValueType payload = WorldGetRelationData(world, a, b, relationType);
-                scene.Relations.Add(new SceneRelationData {
-                    Type = typeName,
-                    EntityA = guidA,
-                    EntityB = guidB,
-                    Value = payload,
-                });
-            }
-        }
-
-        return scene;
-    }
-
-    // -------------------------------------------------------------------------
-    // Instantiate  (SceneData → world)
-    // -------------------------------------------------------------------------
-
-    public static Dictionary<Guid, Entity> Instantiate(World world, SceneData scene) {
-        Dictionary<Guid, Entity> guidToEntity = new(scene.Entities.Count);
-
-        // Pass 1 – create all entities.
-        foreach(SceneEntityData entityData in scene.Entities) {
-            Entity entity = world.CreateEntity(entityData.Tag);
-            guidToEntity[entityData.Id] = entity;
-        }
-
-        // Pass 2 – set components and wire up the ChildParentRelation hierarchy.
-        foreach(SceneEntityData entityData in scene.Entities) {
-            Entity entity = guidToEntity[entityData.Id];
-
-            foreach(SceneComponentData componentData in entityData.Components)
-                WorldSetComponent(world, entity, componentData.Type, componentData.Value);
-
-            if(entityData.ParentId is Guid parentGuid && guidToEntity.TryGetValue(parentGuid, out Entity parent)) {
-                world.Set(entity, new Child());
-                world.Relate(entity, parent, new ChildParentRelation());
-            } else {
-                world.Set(entity, new Root());
-            }
-        }
-
-        // Pass 3 – restore all user-defined relations.
-        foreach(SceneRelationData relationData in scene.Relations) {
-            if(!guidToEntity.TryGetValue(relationData.EntityA, out Entity entityA) ||
-                !guidToEntity.TryGetValue(relationData.EntityB, out Entity entityB))
-                continue;
-
-            WorldRelate(world, entityA, entityB, relationData.Type, relationData.Value);
-        }
-
-        return guidToEntity;
-    }
-
-    // -------------------------------------------------------------------------
-    // Helpers – entity ordering
-    // -------------------------------------------------------------------------
-
-    // Returns entities sorted so that a parent always appears before its children,
-    // making the JSON file human-readable and easier to diff.
-    private static List<SceneEntityData> BuildSortedEntityList(
-        World world,
-        Dictionary<uint, Guid> entityToGuid) {
-        // Build per-entity data (unsorted first).
-        Dictionary<Guid, SceneEntityData> byGuid = new(entityToGuid.Count);
-
-        foreach((uint entityId, Guid guid) in entityToGuid) {
-            Entity entity = new(entityId);
-
-            Guid? parentId = null;
-            if(world.HasOutRelation<ChildParentRelation>(entity)) {
-                // Iterate all out-relations — an entity may have multiple parents
-                // in theory, but ChildParentRelation is designed as singleton.
-                // We capture the first valid one here.
-                foreach(Entity parent in world.OutRelations<ChildParentRelation>(entity)) {
-                    if(entityToGuid.TryGetValue(parent.ID, out Guid parentGuid)) {
-                        parentId = parentGuid;
-                        break;
-                    }
-                }
-            }
-
-            List<SceneComponentData> components = new();
-            foreach((string typeName, Type componentType) in ComponentRegistry) {
-                if(!WorldHasComponent(world, entity, componentType)) continue;
-                ValueType value = WorldGetComponent(world, entity, componentType);
-                components.Add(new SceneComponentData { Type = typeName, Value = value });
-            }
-
-            byGuid[guid] = new SceneEntityData {
-                Id = guid,
-                Tag = world.GetTag(entity),
-                ParentId = parentId,
-                Components = components,
-            };
-        }
-
-        // Topological sort: parents before children.
-        List<SceneEntityData> sorted = new(byGuid.Count);
-        HashSet<Guid> visited = new(byGuid.Count);
-
-        void Visit(Guid id) {
-            if(!visited.Add(id)) return;
-            SceneEntityData data = byGuid[id];
-            if(data.ParentId is Guid pid && byGuid.ContainsKey(pid))
-                Visit(pid);
-            sorted.Add(data);
-        }
-
-        foreach(Guid id in byGuid.Keys)
-            Visit(id);
-
-        return sorted;
-    }
-
-    // -------------------------------------------------------------------------
-    // Reflection helpers – components
-    // -------------------------------------------------------------------------
-
-    private static bool HasAnySceneComponent(World world, Entity entity) {
-        foreach(Type componentType in ComponentRegistry.Values) {
-            if(WorldHasComponent(world, entity, componentType)) return true;
-        }
-        return false;
-    }
-
-    private static bool WorldHasComponent(World world, Entity entity, Type componentType) {
-        if(!HasComponentCache.TryGetValue(componentType, out Func<World, Entity, bool>? fn)) {
-            MethodInfo method = FindGenericMethod(nameof(World.Has)).MakeGenericMethod(componentType);
-            fn = (w, e) => (bool)method.Invoke(w, new object[] { e })!;
-            HasComponentCache[componentType] = fn;
-        }
-        return fn(world, entity);
-    }
-
-    private static ValueType WorldGetComponent(World world, Entity entity, Type componentType) {
-        if(!GetComponentCache.TryGetValue(componentType, out Func<World, Entity, ValueType>? fn)) {
-            MethodInfo method = FindGenericMethod(nameof(World.Get)).MakeGenericMethod(componentType);
-            fn = (w, e) => (ValueType)method.Invoke(w, new object[] { e })!;
-            GetComponentCache[componentType] = fn;
-        }
-        return fn(world, entity);
-    }
-
-    private static void WorldSetComponent(World world, Entity entity, string typeName, ValueType value) {
-        if(!ComponentRegistry.TryGetValue(typeName, out Type? componentType)) return;
-
-        if(!SetComponentCache.TryGetValue(componentType, out Action<World, Entity, ValueType>? fn)) {
-            MethodInfo method = FindGenericMethod(nameof(World.Set)).MakeGenericMethod(componentType);
-            fn = (w, e, v) => method.Invoke(w, new object[] { e, v });
-            SetComponentCache[componentType] = fn;
-        }
-        fn(world, entity, value);
-    }
-
-    // -------------------------------------------------------------------------
-    // Reflection helpers – relations
-    // -------------------------------------------------------------------------
-
-    private static IEnumerable<(Entity, Entity)> WorldAllRelations(World world, Type relationType) {
-        // World.Relations<T>() returns ReverseSpanEnumerator<(Entity,Entity)>.
-        // We materialise it into a list so the caller can iterate freely.
-        MethodInfo method = FindGenericMethod(nameof(World.Relations)).MakeGenericMethod(relationType);
-        // Returns a boxed ReverseSpanEnumerator; invoke MoveNext/Current via dynamic.
-        // Easiest: call via dynamic to avoid unsafe span-from-box issues.
-        dynamic enumerator = method.Invoke(world, null)!;
-        List<(Entity, Entity)> results = new();
-        while(enumerator.MoveNext())
-            results.Add(enumerator.Current);
-        return results;
-    }
-
-    private static ValueType WorldGetRelationData(World world, Entity a, Entity b, Type relationType) {
-        if(!GetRelationDataCache.TryGetValue(relationType, out Func<World, Entity, Entity, ValueType>? fn)) {
-            MethodInfo method = FindGenericMethod(nameof(World.GetRelationData)).MakeGenericMethod(relationType);
-            fn = (w, ea, eb) => (ValueType)method.Invoke(w, new object[] { ea, eb })!;
-            GetRelationDataCache[relationType] = fn;
-        }
-        return fn(world, a, b);
-    }
-
-    private static void WorldRelate(World world, Entity a, Entity b, string typeName, ValueType value) {
-        if(!RelationRegistry.TryGetValue(typeName, out Type? relationType)) return;
-
-        if(!RelateCache.TryGetValue(relationType, out Action<World, Entity, Entity, ValueType>? fn)) {
-            MethodInfo method = FindGenericMethod(nameof(World.Relate)).MakeGenericMethod(relationType);
-            fn = (w, ea, eb, v) => method.Invoke(w, new object[] { ea, eb, v });
-            RelateCache[relationType] = fn;
-        }
-        fn(world, a, b, value);
-    }
-
-    // -------------------------------------------------------------------------
-    // Utility
-    // -------------------------------------------------------------------------
-
-    private static MethodInfo FindGenericMethod(string name) {
-        foreach(MethodInfo m in typeof(World).GetMethods(BindingFlags.Public | BindingFlags.Instance)) {
-            if(m.Name == name && m.IsGenericMethodDefinition)
-                return m;
-        }
-        throw new InvalidOperationException($"Could not find generic method '{name}' on {nameof(World)}.");
-    }
-}

Nerfed.Runtime/Scene/SceneRelationAttribute.cs

@@ -1,10 +0,0 @@
-namespace Nerfed.Runtime.Scene;
-
-/// <summary>
-/// Marks an unmanaged struct as a serializable scene relation kind.
-/// Both endpoints and the data payload will be saved/loaded by the scene system.
-/// The <see cref="Components.ChildParentRelation"/> hierarchy is handled separately via
-/// <see cref="SceneEntityData.ParentId"/> and should NOT be marked with this attribute.
-/// </summary>
-[AttributeUsage(AttributeTargets.Struct, Inherited = false)]
-public sealed class SceneRelationAttribute : Attribute { }

Nerfed.Runtime/Scene/Streaming/ChunkStreamingSystem.cs

@@ -1,202 +0,0 @@
-using MoonTools.ECS;
-using System.Collections.Generic;
-using System;
-using System.Numerics;
-using Nerfed.Runtime.Components;
-
-namespace Nerfed.Runtime.Scene.Streaming;
-
-/// <summary>
-/// Status of a chunk in the streaming system.
-/// </summary>
-public enum ChunkState
-{
-    Unloaded,
-    Loading,
-    Loaded,
-    Unloading
-}
-
-/// <summary>
-/// A system that manages spatial partitioning. It determines which chunks should be loaded based on observers.
-/// </summary>
-public class ChunkStreamingSystem : MoonTools.ECS.System
-{
-    private readonly struct ChunkCoord : IEquatable<ChunkCoord>
-    {
-        public readonly int X;
-        public readonly int Y;
-        public readonly int Z;
-        
-        // Pre-calculated on creation
-        public readonly long Id;
-        
-        public ChunkCoord(int x, int y, int z)
-        {
-            X = x;
-            Y = y;
-            Z = z;
-            
-            // We allocate 21 bits per axis (allowing ~2 million chunks positive and negative).
-            var hashX = (long)x & 0x1FFFFF; 
-            var hashY = (long)y & 0x1FFFFF; 
-            var hashZ = (long)z & 0x1FFFFF; 
-            
-            Id = hashX | (hashY << 21) | (hashZ << 42); 
-        }
-
-        public bool Equals(ChunkCoord other) => Id == other.Id;
-        public override bool Equals(object? obj) => obj is ChunkCoord other && Equals(other);
-        public override int GetHashCode() => Id.GetHashCode();
-    }
-
-    // Configurable size of a chunk in world coordinates.
-    public float ChunkSize { get; set; } = 64f;
-
-    private readonly Filter _observerFilter;
-    private readonly Filter _chunkMemberFilter;
-    private readonly Filter _unloadedFilter;
-
-    // Active loaded/loading chunks
-    private readonly Dictionary<ChunkCoord, ChunkState> _activeChunks = new();
-    
-    // Queue of chunks waiting to be loaded
-    private readonly Queue<ChunkCoord> _pendingLoads = new();
-    
-    // Queue of chunks waiting to be completely tagged for unloading
-    private readonly Queue<ChunkCoord> _pendingUnloads = new();
-
-    public ChunkStreamingSystem(World world) : base(world)
-    {
-        _observerFilter = FilterBuilder
-            .Include<ChunkObserverComponent>()
-            .Include<LocalToWorld>() // Needs a world position
-            .Exclude<ChunkUnloadPendingTag>()  // Ignore dying observers
-            .Build();
-
-        _chunkMemberFilter = FilterBuilder
-            .Include<ChunkMemberComponent>()
-            .Exclude<ChunkUnloadPendingTag>()  // Ignore entities already marked for death
-            .Build();
-
-        _unloadedFilter = FilterBuilder
-            .Include<ChunkUnloadPendingTag>()
-            .Build();
-    }
-
-    public override void Update(TimeSpan delta)
-    {
-        var requiredChunks = new HashSet<ChunkCoord>();
-
-        // 1. Find all chunks that should be loaded based on observers
-        foreach (var observerEntity in _observerFilter.Entities)
-        {
-            var observer = Get<ChunkObserverComponent>(observerEntity);
-            var transform = Get<LocalToWorld>(observerEntity);
-
-            // Convert world pos to grid coordinates
-            var worldPos = transform.localToWorldMatrix.Translation;
-            var centerChunk = GetChunkCoord(worldPos);
-
-            // Determine chunk radius based on observer radius and chunk size
-            int chunkRadius = (int)MathF.Ceiling(observer.ViewRadius / ChunkSize);
-
-            for (int x = -chunkRadius; x <= chunkRadius; x++)
-            {
-                for (int y = -chunkRadius; y <= chunkRadius; y++)
-                {
-                    for (int z = -chunkRadius; z <= chunkRadius; z++)
-                    {
-                        var coord = new ChunkCoord(centerChunk.X + x, centerChunk.Y + y, centerChunk.Z + z);
-                        requiredChunks.Add(coord);
-                    }
-                }
-            }
-        }
-
-        // 2. Unload chunks that are active but no longer required
-        var chunksToUnload = new List<ChunkCoord>();
-        foreach (var activeChunk in _activeChunks.Keys)
-        {
-            if (!requiredChunks.Contains(activeChunk) && _activeChunks[activeChunk] != ChunkState.Unloading)
-            {
-                chunksToUnload.Add(activeChunk);
-            }
-        }
-
-        foreach (var coord in chunksToUnload)
-        {
-            _activeChunks[coord] = ChunkState.Unloading;
-            _pendingUnloads.Enqueue(coord);
-        }
-
-        // 3. Queue newly required chunks
-        foreach (var coord in requiredChunks)
-        {
-            if (!_activeChunks.ContainsKey(coord))
-            {
-                // Mark as unloaded so we don't queue it multiple times
-                _activeChunks[coord] = ChunkState.Unloaded; 
-                _pendingLoads.Enqueue(coord);
-            }
-        }
-
-        // 4. Process only ONE chunk load per frame to prevent stuttering
-        if (_pendingLoads.Count > 0)
-        {
-            var chunkToLoad = _pendingLoads.Dequeue();
-            // Double check it wasn't unloaded before we got around to loading it
-            if (_activeChunks.TryGetValue(chunkToLoad, out var state) && state == ChunkState.Unloaded)
-            {
-                LoadChunk(chunkToLoad);
-            }
-        }
-        
-        // 5. Process only ONE chunk unload tagging per frame
-        if (_pendingUnloads.Count > 0)
-        {
-            var chunkToUnload = _pendingUnloads.Dequeue();
-            UnloadChunk(chunkToUnload);
-        }
-    }
-
-    private ChunkCoord GetChunkCoord(Vector3 worldPos)
-    {
-        return new ChunkCoord(
-            (int)MathF.Floor(worldPos.X / ChunkSize),
-            (int)MathF.Floor(worldPos.Y / ChunkSize),
-            (int)MathF.Floor(worldPos.Z / ChunkSize)
-        );
-    }
-
-    private void LoadChunk(ChunkCoord coord)
-    {
-        _activeChunks[coord] = ChunkState.Loading;
-
-        // TODO: In a real system, you'd queue async I/O here to read SceneData for this chunk
-        // and spawn the entities. Once they are all spawned, set state to Loaded.
-
-        // For demonstration, immediately set to loaded.
-        _activeChunks[coord] = ChunkState.Loaded;
-    }
-
-    private void UnloadChunk(ChunkCoord coord)
-    {
-        // Instead of destroying everything instantly, we tag the entities as 'Unloaded'
-        // so that they stop participating in rendering/gameplay, and get destroyed slowly
-        // by the ChunkTeardownSystem.
-        long coordId = coord.Id;
-        foreach (var entity in _chunkMemberFilter.Entities)
-        {
-            var chunkMember = Get<ChunkMemberComponent>(entity);
-            if (chunkMember.ChunkId == coordId)
-            {
-                Set(entity, new ChunkUnloadPendingTag());
-            }
-        }
-
-        // Immediately remove it from the required grid so it can be re-loaded 
-        // if the player turns around quickly, while older entities are just garbage collected.
-        _activeChunks.Remove(coord);
-    }
-}

Nerfed.Runtime/Scene/Streaming/ChunkTeardownSystem.cs

@@ -1,35 +0,0 @@
-using MoonTools.ECS;
-using System;
-
-namespace Nerfed.Runtime.Scene.Streaming;
-
-/// <summary>
-/// A centralized cleanup system for slowly destroying chunk entities to avoid frame stutters.
-/// </summary>
-public class ChunkTeardownSystem : MoonTools.ECS.System
-{
-    private readonly Filter _unloadedFilter;
-
-    // Adjustable limit to prevent massive stutters when unloading chunks.
-    public int MaxEntitiesToDestroyPerFrame { get; set; } = 250;
-
-    public ChunkTeardownSystem(World world) : base(world)
-    {
-        _unloadedFilter = FilterBuilder
-            .Include<ChunkUnloadPendingTag>()
-            .Build();
-    }
-
-    public override void Update(TimeSpan delta)
-    {
-        int destroyed = 0;
-
-        foreach (var entity in _unloadedFilter.Entities)
-        {
-            if (destroyed >= MaxEntitiesToDestroyPerFrame) break;
-
-            Destroy(entity);
-            destroyed++;
-        }
-    }
-}

Nerfed.Runtime/Scene/Streaming/StreamingComponents.cs

@@ -1,28 +0,0 @@
-using MoonTools.ECS;
-using System.Numerics;
-
-namespace Nerfed.Runtime.Scene.Streaming;
-
-/// <summary>
-/// Marks an entity as a streaming observer (e.g. the player camera) that causes chunks
-/// to be loaded around it.
-/// </summary>
-public struct ChunkObserverComponent
-{
-    public float ViewRadius;
-}
-
-/// <summary>
-/// Tags an entity as belonging to a specific chunk, allowing it to be unloaded when the chunk is out of range.
-/// </summary>
-public struct ChunkMemberComponent
-{
-    // A 64-bit spatial hash combining the X, Y, and Z coordinates.
-    public long ChunkId;
-}
-
-/// <summary>
-/// Added to entities that belong to a chunk that has been unloaded. 
-/// A dedicated system will process and destroy these slowly over multiple frames.
-/// </summary>
-public struct ChunkUnloadPendingTag { }

Nerfed.Runtime/Serialization/ComponentHelper.cs

@@ -1,68 +0,0 @@
-using System.Numerics;
-using ImGuiNET;
-using MoonTools.ECS;
-using Nerfed.Runtime.Components;
-
-namespace Nerfed.Runtime.Serialization;
-
-public static class ComponentHelper
-{
-    // Auto generate this.
-    public static readonly Dictionary<Type, Func<World, Entity, ValueType>> GetComponentByType = new()
-    {
-        { typeof(LocalTransform), (world, entity) => world.Get<LocalTransform>(entity) },
-        { typeof(Root), (world, entity) => world.Get<Root>(entity) },
-    };
-    
-    // Auto generate this.
-    public static readonly Dictionary<Type, Action<World, Entity, ValueType>> SetComponentByType = new()
-    {
-        { typeof(LocalTransform), (world, entity, component) => world.Set(entity, (LocalTransform)component) },
-        { typeof(Root), (world, entity, component) => world.Set(entity, (Root)component) },
-    };
-    
-    // Auto generate this, but it should only contain user assignable components (so something like 'root' should be excluded).
-    // Maybe use an attribute for this.
-    public static readonly Dictionary<Type, Action<World, Entity>> AddComponentByType = new()
-    {
-        { typeof(LocalTransform), (world, entity) => world.Set(entity, LocalTransform.Identity) },
-    };
-
-    // Auto generate this, but also keep the option for 'custom inspectors'.
-    // Maybe via attribute?
-    public static readonly Dictionary<Type, Action<World, Entity>> ComponentInspectorByType = new()
-    {
-        {
-            typeof(LocalTransform), (world, entity) =>
-            {
-                (Vector3 position, Quaternion rotation, Vector3 scale) = world.Get<LocalTransform>(entity);
-                Vector3 eulerAngles = MathEx.ToEulerAngles(rotation);
-                eulerAngles = new Vector3(float.RadiansToDegrees(eulerAngles.X), float.RadiansToDegrees(eulerAngles.Y), float.RadiansToDegrees(eulerAngles.Z));
-                bool isDirty = false;
-                
-                ImGui.BeginGroup();
-                ImGui.Text($"{nameof(LocalTransform)}");
-                isDirty |= ImGui.DragFloat3("Position", ref position, 0.2f, float.MinValue, float.MaxValue /*, "%f0 m" */); // TODO: right format.
-                isDirty |= ImGui.DragFloat3("Rotation", ref eulerAngles);
-                isDirty |= ImGui.DragFloat3("Scale", ref scale);
-                ImGui.EndGroup();
-
-                if (!isDirty)
-                {
-                    return;
-                }
-
-                eulerAngles = new Vector3(float.DegreesToRadians(eulerAngles.X), float.DegreesToRadians(eulerAngles.Y), float.DegreesToRadians(eulerAngles.Z));
-                world.Set(entity, new LocalTransform(position, MathEx.ToQuaternion(eulerAngles), scale));
-            }
-        },
-        {
-            typeof(Root), (world, entity) =>
-            {
-                ImGui.BeginGroup();
-                ImGui.Text($"{nameof(Root)}");
-                ImGui.EndGroup();
-            }
-        },
-    };
-}

Nerfed.Runtime/Systems/LocalToWorldSystem.cs

@@ -1,120 +0,0 @@
-using MoonTools.ECS;
-using Nerfed.Runtime.Components;
-using Nerfed.Runtime.Util;
-using System;
-using System.Collections.Generic;
-using System.Numerics;
-
-// TODO:
-// Explore if having a WorldTransform and LocalTransfom component each holding position, rotation, scale values and the matricies is useful.
-// Often you need to either get or set these values.
-// If so, we probably need a utility funciton to do so. Since changing these values means that we need to update all the related data + children as well.
-
-// TODO:
-// When modifying transform all the children need to be updated as well.
-
-namespace Nerfed.Runtime.Systems
-{
-    public class LocalToWorldSystem : MoonTools.ECS.System
-    {
-        public override IReadOnlySet<Type> ReadsComponents { get; } = new HashSet<Type> { typeof(LocalTransform) };
-        public override IReadOnlySet<Type> WritesComponents { get; } = new HashSet<Type> { typeof(LocalToWorld) };
-
-        private readonly bool useParallelFor = true;
-        private const int ParallelForMinCount = 32; // Below this, parallel overhead costs more than it saves.
-        private static readonly System.Threading.Tasks.ParallelOptions ParallelOptions = new()
-        {
-            MaxDegreeOfParallelism = Environment.ProcessorCount
-        };
-        private readonly Filter rootEntitiesFilter;
-        private readonly Filter entitiesWithoutLocalToWorldFilter;
-        private readonly Action<int> updateWorldTransform;
-        private ParallelWriter<LocalToWorld> _parallelWriter;
-
-        public LocalToWorldSystem(World world) : base(world)
-        {
-            rootEntitiesFilter = FilterBuilder.Include<LocalTransform>().Exclude<Child>().Build();
-            if (useParallelFor)
-            {
-                entitiesWithoutLocalToWorldFilter = FilterBuilder.Include<LocalTransform>().Exclude<LocalToWorld>().Build();
-                updateWorldTransform = UpdateWorldTransformByIndex;
-            }
-        }
-
-        public override void Update(TimeSpan delta)
-        {
-            if (rootEntitiesFilter.Empty)
-            {
-                return;
-            }
-
-            if (useParallelFor)
-            {
-                // This check is needed because some entities might not have a LocalToWorld component yet.
-                // Adding this during the loop will break.
-                Profiler.BeginSample("ParallelFor.LocalToWorldCheck");
-                foreach (Entity entity in entitiesWithoutLocalToWorldFilter.Entities) {
-                    Set(entity, new LocalToWorld(Matrix4x4.Identity));
-                }
-                Profiler.EndSample();
-
-                // Acquire a ParallelWriter AFTER pre-allocation — all entities now have LocalToWorld.
-                // This writer only permits updating existing values; no structural mutations allowed.
-                _parallelWriter = World.GetParallelWriter<LocalToWorld>();
-
-                Profiler.BeginSample("ParallelFor.LocalToWorldUpdate");
-                if (rootEntitiesFilter.Count >= ParallelForMinCount)
-                {
-                    Parallel.For(0, rootEntitiesFilter.Count, ParallelOptions, updateWorldTransform);
-                }
-                else
-                {
-                    // Not enough work to justify thread overhead — run serially.
-                    for (int i = 0; i < rootEntitiesFilter.Count; i++)
-                    {
-                        updateWorldTransform(i);
-                    }
-                }
-                Profiler.EndSample();
-            }
-            else
-            {
-                foreach (Entity entity in rootEntitiesFilter.Entities)
-                {
-                    // Profiler.BeginSample("UpdateWorldTransform");
-                    UpdateWorldTransform(entity, Matrix4x4.Identity);
-                    // Profiler.EndSample();
-                }
-            }
-        }
-
-        private void UpdateWorldTransformByIndex(int entityFilterIndex)
-        {
-            // Profiler.BeginSample("UpdateWorldTransformByIndex");
-            Entity entity = rootEntitiesFilter.NthEntity(entityFilterIndex);
-            UpdateWorldTransform(entity, Matrix4x4.Identity);
-            // Profiler.EndSample();
-        }
-
-        private void UpdateWorldTransform(in Entity entity, Matrix4x4 localToWorldMatrix)
-        {
-            if (Has<LocalTransform>(entity))
-            {
-                LocalTransform localTransform = Get<LocalTransform>(entity);
-                localToWorldMatrix = Matrix4x4.Multiply(localToWorldMatrix, localTransform.TRS());
-                LocalToWorld localToWorld = new(localToWorldMatrix);
-
-                if (useParallelFor)
-                    _parallelWriter.Set(entity, localToWorld); // thread-safe: direct write, no structural mutation
-                else
-                    Set(entity, localToWorld);
-            }
-
-            ReverseSpanEnumerator<Entity> childEntities = World.InRelations<ChildParentRelation>(entity);
-            foreach (Entity childEntity in childEntities)
-            {
-                UpdateWorldTransform(childEntity, localToWorldMatrix);
-            }
-        }
-    }
-}

Nerfed.Runtime/Util/BoundedQueue.cs

@@ -1,73 +0,0 @@
-using System.Collections;
-
-namespace Nerfed.Runtime;
-
-public class BoundedQueue<T> : IEnumerable<T>, ICollection, IReadOnlyCollection<T>
-{
-    private readonly Queue<T> queue = null;
-    private readonly int maxSize = 10;
-    private T lastAddedElement;
-
-    public BoundedQueue(int maxSize)
-    {
-        this.maxSize = maxSize;
-        queue = new Queue<T>(maxSize);
-    }
-
-    public void Enqueue(T item)
-    {
-        queue.Enqueue(item);
-        if (queue.Count > maxSize)
-        {
-            queue.Dequeue(); // Remove the oldest element
-        }
-
-        lastAddedElement = item;
-    }
-
-    public T Dequeue()
-    {
-        return queue.Dequeue();
-    }
-
-    public T Peek()
-    {
-        return queue.Peek();
-    }
-
-    public T LastAddedElement()
-    {
-        return lastAddedElement;
-    }
-
-    public void Clear()
-    {
-        queue.Clear();
-    }
-
-    public bool Contains(T item)
-    {
-        return queue.Contains(item);
-    }
-
-    public IEnumerator<T> GetEnumerator()
-    {
-        return queue.GetEnumerator();
-    }
-
-    IEnumerator IEnumerable.GetEnumerator()
-    {
-        return queue.GetEnumerator();
-    }
-
-    public void CopyTo(Array array, int index)
-    {
-        ((ICollection)queue).CopyTo(array, index);
-    }
-
-    public int Count => queue.Count;
-    public int Capacity => maxSize;
-    public bool IsSynchronized => ((ICollection)queue).IsSynchronized;
-    public object SyncRoot => ((ICollection)queue).SyncRoot;
-    int IReadOnlyCollection<T>.Count => queue.Count;
-}

Nerfed.Runtime/Util/MathEx.cs

@@ -1,5 +1,3 @@
-using System.Numerics;
-
 namespace Nerfed.Runtime;
 
 public static class MathEx
@@ -19,51 +17,4 @@ public static class MathEx
     public static float Remap(float value, float oldMin, float oldMax, float newMin, float newMax) {
         return (value - oldMin) / (oldMax - oldMin) * (newMax - newMin) + newMin;
     }
-    
-    // https://stackoverflow.com/questions/70462758/c-sharp-how-to-convert-quaternions-to-euler-angles-xyz
-    public static Quaternion ToQuaternion(Vector3 v)
-    {
-        float cy = (float)Math.Cos(v.Z * 0.5);
-        float sy = (float)Math.Sin(v.Z * 0.5);
-        float cp = (float)Math.Cos(v.Y * 0.5);
-        float sp = (float)Math.Sin(v.Y * 0.5);
-        float cr = (float)Math.Cos(v.X * 0.5);
-        float sr = (float)Math.Sin(v.X * 0.5);
-
-        return new Quaternion
-        {
-            W = (cr * cp * cy + sr * sp * sy),
-            X = (sr * cp * cy - cr * sp * sy),
-            Y = (cr * sp * cy + sr * cp * sy),
-            Z = (cr * cp * sy - sr * sp * cy),
-        };
-    }
-
-    public static Vector3 ToEulerAngles(Quaternion q)
-    {
-        Vector3 angles = new();
-
-        // roll / x
-        double sinrCosp = 2 * (q.W * q.X + q.Y * q.Z);
-        double cosrCosp = 1 - 2 * (q.X * q.X + q.Y * q.Y);
-        angles.X = (float)Math.Atan2(sinrCosp, cosrCosp);
-
-        // pitch / y
-        double sinp = 2 * (q.W * q.Y - q.Z * q.X);
-        if (Math.Abs(sinp) >= 1)
-        {
-            angles.Y = (float)Math.CopySign(Math.PI / 2, sinp);
-        }
-        else
-        {
-            angles.Y = (float)Math.Asin(sinp);
-        }
-
-        // yaw / z
-        double sinyCosp = 2 * (q.W * q.Z + q.X * q.Y);
-        double cosyCosp = 1 - 2 * (q.Y * q.Y + q.Z * q.Z);
-        angles.Z = (float)Math.Atan2(sinyCosp, cosyCosp);
-
-        return angles;
-    }
 }

Nerfed.Runtime/Util/RandomId.cs

@@ -1,13 +0,0 @@
-using System.Security.Cryptography;
-
-namespace Nerfed.Runtime.Util;
-
-public static class RandomId
-{
-    public static uint GenerateSecureRandomUInt()
-    {
-        byte[] buffer = new byte[4];
-        RandomNumberGenerator.Fill(buffer);
-        return BitConverter.ToUInt32(buffer, 0);
-    }
-}

Nerfed.Runtime/Util/Transform.cs

@@ -1,99 +0,0 @@
-using MoonTools.ECS;
-using Nerfed.Runtime.Components;
-using System.Collections.Generic;
-using System.Numerics;
-
-namespace Nerfed.Runtime.Util
-{
-    // https://github.com/needle-mirror/com.unity.entities/blob/master/Unity.Transforms/TransformHelpers.cs
-    public static class Transform
-    {
-        public static Vector3 Forward(in this Matrix4x4 matrix) => new Vector3(matrix.M31, matrix.M32, matrix.M33);
-        public static Vector3 Back(in this Matrix4x4 matrix) => -matrix.Forward();
-        public static Vector3 Up(in this Matrix4x4 matrix) => new Vector3(matrix.M21, matrix.M22, matrix.M23);
-        public static Vector3 Down(in this Matrix4x4 matrix) => -matrix.Up();
-        public static Vector3 Right(in this Matrix4x4 matrix) => new Vector3(matrix.M11, matrix.M12, matrix.M13);
-        public static Vector3 Left(in this Matrix4x4 matrix) => -matrix.Right();
-        //public static Vector3 Translation(in this Matrix4x4 matrix) => new Vector3();
-        //public static Quaternion Rotation(in this Matrix4x4 matrix) => new Quaternion();
-
-        public static Matrix4x4 TRS(in this LocalTransform localTransform)
-        {
-            return Matrix4x4.CreateScale(localTransform.scale) *
-                Matrix4x4.CreateFromQuaternion(localTransform.rotation) *
-                Matrix4x4.CreateTranslation(localTransform.position);
-        }
-
-        // Sets the parent child relation and adds a child component.
-        // Relation goes from child to parent.
-        public static void SetParent(in World world, in Entity child, in Entity parent)
-        {
-            RemoveParent(world, child);
-
-            world.Relate(child, parent, new ChildParentRelation());
-            world.Set(child, new Child());
-            world.Remove<Root>(child);
-            return;
-        }
-
-        // Removes any parent child relation ship, thus making it a 'root' object.
-        public static void RemoveParent(in World world, in Entity child)
-        {
-            if (!world.HasOutRelation<ChildParentRelation>(child))
-            {
-                return;
-            }
-
-            Entity parent = world.OutRelationSingleton<ChildParentRelation>(child);
-
-            // TODO: Check if Unrelate all also unrelates incomming relations..?
-            world.Unrelate<ChildParentRelation>(child, parent);
-            world.Remove<Child>(child);
-            world.Set(child, new Root());
-        }
-
-        public static Entity CreateBaseEntity(this World world, string tag = "")
-        {
-            Entity entity = world.CreateEntity(tag);
-            world.Set(entity, new Root());
-            return entity;
-        }
-
-        // Force update the transform data of an entity (and children).
-        // Useful for when you need precise up to date transform data.
-        public static void ForceUpdateLocalToWorld(in World world, in Entity entity)
-        {
-            Matrix4x4 parentLocalToWorldMatrix = Matrix4x4.Identity;
-
-            if (world.HasOutRelation<ChildParentRelation>(entity)) {
-                Entity parent = world.OutRelationSingleton<ChildParentRelation>(entity);
-
-                if (world.Has<LocalToWorld>(parent))
-                {
-                    parentLocalToWorldMatrix = world.Get<LocalToWorld>(parent).localToWorldMatrix;
-                }
-            }
-
-            ForceUpdateLocalToWorld(world, entity, parentLocalToWorldMatrix);
-        }
-
-        private static void ForceUpdateLocalToWorld(in World world, in Entity entity, Matrix4x4 localToWorldMatrix)
-        {
-            if (world.Has<LocalTransform>(entity))
-            {
-                LocalTransform localTransform = world.Get<LocalTransform>(entity);
-                localToWorldMatrix = Matrix4x4.Multiply(localToWorldMatrix, localTransform.TRS());
-                LocalToWorld localToWorld = new(localToWorldMatrix);
-                world.Set(entity, localToWorld);
-
-                Log.Info($"Entity {entity} | local position {localTransform.position} | world position {localToWorldMatrix.Translation}");
-            }
-
-            ReverseSpanEnumerator<Entity> childEntities = world.InRelations<ChildParentRelation>(entity);
-            foreach (Entity childEntity in childEntities)
-            {
-                ForceUpdateLocalToWorld(world, childEntity, localToWorldMatrix);
-            }
-        }
-    }
-}

Nerfed.sln

@@ -5,38 +5,54 @@ VisualStudioVersion = 17.10.35013.160
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Runtime", "Nerfed.Runtime\Nerfed.Runtime.csproj", "{98E09BAF-587F-4238-89BD-7693C036C233}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nerfed.Builder", "Nerfed.Builder\Nerfed.Builder.csproj", "{1B88DE56-2AD8-441E-9B10-073AA43840BF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Builder", "Nerfed.Builder\Nerfed.Builder.csproj", "{1B88DE56-2AD8-441E-9B10-073AA43840BF}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nerfed.Editor", "Nerfed.Editor\Nerfed.Editor.csproj", "{FF7D032D-7F0B-4700-A818-0606D66AECF8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Editor", "Nerfed.Editor\Nerfed.Editor.csproj", "{FF7D032D-7F0B-4700-A818-0606D66AECF8}"
 	ProjectSection(ProjectDependencies) = postProject
 		{1B88DE56-2AD8-441E-9B10-073AA43840BF} = {1B88DE56-2AD8-441E-9B10-073AA43840BF}
 	EndProjectSection
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Nerfed.Compiler", "Nerfed.Compiler\Nerfed.Compiler.csproj", "{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nerfed.Runtime.Generator", "Nerfed.Runtime.Generator\Nerfed.Runtime.Generator.csproj", "{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Test|x64 = Test|x64
-		Release|x64 = Release|x64
 		Debug|x64 = Debug|x64
+		Release|x64 = Release|x64
+		Test|x64 = Test|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Test|x64.ActiveCfg = Test|x64
-		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Test|x64.Build.0 = Test|x64
-		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.ActiveCfg = Release|x64
-		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.Build.0 = Release|x64
-		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.ActiveCfg = Debug|x64
-		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.Build.0 = Debug|x64
-		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Test|x64.ActiveCfg = Test|x64
-		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Test|x64.Build.0 = Test|x64
-		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.ActiveCfg = Release|x64
-		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.Build.0 = Release|x64
-		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.ActiveCfg = Debug|x64
-		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.Build.0 = Debug|x64
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.ActiveCfg = Test|x64
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.Build.0 = Test|x64
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.ActiveCfg = Release|x64
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.Build.0 = Release|x64
 		{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|x64.ActiveCfg = Debug|x64
 		{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|x64.Build.0 = Debug|x64
+		{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.ActiveCfg = Release|x64
+		{98E09BAF-587F-4238-89BD-7693C036C233}.Release|x64.Build.0 = Release|x64
+		{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.ActiveCfg = Test|x64
+		{98E09BAF-587F-4238-89BD-7693C036C233}.Test|x64.Build.0 = Test|x64
+		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.ActiveCfg = Debug|x64
+		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Debug|x64.Build.0 = Debug|x64
+		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.ActiveCfg = Release|x64
+		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Release|x64.Build.0 = Release|x64
+		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Test|x64.ActiveCfg = Test|x64
+		{1B88DE56-2AD8-441E-9B10-073AA43840BF}.Test|x64.Build.0 = Test|x64
+		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.ActiveCfg = Debug|x64
+		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Debug|x64.Build.0 = Debug|x64
+		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.ActiveCfg = Release|x64
+		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Release|x64.Build.0 = Release|x64
+		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Test|x64.ActiveCfg = Test|x64
+		{FF7D032D-7F0B-4700-A818-0606D66AECF8}.Test|x64.Build.0 = Test|x64
+		{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Debug|x64.ActiveCfg = Debug|x64
+		{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Debug|x64.Build.0 = Debug|x64
+		{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Release|x64.ActiveCfg = Release|x64
+		{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Release|x64.Build.0 = Release|x64
+		{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Test|x64.ActiveCfg = Test|x64
+		{3DFEB8A4-5354-41EA-A249-27ADC7F666CF}.Test|x64.Build.0 = Test|x64
+		{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Debug|x64.ActiveCfg = Debug|x64
+		{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Debug|x64.Build.0 = Debug|x64
+		{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Release|x64.ActiveCfg = Release|x64
+		{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Release|x64.Build.0 = Release|x64
+		{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Test|x64.ActiveCfg = Test|x64
+		{8743FDEF-4FF6-48F9-9F64-7BDEC543C105}.Test|x64.Build.0 = Test|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE