EditorGui setup

- Configured csprojects
- CopyLibs functionality in builder

.gitignore

@@ -451,8 +451,13 @@ FodyWeavers.xsd
 
 #------------------------- Nerfed -------------------------
 
+Bin/
+Intermediate/
+
 imgui.ini
 
 # include libs
-!/libs/lib64
-!/libs/x64
+!/Native/lib64
+!/Native/x64
+
+

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

@@ -2,5 +2,10 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/FAudio" 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" />
+    <mapping directory="$PROJECT_DIR$/Nerfed.Runtime/Libraries/dav1dfile" vcs="Git" />
   </component>
 </project>

Directory.Build.props

@@ -0,0 +1,7 @@
+<Project>
+   <PropertyGroup>
+      <OutDir>../Bin/$(MSBuildProjectName)</OutDir>
+      <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">../Intermediate/$(MSBuildProjectName)</BaseIntermediateOutputPath>
+   </PropertyGroup>
+</Project>
+

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Nerfed Engine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Nerfed.Builder/ArgsParser.cs

@@ -0,0 +1,129 @@
+using System.Collections;
+using System.ComponentModel;
+using System.Reflection;
+
+namespace Nerfed.Builder;
+
+
+public class ArgsParser<TArgs> where TArgs : new()
+{
+    private enum ArgType
+    {
+        None,
+        Key,
+        Value
+    }
+
+    public TArgs Arguments { get; }
+
+    private readonly string[] args;
+    private readonly Dictionary<string, PropertyInfo> argKeyPropertyMap = new Dictionary<string, PropertyInfo>();
+
+    public ArgsParser(string[] args)
+    {
+        this.args = args;
+        Arguments = new TArgs();
+        PropertyInfo[] properties = Arguments.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
+        foreach (PropertyInfo property in properties)
+        {
+            ArgumentAttribute argAttribute = property.GetCustomAttribute<ArgumentAttribute>();
+            if (argAttribute == null || string.IsNullOrEmpty(argAttribute.ArgKey))
+            {
+                continue;
+            }
+
+            argKeyPropertyMap.Add(argAttribute.ArgKey, property);
+        }
+    }
+
+    public bool Parse()
+    {
+        PropertyInfo property = null;
+        ArgType lastArgType = ArgType.None;
+
+        for (int i = 0; i < args.Length; i++)
+        {
+            string arg = args[i];
+            if (arg[0] == '-')
+            {
+                if (!argKeyPropertyMap.TryGetValue(arg, out property))
+                {
+                    Console.Error.WriteLine($"Invalid argument: {arg}, no such argument key exists");
+                    return false;
+                }
+
+                // Boolean arguments require no value, set to true immidiately.
+                if (property.PropertyType == typeof(bool))
+                {
+                    property.SetValue(Arguments, true);
+                    lastArgType = ArgType.Value;
+                }
+                else
+                {
+                    lastArgType = ArgType.Key;
+                }
+            }
+            else
+            {
+                if (lastArgType == ArgType.None)
+                {
+                    Console.Error.WriteLine($"Invalid argument: {arg}, no argument key was provided");
+                    return false;
+                }
+
+                Type propertyType = property.PropertyType;
+                if (propertyType.IsArray)
+                {
+                    throw new InvalidOperationException("Arrays are not supported, use List<T> instead");
+                }
+
+                bool propertyTypeIsList = propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(List<>);
+                if (propertyTypeIsList)
+                {
+                    propertyType = propertyType.GenericTypeArguments[0];
+                }
+
+                TypeConverter typeConverter = TypeDescriptor.GetConverter(propertyType);
+                object value = typeConverter.ConvertFromString(arg);
+
+                if (value is string stringValue)
+                {
+                    if (!string.IsNullOrEmpty(stringValue))
+                    {
+                        if (stringValue[0] == '"')
+                        {
+                            stringValue = stringValue.Substring(1, stringValue.Length - 1);
+                        }
+
+                        if (stringValue[^1] == '"')
+                        {
+                            stringValue = stringValue.Substring(0, stringValue.Length - 1);
+                        }
+
+                        value = stringValue;
+                    }
+                }
+
+                if (propertyTypeIsList)
+                {
+                    IList list = (IList)property.GetValue(Arguments);
+                    if (list == null)
+                    {
+                        list = (IList)Activator.CreateInstance(property.PropertyType);
+                        property.SetValue(Arguments, list);
+                    }
+
+                    list.Add(value);
+                }
+                else
+                {
+                    property.SetValue(Arguments, value);
+                }
+
+                lastArgType = ArgType.Value;
+            }
+        }
+
+        return true;
+    }
+}

Nerfed.Builder/ArgumentAttribute.cs

@@ -0,0 +1,11 @@
+namespace Nerfed.Builder;
+
+public class ArgumentAttribute : Attribute
+{
+    public string ArgKey { get; }
+
+    public ArgumentAttribute(string argKey)
+    {
+        ArgKey = argKey;
+    }
+}

Nerfed.Builder/Builder/BuildArgs.cs

@@ -0,0 +1,16 @@
+namespace Nerfed.Builder;
+
+public class BuildArgs
+{
+    [Argument("-build")]
+    public bool Build { get; set; }
+    
+    [Argument("-projectPath")]
+    public string ProjectPath { get; set; }
+
+    [Argument("-platform")]
+    public string Platform { get; set; }
+
+    [Argument("-content")]
+    public List<string> ContentFiles { get; set; }
+}

Nerfed.Builder/Builder/Builder.cs

