Add heuristics to not always rebuild script project on play

BeefSpace.toml

@@ -1,8 +1,10 @@
 FileVersion = 1
 Locked = ["ImGui"]
+Unlocked = ["corlib"]
 
 [Workspace]
 StartupProject = "GlitchyEditor"
+PreprocessorMacros = ["IMGUI"]
 
 [Projects]
 GlitchyEngine = {Path = "GlitchyEngine"}
@@ -20,17 +22,24 @@ ImGuizmo = {Path = "GlitchyEngine/vendor/imgui/ImGuizmo"}
 GlitchyEngineHelper = {Path = "GlitchyEngineHelper"}
 bon = {Path = "GlitchyEngine/vendor/bon"}
 box2d-beef = {Path = "GlitchyEngine/vendor/box2D"}
-"Beef.Linq" = {Path = "GlitchyEngine/vendor/Beef.Linq/src"}
 ScriptCore = {Path = "ScriptCore"}
 NetHostBeef = {Path = "GlitchyEngine/vendor/NetHostBeef/NetHostBeef"}
 "GlitchyEngine.Test" = {Path = "GlitchyEngine.Test"}
 Xml-Beef = {Path = "GlitchyEngine/vendor/Xml-Beef"}
 "GlitchyEngine.Benchmark" = {Path = "GlitchyEngine.Benchmark"}
+"Beef.Linq" = {Path = "GlitchyEngine/vendor/Beef.Linq"}
+"Oregano.git" = {Git = "https://github.com/zerkawei/Oregano.git"}
 
 [WorkspaceFolders]
 GlitchyEngine = ["GlitchyEngine", "GlitchLog", "GlitchyEngineHelper", "ScriptCore", "GlitchyEngine.Test", "GlitchyEngine.Benchmark"]
-"GlitchyEngine/Dependencies" = ["cgltf-beef", "DirectX", "FreeType", "ImGui", "ImGuiImplDX11", "ImGuiImplWin32", "ImGuizmo", "LodePng", "msdfgen-beef", "bon", "box2d-beef", "Beef.Linq", "NetHostBeef", "Xml-Beef"]
+"GlitchyEngine/Dependencies" = ["cgltf-beef", "DirectX", "FreeType", "ImGui", "ImGuiImplDX11", "ImGuiImplWin32", "ImGuizmo", "LodePng", "msdfgen-beef", "bon", "box2d-beef", "NetHostBeef", "Xml-Beef", "Beef.Linq"]
 Beef = ["Beefy2D", "corlib"]
 
 [Configs.Debug.Win64]
 AllocStackTraceDepth = 12
+ConfigSelections = {"GlitchyEngine.Test" = {Enabled = false}}
+
+[Configs.Release.Win64]
+Toolset = "Microsoft"
+LTOType = "None"
+ConfigSelections = {"GlitchyEngine.Test" = {Enabled = false}}

BeefSpace_Lock.toml

@@ -0,0 +1,6 @@
+FileVersion = 1
+
+[Locks."Oregano.git".Git]
+URL = "https://github.com/zerkawei/Oregano.git"
+Tag = ""
+Hash = "0811b2dc6a878c472d2bc08b37ebc0862f853290"

GlitchyEditor/BeefProj.toml

@@ -15,13 +15,14 @@ ImGuiImplDX11 = "*"
 ImGuiImplWin32 = "*"
 ImGuizmo = "*"
 "Beef.Linq" = "*"
+"Oregano.git" = {Git = "https://github.com/zerkawei/Oregano.git"}
 
 [Platform.Windows]
 IconFile = "$(ProjectDir)/Resources/Textures/GlitchyEngineIcon.ico"
 
 [Configs.Debug.Win64]
 PostBuildCmds = ["CopyFilesIfNewer(\"$(WorkspaceDir)/bin/vswhere.exe\", \"$(TargetDir)\")"]
-DebugCommandArguments = "\"$(ProjectDir)/../GlitchyEngine.Test/content/TestProject\""
+DebugCommandArguments = "\"D:\\Development\\Git\\SingleStateToOrbit\\\""
 PreprocessorMacros = ["DEBUG", "IMGUI"]
 
 [Configs.Release.Win64]

