rfg-modding · Jul 17, 2022 · Jul 31, 2022 · Aug 21, 2022 · Aug 21, 2022 · Aug 21, 2022
Showing 432 changed files with 16,829 additions and 20,545 deletions.
diff --git a/.github/workflows/dotnet-desktop.yml b/.github/workflows/dotnet-desktop.yml
@@ -0,0 +1,42 @@
+name: .NET Core Desktop
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+
+  build:
+
+    strategy:
+      matrix:
+        configuration: [Release]
+
+    runs-on: windows-latest  # For a list of available runner types, refer to
+                             # https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions#jobsjob_idruns-on
+
+    env:
+      Solution_Name: Nanoforge.sln
+      Test_Project_Path: Nanoforge.Tests\Nanoforge.Tests.csproj
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    # Install the .NET Core workload
+    - name: Install .NET Core
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+
+    # Add  MSBuild to the PATH: https://github.com/microsoft/setup-msbuild
+    - name: Setup MSBuild.exe
+      uses: microsoft/setup-msbuild@v2
+
+    # Execute all unit tests in the solution
+    - name: Execute unit tests
+      run: dotnet test
diff --git a/.gitignore b/.gitignore
@@ -279,3 +279,23 @@ Project26CppCheck-cppcheck-build-dir/
 Project26CppCheck.cppcheck
 
 StructLayoutSettings.json