@@ -0,0 +1,149 @@
+using System.Diagnostics;
+
+namespace Nerfed.Builder;
+
+public class Builder : IDisposable
+{
+    private readonly Dictionary<string, IImporter> importers = new Dictionary<string, IImporter>();
+    private readonly RawFileImporter rawFileImporter;
+
+    public Builder()
+    {
+        rawFileImporter = new RawFileImporter();
+
+        ShaderImporter shaderImporter = new ShaderImporter();
+        importers.Add(".vert", shaderImporter); // Vertex shader
+        importers.Add(".frag", shaderImporter); // Fragment shader
+        importers.Add(".tesc", shaderImporter); // Tessellation control shader
+        importers.Add(".tese", shaderImporter); // Tessellation evaluation shader
+        importers.Add(".geom", shaderImporter); // Geometry shader
+        importers.Add(".comp", shaderImporter); // Compute shader
+    }
+
+    public void Run(BuildArgs args)
+    {
+        Stopwatch stopwatch = new Stopwatch();
+        stopwatch.Start();
+
+        CopyLibs(args.ProjectPath);
+
+        List<string> contentFiles = args.ContentFiles;
+        string absContentPath = $"{args.ProjectPath}/{PathUtil.ContentFolderName}";
+
+        // If no files are provided, build all content.
+        if (args.ContentFiles == null)
+        {
+            contentFiles = [];
+            CollectAssetFiles(absContentPath, absContentPath, ref contentFiles);
+        }
+
+        string importPath = $"{args.ProjectPath}/{PathUtil.ImportFolderName}";
+
+        ParallelOptions parallelOptions = new ParallelOptions
+        {
+            MaxDegreeOfParallelism = contentFiles.Count
+        };
+        Parallel.ForEach(contentFiles, parallelOptions, relativeFile =>
+        {
+            try
+            {
+                string inFile = $"{args.ProjectPath}/{PathUtil.ContentFolderName}/{relativeFile}";
+
+                if (!File.Exists(inFile))
+                {
+                    Console.Error.WriteLine($"Asset file '{relativeFile}' not found");
+                    return;
+                }
+
+                string outFile = $"{importPath}/{relativeFile}{PathUtil.ImportedFileExtension}";
+
+                FileInfo inFileInfo = new FileInfo(inFile);
+                FileInfo outFileInfo = new FileInfo(outFile);
+
+                if (!FileUtil.IsNewer(inFileInfo, outFileInfo))
+                {
+                    // File has not changed since last build, no need to build this one.
+                    return;
+                }
+
+                string outDir = Path.GetDirectoryName(outFile);
+                if (!Directory.Exists(outDir))
+                {
+                    Directory.CreateDirectory(outDir);
+                }
+
+                string ext = Path.GetExtension(inFile).ToLower();
+                if (importers.TryGetValue(ext, out IImporter importer))
+                {
+                    importer.Import(inFile, outFile);
+                }
+                else
+                {
+                    rawFileImporter.Import(inFile, outFile);
+                }
+
+                Console.WriteLine(relativeFile);
+            }
+            catch (Exception e)
+            {
+                Console.Error.WriteLine($"Import error on asset '{relativeFile}': {e.Message}");
+            }
+        });
+
+        Console.WriteLine($"Build content completed in {stopwatch.Elapsed.TotalSeconds:F2} seconds");
+    }
+
+    private void CopyLibs(string projectPath)
+    {
+        string libDir = $"{Directory.GetCurrentDirectory()}/../../Native/";
+        if (OperatingSystem.IsWindows())
+        {
+            libDir += "x64";
+        }
+        else if (OperatingSystem.IsLinux())
+        {
+            libDir += "lib64";
+        }
+        else if (OperatingSystem.IsMacOS())
+        {
+            libDir += "osx";
+        }
+
+        libDir = Path.GetFullPath(libDir);
+        foreach (string libFile in Directory.EnumerateFiles(libDir))
+        {
+            FileInfo srcFileInfo = new FileInfo(libFile);
+            FileInfo dstFileInfo = new FileInfo($"{projectPath}/{PathUtil.BuildFolderName}/{Path.GetFileName(libFile)}");
+            if (FileUtil.IsNewer(srcFileInfo, dstFileInfo))
+            {
+                FileUtil.Copy(srcFileInfo, dstFileInfo);
+            }
+        }
+    }
+
+    private void CollectAssetFiles(string assetDir, string dir, ref List<string> files)
+    {
+        foreach (string file in Directory.EnumerateFiles(dir))
+        {
+            if (Path.GetExtension(file).Equals(PathUtil.ImportFileExtension, StringComparison.CurrentCultureIgnoreCase))
+            {
+                continue;
+            }
+
+            string relativeFile = file.Substring(assetDir.Length, file.Length - assetDir.Length);
+            if (relativeFile[0] == Path.DirectorySeparatorChar || relativeFile[0] == Path.AltDirectorySeparatorChar)
+            {
+                relativeFile = relativeFile.Substring(1, relativeFile.Length - 1);
+            }
+
+            files.Add(relativeFile);
+        }
+
+        foreach (string subDir in Directory.EnumerateDirectories(dir))
+        {
+            CollectAssetFiles(assetDir, subDir, ref files);
+        }
+    }
+
+    public void Dispose() { }
+}

Nerfed.Builder/Builder/FileUtil.cs