GlitchyEditor/src/Assets/AssetHierarchy.bf

@@ -33,6 +33,10 @@ class AssetHierarchy
 
 	public TreeNode<AssetNode> RootNode => _assetRootNode;
 
+	private append ScriptProjectDirtyManager _scriptProjectDirtyManager = .();
+
+	public ScriptProjectDirtyManager ScriptProjectDirtyManager => _scriptProjectDirtyManager;
+
 	public StringView ResourcesDirectory
 	{
 		get => _resourcesDirectory;
@@ -235,6 +239,8 @@ class AssetHierarchy
 		//SetupResourcesFileSystemWatcher();
 
 		UpdateFiles();
+
+		ScriptProjectDirtyManager.SetVeryDirty();
 	}
 
 	/// Sets path to the directory that contains the game assets.
@@ -322,18 +328,24 @@ class AssetHierarchy
 			Log.EngineLogger.Trace($"File content changed (\"{filename}\")");
 
 			FileContentChanged(filename);
+
+			ScriptProjectDirtyManager.AssetChanged(filename);
 		});
 
 		fsw.OnCreated.Add(new (filename) => {
 			Log.EngineLogger.Trace($"File created (\"{filename}\")");
 
 			DeferFileTreeUpdate();
+
+			ScriptProjectDirtyManager.AssetChanged(filename);
 		});
 
 		fsw.OnDeleted.Add(new (filename) => {
 			Log.EngineLogger.Trace($"File deleted (\"{filename}\")");
 
 			DeferFileTreeUpdate();
+
+			ScriptProjectDirtyManager.AssetChanged(filename);
 		});
 
 		fsw.OnRenamed.Add(new (oldName, newName) => {
@@ -342,6 +354,9 @@ class AssetHierarchy
 			FileRenamed(oldName, newName);
 			
 			DeferFileTreeUpdate();
+
+			ScriptProjectDirtyManager.AssetChanged(oldName);
+			ScriptProjectDirtyManager.AssetChanged(newName);
 		});
 
 		fsw.StartRaisingEvents();

GlitchyEditor/src/Assets/ScriptProjectDirtyManager.bf

