Scenes based on type not string id

src/Debug/ConsoleScene.cs

···
     float scrollYOffset = 0;
     bool pressedScroll = false;
 
-    public ConsoleScene(int width, int height, string id) : base(width, height, id)
+    public ConsoleScene(int width, int height) : base(width, height)
     {
         ClearColor = UiStyles.Background;
         UpdateOnlyIfActive = true;

src/Debug/Debug.cs

···
 
     public static void Initialize()
     {
-        SceneHandler.Register(new InspectorScene((int)(Game.Window.Width * 0.201), 1080, "Inspector")
+        SceneHandler.Register(new InspectorScene((int)(Game.Window.Width * 0.201), 1080)
             .SetAllowWindowResize(false)
             .SetAlwaysRebuildTexture(true)
             .SetRelativeWindowSize(0.8f, 0f, 1.0001f, 1f));
 
-        SceneHandler.Register(new ConsoleScene((int)(Game.Window.Width * 0.2), (int)(Game.Window.Height * 0.4), "Console")
+        SceneHandler.Register(new ConsoleScene((int)(Game.Window.Width * 0.2), (int)(Game.Window.Height * 0.4))
             .SetAllowWindowResize(true)
             .SetRelativeWindowSize(0.1f, 0.1f, 0.4f, 0.6f)
             .SetAlwaysRebuildTexture(true));
 
-        SceneHandler.Register(new PerformanceScene((int)(Game.Window.Width * 0.2), (int)(Game.Window.Height * 0.4), "Performance")
+        SceneHandler.Register(new PerformanceScene((int)(Game.Window.Width * 0.2), (int)(Game.Window.Height * 0.4))
             .SetRelativeWindowSize(0f, 0.89f, 0.10f, 1.001f)
             .SetAlwaysRebuildTexture(true));
 
···
         {
             if (args.Length < 1)
             {
-                Debug.Log(SceneHandler.IsLoaded("Performance"));
+                Debug.Log(SceneHandler.IsLoaded<PerformanceScene>());
                 return;
             }
 
···
 
             if ((bool)args[0])
             {
-                SceneHandler.Load("Performance");
+                SceneHandler.Load<PerformanceScene>();
             }
             else
             {
-                SceneHandler.Unload("Performance");
+                SceneHandler.Unload<PerformanceScene>();
             }
         });
 
···
                 lineNum++;
             }
         }
-
-        // Console.WriteLine(message);
 
         StackTrace stackTrace = new StackTrace(); 
         StackFrame? stackFrame = stackTrace.GetFrame(1);

src/Debug/InspectorScene.cs

···
     float yOffset = 0;
     public string SelectedScene = "";
 
-    public InspectorScene(int width, int height, string id) : base(width, height, id)
+    public InspectorScene(int width, int height) : base(width, height)
     {
         ClearColor = UiStyles.Background;
         // SetUpdateOnlyIfActive(true);

src/Debug/OldInspectorScene.cs

···
 {
     float yOffset = 0;
 
-    public OldInspectorScene(int width, int height, string id) : base(width, height, id)
+    public OldInspectorScene(int width, int height) : base(width, height)
     {
         ClearColor = UiStyles.Background;
         UpdateOnlyIfActive = true;

src/Debug/PerformanceScene.cs

···
 
     bool LastSize = false;
 
-    public PerformanceScene(int width, int height, string id) : base(width, height, id)
+    public PerformanceScene(int width, int height) : base(width, height)
     {
     }
 

src/GameManager.cs

···
         SDL_SetRenderDrawColor(SDLRenderer, 0, 0, 0, 255);
         SDL_RenderClear(SDLRenderer);
 
-        foreach (string id in SceneHandler.LoadedScenes)
+        foreach (string id in new List<string>(SceneHandler.LoadedScenes))
         {
             try {
                 SceneHandler.Scenes[id].UpdateCall();
···
 
         if (GlobalKeyboard.Pressed(Key.D, Mod.LShift, Mod.LCtrl))
         {
-            if (!SceneHandler.IsLoaded("Inspector"))
-                SceneHandler.Load("Inspector");
+            if (!SceneHandler.IsLoaded<InspectorScene>())
+                SceneHandler.Load<InspectorScene>();
             else
-                SceneHandler.Unload("Inspector");
+                SceneHandler.Unload<InspectorScene>();
         }
 
         if (GlobalKeyboard.Pressed(Key.C, Mod.LShift, Mod.LCtrl))
         {
-            if (!SceneHandler.IsLoaded("Console")) {
-                SceneHandler.Load("Console");
+            if (!SceneHandler.IsLoaded<ConsoleScene>()) {
+                SceneHandler.Load<ConsoleScene>();
             } else
-                SceneHandler.Unload("Console");
+                SceneHandler.Unload<ConsoleScene>();
         }
 
         if (GlobalKeyboard.Pressed(Key.F, Mod.LShift, Mod.LCtrl))
         {
-            if (!SceneHandler.IsLoaded("Performance"))
+            if (!SceneHandler.IsLoaded<PerformanceScene>())
             {
-                SceneHandler.Load("Performance");
+                SceneHandler.Load<PerformanceScene>();
             }
             else
             {
···
                     else
                         scene.SetRelativeWindowSize(scene.RelativeWindowSize.x + 0.14f, scene.RelativeWindowSize.y, scene.RelativeWindowSize.w, scene.RelativeWindowSize.h);
                     scene.Size = false;
-                    SceneHandler.Unload("Performance");
+                    SceneHandler.Unload<PerformanceScene>();
                 }
                     
             }

src/Scenes/Scene.cs

···
 
 public abstract class Scene : ICloneable
 {
-    public string SceneID { get => SceneID; set => throw new Exception("Can't set SceneID"); }
+    public string SceneID { get; internal set; }
 
     public bool AllowWindowResize { get; set; } = false;
     public bool AlwaysRebuildTexture { get; set; } = false;
···
         };
     }
 
-    public string GetSceneID()
-    {
-        return SceneID;
-    }
-
     public void ApplyOriginalAspectRatio()
     {
         float ratio = OriginalWindowSize.X / OriginalWindowSize.Y;
···
         RelativeWindowSize.h = newSize.Y / Game.Window.Height;
     }
 
-    protected Scene(int width, int height, string id)
+    protected Scene(int width, int height)
     {
         OriginalWindowSize.X = width;
         OriginalWindowSize.Y = height;
         WindowSize.X = width;
         WindowSize.Y = height;
 
-        SceneID = id;
+        SceneID = this.GetType().Name;
         
         RenderTarget = SDL_CreateTexture(Game.SDLRenderer, SDL_PIXELFORMAT_RGBA8888,
             (int)SDL_TextureAccess.SDL_TEXTUREACCESS_TARGET, width, height);
         SDL_SetTextureBlendMode(RenderTarget, SDL_BlendMode.SDL_BLENDMODE_BLEND);
 
-        Keyboard = new(id);
-        Mouse = new(id);
+        Keyboard = new(SceneID);
+        Mouse = new(SceneID);
         Camera = new(this);
     }
 

src/Scenes/SceneHandler.cs

···
     internal static Dictionary<string, Scene> Scenes = new ();
     internal static Dictionary<string, Scene> OriginalScenes = new ();
     
-    private static List<string> _loadedScenes = new(); 
-    
-    internal static List<string> LoadedScenes {
-        get => new List<string>(_loadedScenes);
-        set => _loadedScenes = value;
-    }
+    public static List<string> LoadedScenes = new();
     
     public static void Initialize() {
         Debug.RegisterCommand("scene_unload", (args) => {
···
 
     public static void Register(Scene scene)
     {
-        Scenes.Add(scene.GetSceneID(), (Scene)scene.Clone());
-        OriginalScenes.Add(scene.GetSceneID(), (Scene)scene.Clone());
+        Scenes.Add(scene.SceneID, (Scene)scene.Clone());
+        OriginalScenes.Add(scene.SceneID, (Scene)scene.Clone());
     }
 
-    public static void Load(string id)
+    internal static void Load(string id)
     {
         if (!LoadedScenes.Contains(id))
         {
             LoadedScenes.Add(id);
             Scenes[id].AwakeCall();
+        } else {
+            Debug.Log($"Scene \"{id}\" doesnt exist");
         }
     }
 
-    public static void Unload(string id)
+    internal static void Unload(string id)
     {
         if (LoadedScenes.Contains(id))
         {
···
         FUI.selectedTextField = null;
     }
 
-    public static void Remake(string id)
+    internal static void Remake(string id)
     {
         Scenes[id] = (Scene)OriginalScenes[id].Clone();
         Scenes[id].Entities.Clear();
         Scenes[id].Awake();
     }
 
+    public static void Load<T>()
+    {
+        Load(typeof(T).Name);
+    }
+
+    public static void Unload<T>()
+    {
+        Unload(typeof(T).Name);
+    }
+
+    public static void Remake<T>()
+    {
+        Remake(typeof(T).Name);
+    }
+
     public static T Get<T>()
     {
         var scene = Scenes.Values.ToList().Find((val) => val.GetType() == typeof(T));
···
         }
     }
 
-    public static Scene Get(string id)
+    internal static Scene Get(string id)
     {
         return Scenes[id];
     }
 
-    public static bool IsLoaded(string id)
+    internal static bool IsLoaded(string id)
     {
         return LoadedScenes.Contains(id);
+    }
+
+    public static bool IsLoaded<T>()
+    {
+        return IsLoaded(typeof(T).Name);
     }
 }