@@ -0,0 +1,49 @@
+namespace Nerfed.Builder;
+
+public static class FileUtil
+{
+    public static void Copy(FileInfo srcFile, FileInfo dstFile)
+    {
+        Copy(srcFile.FullName, dstFile.FullName);
+    }
+
+    public static void Copy(string srcFile, string dstFile)
+    {
+        string dstDir = Path.GetDirectoryName(dstFile);
+        if (!Directory.Exists(dstDir))
+        {
+            Directory.CreateDirectory(dstDir);
+        }
+
+        File.Copy(srcFile, dstFile, true);
+        UpdateFileTimeAttributes(dstFile);
+    }
+
+    public static void WriteBytes(string dstFile, byte[] bytes)
+    {
+        File.WriteAllBytes(dstFile, bytes);
+        UpdateFileTimeAttributes(dstFile);
+    }
+
+    public static void UpdateFileTimeAttributes(string file)
+    {
+        // Copy over date time attributes so we can check if the file changed.
+        FileInfo dstFileInfo = new FileInfo(file);
+        DateTime now = DateTime.Now;
+        DateTime utcNow = DateTime.UtcNow;
+        dstFileInfo.CreationTime = now;
+        dstFileInfo.CreationTimeUtc = utcNow;
+        dstFileInfo.LastWriteTime = now;
+        dstFileInfo.LastWriteTimeUtc = utcNow;
+        dstFileInfo.LastAccessTime = now;
+        dstFileInfo.LastAccessTimeUtc = utcNow;
+    }
+
+    /// <summary>
+    /// True if the inFileInfo is newer than the outFileInfo.
+    /// </summary>
+    public static bool IsNewer(FileInfo inFileInfo, FileInfo outFileInfo)
+    {
+        return !outFileInfo.Exists || outFileInfo.LastWriteTime <= inFileInfo.LastWriteTime;
+    }
+}

Nerfed.Builder/Builder/IImporter.cs

@@ -0,0 +1,6 @@
+namespace Nerfed.Builder;
+
+public interface IImporter
+{
+    void Import(string inFile, string outFile);
+}

Nerfed.Builder/Builder/Importers/RawFileImporter.cs

@@ -0,0 +1,9 @@
+namespace Nerfed.Builder;
+
+public class RawFileImporter : IImporter
+{
+    public void Import(string inFile, string outFile)
+    {
+        FileUtil.Copy(inFile, outFile);
+    }
+}

Nerfed.Builder/Builder/Importers/ShaderImporter.cs