@@ -0,0 +1,187 @@
+using System;
+using System.IO;
+using System.Collections;
+using Oregano;
+using System.Diagnostics;
+using GlitchyEditor.Settings;
+
+namespace GlitchyEditor.Assets;
+
+class ScriptProjectDirtyManager
+{
+	private bool _anyAssetDirty;
+	private bool _projectFileDirty;
+	private bool _forceRebuild;
+
+	public void AssetChanged(StringView assetPath)
+	{
+		_anyAssetDirty = true;
+
+		_projectFileDirty |= CheckIfProjectFile(assetPath);
+	}
+
+	private bool CheckIfProjectFile(StringView assetPath)
+	{
+		for (Regex regex in _patterns)
+		{
+			if (regex.IsMatch(assetPath))
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+	
+	public void SetClean()
+	{
+		_anyAssetDirty = false;
+		_projectFileDirty = false;
+		_forceRebuild = false;
+	}
+
+	public void SetVeryDirty()
+	{
+		_forceRebuild = true;
+	}
+
+	public bool NeedsRebuild(RebuildOnPlay rebuildMode)
+	{
+		switch (rebuildMode)
+		{
+		case .Off:
+			return _forceRebuild;
+		case .Always:
+			return true;
+		case .WhenAnyAssetsChanged:
+			return _anyAssetDirty || _forceRebuild;
+		case .UseFastUpToDateCheck:
+			return _projectFileDirty || _forceRebuild;
+		}
+	}
+
+	private static List<StringView> patterns = new .(){
+		"**/*.cs", // C# source files
+		"**/*.csproj", // C# Project file
+		"**/*.props", // MSBuild properties
+		"**/*.targets", // MSBuild targets
+		"**/*.resx", // Embedded .NET-Ressources
+		"**/*.editorconfig", // Compiler- and Analyzer-config
+		"**/*.globalconfig", // Global Analyzer-config
+		"**/global.json",
+		"**/NuGet.Config",
+		"**/packages.lock.json",
+		"**/runtimeconfig.template.json"
+	} ~ delete _;
+
+	private List<Regex> _patterns = new .() ~ DeleteContainerAndItems!(_);
+	// Oregano's Regex doesn't copy the pattern but keeps StringViews into it, so the strings must live as long as the regexes.
+	private List<String> _patternStrings = new .() ~ DeleteContainerAndItems!(_);
+
+	public this()
+	{
+		for (StringView pattern in patterns)
+		{
+			String regexString = new .();
+
+			if (CompileRegexFromGlob(pattern, regexString) case .Ok(let regex))
+			{
+				_patternStrings.Add(regexString);
+				_patterns.Add(regex);
+			}
+			else
+			{
+				delete regexString;
+			}
+		}
+	}
+
+	/// Converts the glob into a regex string (written to outRegex) and compiles it.
+	/// The returned Regex references outRegex, so outRegex must outlive it.
+	private static Result<Regex> CompileRegexFromGlob(StringView glob, String outRegex)
+	{
+		outRegex.Append('^');
+
+		int inBrackets = 0;
+		bool isInBrackets() => inBrackets > 0;
+
+		bool isWildcard = false;
+		bool wasDoubleWildcard = false;
+
+		for (char8 c in glob)
+		{
+			if (isWildcard)
+			{
+				isWildcard = false;
+				if (c == '*')
+				{
+					// **
+					outRegex.Append(@"(?:.*[\\/])?");
+					wasDoubleWildcard = true;
+					continue;
+				}
+				else
+				{
+					outRegex.Append(@"[^\\/]*");
+				}
+			}
+
+			if (c == '[')
+			{
+				inBrackets++;
+				outRegex.Append(c);
+				continue;
+			}
+			else if (c == ']')
+			{
+				inBrackets--;
+				outRegex.Append(c);
+				continue;
+			}
+
+			if (c == '.')
+			{
+				if (isInBrackets())
+					outRegex.Append('.');
+				else
+					outRegex.Append(@"\.");
+
+				continue;
+			}
+
+			if (isInBrackets())
+			{
+				outRegex.Append(c);
+				continue;
+			}
+			else
+			{
+				if (c == '?')
+				{
+					outRegex.Append(@"[^\\/]");
+					continue;
+				}
+				else if (c == '*')
+				{
+					isWildcard = true;
+					continue;
+				}
+				else if (c == '/')
+				{
+					if (!wasDoubleWildcard)
+						outRegex.Append(@"\/");
+					continue;
+				}
+				else
+				{
+					outRegex.Append(c);
+					continue;
+				}
+			}
+		}
+
+		outRegex.Append('$');
+
+		return Regex.Compile(outRegex);
+	}
+}

GlitchyEditor/src/Editor.bf

@@ -232,14 +232,16 @@ namespace GlitchyEditor
 		}
 
 		/// Rebuilds the C# scripts.
-		public BuildScriptsBackgroundTask BuildScripts(bool reloadAfterBuild = true)
+		public BuildScriptsBackgroundTask BuildScripts(bool reloadAfterBuild = true, bool doCleanRebuild = false)
 		{
 			ScriptEngine.SuspendAssemblyWatcher();
 
-			BuildScriptsBackgroundTask task = new .(EditorApp.Instance.Settings.ScriptSettings.DotNetExecutablePath, EditorApp.Instance.EditorLayer.CurrentProject, false){ DeleteWhenEnded = true };
+			BuildScriptsBackgroundTask task = new .(EditorApp.Instance.Settings.ScriptSettings.DotNetExecutablePath, EditorApp.Instance.EditorLayer.CurrentProject, releaseBuild: false, doCleanRebuild){ DeleteWhenEnded = true };
 			task.ContinueWith(new (task) => {
 				ScriptEngine.ResumeAssemblyWatcher();
 
+				EditorApp.Instance.ContentManager.AssetHierarchy.ScriptProjectDirtyManager.SetClean();
+
 				if (reloadAfterBuild)
 				{
 					EditorApp.Instance.InvokeOnMainThread(new () => {

GlitchyEditor/src/EditorApp.bf

@@ -23,6 +23,8 @@ namespace GlitchyEditor
 
 		public new static EditorApp Instance => Application.Instance as EditorApp;
 
+		public new EditorContentManager ContentManager => _contentManager;
+
 		private append BackgroundTaskManager _backgroundTaskManager = .();
 
 		public BackgroundTaskManager BackgroundTaskManager => _backgroundTaskManager;

GlitchyEditor/src/EditorLayer.bf

@@ -824,7 +824,7 @@ namespace GlitchyEditor
 		{
 			Debug.Profiler.ProfileFunction!();
 
-			if (allowRebuild && EditorApp.Instance.Settings.ScriptSettings.RebuildOnPlay)
+			if (allowRebuild && _contentManager.AssetHierarchy.ScriptProjectDirtyManager.NeedsRebuild(EditorApp.Instance.Settings.ScriptSettings.RebuildOnPlayMode))
 			{
 				// Don't immediately reload the scripts after the build, because SetActiveScene will do that anyway.
 				var task = _editor.BuildScripts(reloadAfterBuild: false);
@@ -1543,6 +1543,11 @@ namespace GlitchyEditor
 
 				ImGui.AttachTooltip("Compiles the C# script project.");
 
+				if(ImGui.MenuItem("Clean and build Scripts", "Ctrl+Shift+B"))
+					_editor.BuildScripts(doCleanRebuild: true);
+
+				ImGui.AttachTooltip("Makes a clean rebuild of the C# script project.");
+
 				if(ImGui.MenuItem("Reload Scripts", "Ctrl+Shift+R"))
 					_editor.ReloadScripts();
 

GlitchyEditor/src/Multithreading/BuildScriptsBackgroundTask.bf

@@ -19,16 +19,18 @@ class BuildScriptsBackgroundTask : BackgroundTask
 	private Project _project;
 	private bool _releaseBuild;
 	private StringView _dotnetPath;
+	private bool _doCleanRebuild;
 
 	private String _buildLog = new .() ~ delete _;
 
 	private SpawnedProcess _process ~ delete _;
 
-	public this(StringView dotnetPath, Project project, bool releaseBuild)
+	public this(StringView dotnetPath, Project project, bool releaseBuild, bool doCleanRebuild)
 	{
 		_dotnetPath = dotnetPath;
 		_project = project;
 		_releaseBuild = releaseBuild;
+		_doCleanRebuild = doCleanRebuild;
 	}
 
 	public override RunResult Run()
@@ -81,10 +83,22 @@ class BuildScriptsBackgroundTask : BackgroundTask
 
 		processInfo.SetFileName(EditorApp.Instance.Settings.ScriptSettings.DotNetExecutablePath);
 
+		StringView target;
+
+		if (_doCleanRebuild)
+		{
+			target = "build -t:Rebuild";
+		}
+		else
+		{
+			target = "build";
+		}
+
+
 		// -sc|--self-contained... Publish the .NET runtime with your application so the runtime doesn't need to be installed on the target machine.
 		// 		-> This might be useful to build the final game
 		// -o|--ouput <OUTPUT_DIRECTORY>... might be useful for building the final game
-		processInfo.SetArguments(scope $"build -c {(_releaseBuild ? "Release" : "Debug")}");
+		processInfo.SetArguments(scope $"{target} -c {(_releaseBuild ? "Release" : "Debug")}");
 
 		_process = new SpawnedProcess();
 

GlitchyEditor/src/Settings/Settings.bf

@@ -53,6 +53,20 @@ struct SettingAttribute : Attribute
 	}
 }
 
+/// Fields with this Attribute will be exposed as settings.
+[AttributeUsage(AttributeTargets.StaticField, .ReflectAttribute)]
+struct SettingValueAttribute : Attribute
+{
+	public String Name;
+	public String Tooltip;
+
+	public this(String name, String tooltip = "")
+	{
+		Name = name;
+		Tooltip = tooltip;
+	}
+}
+
 /// Fields with this Attribute will be exposed as settings.
 [AttributeUsage(.Method, .ReflectAttribute | .AlwaysIncludeTarget)]
 struct CustomSettingRendererAttribute : Attribute
@@ -239,6 +253,24 @@ class IdeInstallation
 	// This would however be quite complicated to implement well, when looking at how different Visual Studio and Rider already are.
 }
 
+[Reflect]
+enum RebuildOnPlay
+{
+	[SettingValue("Off", "The scripts will not be rebuild when entering play mode.")]
+	Off,
+	[SettingValue("Always", "The scripts will always be rebuild when entering play mode.")]
+	Always,
+	[SettingValue("When any Asset changed", """
+		The scripts will automatically be rebuild when any asset in asset-directory changed, even if it is not necessary for the build process.
+		This can be helpful if you include files in your build-process that are not detected by the heuristic up to date check.
+		""")]
+	WhenAnyAssetsChanged,
+	[SettingValue("When the fancy dancy heuristic check says so.", """
+		A highly sophisticated heuristic will determine if a rebuild is required.
+		""")]
+	UseFastUpToDateCheck
+}
+
 [Reflect]
 class ScriptSettings
 {
@@ -270,9 +302,8 @@ class ScriptSettings
 	private bool _lookedForVs = false;
 	private bool _lookedForRider = false;
 	
-	
+	[Setting("Tools", "Rebuild scripts on play mode", "Configures if and how the scripts will be rebuilt every time the play mode is entered."), BonInclude]
-	[Setting("Tools", "Rebuild scripts on play", "If active, the scripts will be rebuilt every time the user presses play."), BonInclude]
+	public RebuildOnPlay RebuildOnPlayMode = .UseFastUpToDateCheck;
-	public bool RebuildOnPlay = true;
 
 	[Setting("Tools", "Automatically rebuild changed scripts", "If active, the scripts will be rebuilt every time the user presses play."), BonInclude]
 	public bool AutoRebuildOnChange = true;

GlitchyEditor/src/Settings/SettingsWindow.bf

@@ -363,12 +363,23 @@ namespace GlitchyEditor
 						// TODO: handle multiple Flags (as a separate enum type handler though!)
 						
 						StringView currentName = "";
+						StringView currentTooltip = "";
 
 						for (let (name, value) in Enum.GetEnumerator(fieldInfo.FieldType))
 						{
 							if (value == underlyingValue)
+							{
+								if (fieldInfo.FieldType.GetField(@name.Index) case .Ok(FieldInfo info) &&
+									info.GetCustomAttribute<SettingValueAttribute>() case .Ok(SettingValueAttribute settingValue))
+								{
+									currentName = settingValue.Name;
+									currentTooltip = settingValue.Tooltip;
+								}
+								else
 								{
 									currentName = name;
+								}
+
 								break;
 							}
 						}
@@ -379,7 +390,17 @@ namespace GlitchyEditor
 							{
 								bool isSelected = (name == currentName);
 
-								if (ImGui.Selectable(name.ToScopeCStr!(), isSelected))
+								StringView valueName = name;
+								StringView valueTooltip = "";
+								
+								if (fieldInfo.FieldType.GetField(@name.Index) case .Ok(FieldInfo info) &&
+									info.GetCustomAttribute<SettingValueAttribute>() case .Ok(SettingValueAttribute settingValue))
+								{
+									valueName = settingValue.Name;
+									valueTooltip = settingValue.Tooltip;
+								}
+
+								if (ImGui.Selectable(valueName.ToScopeCStr!(), isSelected))
 								{
 									// Set value in field reference
 									switch (fieldInfo.FieldType.Size)
@@ -393,10 +414,20 @@ namespace GlitchyEditor
 									if (!isSelected)
 										_settingsChanged = true;
 								}
+
+								if (!valueTooltip.IsEmpty)
+								{
+									ImGui.AttachTooltip(valueTooltip);
+								}
 							}
 
 							ImGui.EndCombo();
 						}
+
+						if (!currentTooltip.IsEmpty)
+						{
+							ImGui.AttachTooltip(currentTooltip);
+						}
 					}
 
 					if (setting.Name == _SettingToHighlight)

GlitchyEngine.Test/content/TestProject/Assets/Scenes/TestScene.scene

@@ -0,0 +1,179 @@
+{
+	Version = 1,
+	Entities = [
+		{
+			Id = 8893155135649576304,
+			NameComponent = {
+				Name = "Camera"
+			},
+			TransformComponent = {
+				Position = {
+					X = 0,
+					Y = 2,
+					Z = -5
+				},
+				Rotation = {
+					X = 0,
+					Y = 0.21643962,
+					Z = 0,
+					W = 0.976296
+				},
+				Scale = {
+					X = 1,
+					Y = 1,
+					Z = 1
+				},
+				EditorEulerRotation = {
+					X = 0,
+					Y = 0.43633237,
+					Z = 0
+				}
+			},
+			CameraComponent = {
+				Primary = true,
+				ProjectionType = .InfinitePerspective,
+				PerspectiveFovY = 1.3089969,
+				PerspectiveNearPlane = 0.1,
+				PerspectiveFarPlane = 10000,
+				OrthographicHeight = 10,
+				OrthographicNearPlane = 0,
+				OrthographicFarPlane = 10,
+				AspectRatio = 1.9840086,
+				FixedAspectRatio = false
+			},
+			Editor = {
+				Flags = .Default
+			}
+		},
+		{
+			Id = 14812165297099037146,
+			NameComponent = {
+				Name = "Light"
+			},
+			TransformComponent = {
+				Position = {
+					X = -3,
+					Y = 4,
+					Z = -1.5
+				},
+				Rotation = {
+					X = 0.23977584,
+					Y = 0.6143275,
+					Z = 0.031567074,
+					W = 0.7510744
+				},
+				Scale = {
+					X = 1,
+					Y = 1,
+					Z = 1
+				},
+				EditorEulerRotation = {
+					X = 0.3490659,
+					Y = 1.3089968,
+					Z = 0.34906587
+				}
+			},
+			LightComponent = {
+				LightType = .Directional,
+				Illuminance = 10,
+				Color = {
+					R = 1,
+					G = 0.9500002,
+					B = 0.8
+				}
+			},
+			Editor = {
+				Flags = .Default
+			}
+		},
+		{
+			Id = 4185051642788402424,
+			NameComponent = {
+				Name = "Entity"
+			},
+			TransformComponent = {
+				Position = {
+					X = 0,
+					Y = 0,
+					Z = 0
+				},
+				Rotation = {
+					X = 0,
+					Y = 0,
+					Z = 0,
+					W = 1
+				},
+				Scale = {
+					X = 1,
+					Y = 1,
+					Z = 1
+				},
+				EditorEulerRotation = {
+					X = 0,
+					Y = 0,
+					Z = 0
+				}
+			},
+			ScriptComponent = {
+				ScriptClass = "TestProject.Assets.Scripts.AdvancedSerializationTest",
+				Fields = (TestProject.Assets.Scripts.AdvancedSerializationTest){
+					ID = 4185051642788402424,
+					LeTuple.Item1 = (int32)101,
+					LeTuple.Item2.X = (float)49,
+					LeTuple.Item2.Y = (float)31,
+					LeTuple.Item3 = &16946239429800937368,
+					LeListDeTuple = &13357518334354818316,
+					GenericStructField.MyField = (float)-56,
+					GenericClassField = &6770493598825812026
+				}
+			},
+			Editor = {
+				Flags = .Default
+			}
+		}
+	],
+	ReferencedObjects = [
+		(TestProject.BClass){
+			ID = 16946239429800937368,
+			F = (float)131
+		},
+		(System.Collections.Generic.List`1[System.ValueTuple`3[System.Int32,GlitchyEngine.Math.float2,TestProject.BClass]]){
+			ID = 13357518334354818316,
+			Count = (int32)4,
+			0.Item1 = (int32)64,
+			0.Item2.X = (float)-81,
+			0.Item2.Y = (float)-118,
+			0.Item3 = &14597969159961685574,
+			1.Item1 = (int32)0,
+			1.Item2.X = (float)0,
+			1.Item2.Y = (float)0,
+			1.Item3 = &0,
+			2.Item1 = (int32)73,
+			2.Item2.X = (float)165,
+			2.Item2.Y = (float)115,
+			2.Item3 = &15752578204681304901,
+			3.Item1 = (int32)0,
+			3.Item2.X = (float)0,
+			3.Item2.Y = (float)0,
+			3.Item3 = &0
+		},
+		(TestProject.BClass){
+			ID = 14597969159961685574,
+			F = (float)23
+		},
+		(TestProject.BClass){
+			ID = 15752578204681304901,
+			F = (float)159
+		},
+		(TestProject.Assets.Scripts.SimpleGenericClass`1[System.Double]){
+			ID = 6770493598825812026,
+			MyField = (double)0.9599999785423279
+		}
+	],
+	StaticFields = [
+		(TestProject.SerializationTest){
+			ID = 1460275328679732402,
+			StaticNumber = (int32)0
+		}
+	]
+}

GlitchyEngine.Test/content/TestProject/Assets/Scenes/TestScene.scene.ass

@@ -0,0 +1,11 @@
+{
+	AssetLoader = null,
+	Config = null,
+	Importer = null,
+	ImporterConfig = null,
+	Processor = null,
+	ProcessorConfig = null,
+	Exporter = null,
+	ExporterConfig = null,
+	AssetHandle = 4008662279183989969
+}

GlitchyEngine.Test/content/TestProject/Assets/Scripts/AdvancedSerializationTest.cs

@@ -0,0 +1,28 @@
+using GlitchyEngine;
+using GlitchyEngine.Math;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace TestProject.Assets.Scripts;
+
+public class SimpleGenericClass<T>
+{
+    public T MyField;
+}
+
+public struct SimpleGenericStruct<T>
+{
+    public T MyField;
+}
+
+public class AdvancedSerializationTest : Entity
+{
+    public (int Prim, float2 Struc, BClass Ref) LeTuple;
+
+    public List<(int Prim, float2 Struc, BClass Ref)> LeListDeTuple;
+
+    public SimpleGenericStruct<float> GenericStructField = new SimpleGenericStruct<float>();
+
+    public SimpleGenericClass<double> GenericClassField = new SimpleGenericClass<double>();
+}

GlitchyEngine.Test/content/TestProject/Assets/Scripts/AdvancedSerializationTest.cs.ass

@@ -0,0 +1,11 @@
+{
+	AssetLoader = null,
+	Config = null,
+	Importer = null,
+	ImporterConfig = null,
+	Processor = null,
+	ProcessorConfig = null,
+	Exporter = null,
+	ExporterConfig = null,
+	AssetHandle = 16179505410974622627
+}

GlitchyEngine.Test/content/TestProject/Assets/Scripts/SerializationTest.cs.ass

@@ -0,0 +1,11 @@
+{
+	AssetLoader = null,
+	Config = null,
+	Importer = null,
+	ImporterConfig = null,
+	Processor = null,
+	ProcessorConfig = null,
+	Exporter = null,
+	ExporterConfig = null,
+	AssetHandle = 13036819508142753970
+}

GlitchyEngine.Test/content/TestProject/Assets/Scripts/TestScript.cs.ass

@@ -0,0 +1,11 @@
+{
+	AssetLoader = null,
+	Config = null,
+	Importer = null,
+	ImporterConfig = null,
+	Processor = null,
+	ProcessorConfig = null,
+	Exporter = null,
+	ExporterConfig = null,
+	AssetHandle = 2840305762073418465
+}

GlitchyEngine.Test/content/TestProject/TestProject.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <!-- General configuration -->
     <AssemblyTitle>TestProject</AssemblyTitle>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <OutputType>Library</OutputType>
     <Nullable>enable</Nullable>
     <!-- Define the output path -->

GlitchyEngine.Test/content/TestProject/TestProject.slnx

@@ -1,4 +1,7 @@
 <Solution>
   <Project Path="TestProject.csproj"/>
   <Project Path="D:\Development\Projects\Beef\GlitchyEngine\ScriptCore\ScriptCore.csproj"/>
+  <Project Path="D:\Development\Projects\Beef\GlitchyEngine\ScriptCoreGenerator\ScriptCoreGenerator.csproj"/>
+  <Project Path="D:\Development\Projects\Beef\GlitchyEngine\ScriptCoreGenerator.Test\ScriptCoreGenerator.Test.csproj"/>
+  <Project Path="D:\Development\Projects\Beef\GlitchyEngine\vendor\ImGui.NET\src\ImGui.NET\ImGui.NET.csproj"/>
 </Solution>

GlitchyEngine/src/Scripting/ScriptEngine.bf

@@ -374,8 +374,6 @@ static class ScriptEngine
 		if (script.Instance != null)
 			script.Instance = null;
 
-		script.ScriptClassName = null;
-
 		DestroyInstance(entityId);
 	}
 
@@ -455,26 +453,20 @@ static class ScriptEngine
 
 		LoadScriptAssemblies();
 
+		
+		if (retainScriptData)
+		{
+			if (Context != null)
 			{
 				Debug.Profiler.ProfileScope!("Initialize Instances");
 	
 				// We need to create a new instance for every entity
-			for (let (id, scriptInstance) in _entityScriptInstances)
+				for (let (ecsEntity, scriptComponent) in Context.GetEntities<ScriptComponent>())
 				{
-				if (Context.GetEntityByID(id) case .Ok(let entity))
+					InitializeInstance(Entity(ecsEntity, Context), scriptComponent);
-				{
-					ScriptComponent* script = entity.GetComponent<ScriptComponent>();
-					InitializeInstance(entity, script);
-				}
-				else
-				{
-					Log.EngineLogger.AssertDebug(false, "Entities script was just serialized but the entity doesn't exist anymore.");
-				}
 				}
 			}
 
-		if (retainScriptData)
-		{
 			contextSerializer.DeserializeScriptInstances();
 		}
 

ScriptCore/Editor/EntityEditor.cs

@@ -613,17 +613,10 @@ internal class EntityEditor
         {
 
         }
-        else if (fieldType.IsGenericType)
+        else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(List<>))
-        {
-            if (fieldType.GetGenericTypeDefinition() == typeof(List<>))
         {
             newValue = ShowListEditor(fieldType, reference, fieldName);
         }
-            else
-            {
-                ImGui.TextColored(new Vector4(1, 0, 0, 1), $"{fieldName}: Type {fieldType} is not implemented.");
-            }
-        }
         else if (fieldType.IsArray)
         {
             newValue = ShowArrayEditor(fieldType, reference, fieldName);

ScriptCore/Serialization/SerializedObject.cs

@@ -176,6 +176,9 @@ public class SerializedObject
 
     public void SerializeField(string fieldName, object? fieldValue, Type fieldType)
     {
+        if (TryCustomSerializer(fieldName, fieldValue, fieldType))
+            return;
+
         // Decimals are not actually primitives, but we treat them as if they were, because they are a built-in type
         // and it makes more sense to send them over to the engine as a binary type than to serialize their underlying fields (which would happen when we treated them as a struct).
         if (fieldType.IsPrimitive || fieldType == typeof(decimal))
@@ -202,38 +205,17 @@ public class SerializedObject
 
             SerializeList(fieldName, fieldValue, fieldType, fieldType.GetElementType()!);
         }
-        else if (fieldType.IsGenericType)
+        else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(List<>))
-        {
-            if (TryCustomSerializer(fieldName, fieldValue, fieldType))
-                return;
-
-            if (fieldType.GetGenericTypeDefinition() == typeof(List<>))
         {
             SerializeList(fieldName, fieldValue, fieldType, fieldType.GetGenericArguments()[0]);
         }
-            //else if (fieldType.GetGenericTypeDefinition() == typeof(Dictionary<,>))
-            //{
-            //    ImGui.Text($"{fieldName} Dictionary");
-            //}
-            else
-            {
-                // TODO: what to do?
-                Log.Error($"Generic class serialization not yet implemented");
-            }
-        }
         else if (fieldType.IsValueType)
         {
-            if (TryCustomSerializer(fieldName, fieldValue, fieldType))
-                return;
-
             // Value Types cant be null
             SerializeStruct(fieldName, fieldValue!, fieldType);
         }
         else if (fieldType.IsClass)
         {
-            if (TryCustomSerializer(fieldName, fieldValue, fieldType))
-                return;
-
             SerializeClass(fieldName, fieldValue, fieldType);
         }
         else