Fixed regression for generic handling TypeExtension.FindType

Caused by d2c6c9a948

GlitchyEditor/src/EditWindows/ComponentEditWindow.bf

@@ -205,7 +205,7 @@ namespace GlitchyEditor.EditWindows
 				positionX -= buttonSize.X + ImGui.GetStyle().FramePadding.x;
 				ImGui.SameLine(positionX);
 
-				if (ImGui.ImageButton("save", EditorIcons.Instance.Icon_Save, (.)buttonSize))
+				if (ImGui.ImageButton("save_to_editor", EditorIcons.Instance.Icon_Save, (.)buttonSize))
 				{
 					if (Entity editorEntity = Editor.Instance.EditorScene.GetEntityByID(entity.UUID))
 					{
@@ -213,9 +213,21 @@ namespace GlitchyEditor.EditWindows
 						
 						if (typeof(TComponent) == typeof(ScriptComponent))
 						{
-							// TODO: Copy script data into editor
+							// Dirty hack to get to the serialized script instances of the editor scene.
-							// TODO: Somehow get the scriptserializer used to serialize the editor scene
+							var serializer = EditorApp.Instance.EditorLayer.[Friend]_scriptSerializer;
-							//scriptSerializer.SerializeScriptInstance(((ScriptComponent*)component).Instance);
+
+							// Dirty hack to remove the old data
+							if (serializer.SerializedObjects.GetAndRemove(entity.UUID) case .Ok(let kvPair))
+							{
+								delete kvPair.value;
+							}
+
+							// Just save the new data into the context (what could possibly go wrong?!)
+							// this could probably serialize too much data into our context (because we can serialize reference types)
+							// and leave a bunch of dangling data in it (because we can serialize reference types)
+							serializer.SerializeScriptInstance(((ScriptComponent*)component).Instance);
+							// This is also a massive hack to make sure we don't keep references to types, but this also mean we might serialize too much?
+							serializer.FinishSerialization();
 						}
 					}
 					else

GlitchyEditor/src/EditorApp.bf

@@ -35,6 +35,8 @@ namespace GlitchyEditor
 
 		public Settings Settings { get; private set; } = new .() ~ delete _;
 
+		public EditorLayer EditorLayer => _editorLayer;
+		
 		public this(String[] args)
 		{
 			/*while(!Debug.IsDebuggerPresent)

GlitchyEngine/src/World/Components/Components.bf

@@ -670,7 +670,7 @@ namespace GlitchyEngine.World
 		}
 	}
 
-	struct ScriptComponent : IDisposableComponent
+	struct ScriptComponent : IDisposableComponent, ICopyComponent<ScriptComponent>
 	{
 		private String _scriptClassName = null;
 
@@ -705,5 +705,12 @@ namespace GlitchyEngine.World
 			delete _scriptClassName;
 			ReleaseRefAndNullify!(_instance);
 		}
+
+		public static void Copy(ScriptComponent* source, ScriptComponent* target)
+		{
+			target.ScriptClassName = source.ScriptClassName;
+
+			// TODO: This is just half the work, because we actually have to somehow handle the script instance
+		}
 	}
 }

ScriptCore/Extensions/TypeExtension.cs

@@ -95,12 +95,57 @@ public static class TypeExtension
         ReadOnlySpan<char> typeName = ReadTypeName(fullName);
         rest = rest.Slice(typeName.Length);
 
-        if (rest.IsEmpty || rest[0] != '`')
+        if (rest.IsEmpty || (rest[0] != '[' && rest[0] != '`'))
         {
             // Non generic type, easy!
             return GetType(typeName);
         }
         
+        if (rest[0] == '[')
+        {
+            Type? baseType = GetType(typeName);
+
+            if (baseType == null)
+            {
+                Log.Error($"Failed to find element type {typeName} of array type {fullName}");
+                return null;
+            }
+
+            // Handle array type
+            int rank = 1;
+            bool forceMultiDimensional = false;
+            for (int i = 0; i < rest.Length; i++)
+            {
+                if (rest[i] == ',')
+                {
+                    rank++;
+                }
+                else if (rest[i] == '*')
+                {
+                    forceMultiDimensional = true;
+                }
+                else if (rest[i] == ']')
+                {
+                    rest = rest.Slice(i + 1);
+                    break;
+                }
+            }
+
+            Debug.Assert(rest.IsEmpty);
+
+            // It is important to use MakeArrayType() for single-dimensional arrays, as a single-dimension array is distinct from a multi-dimension array of rank 1. The latter cannot be created using normal code, but can be created using reflection.
+            if (rank == 1 && !forceMultiDimensional)
+            {
+                return baseType.MakeArrayType();
+            }
+            else
+            {
+                return baseType.MakeArrayType(rank);
+            }
+        }
+        
+        if (rest[0] == '`')
+        {
             // Handle generic type
 
             int brackedIndex = fullName.IndexOf('[');
@@ -110,14 +155,11 @@ public static class TypeExtension
 
             Type? genericType = GetType(typeName);
 
-        Console.WriteLine($"Generic Type: {genericType}");
-        
             List<Type> arguments = new List<Type>();
 
             while (true)
             {
                 Type? argument = FindType(rest, ref rest);
-            Console.WriteLine($"Argument:  {argument}");
 
                 Debug.Assert(argument != null);
 
@@ -143,6 +185,10 @@ public static class TypeExtension
             return genericType?.MakeGenericType(arguments.ToArray());
         }
 
+        Log.Error($"Failed to find a type for {typeName}.");
+        return null;
+    }
+
     private static Type? GetType(ReadOnlySpan<char> fullName)
     {
         string name = fullName.TrimEnd(']').ToString();

ScriptCore/Serialization/DeserializationObject.cs

@@ -56,6 +56,7 @@ public class DeserializationObject
         {
             ScriptGlue.Serialization_GetObjectTypeName(_internalContext, out string fullTypeName);
 
+            // TODO: Retrieving the entire type by name is not ideal, we should probably consider using a more efficient approach.
             return GetTypeFromName(fullTypeName);
         }
     }