@@ -0,0 +1,33 @@
+using System.Diagnostics;
+
+namespace Nerfed.Builder;
+
+public class ShaderImporter : IImporter
+{
+    public void Import(string inFile, string outFile)
+    {
+        using (Process proc = new Process())
+        {
+            string glslc;
+            if (OperatingSystem.IsWindows())
+            {
+                glslc = "Win64/glslc.exe";
+            }
+            else if (OperatingSystem.IsLinux())
+            {
+                glslc = "Linux/glslc";
+            }
+            else
+            {
+                throw new PlatformNotSupportedException("No shader compiler found for current platform");
+            }
+
+            proc.StartInfo.FileName = glslc;
+            proc.StartInfo.Arguments = @$"""{inFile}"" -o ""{outFile}"" -c";
+            proc.StartInfo.CreateNoWindow = true;
+            proc.StartInfo.UseShellExecute = false;
+            proc.Start();
+            proc.WaitForExit();
+        }
+    }
+}

Nerfed.Builder/Nerfed.Builder.csproj

@@ -0,0 +1,25 @@
+<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' ">
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Test|x64' ">
+        <Optimize>true</Optimize>
+    </PropertyGroup>
+    
+    <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+        <Optimize>true</Optimize>
+    </PropertyGroup>
+    
+</Project>

Nerfed.Builder/Nerfed.Builder.csproj.DotSettings

@@ -0,0 +1,4 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=builder/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=builder_005Cimporters/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=packager/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Nerfed.Builder/Packager/PackageArgs.cs

@@ -0,0 +1,6 @@
+namespace Nerfed.Builder;
+
+public class PackageArgs
+{
+    
+}

Nerfed.Builder/Packager/Packager.cs

@@ -0,0 +1,12 @@
+namespace Nerfed.Builder;
+
+public class Packager : IDisposable
+{
+    public void Run(PackageArgs args)
+    {
+    }
+
+    public void Dispose()
+    {
+    }
+}

Nerfed.Builder/PathUtil.cs

@@ -0,0 +1,10 @@
+namespace Nerfed.Builder;
+
+public static class PathUtil
+{
+    public const string ImportedFileExtension = ".bin";
+    public const string BuildFolderName = ".build";
+    public const string ImportFileExtension = ".import";
+    public const string ImportFolderName = $"{BuildFolderName}/Import";
+    public const string ContentFolderName = "Content";
+}

Nerfed.Builder/Program.cs

@@ -0,0 +1,70 @@
+using System.Diagnostics;
+
+namespace Nerfed.Builder;
+
+internal class Program
+{
+    private static int Main(string[] args)
+    {
+        if (Debugger.IsAttached)
+        {
+            return Run(args);
+        }
+        else
+        {
+            try
+            {
+                return Run(args);
+            }
+            catch (Exception e)
+            {
+                Console.Error.WriteLine(e.Message);
+                return -1;
+            }
+        }
+    }
+
+    private static int Run(string[] rawArgs)
+    {
+        if (rawArgs.Length == 0)
+        {
+            Console.Error.WriteLine($"Invalid build type '{rawArgs[0]}' expected '-build' or '-package'");
+            return -1;
+        }
+
+        string buildType = rawArgs[0].ToLower();
+        if (buildType == "-build")
+        {
+            ArgsParser<BuildArgs> parser = new ArgsParser<BuildArgs>(rawArgs);
+            if (!parser.Parse())
+            {
+                Console.Error.Write("Failed to parse build arguments");
+                return -1;
+            }
+
+            using (Builder builder = new Builder())
+            {
+                builder.Run(parser.Arguments);
+            }
+        }
+        else if (buildType == "-package")
+        {
+            ArgsParser<PackageArgs> parser = new ArgsParser<PackageArgs>(rawArgs);
+            if (!parser.Parse())
+            {
+                Console.Error.Write("Failed to parse package arguments");
+                return -1;
+            }
+
+            using (Packager packager = new Packager())
+            {
+                packager.Run(parser.Arguments);
+            }
+
+            Console.Error.WriteLine("Packaging not yet implemented");
+            return -1;
+        }
+
+        return 0;
+    }
+}

Nerfed.Editor/CopyLibs.targets

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <Target Name="Runtime ID" AfterTargets="Build">
+        <Message Text="Runtime ID: $(RuntimeIdentifier)" Importance="high"/>
+    </Target>
+
+    <ItemGroup Condition="$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Windows)))">
+        <Libs Include="..\Native\x64\**\*.*"/>
+    </ItemGroup>
+    <ItemGroup Condition="$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Linux)))">
+        <Libs Include="..\Native\lib64\**\*.*"/>
+    </ItemGroup>
+    <ItemGroup Condition="$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::OSX)))">
+        <Libs Include="..\Native\osx\**\*.*"/>
+    </ItemGroup>
+
+    <Target Name="CopyLibs" AfterTargets="Build">
+        <Copy SourceFiles="@(Libs)" DestinationFolder="$(OutDir)" SkipUnchangedFiles="true" OverwriteReadOnlyFiles="true"/>
+    </Target>
+
+</Project>

Nerfed.Editor/Editor/EditorGui.cs

@@ -0,0 +1,71 @@
+using ImGuiNET;
+using Nerfed.Runtime;
+using Nerfed.Runtime.Graphics;
+using Nerfed.Runtime.Gui;
+
+namespace Nerfed.Editor
+{
+    internal static class EditorGui
+    {
+        private static GuiController guiController;
+
+        internal static void Initialize()
+        {
+            // Create GuiController.
+            guiController = new GuiController(Engine.GraphicsDevice, Engine.MainWindow, Color.DimGray);
+            // Subscribe to GUI update.
+            // GuiController.OnGui call => UpdateDock;
+            // GuiController.OnGui call => UpdateEditorWindows;
+            // GuiController.OnGui call => ...;
+            guiController.OnGui += HandleOnGui;
+        }
+
+        internal static void Update()
+        {
+            // Update GuiController.
+            guiController.Update(Engine.Timestep.TotalSeconds);
+        }
+
+        internal static void Render()
+        {
+            // Reneder GuiController.
+            guiController.Render();
+        }
+
+        internal static void Quit()
+        {
+            guiController.Dispose();
+        }
+
+        private static void UpdateDock()
+        {
+            // Setup default dockspace for the main window.
+            uint id = ImGui.GetID("MainDockSpace");
+            ImGui.DockSpaceOverViewport(id, ImGui.GetMainViewport(), ImGuiDockNodeFlags.None);
+        }
+
+        private static void UpdateMainMenu()
+        {
+            if (ImGui.BeginMainMenuBar())
+            {
+                if (ImGui.BeginMenu("File"))
+                {
+                    if (ImGui.MenuItem("Exit"))
+                    {
+                        Engine.Quit();
+                    }
+                    ImGui.EndMenu();
+                }
+                ImGui.EndMainMenuBar();
+            }
+        }
+
+        private static void HandleOnGui()
+        {
+            UpdateMainMenu();
+            UpdateDock();
+
+            ImGui.ShowDemoWindow();
+        }
+    }
+}

Nerfed.Editor/Nerfed.Editor.csproj

@@ -0,0 +1,30 @@
+<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' ">
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Test|x64' ">
+        <Optimize>true</Optimize>
+    </PropertyGroup>
+    
+    <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+        <Optimize>true</Optimize>
+    </PropertyGroup>
+    
+    <ItemGroup>
+        <ProjectReference Include="..\Nerfed.Runtime\Nerfed.Runtime.csproj" />
+    </ItemGroup>
+
+    <Import Project=".\CopyLibs.targets" />
+</Project>

Nerfed.Editor/Program.cs

@@ -0,0 +1,42 @@
+using Nerfed.Runtime;
+
+namespace Nerfed.Editor;
+
+internal class Program
+{
+    private static void Main(string[] args)
+    {
+        Engine.OnInitialize += HandleOnInitialize;
+        Engine.OnUpdate += HandleOnUpdate;
+        Engine.OnRender += HandleOnRender;
+        Engine.OnQuit += HandleOnQuit;
+
+        Engine.Run(args);
+    }
+
+    private static void HandleOnInitialize()
+    {
+        // Open project.
+        // Setip EditorGui.
+        EditorGui.Initialize();
+    }
+
+    private static void HandleOnUpdate()
+    {
+        // Editor Update.
+        EditorGui.Update();
+
+
+        // Try Catch UserCode Update.
+    }
+
+    private static void HandleOnRender()
+    {
+        EditorGui.Render();
+    }
+
+    private static void HandleOnQuit()
+    {
+        EditorGui.Quit();
+    }
+}

Nerfed.Runtime/CopyLibs.targets

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-
-	<Target Name="Runtime ID"  AfterTargets="Build">
-    	<Message Text="Runtime ID: $(RuntimeIdentifier)" Importance="high"/>
-	</Target>
-
-	<ItemGroup Condition="$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Windows)))">
-		<Content Include="..\libs\x64\**\*.*" >
-			<Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-		</Content>
-	</ItemGroup>
-	<ItemGroup Condition="$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Linux)))">
-		<Content Include="..\libs\lib64\**\*.*" >
-			<Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-		</Content>
-	</ItemGroup>
-	<ItemGroup Condition="$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::OSX)))">
-		<Content Include="..\libs\osx\**\*.*" >
-			<Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-		</Content>
-	</ItemGroup>
-
-</Project>

Nerfed.Runtime/Engine.cs

@@ -7,6 +7,11 @@ namespace Nerfed.Runtime;
 
 public static class Engine
 {
+    public static event Action OnInitialize;
+    public static event Action OnUpdate;
+    public static event Action OnRender;
+    public static event Action OnQuit;
+
     public static TimeSpan MaxDeltaTime { get; set; } = TimeSpan.FromMilliseconds(100);
     public static bool VSync { get; set; }
 
@@ -39,9 +44,7 @@ public static class Engine
     private const string WindowTitle = "Nerfed";
     //..
 
-    private static Gui.GuiController Controller;
-
-    internal static void Run(string[] args)
+    public static void Run(string[] args)
     {
         Timestep = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / TargetTimestep);
         gameTimer = Stopwatch.StartNew();
@@ -56,7 +59,7 @@ public static class Engine
         {
             throw new Exception("Failed to init SDL");
         }
-
+        
         GraphicsDevice = new GraphicsDevice(BackendFlags.All);
 
         MainWindow = new Window(GraphicsDevice, new WindowCreateInfo(WindowTitle, WindowWidth, WindowHeight, ScreenMode.Windowed));
@@ -67,17 +70,15 @@ public static class Engine
 
         AudioDevice = new AudioDevice();
 
-        Controller = new Gui.GuiController(GraphicsDevice, MainWindow, Color.DarkOliveGreen);
-        Controller.OnGui += () => {
-            ImGuiNET.ImGui.ShowDemoWindow();
-        };
+        OnInitialize?.Invoke();
 
         while (!quit)
         {
             Tick();
         }
 
-        Controller.Dispose();
+        OnQuit?.Invoke();
+
         GraphicsDevice.UnclaimWindow(MainWindow);
         MainWindow.Dispose();
         GraphicsDevice.Dispose();
@@ -154,7 +155,7 @@ public static class Engine
                 ProcessSDLEvents();
 
                 // Tick game here...
-                Controller.Update((float)Timestep.TotalSeconds);
+                OnUpdate?.Invoke();
 
                 AudioDevice.WakeThread();
                 accumulatedUpdateTime -= Timestep;
@@ -163,7 +164,7 @@ public static class Engine
             double alpha = accumulatedUpdateTime / Timestep;
 
             // Render here..
-            Controller.Render();
+            OnRender?.Invoke();
 
             accumulatedDrawTime -= framerateCapTimeSpan;
         }

Nerfed.Runtime/Gui/GuiController.cs

@@ -9,11 +9,11 @@ using System.Runtime.InteropServices;
 
 namespace Nerfed.Runtime.Gui;
 
-internal class GuiController : IDisposable
+public class GuiController : IDisposable
 {
     public event Action OnGui;
 
-    private readonly string shaderContentPath = Path.Combine(System.AppContext.BaseDirectory, "Assets", "Shaders");
+    private readonly string shaderContentPath = Path.Combine(System.AppContext.BaseDirectory, "Content", "Shaders");
 
     private readonly GraphicsDevice graphicsDevice;
     private readonly Window mainWindow;
@@ -37,7 +37,7 @@ internal class GuiController : IDisposable
     private readonly Shader imGuiFragmentShader;
     private readonly Sampler imGuiSampler;
     private readonly GuiTextureStorage textureStorage = new GuiTextureStorage();
-    private readonly Dictionary<Window, GCHandle> windows = new Dictionary<Window, GCHandle>(16);
+    private readonly GuiViewportWindow mainViewportWindow;
 
     private Texture fontTexture = null;
     private uint vertexCount = 0;
@@ -48,8 +48,8 @@ internal class GuiController : IDisposable
 
     public GuiController(GraphicsDevice graphicsDevice, Window mainWindow, Color clearColor, ImGuiConfigFlags configFlags = ImGuiConfigFlags.NavEnableKeyboard | ImGuiConfigFlags.DockingEnable | ImGuiConfigFlags.ViewportsEnable)
     {
-        this.mainWindow = mainWindow;
         this.graphicsDevice = graphicsDevice;
+        this.mainWindow = mainWindow;
         this.clearColor = clearColor;
 
         resourceUploader = new ResourceUploader(graphicsDevice);
@@ -100,7 +100,6 @@ internal class GuiController : IDisposable
         BuildFontAtlas();
 
         io.ConfigFlags = configFlags;
-        //io.MouseDrawCursor = true;
 
         if (!OperatingSystem.IsWindows())
         {
@@ -111,9 +110,7 @@ internal class GuiController : IDisposable
         ImGuiPlatformIOPtr platformIO = ImGui.GetPlatformIO();
         ImGuiViewportPtr mainViewport = platformIO.Viewports[0];
         mainViewport.PlatformHandle = mainWindow.Handle;
-        GCHandle handle = GCHandle.Alloc(mainWindow);
-        mainViewport.PlatformUserData = (IntPtr)handle;
-        AddWindow(mainWindow, mainViewport, handle);
+        mainViewportWindow = new GuiViewportWindow(graphicsDevice, mainViewport, mainWindow);
 
         unsafe
         {
@@ -147,9 +144,13 @@ internal class GuiController : IDisposable
         io.BackendFlags |= ImGuiBackendFlags.HasSetMousePos;
         io.BackendFlags |= ImGuiBackendFlags.PlatformHasViewports;
         io.BackendFlags |= ImGuiBackendFlags.RendererHasViewports;
+
+        UpdatePerFrameImGuiData(1.0 / 60.0);
+        ImGui.NewFrame();
+        frameBegun = true;
     }
 
-    public void Update(float deltaTime)
+    public void Update(double deltaTime)
     {
         if (frameBegun)
         {
@@ -167,20 +168,15 @@ internal class GuiController : IDisposable
 
         OnGui?.Invoke();
 
-        {   // Debug
-            ImGuiIOPtr io = ImGui.GetIO();
-            ImGui.Text($"mouse pos: {io.MousePos}");
-        }
-
         ImGui.EndFrame();
     }
 
-    private void UpdatePerFrameImGuiData(float deltaSeconds)
+    private void UpdatePerFrameImGuiData(double deltaSeconds)
     {
         ImGuiIOPtr io = ImGui.GetIO();
         io.DisplaySize = new Vector2(mainWindow.Width, mainWindow.Height);
         io.DisplayFramebufferScale = new Vector2(1, 1);
-        io.DeltaTime = deltaSeconds; // DeltaTime is in seconds.
+        io.DeltaTime = (float)deltaSeconds; // DeltaTime is in seconds.
     }
 
     private void UpdateInput()
@@ -261,7 +257,7 @@ internal class GuiController : IDisposable
 
         if (imGuiCursor == ImGuiMouseCursor.None || io.MouseDrawCursor)
         {
-            SDL2.SDL.SDL_ShowCursor(0);
+            _ = SDL2.SDL.SDL_ShowCursor(0);
         }
         else
         {
@@ -279,7 +275,7 @@ internal class GuiController : IDisposable
                 _ => SDL2.SDL.SDL_CreateSystemCursor(SDL2.SDL.SDL_SystemCursor.SDL_SYSTEM_CURSOR_ARROW),
             };
             SDL2.SDL.SDL_SetCursor(sdlCursor);
-            SDL2.SDL.SDL_ShowCursor(1);
+            _ = SDL2.SDL.SDL_ShowCursor(1);
         }
     }
 
@@ -324,9 +320,9 @@ internal class GuiController : IDisposable
             for (int i = 0; i < platformIO.Viewports.Size; i++)
             {
                 ImGuiViewportPtr vp = platformIO.Viewports[i];
-                Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+                GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
 
-                if (!window.Claimed)
+                if (!window.Window.Claimed)
                 {
                     continue;
                 }
@@ -334,7 +330,7 @@ internal class GuiController : IDisposable
                 UpdateImGuiBuffers(vp.DrawData);
 
                 CommandBuffer commandBuffer = graphicsDevice.AcquireCommandBuffer();
-                Texture swapchainTexture = commandBuffer.AcquireSwapchainTexture(window);
+                Texture swapchainTexture = commandBuffer.AcquireSwapchainTexture(window.Window);
 
                 if (swapchainTexture != null)
                 {
@@ -363,7 +359,7 @@ internal class GuiController : IDisposable
             {
                 RenderCommandLists(commandBuffer, swapchainTexture, drawDataPtr);
                 graphicsDevice.Submit(commandBuffer);
-                graphicsDevice.Wait();
+                //graphicsDevice.Wait();
             }
         }
     }
@@ -508,6 +504,7 @@ internal class GuiController : IDisposable
         commandBuffer.EndRenderPass(renderPass);
     }
 
+    #region Resources
     private unsafe void BuildFontAtlas()
     {
         ResourceUploader resourceUploader = new ResourceUploader(graphicsDevice);
@@ -536,86 +533,38 @@ internal class GuiController : IDisposable
         textureStorage.Add(fontTexture);    // <-- The fontTexture seems to get lost after some time (CG?).
         this.fontTexture = fontTexture;     // <-- So we also keep a reference to make sure it doesn't happen.
     }
+    #endregion
 
     #region Window
     private void CreateWindow(ImGuiViewportPtr vp)
     {
-        // TODO: Handle all flags.
-        ScreenMode screenMode = vp.Flags.HasFlag(ImGuiViewportFlags.NoDecoration) ? ScreenMode.WindowedBorderless : ScreenMode.Windowed;
-        bool systemResizable = !vp.Flags.HasFlag(ImGuiViewportFlags.NoDecoration);
-
-        WindowCreateInfo info = new WindowCreateInfo("Window Title", (uint)vp.Pos.X, (uint)vp.Pos.Y, screenMode, systemResizable, false);
-
-        Window window = new Window(graphicsDevice, info);
-        graphicsDevice.ClaimWindow(window, SwapchainComposition.SDR, PresentMode.Immediate); // What PresentMode do we need?
-
-        GCHandle handle = GCHandle.Alloc(window);
-        vp.PlatformUserData = (IntPtr)handle;
-
-        AddWindow(window, vp, handle);
+        GuiViewportWindow window = new GuiViewportWindow(graphicsDevice, vp);
     }
 
     private void DestroyWindow(ImGuiViewportPtr vp)
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        graphicsDevice.UnclaimWindow(window);
-
-        if (windows.TryGetValue(window, out GCHandle handle))
-        {
-            handle.Free();
-            windows.Remove(window);
-        }
-
-        //graphicsDevice.Wait();
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
         window.Dispose();
 
         vp.PlatformUserData = IntPtr.Zero;
     }
 
-    private void AddWindow(Window window, ImGuiViewportPtr vp, GCHandle handle)
-    {
-        window.OnResizedEvent += ((win, w, h) => {
-            vp.PlatformRequestResize = true;
-        });
-
-        window.OnMovedEvent += ((win, x, y) =>
-        {
-            vp.PlatformRequestMove = true;
-        });
-
-        window.OnCloseEvent += (win) =>
-        {
-            ImGuiPlatformIOPtr platformIO = ImGui.GetPlatformIO();
-
-            for (int i = 0; i < platformIO.Viewports.Capacity; i++)
-            {
-                ImGuiViewportPtr vp = platformIO.Viewports[i];
-                if(win == (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target)
-                {
-                    DestroyWindow(vp);
-                }
-            }
-        };
-
-        windows.Add(window, handle);
-    }
-
     private void ShowWindow(ImGuiViewportPtr vp)
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        SDL2.SDL.SDL_ShowWindow(window.Handle);
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        SDL2.SDL.SDL_ShowWindow(window.Window.Handle);
     }
 
     private unsafe void GetWindowPos(ImGuiViewportPtr vp, Vector2* outPos)
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        SDL2.SDL.SDL_GetWindowPosition(window.Handle, out int x, out int y);
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        SDL2.SDL.SDL_GetWindowPosition(window.Window.Handle, out int x, out int y);
         *outPos = new Vector2(x, y);
     }
 
@@ -623,24 +572,24 @@ internal class GuiController : IDisposable
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        SDL2.SDL.SDL_SetWindowPosition(window.Handle, (int)pos.X, (int)pos.Y);
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        SDL2.SDL.SDL_SetWindowPosition(window.Window.Handle, (int)pos.X, (int)pos.Y);
     }
 
     private void SetWindowSize(ImGuiViewportPtr vp, Vector2 size)
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        SDL2.SDL.SDL_SetWindowSize(window.Handle, (int)size.X, (int)size.Y);
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        SDL2.SDL.SDL_SetWindowSize(window.Window.Handle, (int)size.X, (int)size.Y);
     }
 
     private unsafe void GetWindowSize(ImGuiViewportPtr vp, Vector2* outSize)
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        SDL2.SDL.SDL_GetWindowSize(window.Handle, out int w, out int h);
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        SDL2.SDL.SDL_GetWindowSize(window.Window.Handle, out int w, out int h);
         *outSize = new Vector2(w, h);
     }
 
@@ -648,26 +597,28 @@ internal class GuiController : IDisposable
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
         //SDL2.SDL.SDL_SetWindowInputFocus(window.Handle);
-        SDL2.SDL.SDL_RaiseWindow(window.Handle);
+        SDL2.SDL.SDL_RaiseWindow(window.Window.Handle);
     }
 
     private byte GetWindowFocus(ImGuiViewportPtr vp)
     {
         if (vp.PlatformUserData == IntPtr.Zero) return (byte)0;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        SDL2.SDL.SDL_WindowFlags flags = (SDL2.SDL.SDL_WindowFlags)SDL2.SDL.SDL_GetWindowFlags(window.Handle);
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        SDL2.SDL.SDL_WindowFlags flags = (SDL2.SDL.SDL_WindowFlags)SDL2.SDL.SDL_GetWindowFlags(window.Window.Handle);
+
         return (flags & SDL2.SDL.SDL_WindowFlags.SDL_WINDOW_INPUT_FOCUS) != 0 ? (byte)1 : (byte)0;
     }
 
     private byte GetWindowMinimized(ImGuiViewportPtr vp)
     {
-        if (vp.PlatformUserData == IntPtr.Zero) return (byte)0;
+        if (vp.PlatformUserData == IntPtr.Zero) return 0;
+
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        SDL2.SDL.SDL_WindowFlags flags = (SDL2.SDL.SDL_WindowFlags)SDL2.SDL.SDL_GetWindowFlags(window.Window.Handle);
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
-        SDL2.SDL.SDL_WindowFlags flags = (SDL2.SDL.SDL_WindowFlags)SDL2.SDL.SDL_GetWindowFlags(window.Handle);
         return (flags & SDL2.SDL.SDL_WindowFlags.SDL_WINDOW_MINIMIZED) != 0 ? (byte)1 : (byte)0;
     }
 
@@ -675,14 +626,14 @@ internal class GuiController : IDisposable
     {
         if (vp.PlatformUserData == IntPtr.Zero) return;
 
-        Window window = (Window)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
+        GuiViewportWindow window = (GuiViewportWindow)GCHandle.FromIntPtr(vp.PlatformUserData).Target;
         byte* titlePtr = (byte*)title;
         int count = 0;
         while (titlePtr[count] != 0)
         {
             count += 1;
         }
-        SDL2.SDL.SDL_SetWindowTitle(window.Handle, System.Text.Encoding.ASCII.GetString(titlePtr, count));
+        SDL2.SDL.SDL_SetWindowTitle(window.Window.Handle, System.Text.Encoding.ASCII.GetString(titlePtr, count));
     }
     #endregion
 
@@ -696,15 +647,5 @@ internal class GuiController : IDisposable
         imGuiPipeline?.Dispose();
         imGuiSampler?.Dispose();
         resourceUploader?.Dispose();
-
-        foreach (KeyValuePair<Window, GCHandle> window in windows)
-        {
-            if (window.Key == mainWindow) continue;
-
-            graphicsDevice.UnclaimWindow(window.Key);
-            window.Key.Dispose();
-            window.Value.Free();
-        }
-        windows.Clear();
     }
 }

Nerfed.Runtime/Gui/GuiViewportWindow.cs

@@ -0,0 +1,87 @@
+using ImGuiNET;
+using Nerfed.Runtime.Graphics;
+using System.Runtime.InteropServices;
+
+namespace Nerfed.Runtime.Gui
+{
+    internal class GuiViewportWindow
+    {
+        public Window Window => window;
+
+        private readonly GCHandle gcHandle;
+        private readonly GraphicsDevice graphicsDevice;
+        private readonly ImGuiViewportPtr vp;
+        private readonly Window window;
+
+        public GuiViewportWindow(GraphicsDevice graphicsDevice, ImGuiViewportPtr vp, Window window)
+        {
+            this.graphicsDevice = graphicsDevice;
+            this.vp = vp;
+            this.window = window;
+
+            gcHandle = GCHandle.Alloc(this);
+
+            if (!window.Claimed)
+            {
+                graphicsDevice.ClaimWindow(window, SwapchainComposition.SDR, PresentMode.Immediate); // What PresentMode do we need?
+            }
+
+            vp.PlatformUserData = (IntPtr)gcHandle;
+        }
+
+        public GuiViewportWindow(GraphicsDevice graphicsDevice, ImGuiViewportPtr vp)
+        {
+            this.graphicsDevice = graphicsDevice;
+            this.vp = vp;
+
+            gcHandle = GCHandle.Alloc(this);
+
+            // TODO: Handle all flags.
+            ScreenMode screenMode = ScreenMode.Windowed;
+            bool systemResizable = true;
+
+            if ((vp.Flags & ImGuiViewportFlags.NoDecoration) == ImGuiViewportFlags.NoDecoration)
+            {
+                screenMode = ScreenMode.WindowedBorderless;
+                systemResizable = false;
+            }
+
+            WindowCreateInfo info = new WindowCreateInfo("Window Title", (uint)vp.Pos.X, (uint)vp.Pos.Y, screenMode, systemResizable, false);
+
+            window = new Window(graphicsDevice, info);
+            graphicsDevice.ClaimWindow(window, SwapchainComposition.SDR, PresentMode.Immediate); // What PresentMode do we need?
+
+            window.OnMovedEvent += HandleOnMovedEvent;
+            window.OnResizedEvent += HandleOnResizedEvent;
+            window.OnCloseEvent += HandleOnCloseEvent;
+
+            vp.PlatformUserData = (IntPtr)gcHandle;
+        }
+
+        public void Dispose()
+        {
+            window.OnMovedEvent -= HandleOnMovedEvent;
+            window.OnResizedEvent -= HandleOnResizedEvent;
+            window.OnCloseEvent -= HandleOnCloseEvent;
+
+            graphicsDevice.UnclaimWindow(window);
+            window.Dispose();
+            gcHandle.Free();
+        }
+
+        private void HandleOnMovedEvent(Window window, int x, int y)
+        {
+            vp.PlatformRequestMove = true;
+        }
+
+        private void HandleOnResizedEvent(Window window, uint w, uint h)
+        {
+            vp.PlatformRequestResize = true;
+        }
+
+        private void HandleOnCloseEvent(Window window)
+        {
+            vp.PlatformRequestClose = true;
+        }
+    }
+}

Nerfed.Runtime/Nerfed.Runtime.csproj

@@ -1,36 +1,43 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <DefaultItemExcludes>$(DefaultItemExcludes);Libraries\**\*</DefaultItemExcludes>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <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" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="Libraries\ImGui.NET\src\ImGui.NET\ImGui.NET.csproj" />
-    </ItemGroup>
-
-    <ItemGroup>
-        <Content Include="Assets\**\*.*">
-            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-        </Content>
-    </ItemGroup>
-
-    <PropertyGroup>
-        <OutputType>Exe</OutputType>
         <TargetFramework>net8.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>disable</Nullable>
         <PublishAot>true</PublishAot>
         <InvariantGlobalization>true</InvariantGlobalization>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+        <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+        <IsPackable>false</IsPackable>
+        <Configurations>Debug;Test;Release</Configurations>
+        <Platforms>x64</Platforms>
     </PropertyGroup>
 
-    <Import Project=".\CopyLibs.targets" />
+    <PropertyGroup>
+        <DefaultItemExcludes>$(DefaultItemExcludes);Libraries\**\*</DefaultItemExcludes>
+    </PropertyGroup>
+
+    <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>
+    
+    <ItemGroup>
+        <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>
+    
 </Project>

Nerfed.Runtime/Profiler.cs

@@ -17,12 +17,12 @@ public struct ProfilerScope : IDisposable
 
 public static class Profiler
 {
-    [Conditional("PROFILER")]
+    [Conditional("PROFILING")]
     public static void BeginSample(string label) {
 
     }
 
-    [Conditional("PROFILER")]
+    [Conditional("PROFILING")]
     public static void EndSample() {
 
     }

Nerfed.Runtime/Program.cs

@@ -1,9 +0,0 @@
-namespace Nerfed.Runtime;
-
-internal class Program
-{
-    private static void Main(string[] args)
-    {
-        Engine.Run(args);
-    }
-}

Nerfed.Runtime/Window/Window.cs

@@ -136,9 +136,9 @@ public class Window
 
     private void ProcessCloseEvent(ref SDL.SDL_WindowEvent ev)
 	{
+		OnCloseEvent?.Invoke(this);
 		Engine.GraphicsDevice.UnclaimWindow(this);
 		Dispose();
-		OnCloseEvent?.Invoke(this);
 	}
 
 	/// <summary>

Nerfed.sln

@@ -5,22 +5,35 @@ 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("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ImGui.NET", "Nerfed.Runtime\Libraries\ImGui.NET\src\ImGui.NET\ImGui.NET.csproj", "{4EC3C399-4E09-4A36-B11E-391F0792C1C8}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "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}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
+		Test|x64 = Test|x64
+		Release|x64 = Release|x64
+		Debug|x64 = Debug|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{98E09BAF-587F-4238-89BD-7693C036C233}.Release|Any CPU.Build.0 = Release|Any CPU
-		{4EC3C399-4E09-4A36-B11E-391F0792C1C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4EC3C399-4E09-4A36-B11E-391F0792C1C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4EC3C399-4E09-4A36-B11E-391F0792C1C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4EC3C399-4E09-4A36-B11E-391F0792C1C8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{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
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

README.md

@@ -1,3 +1,11 @@
 # Nerfed
 
-nerfed game engine
+nerfed game engine
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Third-Party Licenses
+
+This project includes third-party libraries with their respective licenses, which can be found in the [THIRD_PARTY_LICENSES](THIRD_PARTY_LICENSES) file.

THIRD_PARTY_LICENSES

@@ -0,0 +1,29 @@
+# Third-Party Licenses
+
+## ImGui
+
+**Name:** Dear ImGui  
+**License:** MIT License
+
+MIT License
+
+Copyright (c) 2014-2022 Omar Cornut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

Tools/Nerfed.Builder/Nerfed.Builder.deps.json

@@ -0,0 +1,23 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v8.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v8.0": {
+      "Nerfed.Builder/1.0.0": {
+        "runtime": {
+          "Nerfed.Builder.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "Nerfed.Builder/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

Tools/Nerfed.Builder/Nerfed.Builder.runtimeconfig.json

@@ -0,0 +1,13 @@
+{
+  "runtimeOptions": {
+    "tfm": "net8.0",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "8.0.0"
+    },
+    "configProperties": {
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}