+
+recovery/
+
+build/
+
+BeefSpace_User.toml
+imgui.ini
+OLD_TODO
+TODO.old.cppVersion
+Count.bat
+combined.txt
+GourceCombined.txt
+GourceCombinedFiltered.txt
+GourceNF.txt
+GourceRfgTools.txt
+GourceRfgToolsPlusPlus.txt
+Config.nanodata
+
+
+.idea/
diff --git a/.gitmodules b/.gitmodules
diff --git a/Assets/fonts/fa-solid-900.ttf b/Assets/fonts/fa-solid-900.ttf
diff --git a/Assets/shaders/Linelist.hlsl b/Assets/shaders/Linelist.hlsl
diff --git a/Assets/shaders/LitTriList.hlsl b/Assets/shaders/LitTriList.hlsl
diff --git a/Assets/shaders/Pixlit.hlsl b/Assets/shaders/Pixlit.hlsl
diff --git a/Assets/shaders/Pixlit1Uv.hlsl b/Assets/shaders/Pixlit1Uv.hlsl
diff --git a/Assets/shaders/Pixlit1UvNmap.hlsl b/Assets/shaders/Pixlit1UvNmap.hlsl
diff --git a/Assets/shaders/Pixlit1UvNmapCa.hlsl b/Assets/shaders/Pixlit1UvNmapCa.hlsl
diff --git a/Assets/shaders/Pixlit2UvNmap.hlsl b/Assets/shaders/Pixlit2UvNmap.hlsl
diff --git a/Assets/shaders/Pixlit3UvNmap.hlsl b/Assets/shaders/Pixlit3UvNmap.hlsl
diff --git a/Assets/shaders/Pixlit3UvNmapCa.hlsl b/Assets/shaders/Pixlit3UvNmapCa.hlsl
diff --git a/Assets/shaders/SolidTriList.hlsl b/Assets/shaders/SolidTriList.hlsl
diff --git a/Assets/shaders/Terrain.hlsl b/Assets/shaders/Terrain.hlsl
diff --git a/Assets/shaders/TerrainLowLod.hlsl b/Assets/shaders/TerrainLowLod.hlsl
diff --git a/Assets/shaders/TerrainRoad.hlsl b/Assets/shaders/TerrainRoad.hlsl
diff --git a/Assets/shaders/TerrainStitch.hlsl b/Assets/shaders/TerrainStitch.hlsl
diff --git a/Assets/shaders/imgui.hlsl b/Assets/shaders/imgui.hlsl
diff --git a/CMakeLists.txt b/CMakeLists.txt
diff --git a/CMakeSettings.json b/CMakeSettings.json
diff --git a/Dependencies/CMakeLists.txt b/Dependencies/CMakeLists.txt
diff --git a/Dependencies/DirectXTex b/Dependencies/DirectXTex
diff --git a/Dependencies/IconFontCppHeaders b/Dependencies/IconFontCppHeaders
diff --git a/Dependencies/RfgToolsPlusPlus b/Dependencies/RfgToolsPlusPlus
diff --git a/Dependencies/imgui b/Dependencies/imgui
diff --git a/Dependencies/imgui_markdown b/Dependencies/imgui_markdown
diff --git a/Dependencies/imnodes b/Dependencies/imnodes
diff --git a/Dependencies/nativefiledialog b/Dependencies/nativefiledialog
diff --git a/Dependencies/spdlog b/Dependencies/spdlog
diff --git a/Dependencies/tinyxml2 b/Dependencies/tinyxml2
diff --git a/Dependencies/tracy b/Dependencies/tracy
diff --git a/Nanoforge.Tests/DataHelperTests.cs b/Nanoforge.Tests/DataHelperTests.cs
@@ -0,0 +1,97 @@
+using Nanoforge.Misc;
+using Nanoforge.Rfg;
+
+namespace Nanoforge.Tests;
+
+///Tests for <see cref="Nanoforge.Misc.DataHelper"/>
+public class DataHelperTests
+{
+    [Fact]
+    public void DeepCopyToggleableBytes()
+    {
+        Toggleable<byte[]?> obj = new([1, 2, 3]);
+        Toggleable<byte[]?> objCopy = DataHelper.DeepCopyToggleableBytes(obj);
+        Assert.False(ReferenceEquals(obj, objCopy));
+        Assert.False(ReferenceEquals(obj.Value, objCopy.Value));
+        Assert.NotNull(objCopy.Value);
+
+        Toggleable<byte[]?> objWithNullArray = new(null);
+        Toggleable<byte[]?> objWithNullArrayCopy = DataHelper.DeepCopyToggleableBytes(objWithNullArray);
+        Assert.False(ReferenceEquals(objWithNullArray, objWithNullArrayCopy));
+        Assert.Null(objWithNullArray.Value);
+        Assert.Null(objWithNullArrayCopy.Value);
+    }
+
+    [Fact]
+    public void EnumToRfgName()
+    {
+        //Test a few of the zone object enums that have RfgNameAttribute
+        Assert.True(DataHelper.ToRfgName(ObjectBoundingBox.BoundingBoxType.GpsTarget, out string boundBoxTypeRfgName) && boundBoxTypeRfgName == "GPS Target");
+        Assert.True(DataHelper.ToRfgName(ObjectDummy.DummyTypeEnum.Rally, out string dummyTypeRfgName) && dummyTypeRfgName == "Rally");
+        Assert.True(DataHelper.ToRfgName(TriggerRegion.RegionTypeEnum.KillHuman, out string regionTypeRfgName) && regionTypeRfgName == "kill human");
+        Assert.True(DataHelper.ToRfgName(ObjLight.LightTypeEnum.Spot, out string lightTypeRfgName) && lightTypeRfgName == "spot");
+        Assert.True(DataHelper.ToRfgName(MultiMarker.MultiMarkerType.KingOfTheHillTarget, out string markerTypeRfgName) && markerTypeRfgName == "King of the Hill target");
+
+        //This enum doesn't have RfgNameAttribute so it should return false
+        Assert.False(DataHelper.ToRfgName<RfgMover.MoveTypeEnum>(RfgMover.MoveTypeEnum.Normal, out string moveTypeRfgName));
+    }
+
+    [Fact]
+    public void RfgNameToEnum()
+    {
+        Assert.True(DataHelper.FromRfgName("GPS Target", out ObjectBoundingBox.BoundingBoxType boundingBoxType) && boundingBoxType == ObjectBoundingBox.BoundingBoxType.GpsTarget);
+        Assert.True(DataHelper.FromRfgName("None", out ObjectBoundingBox.BoundingBoxType boundingBoxType2) && boundingBoxType2 == ObjectBoundingBox.BoundingBoxType.None);
+        //This one is important to test since the rfg name has a typo in it. We need to preserve that typo during map export for the game to properly read the field.
+        // ReSharper disable once StringLiteralTypo
+        Assert.True(DataHelper.FromRfgName("Tech Reponse Pos", out ObjectDummy.DummyTypeEnum dummyType) && dummyType == ObjectDummy.DummyTypeEnum.TechResponsePos);
+        Assert.True(DataHelper.FromRfgName("kill human", out TriggerRegion.RegionTypeEnum regionType) && regionType == TriggerRegion.RegionTypeEnum.KillHuman);
+        Assert.True(DataHelper.FromRfgName("spot", out ObjLight.LightTypeEnum lightType) && lightType == ObjLight.LightTypeEnum.Spot);
+        Assert.True(DataHelper.FromRfgName("King of the Hill target", out MultiMarker.MultiMarkerType markerType) && markerType == MultiMarker.MultiMarkerType.KingOfTheHillTarget);
+
+        //Fake/undefined rfg names. Should fail
+        Assert.False(DataHelper.FromRfgName("Directional", out ObjLight.LightTypeEnum badLightType));
+        Assert.False(DataHelper.FromRfgName("Tech Response Pos", out ObjectDummy.DummyTypeEnum badDummyType)); //Another check to make sure the typo isn't fixed
+        Assert.False(DataHelper.FromRfgName("Fake dummy type name", out ObjectDummy.DummyTypeEnum badDummyType2)); //Another check to make sure the typo isn't fixed
+        Assert.False(DataHelper.FromRfgName("Marker type", out MultiMarker.MultiMarkerType badMarkerType));
+    }
+
+    [Fact]
+    public void EnumToRfgFlagsString()
+    {
+        ObjectMover.BuildingTypeFlagsEnum buildingTypeFlags = ObjectMover.BuildingTypeFlagsEnum.Dynamic | ObjectMover.BuildingTypeFlagsEnum.ForceField | ObjectMover.BuildingTypeFlagsEnum.House;
+        ObjectMover.BuildingTypeFlagsEnum buildingTypeFlags2 = ObjectMover.BuildingTypeFlagsEnum.None;
+        ObjectMover.ChunkFlagsEnum chunkFlags = ObjectMover.ChunkFlagsEnum.Building | ObjectMover.ChunkFlagsEnum.Regenerate;
+        ObjectMover.ChunkFlagsEnum chunkFlags2 = ObjectMover.ChunkFlagsEnum.PlumeOnDeath | ObjectMover.ChunkFlagsEnum.InheritDamagePercentage;
+        ObjLight.ObjLightFlags objLightFlags = ObjLight.ObjLightFlags.UseClipping | ObjLight.ObjLightFlags.NightTime | ObjLight.ObjLightFlags.DayTime;
+        ObjLight.ObjLightFlags objLightFlags2 = ObjLight.ObjLightFlags.UseClipping;
+        ObjLight.ObjLightFlags objLightFlags3 = ObjLight.ObjLightFlags.None;
+
+        Assert.True(DataHelper.ToRfgFlagsString(buildingTypeFlags, out string buildingTypeFlagsString) && buildingTypeFlagsString == "Dynamic Force_Field House");
+        Assert.True(DataHelper.ToRfgFlagsString(buildingTypeFlags2, out string buildingTypeFlagsString2) && buildingTypeFlagsString2 == "");
+        Assert.True(DataHelper.ToRfgFlagsString(chunkFlags, out string chunkFlagsString) && chunkFlagsString == "building regenerate");
+        Assert.True(DataHelper.ToRfgFlagsString(chunkFlags2, out string chunkFlagsString2) && chunkFlagsString2 == "plume_on_death inherit_damage_pct");
+        Assert.True(DataHelper.ToRfgFlagsString(objLightFlags, out string objLightFlagsString) && objLightFlagsString == "use_clipping daytime nighttime");
+        Assert.True(DataHelper.ToRfgFlagsString(objLightFlags2, out string objLightFlagsString2) && objLightFlagsString2 == "use_clipping");
+        Assert.True(DataHelper.ToRfgFlagsString(objLightFlags3, out string objLightFlagsString3) && objLightFlagsString3 == "");
+    }
+
+    [Fact]
+    public void RfgFlagsStringToEnum()
+    {
+        string buildingTypeFlagsString = "Dynamic Force_Field House";
+        string buildingTypeFlagsString2 = "";
+        string chunkFlagsString = "building regenerate";
+        string chunkFlagsString2 = "plume_on_death inherit_damage_pct";
+        string objLightFlagsString = "use_clipping daytime nighttime";
+        string objLightFlagsString2 = "use_clipping";
+        string objLightFlagsString3 = "";
+
+        Assert.True(DataHelper.FromRfgFlagsString(buildingTypeFlagsString, out ObjectMover.BuildingTypeFlagsEnum buildingTypeFlags) && buildingTypeFlags == (ObjectMover.BuildingTypeFlagsEnum.Dynamic | ObjectMover.BuildingTypeFlagsEnum.ForceField | ObjectMover.BuildingTypeFlagsEnum.House));
+        Assert.True(DataHelper.FromRfgFlagsString(buildingTypeFlagsString2, out ObjectMover.BuildingTypeFlagsEnum buildingTypeFlags2) && buildingTypeFlags2 == ObjectMover.BuildingTypeFlagsEnum.None);
+        Assert.True(DataHelper.FromRfgFlagsString(chunkFlagsString, out ObjectMover.ChunkFlagsEnum chunkFlags) && chunkFlags == (ObjectMover.ChunkFlagsEnum.Building | ObjectMover.ChunkFlagsEnum.Regenerate));
+        Assert.True(DataHelper.FromRfgFlagsString(chunkFlagsString2, out ObjectMover.ChunkFlagsEnum chunkFlags2) && chunkFlags2 == (ObjectMover.ChunkFlagsEnum.PlumeOnDeath | ObjectMover.ChunkFlagsEnum.InheritDamagePercentage));
+        Assert.True(DataHelper.FromRfgFlagsString(objLightFlagsString, out ObjLight.ObjLightFlags lightFlags) && lightFlags == (ObjLight.ObjLightFlags.UseClipping | ObjLight.ObjLightFlags.NightTime | ObjLight.ObjLightFlags.DayTime));
+        Assert.True(DataHelper.FromRfgFlagsString(objLightFlagsString2, out ObjLight.ObjLightFlags lightFlags2) && lightFlags2 == ObjLight.ObjLightFlags.UseClipping);
+        Assert.True(DataHelper.FromRfgFlagsString(objLightFlagsString3, out ObjLight.ObjLightFlags lightFlags3) && lightFlags3 == ObjLight.ObjLightFlags.None);
+    }
+}
diff --git a/Nanoforge.Tests/GlobalUsings.cs b/Nanoforge.Tests/GlobalUsings.cs
@@ -0,0 +1 @@
+global using Xunit;
diff --git a/Nanoforge.Tests/NanoDBTests.cs b/Nanoforge.Tests/NanoDBTests.cs
@@ -0,0 +1,283 @@
+using System.Reflection;
+using AutoFixture;
+using AutoFixture.Kernel;
+using FluentAssertions;
+using Nanoforge.Editor;
+using Nanoforge.Render.Resources;
+using Nanoforge.Rfg;
+
+namespace Nanoforge.Tests;
+
+public class NanoDBTests
+{
+    private static List<Type> _editorObjectTypes => AppDomain.CurrentDomain.GetAssemblies()
+        .SelectMany(assembly => assembly.GetTypes())
+        .Where(type => typeof(EditorObject).IsAssignableFrom(type)).ToList();
+
+    public static IEnumerable<object[]> TestEditorObjects;
+
+    static NanoDBTests()
+    {
+        var typeList = _editorObjectTypes;
+        Fixture fixture = new();
+        //Make it so the fixture doesn't complain about circular references on objects. All ZoneObjects can have this issue due to the Parent and Children fields
+        fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => fixture.Behaviors.Remove(b));
+        fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+        //Don't set RenderObject fields. AutoFixture throws exceptions on some unsafe types. For the moment its fine to exclude that type from the tests.
+        fixture.Customizations.Add(new PropertyTypeOmitter(typeof(RenderObjectBase)));
+
+        TestEditorObjects = _editorObjectTypes.Select(type => new object[] { new SpecimenContext(fixture).Resolve(type) });
+        var list = TestEditorObjects.ToList();
+    }
+
+    //Runs once per class that is derived from EditorObject. Tests serialization and deserialization of a single object.
+    [Theory, MemberData(nameof(TestEditorObjects))]
+    public void AllEditorObjectSaveLoad(EditorObject originalObject)
+    {
+        string testObjectName = "TestObject";
+        originalObject.Name = testObjectName;
+
+        //TODO: Change to write to temporary directory in project dir that gets git ignored
+        string projectDirectory = "./AllEditorObjectSaveLoadTest/";
+        string projectFilePath = "";
+        NanoDB.NewProject(projectDirectory, "AllEditorObjectSaveLoadTest", "UnitTestRunner", "", false);
+        projectFilePath = NanoDB.CurrentProject.FilePath;
+
+        NanoDB.AddObject(originalObject);
+        NanoDB.Save();
+        NanoDB.Load(projectFilePath);
+
+        EditorObject? deserializedObject = NanoDB.Find(testObjectName);
+        Assert.NotNull(deserializedObject);
+        deserializedObject.Should().BeEquivalentTo(originalObject);
+    }
+
+    //Tests serialization & deserialization on several ZoneObjects with parent-child relationships set.
+    [Fact]
+    public void ObjectSaveLoadWithHierarchy()
+    {
+        string projectDirectory = "./ObjectSaveLoadWithHierarchyTest/";
+        string projectFilePath = "";
+        NanoDB.NewProject(projectDirectory, "ObjectSaveLoadWithHierarchyTest", "UnitTestRunner", "", false);
+        projectFilePath = NanoDB.CurrentProject.FilePath;
+
+        Fixture fixture = new();
+        fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList().ForEach(b => fixture.Behaviors.Remove(b));
+        fixture.Behaviors.Add(new OmitOnRecursionBehavior());
+        fixture.Customizations.Add(new PropertyTypeOmitter(typeof(RenderObjectBase)));
+
+        //Note: The object types were picked at random to have some variety. This is not representative of a typical RFG map.
+        var objectA = fixture.Create<RfgMover>();
+        objectA.Name = "objectA";
+        objectA.Parent = null;
+        objectA.Children.Clear();
+        var objectB = fixture.Create<PlayerStart>();
+        objectB.Name = "objectB";
+        objectB.Parent = null;
+        objectB.Children.Clear();
+        var objectC = fixture.Create<PlayerStart>();
+        objectC.Name = "objectC";
+        objectC.Parent = null;
+        objectC.Children.Clear();
+        var objectD = fixture.Create<Weapon>();
+        objectD.Name = "objectD";
+        objectD.Parent = null;
+        objectD.Children.Clear();
+
+        objectA.AddChild(objectB);
+        objectA.AddChild(objectC);
+        objectC.AddChild(objectD);
+
+        NanoDB.AddObject(objectA);
+        NanoDB.AddObject(objectB);
+        NanoDB.AddObject(objectC);
+        NanoDB.AddObject(objectD);
+
+        NanoDB.Save();
+        NanoDB.Load(projectFilePath);
+
+        ZoneObject? objectA2 = (ZoneObject?)NanoDB.Find(objectA.Name);
+        ZoneObject? objectB2 = (ZoneObject?)NanoDB.Find(objectB.Name);
+        ZoneObject? objectC2 = (ZoneObject?)NanoDB.Find(objectC.Name);
+        ZoneObject? objectD2 = (ZoneObject?)NanoDB.Find(objectD.Name);
+
+        Assert.NotNull(objectA2);
+        Assert.NotNull(objectB2);
+        Assert.NotNull(objectC2);
+        Assert.NotNull(objectD2);
+
+        objectA2.Should().BeEquivalentTo(objectA, options => options.IgnoringCyclicReferences());
+        objectB2.Should().BeEquivalentTo(objectB, options => options.IgnoringCyclicReferences());
+        objectC2.Should().BeEquivalentTo(objectC, options => options.IgnoringCyclicReferences());
+        objectD2.Should().BeEquivalentTo(objectD, options => options.IgnoringCyclicReferences());
+
+        //TODO: Figure out a better way of handling this
+        //Manually check parent/child fields since I couldn't figure out how to do it with FluentAssertions
+        Assert.True(ReferenceEquals(objectA2, objectB2.Parent));
+        Assert.True(ReferenceEquals(objectA2, objectC2.Parent));
+        Assert.True(objectA2.Children.Count == 2);
+        Assert.Contains(objectB2, objectA2.Children);
+        Assert.Contains(objectC2, objectA2.Children);
+
+        Assert.True(objectB2.Children.Count == 0);
+
+        Assert.True(ReferenceEquals(objectC2, objectD2.Parent));
+        Assert.True(objectC2.Children.Count == 1);
+        Assert.Contains(objectD2, objectC2.Children);
+
+        Assert.True(objectD2.Children.Count == 0);
+    }
+
+    //Tests save/load for global objects. These are just like normal editor objects, except they aren't tied to a project. Used for persistent data like editor settings.
+    [Fact]
+    public void GlobalObjectSaveLoad()
+    {
+        Fixture fixture = new();
+        fixture.Customizations.Add(new PropertyTypeOmitter(typeof(RenderObjectBase)));
+        GeneralSettings objA = fixture.Create<GeneralSettings>();
+        objA.Name = "objA-Global";
+
+        NanoDB.AddGlobalObject(objA);
+
+        NanoDB.SaveGlobals();
+        NanoDB.LoadGlobals();
+
+        GeneralSettings? objA2 = (GeneralSettings?)NanoDB.Find(objA.Name);
+
+        Assert.NotNull(objA2);
+        objA.Should().BeEquivalentTo(objA2, options => options.IgnoringCyclicReferences());
+
+        //Cleanup globals so there's a clean state for any tests that follow
+        NanoDB.ClearGlobals();
+        NanoDB.SaveGlobals();
+    }
+
+    //Test basic buffer save/load
+    [Fact]
+    public void BufferSaveLoad()
+    {
+        string projectDirectory = "./BufferSaveLoadTest/";
+        NanoDB.NewProject(projectDirectory, "BufferSaveLoadTest", "UnitTestRunner", "", false);
+
+        Fixture fixture = new();
+        byte[] bufferBytes = fixture.CreateMany<byte>(1024).ToArray();
+        Assert.NotNull(bufferBytes);
+
+        ProjectBuffer? buffer = NanoDB.CreateBuffer(bufferBytes, "TestProjectBuffer");
+        Assert.NotNull(buffer);
+
+        byte[] bufferBytesLoaded = buffer.Load();
+        Assert.NotNull(bufferBytesLoaded);
+        Assert.Equal(bufferBytes, bufferBytesLoaded);
+    }
+
+    //Test that buffer metadata is preserved across project save/load
+    [Fact]
+    public void BufferProjectSaveLoad()
+    {
+        string projectDirectory = "./BufferProjectSaveLoadTest/";
+        string projectFilePath = "";
+        NanoDB.NewProject(projectDirectory, "BufferProjectSaveLoadTest", "UnitTestRunner", "", false);
+        projectFilePath = NanoDB.CurrentProject.FilePath;
+
+        Fixture fixture = new();
+        byte[] bufferBytes = fixture.CreateMany<byte>(1024).ToArray();
+        Assert.NotNull(bufferBytes);
+
+        ProjectBuffer? buffer = NanoDB.CreateBuffer(bufferBytes, "TestProjectBuffer");
+        Assert.NotNull(buffer);
+
+        NanoDB.Save();
+        NanoDB.Load(projectFilePath);
+
+        ProjectBuffer? bufferLoaded = NanoDB.Find<ProjectBuffer>(buffer.Name);
+        Assert.NotNull(bufferLoaded);
+
+        //Load the buffer from the drive again and make sure it still works
+        byte[] bufferBytesLoaded = bufferLoaded.Load();
+        Assert.NotNull(bufferBytesLoaded);
+        Assert.Equal(bufferBytes, bufferBytesLoaded);
+    }
+
+    //Test writing a smaller byte array to a buffer than it originally had
+    [Fact]
+    public void BufferShrink()
+    {
+        string projectDirectory = "./BufferShrinkTest/";
+        NanoDB.NewProject(projectDirectory, "BufferShrinkTest", "UnitTestRunner", "", false);
+
+        Fixture fixture = new();
+        byte[] bufferBytes = fixture.CreateMany<byte>(1024).ToArray();
+        Assert.NotNull(bufferBytes);
+
+        ProjectBuffer? buffer = NanoDB.CreateBuffer(bufferBytes, "TestProjectBuffer");
+        Assert.NotNull(buffer);
+
+        byte[] bufferBytes2 = fixture.CreateMany<byte>(10).ToArray();
+        Assert.NotNull(bufferBytes2);
+        Assert.True(buffer.Save(bufferBytes2));
+
+        byte[] bufferBytes2Loaded = buffer.Load();
+        Assert.NotNull(bufferBytes2Loaded);
+        Assert.Equal(bufferBytes2, bufferBytes2Loaded);
+        Assert.NotEqual(bufferBytes, bufferBytes2Loaded);
+    }
+
+    //Test writing a larger byte array to a buffer than it originally had
+    [Fact]
+    public void BufferGrow()
+    {
+        string projectDirectory = "./BufferGrowTest/";
+        NanoDB.NewProject(projectDirectory, "BufferGrowTest", "UnitTestRunner", "", false);
+
+        Fixture fixture = new();
+        byte[] bufferBytes = fixture.CreateMany<byte>(1024).ToArray();
+        Assert.NotNull(bufferBytes);
+
+        ProjectBuffer? buffer = NanoDB.CreateBuffer(bufferBytes, "TestProjectBuffer");
+        Assert.NotNull(buffer);
+
+        byte[] bufferBytes2 = fixture.CreateMany<byte>(2048).ToArray();
+        Assert.NotNull(bufferBytes2);
+        Assert.True(buffer.Save(bufferBytes2));
+
+        byte[] bufferBytes2Loaded = buffer.Load();
+        Assert.NotNull(bufferBytes2Loaded);
+        Assert.Equal(bufferBytes2, bufferBytes2Loaded);
+        Assert.NotEqual(bufferBytes, bufferBytes2Loaded);
+    }
+
+    [Fact]
+    public void ReferencedBufferSaveLoad()
+    {
+        string projectDirectory = "./ReferencedBufferSaveLoad/";
+        string projectFilePath = "";
+        NanoDB.NewProject(projectDirectory, "ReferencedBufferSaveLoad", "UnitTestRunner", "", false);
+        projectFilePath = NanoDB.CurrentProject.FilePath;
+
+        Fixture fixture = new();
+        byte[] bufferBytes = fixture.CreateMany<byte>(1024).ToArray();
+        ProjectBuffer? buffer = NanoDB.CreateBuffer(bufferBytes, "ReferencedProjectBuffer");
+        Assert.NotNull(buffer);
+
+        ProjectTexture referencingObject = new(buffer);
+        referencingObject.Name = "ObjectThatReferencesBuffer";
+        NanoDB.AddObject(referencingObject);
+
+        NanoDB.Save();
+        NanoDB.Load(projectFilePath);
+
+        ProjectTexture? referencingObjectLoaded = NanoDB.Find<ProjectTexture>(referencingObject.Name);
+        Assert.NotNull(referencingObjectLoaded);
+
+        ProjectBuffer? bufferLoadedFromReference = referencingObjectLoaded.Data;
+        Assert.NotNull(bufferLoadedFromReference);
+
+        ProjectBuffer? bufferLoadedFromSearch = NanoDB.Find<ProjectBuffer>(buffer.Name);
+        Assert.NotNull(bufferLoadedFromSearch);
+        //The object should be referencing the same ProjectBuffer instance that NanoDB tracks
+        Assert.True(ReferenceEquals(bufferLoadedFromReference, bufferLoadedFromSearch));
+        //The original buffer and the instance created while loading the project should have the same name and size
+        Assert.Equivalent(buffer, bufferLoadedFromSearch);
+    }
+}
diff --git a/Nanoforge.Tests/Nanoforge.Tests.csproj b/Nanoforge.Tests/Nanoforge.Tests.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    	<WarningsAsErrors>Nullable</WarningsAsErrors>
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="AutoFixture" Version="4.18.1" />
+        <PackageReference Include="AutoFixture.Xunit2" Version="4.18.1" />
+        <PackageReference Include="FluentAssertions" Version="6.12.2" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
+        <PackageReference Include="xunit" Version="2.4.2"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="coverlet.collector" Version="6.0.0">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Nanoforge\Nanoforge.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/Nanoforge.Tests/PropertyTypeOmitter.cs b/Nanoforge.Tests/PropertyTypeOmitter.cs
@@ -0,0 +1,28 @@
+using System.Reflection;
+using AutoFixture.Kernel;
+
+namespace Nanoforge.Tests;
+
+public class PropertyTypeOmitter : ISpecimenBuilder
+{
+    Type[] _typesToOmit;
+
+    public PropertyTypeOmitter(Type typeToOmit)
+    {
+        _typesToOmit = [typeToOmit];
+    }
+
+    public PropertyTypeOmitter(Type[] typesToOmit)
+    {
+        _typesToOmit = typesToOmit;
+    }
+
+    public object Create(object request, ISpecimenContext context)
+    {
+        var propInfo = request as PropertyInfo;
+        if (propInfo != null && _typesToOmit.Contains(propInfo.PropertyType))
+            return new OmitSpecimen();
+
+        return new NoSpecimen();
+    }
+}
diff --git a/Nanoforge.sln b/Nanoforge.sln
@@ -0,0 +1,22 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nanoforge", "Nanoforge\Nanoforge.csproj", "{0BCBDFFF-431D-49B1-9A15-1C238BB280F9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Nanoforge.Tests", "Nanoforge.Tests\Nanoforge.Tests.csproj", "{D544DFAF-EF6F-4CA1-887C-736D3DD6840C}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0BCBDFFF-431D-49B1-9A15-1C238BB280F9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0BCBDFFF-431D-49B1-9A15-1C238BB280F9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0BCBDFFF-431D-49B1-9A15-1C238BB280F9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0BCBDFFF-431D-49B1-9A15-1C238BB280F9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D544DFAF-EF6F-4CA1-887C-736D3DD6840C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D544DFAF-EF6F-4CA1-887C-736D3DD6840C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D544DFAF-EF6F-4CA1-887C-736D3DD6840C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D544DFAF-EF6F-4CA1-887C-736D3DD6840C}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal
diff --git a/Nanoforge/App.axaml b/Nanoforge/App.axaml
@@ -0,0 +1,54 @@
+<Application xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="Nanoforge.App"
+             xmlns:local="using:Nanoforge"
+             xmlns:core="clr-namespace:Dock.Model.Core;assembly=Dock.Model"
+             RequestedThemeVariant="Default">
+             <!-- "Default" ThemeVariant follows system theme variant. "Dark" or "Light" are other available options. -->
+
+    <Application.DataTemplates>
+        <local:ViewLocator/>
+    </Application.DataTemplates>
+
+    <Application.Resources>
+        <ControlRecycling x:Key="ControlRecyclingKey" />
+    </Application.Resources>
+
+    <Application.Styles>
+        <FluentTheme />
+        <StyleInclude Source="avares://Avalonia.Controls.TreeDataGrid/Themes/Fluent.axaml"/>
+
+        <Style Selector="DockControl">
+            <Setter Property="(ControlRecyclingDataTemplate.ControlRecycling)" Value="{StaticResource ControlRecyclingKey}" />
+        </Style>
+
+        <Style Selector="DocumentControl">
+            <Setter Property="HeaderTemplate">
+                <DataTemplate DataType="core:IDockable">
+                    <StackPanel Orientation="Horizontal">
+                        <PathIcon
+                            Data="M5 1C3.89543 1 3 1.89543 3 3V13C3 14.1046 3.89543 15 5 15H11C12.1046 15 13 14.1046 13 13V5.41421C13 5.01639 12.842 4.63486 12.5607 4.35355L9.64645 1.43934C9.36514 1.15804 8.98361 1 8.58579 1H5ZM4 3C4 2.44772 4.44772 2 5 2H8V4.5C8 5.32843 8.67157 6 9.5 6H12V13C12 13.5523 11.5523 14 11 14H5C4.44772 14 4 13.5523 4 13V3ZM11.7929 5H9.5C9.22386 5 9 4.77614 9 4.5V2.20711L11.7929 5Z"
+                            Width="16"
+                            Height="16"
+                            Margin="0" />
+                        <TextBlock Text="{Binding Title}"
+                                   VerticalAlignment="Center"
+                                   Padding="4,0,0,0" />
+                    </StackPanel>
+                </DataTemplate>
+            </Setter>
+        </Style>
+
+        <Style Selector="ToolControl">
+            <Setter Property="HeaderTemplate">
+                <DataTemplate DataType="core:IDockable">
+                    <TextBlock Text="{Binding Title}" Padding="2" />
+                </DataTemplate>
+            </Setter>
+        </Style>
+
+        <Style Selector="ToolChromeControl">
+            <Setter Property="Background" Value="Transparent" />
+        </Style>
+    </Application.Styles>
+</Application>
diff --git a/Nanoforge/App.axaml.cs b/Nanoforge/App.axaml.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Data.Core.Plugins;
+using Avalonia.Markup.Xaml;
+using Microsoft.Extensions.DependencyInjection;
+using Nanoforge.Gui.Themes;
+using Nanoforge.Gui.Views;
+using Nanoforge.Render;
+using Nanoforge.Services;
+using MainWindowViewModel = Nanoforge.Gui.ViewModels.MainWindowViewModel;
+
+namespace Nanoforge;
+
+public partial class App : Application
+{
+    public readonly Renderer? Renderer;
+
+    public static IThemeManager? ThemeManager;
+
+    public new static App Current => (App)Application.Current!;
+
+    public ServiceProvider Services { get; }
+
+    private static IEnumerable<Window> Windows => (Application.Current?.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)?.Windows ?? Array.Empty<Window>();
+
+    public App()
+    {
+        //Don't try starting the renderer if we're in the designer. Breaks the preview.
+        if (!Design.IsDesignMode)
+        {
+            Renderer = new Renderer(1920, 1080);
+        }
+        Services = ConfigureServices();
+    }
+
+    public override void Initialize()
+    {
+        ThemeManager = new FluentThemeManager();
+        ThemeManager.Initialize(this);
+
+        AvaloniaXamlLoader.Load(this);
+
+        //TODO: Make this user configurable
+        //Default to dark theme for now
+        ThemeManager.Switch(1);
+    }
+
+    public override void OnFrameworkInitializationCompleted()
+    {
+        // DockManager.s_enableSplitToWindow = true;
+
+        var mainWindowViewModel = new MainWindowViewModel();
+
+        switch (ApplicationLifetime)
+        {
+            case IClassicDesktopStyleApplicationLifetime desktopLifetime:
+            {
+                // Line below is needed to remove Avalonia data validation.
+                // Without this line you will get duplicate validations from both Avalonia and CT
+                BindingPlugins.DataValidators.RemoveAt(0);
+                var mainWindow = new MainWindow
+                {
+                    DataContext = mainWindowViewModel
+                };
+
+                mainWindow.Closing += (_, _) =>
+                {
+                    mainWindowViewModel.CloseLayout();
+                };
+
+                desktopLifetime.MainWindow = mainWindow;
+
+                desktopLifetime.Exit += (_, _) =>
+                {
+                    mainWindowViewModel.CloseLayout();
+                };
+
+                break;
+            }
+            case ISingleViewApplicationLifetime singleViewLifetime:
+            {
+                var mainView = new MainView()
+                {
+                    DataContext = mainWindowViewModel
+                };
+
+                singleViewLifetime.MainView = mainView;
+
+                break;
+            }
+        }
+
+        base.OnFrameworkInitializationCompleted();
+#if DEBUG
+        this.AttachDevTools();
+#endif
+    }
+
+    private ServiceProvider ConfigureServices()
+    {
+        var services = new ServiceCollection();
+        services.AddSingleton<IFileDialogService, FileDialogService>();
+        return services.BuildServiceProvider();
+    }
+
+    public Window? FindWindowByViewModel(INotifyPropertyChanged viewModel)
+    {
+        return Windows.FirstOrDefault(x => ReferenceEquals(viewModel, x.DataContext));
+    }
+}
diff --git a/Nanoforge/BuildConfig.cs b/Nanoforge/BuildConfig.cs
@@ -0,0 +1,29 @@
+
+using System;
+using System.IO;
+
+namespace Nanoforge;
+
+public static class BuildConfig
+{
+    public static readonly string ProjectName;
+    public static readonly string AssetsDirectory;
+    public static readonly string ShadersDirectory;
+    public static readonly string Version;
+    public static readonly bool EnableGraphicsDebugFeatures = false;
+
+    static BuildConfig()
+    {
+        ProjectName = "Nanoforge";
+#if DEBUG
+        string workingDirectory = Environment.CurrentDirectory;
+        string? projectDir = Directory.GetParent(workingDirectory)?.Parent?.Parent?.FullName;
+
+        AssetsDirectory = $"{projectDir}/assets/";
+#else
+        AssetsDirectory = "./assets/";
+#endif
+        ShadersDirectory = $@"{AssetsDirectory}shaders/";
+        Version = "v2.0.0";
+    }
+}
diff --git a/Nanoforge/BuildConfig.h b/Nanoforge/BuildConfig.h
diff --git a/Nanoforge/CMakeLists.txt b/Nanoforge/CMakeLists.txt
diff --git a/Nanoforge/CrashHandler.h b/Nanoforge/CrashHandler.h
diff --git a/Nanoforge/Editor/Config.cs b/Nanoforge/Editor/Config.cs
@@ -0,0 +1,39 @@
+
+namespace Nanoforge.Editor;
+
+/// <summary>
+/// CVars are an easy way to define global EditorObjects without needing to manually add & retrieve them from NanoDB.
+/// Just define a field/property of the type CVar<T> where T is an EditorObject you want to persist across NanoDB sessions and projects.
+/// When the instance is it'll handle loading its value from NanoDB and creating a global EditorObject for the data if it doesn't already exist.    
+/// </summary>
+public class CVar<T> where T : EditorObject, new()
+{
+    public T Value { get; private set; }
+    public readonly string Name;
+
+    public CVar(string name)
+    {
+        Name = name;
+        if (!NanoDB.LoadedGlobalObjects)
+        {
+            NanoDB.LoadGlobals();
+        }
+
+        T? value = NanoDB.Find<T>(Name);
+        if (value == null)
+        {
+            Value = NanoDB.CreateGlobalObject<T>(Name);
+            NanoDB.SaveGlobals();   
+        }
+        else
+        {
+            Value = value;
+        }
+    }
+
+    //Save the variable to Settings.nanodata. Note: Really saves all the CVars since ProjectDB doesn't support selective saves. So don't spam this.
+    public void Save()
+    {
+        NanoDB.SaveGlobals();
+    }
+}
diff --git a/Nanoforge/Editor/EditorObject.cs b/Nanoforge/Editor/EditorObject.cs
@@ -0,0 +1,41 @@
+using System.Text.Json.Serialization;
+
+namespace Nanoforge.Editor;
+
+public class EditorObject
+{
+    // ReSharper disable once InconsistentNaming
+    public const ulong NullUID = ulong.MaxValue;
+
+    [JsonInclude]
+    private ulong _uid = NullUID;
+
+    // ReSharper disable once InconsistentNaming
+    [JsonIgnore]
+    public ulong UID
+    {
+        get => _uid;
+        private set
+        {
+            _uid = value;    
+        }
+
+    }
+
+    public string Name = "";
+
+    public virtual EditorObject Clone()
+    {
+        EditorObject clone = (EditorObject)MemberwiseClone();
+        clone.UID = NullUID; //Default to NullUID so it's clear in the debugger that the object isn't valid yet. Gets a valid UID when finally added to NanoDB.
+        clone.Name = new string(Name);
+        return clone;
+    }
+
+    //Do NOT call this unless you know what you're doing. This is really only for NanoDB to use when creating objects.
+    //I made it into a function instead of using the property so it's hard to accidentally change the UID.
+    public void SetUID(ulong uid)
+    {
+        UID = uid;
+    }
+}
diff --git a/Nanoforge/Editor/GeneralSettings.cs b/Nanoforge/Editor/GeneralSettings.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace Nanoforge.Editor;
+
+public class GeneralSettings : EditorObject
+{
+    public string DataPath = "";
+    public ObservableCollection<string> RecentProjects { get; set; } = new();
+    public string NewProjectDirectory = ""; //So you don't have to keep picking the folder every time you make a project
+
+    public static CVar<GeneralSettings> CVar { get; } = new("GeneralSettings");
+}