From 38484415f10e8d9066668be59ecc83709f5f4b5f Mon Sep 17 00:00:00 2001
From: antopilo <antoinepilote1@hotmail.com>
Date: Mon, 16 Sep 2024 17:28:01 -0400
Subject: [PATCH 1/7] Now displaying camera frustum gizmo

---
 Editor/src/Misc/GizmoDrawer.cpp       | 22 +++++++++++++++++++++-
 Nuake/src/Rendering/SceneRenderer.cpp | 10 ++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/Editor/src/Misc/GizmoDrawer.cpp b/Editor/src/Misc/GizmoDrawer.cpp
index 8571bdd1..d5379941 100644
--- a/Editor/src/Misc/GizmoDrawer.cpp
+++ b/Editor/src/Misc/GizmoDrawer.cpp
@@ -27,6 +27,7 @@
 #include <DetourDebugDraw.h>
 #include <src/Scene/Components/BSPBrushComponent.h>
 
+
 GizmoDrawer::GizmoDrawer(EditorInterface* editor)
 {
 	m_LineShader = Nuake::ShaderManager::GetShader("Resources/Shaders/line.shader");
@@ -222,6 +223,8 @@ void GizmoDrawer::DrawGizmos(Ref<Scene> scene, bool occluded)
 {
 	using namespace Nuake;
 
+	auto camView = scene->m_Registry.view<TransformComponent, CameraComponent>();
+
 	RenderCommand::Enable(RendererEnum::DEPTH_TEST);
 
 	glLineWidth(3.0f);
@@ -459,6 +462,24 @@ void GizmoDrawer::DrawGizmos(Ref<Scene> scene, bool occluded)
 		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	}
 
+	for (auto e : camView)
+	{
+		auto [transform, camera] = scene->m_Registry.get<TransformComponent, CameraComponent>(e);
+		const Quat& globalRotation = glm::normalize(transform.GetGlobalRotation());
+		const Matrix4& rotationMatrix = glm::mat4_cast(globalRotation);
+
+		m_LineShader->Bind();
+		m_LineShader->SetUniform("u_Opacity", 1.f);
+		const float aspectRatio = camera.CameraInstance->AspectRatio;
+		const float fov = camera.CameraInstance->Fov;
+		Matrix4 clampedPerspective = glm::perspectiveFov(glm::radians(fov), 9.0f * aspectRatio, 9.0f, 0.05f, 3.0f);
+		m_LineShader->SetUniform("u_View", glm::translate(scene->m_EditorCamera->GetTransform(), Vector3(transform.GetGlobalTransform()[3])) * rotationMatrix * glm::inverse(clampedPerspective));
+		m_LineShader->SetUniform("u_Projection", scene->m_EditorCamera->GetPerspective());
+
+		m_BoxBuffer->Bind();
+		Nuake::RenderCommand::DrawLines(0, 26);
+	}
+
 	auto flatShader = ShaderManager::GetShader("Resources/Shaders/flat.shader");
 	flatShader->Bind();
 	flatShader->SetUniform("u_View", scene->m_EditorCamera->GetTransform());
@@ -484,7 +505,6 @@ void GizmoDrawer::DrawGizmos(Ref<Scene> scene, bool occluded)
 	const Vector3 gizmoSize = Vector3(Engine::GetProject()->Settings.GizmoSize);
 
 	// Camera
-	auto camView = scene->m_Registry.view<TransformComponent, CameraComponent>();
 	for (auto e : camView)
 	{
 		gizmoShader->SetUniform("gizmo_texture", TextureManager::Get()->GetTexture("Resources/Gizmos/camera.png").get());
diff --git a/Nuake/src/Rendering/SceneRenderer.cpp b/Nuake/src/Rendering/SceneRenderer.cpp
index 773af6cb..2936c6e4 100644
--- a/Nuake/src/Rendering/SceneRenderer.cpp
+++ b/Nuake/src/Rendering/SceneRenderer.cpp
@@ -471,6 +471,11 @@ namespace Nuake
 			{
 				// Fetch resource from resource manager using UUID
 				Ref<UIResource> uiResource = ResourceManager::GetResource<UIResource>(uiComponent.UIResource);
+				if (!uiResource)
+				{
+					continue;
+				}
+
 				uiResource->Resize(framebuffer.GetSize());
 
 				// Copy UI onto final viewport
@@ -989,6 +994,11 @@ namespace Nuake
 					}
 
 					Ref<UIResource> uiResource = ResourceManager::GetResource<UIResource>(uiComponent.UIResource);
+					if (!uiResource)
+					{
+						continue;
+					}
+
 					Matrix4 finalTransform = transform.GetGlobalTransform();
 					Renderer::QuadMesh->GetMaterial()->SetAlbedo(uiResource->GetOutputTexture());
 					Renderer::SubmitMesh(Renderer::QuadMesh, finalTransform, (uint32_t)e);

From da995b99c857eef91fe503d8092a569fca50daf9 Mon Sep 17 00:00:00 2001
From: antopilo <antoinepilote1@hotmail.com>
Date: Mon, 16 Sep 2024 20:12:02 -0400
Subject: [PATCH 2/7] Renamed textures to Textures

---
 Editor/src/Commands/Commands/Commands.cpp | 2 +-
 Editor/src/Windows/MapImporterWindow.cpp  | 4 ++--
 Nuake/src/Scene/Systems/WadConverter.cpp  | 6 +++---
 Nuake/src/Vendors/katana-parser/katana.h  | 2 +-
 Nuake/src/Vendors/katana-parser/parser.c  | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Editor/src/Commands/Commands/Commands.cpp b/Editor/src/Commands/Commands/Commands.cpp
index 46829eb6..75bc8417 100644
--- a/Editor/src/Commands/Commands/Commands.cpp
+++ b/Editor/src/Commands/Commands/Commands.cpp
@@ -65,7 +65,7 @@ namespace NuakeEditor
         "packageformat": { "extension": ".zip", "format": "zip" }
     },
     "textures": {
-        "root": "textures",
+        "root": "Textures",
         "extensions": [ ".jpg", ".png", ".tga" ]
     },
     "entities": {
diff --git a/Editor/src/Windows/MapImporterWindow.cpp b/Editor/src/Windows/MapImporterWindow.cpp
index 788d7d2e..c6031271 100644
--- a/Editor/src/Windows/MapImporterWindow.cpp
+++ b/Editor/src/Windows/MapImporterWindow.cpp
@@ -240,7 +240,7 @@ std::vector<std::string> MapImporterWindow::ScanUsedWads()
 
 std::string MapImporterWindow::GetTransformedWadPath(const std::string& path)
 {
-	const std::string& baseTextureDir = "/textures/";
+	const std::string& baseTextureDir = "/Textures/";
 
 	using namespace Nuake;
 	if (m_WadToMaterialMap.find(path) != m_WadToMaterialMap.end())
@@ -285,7 +285,7 @@ std::string MapImporterWindow::GetTransformedWadPath(const std::string& path)
 
 		if (entry.is_regular_file() && stem == upperInput)
 		{
-			std::filesystem::path relativePath = std::filesystem::relative(entry.path(), FileSystem::Root + "/textures/");
+			std::filesystem::path relativePath = std::filesystem::relative(entry.path(), FileSystem::Root + "/Textures/");
 			std::filesystem::path pathWithoutExtension = relativePath;
 			pathWithoutExtension = pathWithoutExtension.parent_path(); // Remove the file name
 
diff --git a/Nuake/src/Scene/Systems/WadConverter.cpp b/Nuake/src/Scene/Systems/WadConverter.cpp
index 5dfce72f..604ef99d 100644
--- a/Nuake/src/Scene/Systems/WadConverter.cpp
+++ b/Nuake/src/Scene/Systems/WadConverter.cpp
@@ -358,11 +358,11 @@ namespace Nuake
 		auto pathSplits = String::Split(std::string(wadPath.begin(), wadPath.end() - 4), '/');
 		pathSplits = String::Split(pathSplits[std::size(pathSplits) - 1], '\\');
 		WadName = pathSplits[std::size(pathSplits) - 1];
-		TargetDirectory = "/textures/" + WadName + "/";
+		TargetDirectory = "/Textures/" + WadName + "/";
 
-		if (!FileSystem::DirectoryExists("/textures/"))
+		if (!FileSystem::DirectoryExists("/Textures/"))
 		{
-			FileSystem::MakeDirectory("/textures/");
+			FileSystem::MakeDirectory("/Textures/");
 		}
 
 		if (!FileSystem::DirectoryExists(TargetDirectory))
diff --git a/Nuake/src/Vendors/katana-parser/katana.h b/Nuake/src/Vendors/katana-parser/katana.h
index d06d7681..90455b9e 100644
--- a/Nuake/src/Vendors/katana-parser/katana.h
+++ b/Nuake/src/Vendors/katana-parser/katana.h
@@ -36,7 +36,7 @@ extern "C" {
 #define KATANA_ERROR_MESSAGE_SIZE 100
 
 typedef enum {
-    KatanaRuleUnkown,
+    KatanaRuleUnknown,
     KatanaRuleStyle,
     KatanaRuleImport,
     KatanaRuleMedia,
diff --git a/Nuake/src/Vendors/katana-parser/parser.c b/Nuake/src/Vendors/katana-parser/parser.c
index 13b89ce6..02065c9f 100644
--- a/Nuake/src/Vendors/katana-parser/parser.c
+++ b/Nuake/src/Vendors/katana-parser/parser.c
@@ -1376,7 +1376,7 @@ void katana_print_rule(KatanaParser* parser, KatanaRule* rule)
             break;
         case KatanaRuleSupports:
             break;
-        case KatanaRuleUnkown:
+        case KatanaRuleUnknown:
             break;
             
         default:

From dd3cc823c069c318aa219ae4f99cd9682c635ce1 Mon Sep 17 00:00:00 2001
From: antopilo <antoinepilote1@hotmail.com>
Date: Mon, 16 Sep 2024 20:12:36 -0400
Subject: [PATCH 3/7] Improved filesystem browser, color accent, drag n drop,
 new icons

---
 Editor/src/EditorApplication.cpp              |   9 +
 Editor/src/EditorApplication.h                |   9 +
 Editor/src/EditorLayer.cpp                    |   7 +-
 Editor/src/EditorLayer.h                      |   1 +
 Editor/src/Windows/EditorInterface.cpp        |  21 ++
 Editor/src/Windows/EditorInterface.h          |   1 +
 Editor/src/Windows/FileSystemUI.cpp           |  80 ++++-
 Editor/src/Windows/FileSystemUI.h             |   2 +
 Nuake/src/Application/Layer.h                 |   1 +
 Nuake/src/FileSystem/File.cpp                 |   7 +-
 Nuake/src/FileSystem/FileSystem.cpp           |  26 +-
 Nuake/src/FileSystem/FileSystem.h             |   1 +
 Nuake/src/FileSystem/FileTypes.h              |   3 +-
 .../src/Rendering/Textures/TextureManager.cpp |   2 +
 Nuake/src/Resource/StaticResources.cpp        | 318 ++++++++++++------
 Nuake/src/Resource/StaticResources.h          |   6 +
 Nuake/src/Window.cpp                          |  29 ++
 Nuake/src/Window.h                            |   4 +-
 Resources/Images/folder_icon.png              | Bin 496 -> 281 bytes
 Resources/Images/project_icon.png             | Bin 719 -> 572 bytes
 Resources/Images/sln_icon.png                 | Bin 0 -> 1190 bytes
 Resources/Images/trenchbroom_icon.png         | Bin 0 -> 546 bytes
 22 files changed, 422 insertions(+), 105 deletions(-)
 create mode 100644 Resources/Images/sln_icon.png
 create mode 100644 Resources/Images/trenchbroom_icon.png

diff --git a/Editor/src/EditorApplication.cpp b/Editor/src/EditorApplication.cpp
index 1af94228..ae70e258 100644
--- a/Editor/src/EditorApplication.cpp
+++ b/Editor/src/EditorApplication.cpp
@@ -10,6 +10,8 @@
 #include "src/UI/NuakeUI.h"
 #include "src/UI/UIInputManager.h"
 
+
+
 void EditorApplication::OnInit()
 {
     using namespace Nuake;
@@ -73,6 +75,13 @@ void EditorApplication::OnInit()
             }
         });
     
+    m_Window->SetOnDragNDropCallback([&](Window& window, const std::vector<std::string>& paths) {
+        for (auto& layer : m_LayerStack)
+        {
+            layer->OnDragNDrop(paths);
+        }
+    });
+
     PushLayer(CreateScope<EditorLayer>());
 }
 
diff --git a/Editor/src/EditorApplication.h b/Editor/src/EditorApplication.h
index 646ecb3f..8e9278b5 100644
--- a/Editor/src/EditorApplication.h
+++ b/Editor/src/EditorApplication.h
@@ -10,6 +10,15 @@
 
 using namespace NuakeEditor;
 
+class DragNDropModule : public Nuake::IApplicationModule
+{
+public:
+	 void OnInit() override 
+	 {
+		
+	 }
+};
+
 class EditorApplication : public Nuake::Application
 {
 private:
diff --git a/Editor/src/EditorLayer.cpp b/Editor/src/EditorLayer.cpp
index c1a1cead..133349c6 100644
--- a/Editor/src/EditorLayer.cpp
+++ b/Editor/src/EditorLayer.cpp
@@ -79,4 +79,9 @@ void EditorLayer::OnDetach()
 void EditorLayer::OnWindowFocused()
 {
     m_EditorInterface->OnWindowFocused();
-}
\ No newline at end of file
+}
+
+void EditorLayer::OnDragNDrop(const std::vector<std::string>& paths)
+{
+    m_EditorInterface->OnDragNDrop(paths);
+}
diff --git a/Editor/src/EditorLayer.h b/Editor/src/EditorLayer.h
index 77759544..4e295bc9 100644
--- a/Editor/src/EditorLayer.h
+++ b/Editor/src/EditorLayer.h
@@ -23,6 +23,7 @@ public:
 	virtual void OnDetach() override;
 
 	virtual void OnWindowFocused() override;
+	virtual void OnDragNDrop(const std::vector<std::string>& paths) override;
 
 private:
 	CommandBuffer mCommandBuffer;
diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp
index bbf4a430..f008d3a3 100644
--- a/Editor/src/Windows/EditorInterface.cpp
+++ b/Editor/src/Windows/EditorInterface.cpp
@@ -3238,6 +3238,27 @@ namespace Nuake {
         
     }
 
+    void EditorInterface::OnDragNDrop(const std::vector<std::string>& paths)
+    {
+        if (Engine::GetProject())
+        {
+            for (const auto& path : paths)
+            {
+                if (!FileSystem::FileExists(path, true))
+                {
+                    continue;
+                }
+
+                if (!FileSystem::DirectoryExists(FileSystemUI::m_CurrentDirectory->GetFullPath(), true))
+                {
+                    return;
+                }
+
+                FileSystem::CopyFileAbsolute(path, FileSystemUI::m_CurrentDirectory->GetFullPath());
+            }
+        }
+    }
+
 	bool EditorInterface::LoadProject(const std::string& projectPath)
 	{
         FileSystem::SetRootDirectory(FileSystem::GetParentPath(projectPath));
diff --git a/Editor/src/Windows/EditorInterface.h b/Editor/src/Windows/EditorInterface.h
index 2b116dac..ea75faeb 100644
--- a/Editor/src/Windows/EditorInterface.h
+++ b/Editor/src/Windows/EditorInterface.h
@@ -106,5 +106,6 @@ namespace Nuake
 
 	public:
 		void OnWindowFocused();
+		void OnDragNDrop(const std::vector<std::string>& paths);
 	};
 }
diff --git a/Editor/src/Windows/FileSystemUI.cpp b/Editor/src/Windows/FileSystemUI.cpp
index 4c52eb43..c2cb3e34 100644
--- a/Editor/src/Windows/FileSystemUI.cpp
+++ b/Editor/src/Windows/FileSystemUI.cpp
@@ -261,6 +261,8 @@ namespace Nuake
                         OS::OpenTrenchbroomMap(file->GetAbsolutePath());
                         break;
                     case FileType::NetScript:
+                    case FileType::UI:
+                    case FileType::CSS:
                         OS::OpenIn(file->GetAbsolutePath());
                         break;
                     case FileType::Scene:
@@ -383,17 +385,30 @@ namespace Nuake
                 textureImage = image;
             }
         }
+        else if (fileType == FileType::Solution)
+        {
+            textureImage = textureMgr->GetTexture("Resources/Images/sln_icon.png");
+        }
+        else if (fileType == FileType::Map)
+        {
+            textureImage = textureMgr->GetTexture("Resources/Images/trenchbroom_icon.png");
+        }
 
         ImGui::SetCursorPos(prevCursor);
         ImGui::Image(reinterpret_cast<ImTextureID>(textureImage->GetID()), ImVec2(100, 100), ImVec2(0, 1), ImVec2(1, 0));
         ImGui::PopStyleVar();
         
-        auto imguiStyle = ImGui::GetStyle();
+        auto& imguiStyle = ImGui::GetStyle();
 
         ImVec2 startOffset = ImVec2(imguiStyle.CellPadding.x / 2.0f, 0);
         ImVec2 offsetEnd = ImVec2(startOffset.x, imguiStyle.CellPadding.y / 2.0f);
         ImU32 rectColor = IM_COL32(255, 255, 255, 16);
         ImGui::GetWindowDrawList()->AddRectFilled(prevScreenPos + ImVec2(0, 100) - startOffset, prevScreenPos + ImVec2(100, 150) + offsetEnd, rectColor, 1.0f);
+
+        ImU32 rectColor2 = UI::PrimaryCol;
+        Color fileTypeColor = GetColorByFileType(file->GetFileType());
+        ImGui::GetWindowDrawList()->AddRectFilled(prevScreenPos + ImVec2(0, 100) - startOffset, prevScreenPos + ImVec2(100, 101) + offsetEnd, IM_COL32(fileTypeColor.r * 255.f, fileTypeColor.g * 255.f, fileTypeColor.b * 255.f, fileTypeColor.a * 255.f), 0.0f);
+
         std::string visibleName = file->GetName();
         const uint32_t MAX_CHAR_NAME = 32;
         if (file->GetName().size() >= MAX_CHAR_NAME)
@@ -670,6 +685,57 @@ namespace Nuake
         Scan();
     }
 
+    Color FileSystemUI::GetColorByFileType(FileType fileType)
+    {
+        switch (fileType)
+        {
+        case Nuake::FileType::Unknown:
+            break;
+        case Nuake::FileType::Image:
+            break;
+        case Nuake::FileType::Material:
+            break;
+        case Nuake::FileType::Mesh:
+            break;
+        case Nuake::FileType::Script:
+            return { 1.0, 0.0, 0.0, 1.0 };
+            break;
+        case Nuake::FileType::NetScript:
+            return { 1.0, 0.0, 0.0, 1.0 };
+            break;
+        case Nuake::FileType::Project:
+            return Engine::GetProject()->Settings.PrimaryColor;
+            break;
+        case Nuake::FileType::Prefab:
+            break;
+        case Nuake::FileType::Scene:
+            return { 0, 1.0f, 1.0, 1.0 };
+            break;
+        case Nuake::FileType::Wad:
+            break;
+        case Nuake::FileType::Map:
+            return { 0.0, 1.0, 0.0, 1.0 };
+            break;
+        case Nuake::FileType::Assembly:
+            break;
+        case Nuake::FileType::Solution:
+            break;
+        case Nuake::FileType::Audio:
+            return { 0.0, 0.0, 1.0, 1.0 };
+            break;
+        case Nuake::FileType::UI:
+            return { 1.0, 1.0, 0.0, 1.0 };
+            break;
+        case Nuake::FileType::CSS:
+            return { 1.0, 0.0, 1.0, 1.0 };
+            break;
+        default:
+            break;
+        }
+
+        return Color(0, 0, 0, 0);
+    }
+
     void FileSystemUI::Scan()
     {
         if (!m_CurrentDirectory)
@@ -888,6 +954,11 @@ namespace Nuake
                         {
                             for (Ref<Directory>& d : m_CurrentDirectory->Directories)
                             {
+                                if (d->GetName() == "bin" || d->GetName() == ".vs" || d->GetName() == "obj")
+                                {
+                                    continue;
+                                }
+
                                 if(String::Sanitize(d->Name).find(String::Sanitize(m_SearchKeyword)) != std::string::npos)
                                 {
                                     if (i + 1 % amount != 0)
@@ -907,6 +978,11 @@ namespace Nuake
                             {
                                 if(m_SearchKeyword.empty() || f->GetName().find(String::Sanitize(m_SearchKeyword)) != std::string::npos)
                                 {
+                                    if (f->GetFileType() == FileType::Unknown || f->GetFileType() == FileType::Assembly)
+                                    {
+                                        continue;
+                                    }
+
                                     if (i + 1 % amount != 0 || i == 1)
                                     {
                                         ImGui::TableNextColumn();
@@ -915,7 +991,7 @@ namespace Nuake
                                     {
                                         ImGui::TableNextRow();
                                     }
-                                
+                                    
                                     DrawFile(f, i);
                                     i++;
                                 }
diff --git a/Editor/src/Windows/FileSystemUI.h b/Editor/src/Windows/FileSystemUI.h
index d4c7f8a6..392ad150 100644
--- a/Editor/src/Windows/FileSystemUI.h
+++ b/Editor/src/Windows/FileSystemUI.h
@@ -33,6 +33,8 @@ namespace Nuake {
 		void DrawContextMenu();
 		void RefreshFileBrowser();
 
+		Color GetColorByFileType(FileType fileType);
+
 		void Scan();
 	};
 }
diff --git a/Nuake/src/Application/Layer.h b/Nuake/src/Application/Layer.h
index 89fb1c1b..9aa6af93 100644
--- a/Nuake/src/Application/Layer.h
+++ b/Nuake/src/Application/Layer.h
@@ -18,6 +18,7 @@ namespace Nuake {
 		virtual void OnDraw() {};
 
 		virtual void OnWindowFocused() {};
+		virtual void OnDragNDrop(const std::vector<std::string>&) {};
 		// TODO: OnEvent
 
 		inline const std::string& GetName() const { return m_Name; }
diff --git a/Nuake/src/FileSystem/File.cpp b/Nuake/src/FileSystem/File.cpp
index ae8fa4b7..577ceed8 100644
--- a/Nuake/src/FileSystem/File.cpp
+++ b/Nuake/src/FileSystem/File.cpp
@@ -78,6 +78,11 @@ FileType File::GetFileType() const
 	{
 		return FileType::Mesh;
 	}
+	
+	if (ext == ".glb" || ext == ".gltf")
+	{
+		return FileType::MeshAsset;
+	}
 
 	if (ext == ".html")
 	{
@@ -89,7 +94,7 @@ FileType File::GetFileType() const
 		return FileType::CSS;
 	}
 
-	return FileType::Unkown;
+	return FileType::Unknown;
 }
 
 std::string File::GetFileTypeAsString() const
diff --git a/Nuake/src/FileSystem/FileSystem.cpp b/Nuake/src/FileSystem/FileSystem.cpp
index fde1b000..7c00c69f 100644
--- a/Nuake/src/FileSystem/FileSystem.cpp
+++ b/Nuake/src/FileSystem/FileSystem.cpp
@@ -76,9 +76,20 @@ void FileSystem::SetRootDirectory(const std::string path)
 					return;
 				}
 
+				if (event == filewatch::Event::added)
+				{
+					const std::string& parent = std::filesystem::path(normalizedPath).parent_path().string();
+					auto parentDirectory = FileSystem::GetDirectory(parent);
+					auto filePath = std::filesystem::path(normalizedPath);
+					std::string name = filePath.filename().string();
+					std::string extension = filePath.extension().string();
+					Ref<File> newImportedFile = CreateRef<File>(parentDirectory, FileSystem::RelativeToAbsolute(normalizedPath), name, extension);
+					parentDirectory->Files.push_back(newImportedFile);
+				}
+
 				if(Ref<File> file = GetFile(normalizedPath); file)
 				{
-					if (file->GetFileType() == FileType::Unkown)
+					if (file->GetFileType() == FileType::Unknown)
 					{
 						return;
 					}
@@ -89,8 +100,8 @@ void FileSystem::SetRootDirectory(const std::string path)
 					{
 						file->SetHasBeenModified(true);
 					}
-				}
 					
+				}
 			}
 	);
 	Scan();
@@ -121,6 +132,12 @@ std::string FileSystem::GetParentPath(const std::string& fullPath)
 	return returnvalue + "/";
 }
 
+void FileSystem::CopyFileAbsolute(const std::string& src, const std::string& dest)
+{
+	const std::string& destPath = dest + "/" + std::filesystem::path(src).filename().string();
+	std::filesystem::copy_file(src, destPath, std::filesystem::copy_options::overwrite_existing);
+}
+
 std::string FileSystem::ReadFile(const std::string& path, bool absolute)
 {
 	std::string finalPath = path;
@@ -288,3 +305,8 @@ std::string Directory::GetName() const
 {
 	return Name;
 }
+
+std::string Directory::GetFullPath() const
+{
+	return FullPath;
+}
diff --git a/Nuake/src/FileSystem/FileSystem.h b/Nuake/src/FileSystem/FileSystem.h
index f7813639..ac4ec08e 100644
--- a/Nuake/src/FileSystem/FileSystem.h
+++ b/Nuake/src/FileSystem/FileSystem.h
@@ -37,6 +37,7 @@ namespace Nuake
 		static bool FileExists(const std::string& path, bool absolute = false);
 
 		static std::string ReadFile(const std::string& path, bool absolute = false);
+		static void CopyFileAbsolute(const std::string& src, const std::string& dest);
 
 		static std::ofstream fileWriter;
 		static bool BeginWriteFile(const std::string path, bool absolute = false);
diff --git a/Nuake/src/FileSystem/FileTypes.h b/Nuake/src/FileSystem/FileTypes.h
index d9e7eb94..8b71b34e 100644
--- a/Nuake/src/FileSystem/FileTypes.h
+++ b/Nuake/src/FileSystem/FileTypes.h
@@ -4,10 +4,11 @@ namespace Nuake
 {
 	enum class FileType
 	{
-		Unkown,
+		Unknown,
 		Image,
 		Material,
 		Mesh,
+		MeshAsset,
 		Script,
 		NetScript,
 		Project,
diff --git a/Nuake/src/Rendering/Textures/TextureManager.cpp b/Nuake/src/Rendering/Textures/TextureManager.cpp
index a10018bb..261550f7 100644
--- a/Nuake/src/Rendering/Textures/TextureManager.cpp
+++ b/Nuake/src/Rendering/Textures/TextureManager.cpp
@@ -37,6 +37,8 @@ namespace Nuake
 		m_Registry.emplace(Resources_Images_scene_icon_png_path, CreateRef<Texture>(Resources_Images_scene_icon_png, Resources_Images_scene_icon_png_len));
 		m_Registry.emplace(Resources_Images_project_icon_png_path, CreateRef<Texture>(Resources_Images_project_icon_png, Resources_Images_project_icon_png_len));
 		m_Registry.emplace(Resources_Images_csharp_icon_png_path, CreateRef<Texture>(Resources_Images_csharp_icon_png, Resources_Images_csharp_icon_png_len));
+		m_Registry.emplace(Resources_Images_sln_icon_png_path, CreateRef<Texture>(Resources_Images_sln_icon_png, Resources_Images_sln_icon_png_len));
+		m_Registry.emplace(Resources_Images_trenchbroom_icon_png_path, CreateRef<Texture>(Resources_Images_trenchbroom_icon_png, Resources_Images_trenchbroom_icon_png_len));
 
 		unsigned char whitePixel[] = { 255, 255, 255, 255 };
 		m_Registry.emplace("Resources/Textures/Default.png", CreateRef<Texture>(Vector2( 1, 1 ), GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, &whitePixel));
diff --git a/Nuake/src/Resource/StaticResources.cpp b/Nuake/src/Resource/StaticResources.cpp
index 76145e47..dbf20f7d 100644
--- a/Nuake/src/Resource/StaticResources.cpp
+++ b/Nuake/src/Resource/StaticResources.cpp
@@ -140647,41 +140647,23 @@ namespace Nuake {
             0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52,
             0x47, 0x42, 0x00, 0xAE, 0xCE, 0x1C, 0xE9, 0x00, 0x00, 0x00, 0x04, 0x67,
             0x41, 0x4D, 0x41, 0x00, 0x00, 0xB1, 0x8F, 0x0B, 0xFC, 0x61, 0x05, 0x00,
-            0x00, 0x01, 0x85, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0xED, 0xDB, 0xD1,
-            0x51, 0x1A, 0x51, 0x14, 0x80, 0xE1, 0x43, 0x26, 0x05, 0xD8, 0x41, 0x28,
-            0x21, 0x56, 0x10, 0xD3, 0x89, 0xE9, 0x80, 0x0E, 0x24, 0x15, 0x68, 0x3A,
-            0x20, 0x95, 0x84, 0x0E, 0x62, 0x07, 0x5A, 0x82, 0x1D, 0xE0, 0xB9, 0xE3,
-            0xFA, 0xE2, 0x93, 0xC2, 0x72, 0xF7, 0xEC, 0xFA, 0x7D, 0x33, 0x67, 0xEE,
-            0xF0, 0xC0, 0x3E, 0xF0, 0x03, 0x97, 0x1D, 0x76, 0x23, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x64, 0x15,
-            0x1D, 0x1D, 0x0E, 0x87, 0x8B, 0x5C, 0x36, 0x39, 0x3F, 0xE2, 0x78, 0xBB,
-            0xD5, 0x6A, 0xF5, 0x37, 0x16, 0xEA, 0x4B, 0xF4, 0xB5, 0xCD, 0xB9, 0xC9,
-            0xB9, 0x88, 0xE3, 0xAC, 0x73, 0x76, 0x19, 0x76, 0x1B, 0x9C, 0x2E, 0x5F,
-            0xC8, 0x7F, 0x6D, 0xE2, 0x04, 0xF9, 0xFC, 0xDB, 0xC3, 0x8B, 0xDB, 0xE0,
-            0x34, 0x63, 0x04, 0x19, 0x8E, 0x73, 0x33, 0x44, 0xF9, 0x9F, 0xB3, 0x0E,
-            0x8E, 0x33, 0x56, 0x90, 0xE1, 0x58, 0x9B, 0x21, 0xCA, 0xC3, 0x92, 0xA2,
-            0xF4, 0xDE, 0x43, 0x46, 0x93, 0x1B, 0xFB, 0x5D, 0x2E, 0x97, 0xC3, 0xC3,
-            0x16, 0xFA, 0x7B, 0x2C, 0xC0, 0x6C, 0x83, 0x34, 0x19, 0xE5, 0x3E, 0x97,
-            0x9F, 0xC3, 0xC3, 0xF6, 0xF5, 0xB5, 0x09, 0xDE, 0x6F, 0xCC, 0xAF, 0xAC,
-            0x37, 0xC7, 0x5D, 0x0F, 0xFB, 0xC9, 0x39, 0x74, 0xDD, 0xA7, 0xBE, 0xC6,
-            0x02, 0xE4, 0x27, 0xE5, 0x31, 0x97, 0xCB, 0x7C, 0xE1, 0xAE, 0x73, 0xFD,
-            0x16, 0xE3, 0x6A, 0x9F, 0xBA, 0xF6, 0x53, 0xFD, 0x57, 0x74, 0xB0, 0x88,
-            0x20, 0xAF, 0x32, 0xCC, 0x2E, 0x46, 0x96, 0x91, 0xAF, 0xE2, 0xE5, 0xFC,
-            0xA7, 0x8B, 0x59, 0xEF, 0x21, 0x4B, 0x24, 0x48, 0x31, 0x82, 0x14, 0x23,
-            0x48, 0x31, 0x82, 0x14, 0x23, 0x48, 0x31, 0x53, 0xFC, 0xEC, 0xBD, 0x6A,
-            0x67, 0x5B, 0x31, 0x2F, 0xFB, 0xE8, 0x64, 0x8A, 0x20, 0x8F, 0x39, 0xBB,
-            0x98, 0x8F, 0xEB, 0xE8, 0x68, 0x92, 0x20, 0x79, 0x02, 0xF7, 0x3B, 0x66,
-            0x62, 0x38, 0x31, 0xEC, 0xC6, 0x1E, 0x52, 0x8C, 0x20, 0xC5, 0x08, 0x52,
-            0x8C, 0x20, 0xC5, 0x08, 0x52, 0x8C, 0x20, 0xC5, 0x08, 0x52, 0x8C, 0x20,
-            0xC5, 0x08, 0x52, 0x8C, 0x20, 0xC5, 0x08, 0x52, 0x8C, 0x20, 0xC5, 0x08,
-            0x52, 0x8C, 0x20, 0xC5, 0x08, 0x52, 0x8C, 0x20, 0xC5, 0x4C, 0x11, 0xE4,
-            0xD8, 0xBB, 0xA7, 0x3E, 0x85, 0xDE, 0xFF, 0x18, 0xEE, 0x73, 0xB6, 0xE7,
-            0xB8, 0xE0, 0xFA, 0x4C, 0xDA, 0x9B, 0xA7, 0xDD, 0xE6, 0x70, 0x17, 0x9D,
-            0x4C, 0x71, 0xD3, 0x67, 0xBB, 0x70, 0x79, 0x4E, 0xF7, 0x72, 0xEC, 0x73,
-            0xFE, 0xE4, 0xDF, 0xCE, 0x4F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0xCF, 0x33, 0x2F, 0x41, 0xDD, 0x09,
-            0x9A, 0x4D, 0xAC, 0x73, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44,
-            0xAE, 0x42, 0x60, 0x82, 
+            0x00, 0x00, 0xAE, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0xED, 0xD1, 0x89,
+            0x11, 0xC2, 0x40, 0x0C, 0x04, 0x41, 0x41, 0xE4, 0xCA, 0x5C, 0x40, 0x06,
+            0x7E, 0x8F, 0x75, 0x55, 0x77, 0x08, 0x33, 0x55, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xCF, 0x5C, 0xA7, 0x8B,
+            0xF3, 0xE6, 0x5A, 0x5D, 0x9C, 0x33, 0xD7, 0xEB, 0xE2, 0xB8, 0xB9, 0x47,
+            0x17, 0xC7, 0xCC, 0x7D, 0xBA, 0xD8, 0x6F, 0xEE, 0xD5, 0xC5, 0x3E, 0x73,
+            0xBF, 0x2E, 0xB6, 0x9B, 0x35, 0xBA, 0xD8, 0x66, 0xD6, 0xE9, 0x7A, 0xB0,
+            0x57, 0x2D, 0xF2, 0x2B, 0x55, 0x0F, 0xF6, 0xFA, 0xAA, 0x05, 0xDE, 0x45,
+            0x14, 0x43, 0xC2, 0x18, 0x12, 0xC6, 0x90, 0x30, 0x86, 0x84, 0x31, 0x24,
+            0x8C, 0x21, 0x61, 0x0C, 0x09, 0x63, 0x48, 0x18, 0x43, 0xC2, 0x18, 0x12,
+            0xC6, 0x90, 0x30, 0x86, 0x84, 0x31, 0x24, 0x8C, 0x21, 0x61, 0x0C, 0x09,
+            0x63, 0x48, 0x18, 0x43, 0xC2, 0x18, 0x12, 0xC6, 0x90, 0x30, 0x86, 0x84,
+            0x31, 0x24, 0x8C, 0x21, 0x61, 0x0C, 0x09, 0x63, 0x48, 0x18, 0x43, 0xC2,
+            0x18, 0x12, 0xC6, 0x90, 0x30, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x85, 0x3E, 0x34, 0x79, 0x38,
+            0xB6, 0xB2, 0x31, 0x93, 0xA8, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E,
+            0x44, 0xAE, 0x42, 0x60, 0x82, 
         };
         unsigned int Resources_Images_folder_icon_png_len = sizeof(Resources_Images_folder_icon_png);
 
@@ -142608,59 +142590,47 @@ namespace Nuake {
             0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52,
             0x47, 0x42, 0x00, 0xAE, 0xCE, 0x1C, 0xE9, 0x00, 0x00, 0x00, 0x04, 0x67,
             0x41, 0x4D, 0x41, 0x00, 0x00, 0xB1, 0x8F, 0x0B, 0xFC, 0x61, 0x05, 0x00,
-            0x00, 0x02, 0x64, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0xED, 0xD7, 0x81,
-            0x71, 0xDA, 0x30, 0x14, 0x80, 0x61, 0xD1, 0xEB, 0x00, 0xDE, 0x00, 0xBA,
-            0x01, 0x1B, 0x34, 0x23, 0xB0, 0x01, 0x74, 0x02, 0xD8, 0x80, 0x76, 0x02,
-            0xB2, 0x81, 0xAF, 0x13, 0xD0, 0x0D, 0xCC, 0x06, 0x4D, 0x27, 0x80, 0x0D,
-            0xEC, 0x0D, 0x54, 0xA9, 0x3C, 0x35, 0x8F, 0x17, 0xD9, 0x24, 0x57, 0xD7,
-            0xE0, 0xCB, 0xFF, 0xDD, 0xE9, 0x6C, 0xCB, 0x7A, 0x4F, 0x8E, 0x84, 0x25,
-            0xC7, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0xF7, 0xCA, 0x7B, 0x3F, 0x0B, 0x65, 0x1B, 0x8F, 0x0E,
-            0xB7, 0x17, 0x26, 0xA2, 0xF2, 0x67, 0x7B, 0xD7, 0xA3, 0x90, 0xAF, 0x90,
-            0xC9, 0x9E, 0x39, 0xBC, 0x5E, 0x18, 0xB0, 0x45, 0x9C, 0x8C, 0x50, 0x1E,
-            0x5C, 0x8F, 0x62, 0x3E, 0x99, 0x68, 0xEF, 0x06, 0xF2, 0xD1, 0x0D, 0x20,
-            0xFD, 0xC2, 0x26, 0x93, 0xC9, 0x29, 0xFE, 0xEA, 0xC2, 0xE9, 0x3C, 0x94,
-            0x53, 0xBC, 0x56, 0x6D, 0x62, 0x7D, 0x2C, 0x8D, 0x54, 0x5D, 0xB4, 0x51,
-            0x71, 0xD1, 0x53, 0xA8, 0x6F, 0x54, 0x17, 0x87, 0x58, 0xA7, 0x62, 0x75,
-            0xCE, 0x99, 0xE4, 0xB5, 0x31, 0xB9, 0x36, 0xB6, 0xBF, 0xC2, 0xFC, 0x0D,
-            0x4D, 0x2E, 0xC7, 0xA8, 0xC8, 0x2B, 0x9F, 0x6C, 0x42, 0xA9, 0xD5, 0xF5,
-            0x4E, 0xB5, 0x2B, 0xA5, 0xAE, 0x0A, 0xE5, 0x28, 0xE7, 0x4B, 0xB9, 0xF7,
-            0xE8, 0x2F, 0xC5, 0xFB, 0x9B, 0x4C, 0x6C, 0xA9, 0xEA, 0x6C, 0x5F, 0xD1,
-            0x57, 0xF3, 0x6C, 0xAD, 0x6D, 0xC2, 0x71, 0xE5, 0x5F, 0xDA, 0xBA, 0xB1,
-            0x33, 0x13, 0x72, 0x8C, 0x93, 0xA0, 0x06, 0x50, 0x0F, 0x7A, 0xAA, 0xAB,
-            0xA5, 0xFC, 0x59, 0x82, 0xD4, 0x64, 0xD4, 0x99, 0xD8, 0x07, 0x13, 0x5B,
-            0xCA, 0xF5, 0x42, 0x0F, 0x62, 0x28, 0x6B, 0xFF, 0x72, 0x92, 0xF5, 0x80,
-            0x97, 0x52, 0xD2, 0xE4, 0x2C, 0x43, 0x99, 0x9B, 0xBE, 0xB6, 0xBE, 0xE7,
-            0x25, 0xF1, 0x26, 0xCC, 0x84, 0x2C, 0x55, 0x7D, 0x25, 0x75, 0x95, 0x5C,
-            0x97, 0x6A, 0xD2, 0xF4, 0x52, 0x51, 0x77, 0xC4, 0xEE, 0x4D, 0x6C, 0x9A,
-            0x90, 0xBD, 0x5C, 0xEB, 0x37, 0x70, 0x61, 0xFA, 0xAB, 0x74, 0x8C, 0xD4,
-            0x6D, 0xA4, 0xFF, 0x94, 0x67, 0xF0, 0x3D, 0xE4, 0x83, 0x1B, 0xD6, 0x2F,
-            0x75, 0xFE, 0x43, 0x8E, 0x33, 0xD3, 0xE6, 0xEF, 0x5A, 0xEF, 0xCF, 0xEB,
-            0x76, 0xD1, 0x11, 0x3B, 0x77, 0x79, 0xA9, 0x7E, 0x25, 0x03, 0x7C, 0x0C,
-            0xE7, 0x3B, 0xD3, 0x5F, 0x3A, 0x1E, 0x52, 0x50, 0xE8, 0xF7, 0x31, 0x94,
-            0x4F, 0xA1, 0x7C, 0x71, 0x37, 0x32, 0xC8, 0xA6, 0xAE, 0xD4, 0xEA, 0xBC,
-            0x68, 0x69, 0xD3, 0xBC, 0x21, 0xF6, 0xDA, 0x06, 0x7B, 0x70, 0xE7, 0xCD,
-            0xBE, 0x2B, 0x7F, 0xE1, 0xEE, 0xC8, 0xD0, 0x6F, 0xC8, 0x2A, 0x73, 0xFE,
-            0xD4, 0xD6, 0x58, 0xBE, 0x78, 0x9A, 0x4C, 0xEC, 0xE2, 0x4A, 0x6C, 0xAA,
-            0x8F, 0x5F, 0x45, 0xDF, 0x62, 0x09, 0xE7, 0xDF, 0x25, 0x57, 0x7A, 0xD3,
-            0x4E, 0x26, 0x97, 0x5E, 0xFA, 0x7A, 0xFD, 0x7F, 0xE6, 0xAE, 0x98, 0x3D,
-            0xA4, 0x96, 0xB5, 0xBB, 0xB2, 0xFB, 0x8A, 0xCF, 0x7C, 0x29, 0x49, 0xFD,
-            0x46, 0xB5, 0xDD, 0x9B, 0xD8, 0x59, 0x2E, 0x56, 0xAF, 0xFD, 0x12, 0xB3,
-            0xF3, 0xCF, 0x7B, 0xD1, 0x2E, 0xD3, 0xE6, 0x67, 0xCB, 0x33, 0xE9, 0x67,
-            0xAF, 0xBC, 0xDA, 0xC7, 0x46, 0xCB, 0xFC, 0x51, 0x0B, 0xFF, 0xFC, 0xB5,
-            0x13, 0x07, 0x68, 0xAD, 0xDA, 0x95, 0x7A, 0x50, 0x4D, 0x8E, 0xAD, 0xBF,
-            0xFC, 0x3C, 0x8D, 0x39, 0x3E, 0x77, 0xC5, 0x9A, 0xBE, 0x52, 0x7F, 0x5B,
-            0x93, 0x37, 0xD7, 0x66, 0x9D, 0xE9, 0xDB, 0xB7, 0x3D, 0xDB, 0xE8, 0x98,
-            0x09, 0x99, 0x4A, 0xDD, 0xD4, 0xAB, 0x2F, 0xA9, 0x37, 0xE4, 0x9A, 0xA6,
-            0x1C, 0xA6, 0x7E, 0xDF, 0x31, 0x99, 0xD3, 0x6B, 0xFD, 0xB5, 0xE5, 0x55,
-            0xF7, 0x8B, 0xAE, 0xFB, 0xA3, 0x92, 0x9B, 0x90, 0x9E, 0xF3, 0x97, 0x2A,
-            0xFF, 0xF8, 0x97, 0x94, 0xFF, 0x6D, 0x80, 0x09, 0x39, 0xCA, 0x52, 0xB3,
-            0x73, 0x78, 0x9D, 0x6B, 0x4B, 0xC2, 0x3F, 0xE6, 0xBE, 0xAB, 0xCF, 0x56,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0,
-            0x8E, 0xFD, 0x06, 0x49, 0x23, 0x01, 0x2C, 0x30, 0xD4, 0xA8, 0x50, 0x00,
-            0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82, 
+            0x00, 0x01, 0xD1, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0xED, 0xDA, 0xE1,
+            0x6D, 0xC2, 0x30, 0x10, 0x40, 0xE1, 0x4B, 0x27, 0x60, 0x04, 0x3A, 0x41,
+            0x19, 0x21, 0x9B, 0x94, 0x4D, 0xE8, 0x06, 0x8C, 0xD0, 0x51, 0xA0, 0x13,
+            0x74, 0x84, 0xB2, 0x01, 0x23, 0xB8, 0xB6, 0x20, 0x12, 0x6D, 0x81, 0x86,
+            0xD8, 0x39, 0x9F, 0xED, 0xF7, 0x49, 0x56, 0x7E, 0x40, 0x30, 0xF2, 0x53,
+            0x00, 0x03, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xAC, 0x13, 0x0D, 0xCE, 0x39, 0x89,
+            0xD5, 0x75, 0x93, 0x9F, 0xAB, 0x9F, 0x7E, 0xE9, 0x0F, 0x3B, 0x3F, 0xC2,
+            0xF1, 0x70, 0x1E, 0x7B, 0x3F, 0x3E, 0xFC, 0xC3, 0xEE, 0xA5, 0x39, 0x21,
+            0x48, 0xEC, 0x98, 0x3E, 0xF5, 0xD2, 0x8F, 0x2F, 0x77, 0x5B, 0xB8, 0xED,
+            0x55, 0x9A, 0x92, 0x29, 0xC8, 0x88, 0x18, 0x8D, 0x86, 0xC9, 0x10, 0xE4,
+            0xC1, 0x18, 0x97, 0xB6, 0x52, 0x3D, 0xE5, 0x20, 0x11, 0x31, 0x06, 0x9F,
+            0x7E, 0x2C, 0xA4, 0x5A, 0x8A, 0x41, 0x12, 0xC4, 0x18, 0xEC, 0xA4, 0x5A,
+            0x4A, 0x41, 0x12, 0xC6, 0x18, 0x54, 0xFA, 0xF2, 0xA5, 0x10, 0x64, 0x86,
+            0x18, 0x83, 0x5E, 0x14, 0x55, 0xB1, 0x0F, 0x71, 0x3F, 0xF7, 0x19, 0xA9,
+            0x1D, 0xFC, 0xD4, 0xCF, 0xA2, 0xE4, 0x49, 0x0A, 0x37, 0x73, 0x8C, 0x20,
+            0x5C, 0x79, 0x6A, 0x1F, 0x87, 0x8B, 0x0E, 0xA2, 0x10, 0x63, 0xB0, 0x16,
+            0x25, 0xC5, 0x06, 0x51, 0x8C, 0x11, 0xF4, 0x5A, 0xEF, 0x25, 0x45, 0x06,
+            0x71, 0xA7, 0x3D, 0x82, 0x56, 0x8C, 0xC1, 0x8B, 0x28, 0x28, 0x2E, 0x48,
+            0xA6, 0x18, 0x41, 0x2F, 0x0A, 0x8A, 0x0A, 0x72, 0x11, 0x63, 0x25, 0xFA,
+            0x54, 0xE6, 0x2C, 0x26, 0x48, 0xE6, 0x18, 0x81, 0xCA, 0x57, 0x29, 0x3A,
+            0xFB, 0x90, 0x48, 0x3E, 0xC6, 0x9B, 0x3F, 0x1C, 0xE5, 0x7E, 0x8C, 0xC5,
+            0x79, 0xAC, 0x64, 0xA6, 0xC5, 0xEB, 0x22, 0x7E, 0x93, 0xA9, 0x46, 0x88,
+            0xE1, 0x1E, 0xDC, 0x58, 0xFA, 0xBB, 0xAF, 0xE7, 0xD8, 0xB5, 0x4B, 0xEB,
+            0x86, 0x18, 0x53, 0x17, 0xC3, 0x9F, 0xB6, 0x71, 0x09, 0x49, 0xCB, 0x2E,
+            0x63, 0xC4, 0x2C, 0x86, 0x3F, 0x75, 0xEB, 0x12, 0x91, 0x56, 0xFD, 0x8E,
+            0x11, 0xBB, 0x18, 0xFE, 0xF4, 0x9D, 0x4B, 0x40, 0x5A, 0x74, 0x2D, 0x46,
+            0x82, 0x20, 0xBD, 0x4B, 0x40, 0x5A, 0x73, 0x2B, 0x46, 0x8A, 0xC5, 0xF0,
+            0x0F, 0x71, 0x74, 0x91, 0xA4, 0x25, 0xF7, 0x62, 0x24, 0x0A, 0xF2, 0xEE,
+            0x22, 0x89, 0x02, 0x13, 0x1B, 0x43, 0x77, 0xDA, 0x67, 0x6C, 0x64, 0x5E,
+            0x07, 0x29, 0x40, 0xF6, 0x20, 0x4A, 0x31, 0x8A, 0x91, 0x35, 0x08, 0x31,
+            0xFE, 0xCA, 0x16, 0x84, 0x18, 0xD7, 0x65, 0x09, 0x42, 0x8C, 0xDB, 0xD4,
+            0x83, 0x10, 0xE3, 0x3E, 0xD5, 0x20, 0xC4, 0xF8, 0x9F, 0x5A, 0x10, 0x62,
+            0x8C, 0xA3, 0x12, 0x84, 0x18, 0xE3, 0x69, 0x5D, 0x21, 0xC4, 0x18, 0xA9,
+            0xF8, 0x3F, 0xCA, 0xD5, 0x86, 0x20, 0xC6, 0x10, 0xC4, 0x18, 0x82, 0x18,
+            0x43, 0x10, 0x63, 0x08, 0x62, 0x0C, 0x41, 0x8C, 0x21, 0x88, 0x31, 0x04,
+            0x31, 0x86, 0x20, 0xC6, 0x10, 0xC4, 0x18, 0x82, 0x18, 0x43, 0x10, 0x63,
+            0x08, 0x62, 0x0C, 0x41, 0x8C, 0x21, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xF3, 0x0D,
+            0xCA, 0x0B, 0x22, 0xC0, 0x80, 0xFC, 0x24, 0xFE, 0x00, 0x00, 0x00, 0x00,
+            0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82, 
         };
         unsigned int Resources_Images_project_icon_png_len = sizeof(Resources_Images_project_icon_png);
 
@@ -265566,6 +265536,112 @@ namespace Nuake {
         };
         unsigned int Resources_Images_shape_png_len = sizeof(Resources_Images_shape_png);
 
+        // Data for file: Resources_Images_sln_icon_png_path
+        const std::string Resources_Images_sln_icon_png_path = R"(Resources/Images/sln_icon.png)";
+        unsigned char Resources_Images_sln_icon_png[] = {
+            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
+            0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64,
+            0x08, 0x06, 0x00, 0x00, 0x00, 0x70, 0xE2, 0x95, 0x54, 0x00, 0x00, 0x00,
+            0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0B, 0x13, 0x00, 0x00, 0x0B,
+            0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52,
+            0x47, 0x42, 0x00, 0xAE, 0xCE, 0x1C, 0xE9, 0x00, 0x00, 0x00, 0x04, 0x67,
+            0x41, 0x4D, 0x41, 0x00, 0x00, 0xB1, 0x8F, 0x0B, 0xFC, 0x61, 0x05, 0x00,
+            0x00, 0x04, 0x3B, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0xED, 0x9C, 0x81,
+            0x55, 0xDB, 0x30, 0x10, 0x86, 0x45, 0x27, 0x60, 0x83, 0x86, 0x0D, 0xCA,
+            0x04, 0xD0, 0x09, 0x60, 0x03, 0xD2, 0x09, 0x60, 0x83, 0xB8, 0x13, 0xC0,
+            0x06, 0xA6, 0x13, 0x30, 0x82, 0xD9, 0x20, 0xDD, 0x40, 0x6C, 0x40, 0x37,
+            0xF8, 0x7B, 0xAA, 0xEC, 0xC6, 0x84, 0x58, 0x3A, 0xCB, 0x8A, 0x13, 0xC7,
+            0xFF, 0xF7, 0x9E, 0x9E, 0x79, 0xCF, 0xB6, 0xCC, 0xBB, 0xDF, 0x3A, 0xDF,
+            0x9D, 0xA4, 0x18, 0x43, 0x08, 0x21, 0x84, 0x10, 0x42, 0x08, 0x21, 0x84,
+            0x10, 0x42, 0x08, 0x21, 0x84, 0x10, 0x42, 0x08, 0x21, 0x84, 0x10, 0x12,
+            0x00, 0xC0, 0xB9, 0xB4, 0x67, 0x69, 0x6B, 0x69, 0xF7, 0xD2, 0x16, 0x86,
+            0x1C, 0x06, 0x67, 0x7C, 0x69, 0x16, 0x9F, 0xA9, 0xA4, 0xDD, 0x51, 0x9C,
+            0x11, 0x11, 0x63, 0x2F, 0xA5, 0xBD, 0x23, 0x0E, 0xC5, 0xD9, 0x27, 0xB5,
+            0x8B, 0x7A, 0x42, 0x1A, 0x15, 0xC5, 0xC9, 0x48, 0xED, 0xA2, 0xD6, 0xC8,
+            0xC3, 0x4B, 0x2D, 0xCE, 0xB9, 0x21, 0xFD, 0x11, 0xC3, 0x5D, 0x23, 0xEC,
+            0xA2, 0xDC, 0x39, 0x8B, 0x04, 0x0C, 0xE9, 0x87, 0xD8, 0xAC, 0x88, 0xD8,
+            0xB4, 0x6A, 0xDE, 0x74, 0x39, 0x5E, 0x49, 0x2B, 0xFB, 0x88, 0x63, 0x88,
+            0x0E, 0x78, 0x17, 0x55, 0x45, 0xEC, 0xB9, 0x0A, 0xDC, 0x7F, 0x55, 0x8B,
+            0x13, 0xFC, 0xF8, 0x1B, 0x12, 0x07, 0xDE, 0x45, 0xD9, 0x80, 0x1D, 0x9D,
+            0x91, 0xAF, 0x7A, 0xF4, 0x77, 0x53, 0x8B, 0x43, 0x41, 0xFA, 0x22, 0x36,
+            0x7A, 0x40, 0x18, 0xF7, 0x61, 0x5F, 0x98, 0x9E, 0xC0, 0x8F, 0x38, 0x0A,
+            0xA2, 0x05, 0x3E, 0xA4, 0x7D, 0x89, 0x88, 0xF1, 0x68, 0x12, 0xA1, 0x20,
+            0x3D, 0x10, 0xBB, 0x7C, 0x43, 0xDC, 0x45, 0xDD, 0x99, 0x01, 0x4C, 0x5A,
+            0x10, 0x67, 0x20, 0x33, 0x12, 0xF0, 0x2E, 0x2A, 0xF4, 0xE1, 0xB5, 0xC8,
+            0x90, 0xCC, 0x4D, 0x52, 0x10, 0xF8, 0x8F, 0x69, 0xD5, 0x32, 0xC4, 0x8D,
+            0xD9, 0x13, 0xD0, 0x65, 0xDD, 0x25, 0x32, 0x25, 0x6F, 0x93, 0x11, 0xA4,
+            0x36, 0x8C, 0xAB, 0x94, 0xAE, 0x03, 0x46, 0x59, 0x98, 0x8C, 0x40, 0x97,
+            0x75, 0xDF, 0x9B, 0x8C, 0xE0, 0xD8, 0x05, 0xA9, 0x85, 0x70, 0x49, 0x97,
+            0xA6, 0x48, 0xE7, 0xAE, 0x29, 0x4C, 0x06, 0xA4, 0x9F, 0x5B, 0xC4, 0x5D,
+            0x54, 0x76, 0x97, 0x39, 0x05, 0x41, 0x52, 0xB0, 0x43, 0x8C, 0x85, 0xB8,
+            0x8B, 0xAA, 0xB0, 0xA7, 0xFA, 0xD2, 0xA9, 0x0A, 0xD2, 0x50, 0xA2, 0x87,
+            0x1B, 0xC3, 0xC0, 0xAC, 0x3B, 0x07, 0x98, 0xB0, 0x20, 0x15, 0x14, 0x25,
+            0x07, 0xF8, 0xD1, 0xF2, 0xA0, 0x78, 0x4E, 0xD6, 0xAC, 0x7B, 0x47, 0xFF,
+            0xAA, 0x11, 0x3B, 0x55, 0x41, 0x6E, 0x5A, 0xE7, 0x17, 0xE8, 0x28, 0x37,
+            0xEC, 0x10, 0x66, 0xD1, 0xF1, 0x8C, 0xBD, 0x64, 0xDD, 0x75, 0xDF, 0x4D,
+            0x94, 0x56, 0x29, 0xAF, 0x9F, 0xA4, 0x20, 0x5F, 0x77, 0x5C, 0xB7, 0x84,
+            0xAE, 0x7A, 0x5A, 0x36, 0xC6, 0xC5, 0xFE, 0xB3, 0xEE, 0xF6, 0xA8, 0x9B,
+            0x97, 0x20, 0xAD, 0xEB, 0x57, 0x88, 0x63, 0xE1, 0x43, 0x68, 0x1B, 0xB8,
+            0x26, 0x39, 0xEB, 0xC6, 0xEE, 0xDC, 0x65, 0x9E, 0x82, 0xD4, 0xF7, 0x68,
+            0xDD, 0x58, 0x17, 0x16, 0xE9, 0x2E, 0xAA, 0xEB, 0x5B, 0x34, 0x5F, 0x41,
+            0x5A, 0xF7, 0x6A, 0xDD, 0x58, 0x9B, 0x12, 0x09, 0x21, 0x2D, 0xE2, 0x19,
+            0x3D, 0x05, 0x69, 0xF5, 0xB1, 0x42, 0x1C, 0xE7, 0xA2, 0x92, 0xB2, 0x6E,
+            0xC4, 0x23, 0x34, 0x0A, 0xB2, 0xA3, 0x9F, 0x90, 0x1B, 0xB3, 0x48, 0x4C,
+            0x24, 0xA1, 0x5F, 0x5D, 0x32, 0xBB, 0x28, 0xAB, 0x82, 0xC2, 0xEF, 0xE3,
+            0xB3, 0x1B, 0x73, 0xF7, 0xA5, 0xB8, 0x28, 0x57, 0x8A, 0xEF, 0xB3, 0xBA,
+            0x64, 0x76, 0x82, 0xD8, 0xFA, 0xDC, 0x63, 0x4C, 0x18, 0x78, 0x7F, 0xBF,
+            0x42, 0x62, 0xD6, 0x8D, 0xF8, 0x82, 0x06, 0x0A, 0x82, 0x8F, 0x6F, 0xBD,
+            0xFB, 0x7B, 0xD0, 0x44, 0x51, 0xC7, 0xFF, 0xA2, 0xA9, 0xFE, 0x1E, 0xAD,
+            0x20, 0x5F, 0xCC, 0xE1, 0x58, 0x48, 0x7B, 0xC6, 0x80, 0x0C, 0x7B, 0x1B,
+            0xF8, 0xF2, 0xCB, 0x5A, 0xDA, 0x68, 0x93, 0x62, 0xB9, 0x39, 0xA4, 0x20,
+            0x0D, 0xCE, 0x78, 0x16, 0x03, 0xCB, 0xE4, 0x72, 0x7F, 0x29, 0x07, 0x97,
+            0xB1, 0x4F, 0x7A, 0x05, 0xE1, 0x31, 0x08, 0xF2, 0x2A, 0xED, 0xF2, 0xEC,
+            0xEC, 0xEC, 0xB7, 0x19, 0x80, 0xDC, 0xFF, 0x43, 0x0E, 0x85, 0x99, 0x38,
+            0x87, 0x14, 0xE4, 0x8F, 0xB4, 0xA5, 0x18, 0xF2, 0xFB, 0x50, 0x31, 0x1A,
+            0xA4, 0x9F, 0x9F, 0x72, 0xB8, 0x90, 0xF6, 0x66, 0x26, 0xCA, 0xA1, 0x04,
+            0x79, 0x92, 0x76, 0x21, 0x06, 0xFC, 0xD5, 0x75, 0x01, 0x36, 0xB3, 0x90,
+            0x85, 0xE9, 0x81, 0xF4, 0xF9, 0x26, 0xCD, 0x89, 0x52, 0x98, 0xB9, 0x02,
+            0x7D, 0x94, 0xE5, 0x3E, 0xE2, 0xD1, 0xF9, 0x0A, 0xF8, 0xA9, 0x59, 0xDB,
+            0xEA, 0xEB, 0x25, 0xE5, 0xC3, 0x8F, 0xEE, 0x8D, 0x38, 0x47, 0x1B, 0x65,
+            0x65, 0x01, 0x4A, 0x41, 0x14, 0xFD, 0x84, 0x66, 0x03, 0x2D, 0xD2, 0x8B,
+            0x89, 0x2B, 0x50, 0x10, 0xBD, 0x20, 0xE8, 0xB7, 0x48, 0xE2, 0xC1, 0x24,
+            0x00, 0xDD, 0x68, 0xA1, 0x20, 0xD0, 0x15, 0xFD, 0xB6, 0x71, 0x99, 0x7E,
+            0x52, 0x78, 0x8B, 0xF0, 0x68, 0x99, 0xFD, 0x7C, 0x48, 0x85, 0x74, 0x2C,
+            0x4E, 0x70, 0x3E, 0x64, 0xF4, 0x28, 0x0B, 0xB5, 0x7B, 0x32, 0x3E, 0xA3,
+            0xBE, 0x0E, 0x5C, 0xEA, 0xC2, 0x62, 0x77, 0xDD, 0x5B, 0xC7, 0xF9, 0x85,
+            0xEB, 0x03, 0x09, 0xE5, 0x17, 0x89, 0xC2, 0x5E, 0xE5, 0x70, 0x69, 0x7C,
+            0xB4, 0x77, 0x7A, 0x40, 0x39, 0x42, 0xA0, 0x77, 0x4F, 0xFF, 0x5D, 0x12,
+            0x74, 0x33, 0x8B, 0x85, 0x49, 0x04, 0x1F, 0x2B, 0xCB, 0x27, 0xED, 0xB2,
+            0xB6, 0x57, 0x9D, 0xC4, 0x16, 0x2A, 0xFC, 0x33, 0x08, 0x3A, 0xC2, 0x62,
+            0xC4, 0x23, 0xA5, 0x21, 0xAB, 0x4E, 0x1A, 0xD1, 0x4F, 0x5A, 0x10, 0x87,
+            0x85, 0x7F, 0xDB, 0x63, 0xD1, 0x93, 0x6A, 0x26, 0x10, 0xF1, 0xAD, 0x06,
+            0xEE, 0xDC, 0xB5, 0x49, 0x04, 0xCA, 0x35, 0x5D, 0x53, 0x16, 0x44, 0x43,
+            0x89, 0x1E, 0x11, 0x13, 0x74, 0xE5, 0xF5, 0xC2, 0xEC, 0x11, 0x9C, 0xA8,
+            0x20, 0xCE, 0xA8, 0x43, 0x56, 0x19, 0xAE, 0x22, 0xFD, 0x27, 0x65, 0xF7,
+            0xCA, 0x67, 0x1F, 0xBD, 0x20, 0x8D, 0x0F, 0xB6, 0x88, 0xE3, 0xDC, 0x53,
+            0xD2, 0x2C, 0xE0, 0x8E, 0xE7, 0x2E, 0x11, 0x77, 0x61, 0x0B, 0x93, 0x99,
+            0xA3, 0x17, 0xA4, 0x4D, 0xC4, 0x48, 0xD9, 0xDF, 0x5A, 0xE8, 0x32, 0xF0,
+            0xC2, 0x64, 0x04, 0x13, 0xDD, 0x41, 0xE5, 0xB6, 0x0F, 0x57, 0xAD, 0x37,
+            0x35, 0xD9, 0x3D, 0x29, 0x9F, 0xF7, 0x18, 0x11, 0xA5, 0xC4, 0xDC, 0x76,
+            0x50, 0xED, 0xA2, 0xFE, 0xE7, 0x47, 0x99, 0xC5, 0x03, 0xF7, 0x18, 0x1E,
+            0x1F, 0x88, 0xBB, 0x30, 0x27, 0x58, 0x52, 0x81, 0x72, 0xEB, 0x19, 0x14,
+            0x44, 0x0B, 0x7C, 0x79, 0xA6, 0x44, 0x18, 0xEE, 0x53, 0x1F, 0x1B, 0xC4,
+            0x43, 0x63, 0x0B, 0xFE, 0x92, 0xC3, 0xB8, 0x40, 0x97, 0xDD, 0xDF, 0x2A,
+            0xFB, 0x72, 0x23, 0xEF, 0x1A, 0x1D, 0x65, 0x20, 0x43, 0x74, 0x40, 0x57,
+            0xEA, 0x2F, 0x02, 0xF7, 0x3B, 0x11, 0xA2, 0x25, 0x20, 0x43, 0xFA, 0x81,
+            0xB8, 0x0B, 0xAB, 0xB0, 0xD9, 0xB9, 0xA5, 0x12, 0x81, 0x82, 0x0C, 0x04,
+            0x9F, 0x17, 0x50, 0x6C, 0x63, 0xFB, 0x88, 0xD0, 0xE2, 0xDD, 0x90, 0x34,
+            0xD0, 0x7F, 0x35, 0x4A, 0xA7, 0x08, 0xD8, 0xFC, 0x20, 0x26, 0x7F, 0x73,
+            0x71, 0x28, 0x88, 0x67, 0xF7, 0x5D, 0x54, 0xF0, 0xFB, 0x1F, 0x29, 0x42,
+            0x6E, 0x10, 0xCF, 0xEE, 0x29, 0xC2, 0xD8, 0x20, 0xFC, 0xCB, 0xD6, 0x14,
+            0xE1, 0x10, 0x60, 0x93, 0xDD, 0x3B, 0x11, 0x56, 0x14, 0x81, 0x10, 0x42,
+            0x08, 0x21, 0x84, 0x10, 0x42, 0x08, 0x21, 0x84, 0x10, 0x42, 0x08, 0x21,
+            0x84, 0x10, 0x42, 0x66, 0xCF, 0x5F, 0xF4, 0xBF, 0xD0, 0x30, 0x2F, 0xE5,
+            0x2A, 0xE9, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42,
+            0x60, 0x82, 
+        };
+        unsigned int Resources_Images_sln_icon_png_len = sizeof(Resources_Images_sln_icon_png);
+
         // Data for file: Resources_Images_speaker_png_path
         const std::string Resources_Images_speaker_png_path = R"(Resources/Images/speaker.png)";
         unsigned char Resources_Images_speaker_png[] = {
@@ -265668,6 +265744,58 @@ namespace Nuake {
         };
         unsigned int Resources_Images_speaker_png_len = sizeof(Resources_Images_speaker_png);
 
+        // Data for file: Resources_Images_trenchbroom_icon_png_path
+        const std::string Resources_Images_trenchbroom_icon_png_path = R"(Resources/Images/trenchbroom_icon.png)";
+        unsigned char Resources_Images_trenchbroom_icon_png[] = {
+            0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D,
+            0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x64, 0x00, 0x00, 0x00, 0x64,
+            0x08, 0x06, 0x00, 0x00, 0x00, 0x70, 0xE2, 0x95, 0x54, 0x00, 0x00, 0x00,
+            0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0B, 0x13, 0x00, 0x00, 0x0B,
+            0x13, 0x01, 0x00, 0x9A, 0x9C, 0x18, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52,
+            0x47, 0x42, 0x00, 0xAE, 0xCE, 0x1C, 0xE9, 0x00, 0x00, 0x00, 0x04, 0x67,
+            0x41, 0x4D, 0x41, 0x00, 0x00, 0xB1, 0x8F, 0x0B, 0xFC, 0x61, 0x05, 0x00,
+            0x00, 0x01, 0xB7, 0x49, 0x44, 0x41, 0x54, 0x78, 0x01, 0xED, 0xDB, 0xD1,
+            0x6D, 0xC2, 0x30, 0x10, 0xC6, 0xF1, 0xA3, 0xEA, 0x7B, 0x19, 0x21, 0x23,
+            0xB0, 0x41, 0x3B, 0x42, 0x37, 0xA0, 0x1B, 0x94, 0x0D, 0xA0, 0x13, 0xD0,
+            0x0D, 0x3A, 0x02, 0x23, 0x44, 0x9D, 0x80, 0x11, 0x32, 0x02, 0x23, 0x5C,
+            0xCF, 0x4A, 0x1E, 0x28, 0x4A, 0xC8, 0x39, 0xD8, 0x06, 0xC4, 0xFF, 0x27,
+            0x59, 0xA0, 0xE0, 0xF0, 0x70, 0x1F, 0xD1, 0xD9, 0x89, 0x10, 0x01, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xC0, 0x18, 0x55, 0x5D, 0xD8, 0xA8, 0x6D, 0x1C,
+            0xB4, 0xB5, 0xB7, 0xB1, 0x14, 0x94, 0x67, 0x85, 0x7F, 0xD7, 0x61, 0x3F,
+            0x82, 0x72, 0xAC, 0xE0, 0xD5, 0xD1, 0x55, 0x31, 0x64, 0x25, 0xC8, 0xAF,
+            0x0B, 0xA3, 0xD1, 0x71, 0xB5, 0x20, 0x3F, 0x2B, 0xF4, 0x4E, 0x9D, 0x04,
+            0x79, 0x59, 0x8D, 0x37, 0xEA, 0x77, 0x10, 0xE4, 0x63, 0x05, 0xFE, 0xD0,
+            0x38, 0x3B, 0x81, 0x9F, 0xB6, 0xBD, 0x20, 0xFC, 0xE2, 0xC3, 0x52, 0xB5,
+            0xD1, 0x76, 0xF9, 0xBA, 0x0D, 0xC7, 0x07, 0xE6, 0x8E, 0x35, 0xF1, 0x53,
+            0x95, 0xC0, 0xC7, 0x8A, 0xB5, 0x3A, 0x53, 0xE0, 0x70, 0x7C, 0x79, 0x34,
+            0xD7, 0xDB, 0xC4, 0x7B, 0xCF, 0xC7, 0x08, 0x2B, 0xD6, 0xB7, 0xB3, 0xB0,
+            0xCB, 0x6E, 0xBE, 0xBB, 0x89, 0x77, 0xC1, 0x55, 0x02, 0x3F, 0x2B, 0xD8,
+            0x3A, 0xA2, 0xC0, 0x31, 0x61, 0xD4, 0x36, 0xE6, 0x82, 0x78, 0x91, 0xA1,
+            0x78, 0xAC, 0x05, 0x97, 0x49, 0x14, 0x0A, 0xFD, 0x22, 0x86, 0xB6, 0xCD,
+            0x3B, 0xAC, 0xA2, 0xE6, 0x03, 0x9F, 0xAF, 0x75, 0xBA, 0x46, 0xE9, 0x17,
+            0x7E, 0xFA, 0xBF, 0x79, 0xA7, 0x0E, 0xA5, 0x56, 0xFA, 0x85, 0x4F, 0x28,
+            0x54, 0x57, 0xB0, 0x53, 0xA9, 0x42, 0x61, 0xC3, 0xE7, 0xA5, 0xE3, 0x7B,
+            0x86, 0x54, 0xA1, 0xD0, 0x37, 0xC6, 0x58, 0x91, 0xDE, 0xD4, 0xB7, 0x9B,
+            0x26, 0x94, 0xDC, 0xB4, 0x6D, 0xDE, 0x31, 0x52, 0x84, 0x72, 0xD0, 0x1B,
+            0xEE, 0x23, 0x4F, 0x72, 0x5D, 0x2F, 0x12, 0x67, 0x61, 0xA3, 0xEE, 0x2B,
+            0xE8, 0x6C, 0x36, 0xFB, 0xB2, 0x97, 0x8D, 0xE3, 0x3B, 0xC2, 0xB9, 0x9F,
+            0x82, 0x7E, 0x3A, 0x6D, 0xB5, 0x74, 0xE9, 0x95, 0xB2, 0x17, 0x0C, 0xD3,
+            0xF2, 0xA1, 0x34, 0x82, 0xF3, 0xB4, 0x6C, 0x28, 0x3C, 0xA6, 0xF5, 0xD0,
+            0x72, 0xA1, 0x6C, 0x05, 0x3E, 0x5A, 0x26, 0x94, 0x4A, 0xE0, 0xA7, 0x79,
+            0x43, 0xE1, 0x0E, 0xEF, 0x14, 0x9A, 0x27, 0x14, 0xC2, 0xB8, 0x84, 0x26,
+            0x0E, 0x05, 0x09, 0x10, 0xCA, 0x0D, 0x22, 0x94, 0x1B, 0x34, 0x35, 0x14,
+            0x41, 0x3E, 0x13, 0x42, 0xA1, 0x89, 0xE7, 0x16, 0x11, 0x0A, 0x61, 0x94,
+            0xE2, 0x08, 0x85, 0x5B, 0x23, 0xA5, 0x9D, 0x09, 0xA5, 0x51, 0x76, 0xE2,
+            0xD7, 0xD1, 0x13, 0x0A, 0x61, 0x5C, 0xDB, 0x49, 0x28, 0xAF, 0x72, 0xE7,
+            0x9E, 0xE5, 0xCE, 0x85, 0x27, 0x85, 0xDA, 0xFD, 0xC7, 0xC6, 0xDE, 0xFF,
+            0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x63, 0xF9, 0x03, 0xF6, 0x93,
+            0x09, 0xAE, 0xDA, 0xF7, 0x5D, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
+            0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82, 
+        };
+        unsigned int Resources_Images_trenchbroom_icon_png_len = sizeof(Resources_Images_trenchbroom_icon_png);
+
         // Data for file: Resources_Images_wrench_png_path
         const std::string Resources_Images_wrench_png_path = R"(Resources/Images/wrench.png)";
         unsigned char Resources_Images_wrench_png[] = {
@@ -268633,15 +268761,11 @@ namespace Nuake {
             0x65, 0x63, 0x33, 0x20, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6F,
             0x6E, 0x3B, 0x0D, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x63, 0x33,
             0x20, 0x43, 0x6F, 0x6C, 0x6F, 0x72, 0x3B, 0x0D, 0x0A, 0x20, 0x20, 0x20,
-            0x20, 0x69, 0x6E, 0x74, 0x20, 0x53, 0x68, 0x61, 0x64, 0x6F, 0x77, 0x4D,
-            0x61, 0x70, 0x73, 0x49, 0x44, 0x73, 0x5B, 0x34, 0x5D, 0x3B, 0x0D, 0x0A,
-            0x20, 0x20, 0x20, 0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x20, 0x43, 0x61,
-            0x73, 0x63, 0x61, 0x64, 0x65, 0x44, 0x65, 0x70, 0x74, 0x68, 0x5B, 0x34,
-            0x5D, 0x3B, 0x0D, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x6D, 0x61, 0x74, 0x34,
-            0x20, 0x4C, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72, 0x61, 0x6E, 0x73, 0x66,
-            0x6F, 0x72, 0x6D, 0x73, 0x5B, 0x34, 0x5D, 0x3B, 0x0D, 0x0A, 0x20, 0x20,
-            0x20, 0x20, 0x69, 0x6E, 0x74, 0x20, 0x56, 0x6F, 0x6C, 0x75, 0x6D, 0x65,
-            0x74, 0x72, 0x69, 0x63, 0x3B, 0x0D, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x69,
+            0x20, 0x66, 0x6C, 0x6F, 0x61, 0x74, 0x20, 0x43, 0x61, 0x73, 0x63, 0x61,
+            0x64, 0x65, 0x44, 0x65, 0x70, 0x74, 0x68, 0x5B, 0x34, 0x5D, 0x3B, 0x0D,
+            0x0A, 0x20, 0x20, 0x20, 0x20, 0x6D, 0x61, 0x74, 0x34, 0x20, 0x4C, 0x69,
+            0x67, 0x68, 0x74, 0x54, 0x72, 0x61, 0x6E, 0x73, 0x66, 0x6F, 0x72, 0x6D,
+            0x73, 0x5B, 0x34, 0x5D, 0x3B, 0x0D, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x69,
             0x6E, 0x74, 0x20, 0x53, 0x68, 0x61, 0x64, 0x6F, 0x77, 0x3B, 0x0D, 0x0A,
             0x7D, 0x3B, 0x0D, 0x0A, 0x0D, 0x0A, 0x75, 0x6E, 0x69, 0x66, 0x6F, 0x72,
             0x6D, 0x20, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x72, 0x32, 0x44, 0x20,
diff --git a/Nuake/src/Resource/StaticResources.h b/Nuake/src/Resource/StaticResources.h
index a5420b00..a60d40b2 100644
--- a/Nuake/src/Resource/StaticResources.h
+++ b/Nuake/src/Resource/StaticResources.h
@@ -119,9 +119,15 @@ namespace Nuake {
         extern const std::string Resources_Images_shape_png_path;
         extern unsigned int Resources_Images_shape_png_len;
         extern unsigned char Resources_Images_shape_png[];
+        extern const std::string Resources_Images_sln_icon_png_path;
+        extern unsigned int Resources_Images_sln_icon_png_len;
+        extern unsigned char Resources_Images_sln_icon_png[];
         extern const std::string Resources_Images_speaker_png_path;
         extern unsigned int Resources_Images_speaker_png_len;
         extern unsigned char Resources_Images_speaker_png[];
+        extern const std::string Resources_Images_trenchbroom_icon_png_path;
+        extern unsigned int Resources_Images_trenchbroom_icon_png_len;
+        extern unsigned char Resources_Images_trenchbroom_icon_png[];
         extern const std::string Resources_Images_wrench_png_path;
         extern unsigned int Resources_Images_wrench_png_len;
         extern unsigned char Resources_Images_wrench_png[];
diff --git a/Nuake/src/Window.cpp b/Nuake/src/Window.cpp
index d8f6f969..18508d7a 100644
--- a/Nuake/src/Window.cpp
+++ b/Nuake/src/Window.cpp
@@ -102,6 +102,22 @@ int Window::Init()
             window->OnWindowFocused(*window, static_cast<bool>(focused));
         });
 
+    glfwSetDropCallback(window, [](GLFWwindow* nativeWindow, int count, const char** paths)
+        {
+            std::vector<std::string> filePaths;
+            filePaths.reserve(count);
+
+            int i;
+            for (i = 0; i < count; i++)
+            {
+                std::string filePath = std::string(paths[i]);
+                filePaths.push_back(filePath);
+            }
+
+            Window* window = reinterpret_cast<Window*>(glfwGetWindowUserPointer(nativeWindow));
+            window->OnDragNDropCallback(*window, filePaths);
+        });
+
     // TODO: have clear color in environnement.
     glClearColor(0.f, 0.f, 0.f, 1.0f);
 
@@ -348,6 +364,11 @@ void Window::SetOnWindowClosedCallback(std::function<void(Window& window)> callb
     onWindowClosedCallback = callback;
 }
 
+void Nuake::Window::SetOnDragNDropCallback(std::function<void(Window&, const std::vector<std::string>& paths)> callback)
+{
+    onDragNDropCallback = callback;
+}
+
 void Window::OnWindowFocused(Window& window, bool focused)
 {
     if (onWindowFocusedCallback)
@@ -364,6 +385,14 @@ void Window::OnWindowClosed(Window& window)
     }
 }
 
+void Window::OnDragNDropCallback(Window& window, const std::vector<std::string>& paths)
+{
+    if (onDragNDropCallback)
+    {
+        onDragNDropCallback(window, paths);
+    }
+}
+
 void Window::InitImgui()
 {
     ImGui::CreateContext();
diff --git a/Nuake/src/Window.h b/Nuake/src/Window.h
index dc3f7b23..63817314 100644
--- a/Nuake/src/Window.h
+++ b/Nuake/src/Window.h
@@ -57,9 +57,11 @@ namespace Nuake
 
 		void OnWindowFocused(Window& window, bool focused);
 		void OnWindowClosed(Window& window);
+		void OnDragNDropCallback(Window& window, const std::vector<std::string>& paths);
 
 		void SetOnWindowFocusedCallback(std::function<void(Window& window, bool focused)> callback);
 		void SetOnWindowClosedCallback(std::function<void(Window& window)> callback);
+		void SetOnDragNDropCallback(std::function<void(Window&, const std::vector<std::string>& paths)> callback);
 
 	private:
 		const std::string DEFAULT_TITLE = "Untitled Window";
@@ -79,10 +81,10 @@ namespace Nuake
 		// Callbacks
 		std::function<void(Window&)> onWindowClosedCallback;
 		std::function<void(Window&, bool)> onWindowFocusedCallback;
+		std::function<void(Window&, const std::vector<std::string>& paths)> onDragNDropCallback;
 
 		void InitImgui();
 
 	private:
-
 	};
 }
diff --git a/Resources/Images/folder_icon.png b/Resources/Images/folder_icon.png
index b58e43ed60dace451118aecea9dad5a47883647e..e793b799ec67474a3de0b7bb3bcfd4e5a317889d 100644
GIT binary patch
delta 204
zcmeysJd<fcXg$L^PZ!6K3dXk=I|UCp@US>KJ~<WRz*g5^8d}a_9Lj(If6m7&@BaKO
zDt3<X_1BMf>~t4Dex`QUjr@04kJ=UQ*V{JRbk~ivYcH!dgzJ9N4(0#$YZdD~R}tq!
z5<<r&7__w*s`Mx(@^B`5NFWQjVi7|VLb!l|;XtdMNu|ZMO@@<KfP_6={an^LB{Ts5
DvTIA0

delta 421
zcmbQq^nrOoXgy=Ar;B4q1>@V>7XzgNMH(JDtFhj2)KCl)xZL@&floy=!%AUl3ttj@
zRFmw3osWM#ntZ6}`<q|2#_8`q9I*SqJYBX-nE?sdrHIPP^0jxzm|5CCs@Q!s>#Mog
zEAKB`&+a_Av*Yoa;xfrH={b7wC+c$_vHbjVyZ&(Z?FS~wERuc2#x6hSZ|3VW4x8{W
zVz%O`!;=<$x##RQS^9UZ-t@zV#eP-m9LQ-lk$h@5eg5IY-@b0;yqAAw{TlP*vHZVJ
zT9({hzV8^*6ZNNt(@)ntTvz;8>~YroUEhNLhL>#UP*`ttM$c{9#PyG!{#o7~`Cidm
z#lx^kL>WlbgUH}NZ}w)TM;q$@ev#6p&~LeWM*r&<8Iu$$nZ8@6C0Q80IVKm>qi~di
zFySNk<i_shcCGjROS~)I_I$^KUp}{HFTeY&Kzy!G;pOz*1(kl^i{2FfdvgDrKO-pA
d<e)(paNbzo@h;~q-!;V`5l>e?mvv4FO#p*r!NmXo

diff --git a/Resources/Images/project_icon.png b/Resources/Images/project_icon.png
index 384eabf2cc0c3bff15b5849cc846f46a149ebf62..d8f48b3065bb6dd86bd0809752a3806dbc8d635b 100644
GIT binary patch
delta 497
zcmX@lx`$;#Xg%XaPZ!6K3dXm$9_Ai05O8?tt)9SQ<tV8*dy4N1ww?=t3xrErHZdyi
z*rp(q+t_x)a{k-zo?&$k2A_f%n3Wh%K*$<l-gB0nS4$_)Up>F>CBL=(p^pV})%JFO
z4!>J!sp#=$hTYdo{rct6JKl!QnxuK6L!!67?WDkygA&uX1=&7T5Hw_)U#GJqs>@O6
zh{T&EQC^Nh$0S02eOfAz(k9UyClb1mztH}><Vx8;SI#eb;>l%R+@lavnI+%e&9_J(
zd4rhhQMSMy!7owoRbAN%m)kal^&ITh(9rW(CgG^h)x}jLn5_CM<e83|$1{n>Q{kFc
zzbAOq+Z~&2FY~mn=V;}clx0U>E7eV2>DKX3?oPz7-Rqy<*y{bdO(IzQ@ceCsoSvuk
zl8@-L*_XZ+ni%%CPjI)yzb|vW9imEf-I^5k0vW~HZe2$|@E4X$T%!6tNrmgvJEcx0
zVQJ^`Tj@C|aqOB7-xRzIyC#})82&pY)*^8|mD8yw>-LpqfyZ`N6^{IvA0?2~vskD_
z;&EoI;t`3JKkQFkZBsZVa73a>!dW1hBZ<ecN3p|@#SlY~10@z1E_~)a#jSLp;g8Bc
Okc6kJpUXO@geCx2V#-Yb

delta 645
zcmdnPa-MZUXgyPkr;B4q1>@W6jfJ-iL>dw=zGk?`u!~XJM0o>a3Db>+GNw(9>xD1y
zo?-J<Z{U5y8?w^Iv|s$DO8E5$r~lu5nRB|zzpq90xFrKF@cmS^J$I^fKi_t7wMC!O
ztFJGfuzteHd6s+PBsRF#&*=$}i|J3Yo0;*R?bAhGg};Z?CZE*&_v+9~n<>G2!g7;p
zb$UZ$w*(em3|^5RBHkXcJgM~D%qLq7cbaY6f9Maduio($C$#71IIX<;)o-iz(sf)<
zHJ*F#{Qg4!=<nG+IV)e~#9s{moU=CfP~p?~Te~(I3m5fFUceT>U$tuW(m#>)O;=K`
z%)G%a9DVAm6MvFM_Wz<uUmK<eU3#M9JahKGZTp_9epEZtq7z!HS~@jmde)^cL4oB*
z-udRtny@$KwRu6}uhk_zS8|v9pOXH;_DQq!HT}|m&V9z0pS_QIfBtpZMM3NG%9VAh
z%r!jEtuM!0$pr<x_-;7Ge_>6bxzUMb>#o$l+LMuad5_|^TWr+@&(H4Du7CLM#D)A5
zTE+jaT#MLOG0W%8Bd?rQ{qe5%lQ^H>R}HVa?58$8?pM{{`e*BA*e;p2b@!&<UFT~w
zJ^#9Gy*v9xq+Zzize1ZopRc~CcllZRY2%ma>-XF`?soc5Aou@2TZP#(*4~<072w;q
zcK;unUQ4^W@}sl%1=UASHou-W_vP*Fwzpr*;GF4o_sVMhmF7=oEt6SRci(X4<?O#(
zpN4+#UiW+Pq}dbZeV(rM|Ht$x|8pBSEl&k)F0PoH?S07p*}m21!*C>m4}E{xJe3)B
T46dvQ04ecw^>bP0l+XkK*)BUl

diff --git a/Resources/Images/sln_icon.png b/Resources/Images/sln_icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..6dee878da87864875fa7de5f8573b8e7db8413b0
GIT binary patch
literal 1190
zcmV;X1X=ruP)<h;3K|Lk000e1NJLTq003kF003kN1^@s6aN?Cz00009a7bBm000XU
z000XU0RWnu7ytkO0drDELIAGL9O(c600d`2O+f$vv5yP<VFdsH1UpGYK~#7F?VN#C
z+b|G@MJHf`h7HOD&<S7z(g|RLxD&tzrV}uN*&y9OY(O{od#dclgjhPuiWA5G_nw}4
z&$i6F-#Xu&q!>d8A%qY@2qA<JLI@#*5JCtcgb)${z`3+%X=`cs(iVms24{R}7N4o4
z-BFwo5o0f<y(13A*(bG&dO{i%#mPwRqSna6OD)d1A^j1<T_fzG+&PN`4C#m1tccjO
zYTk4?UP&wah+~Kjco$Vg?70fue^rYU{P-IZ2i`^5fE}HYuX^-%Q;S1E`XV-ZKp6L7
zUznc2k2ngV1wN#GiHPxN5}_bH5W9Rs+(q4)0ZdvDXCN~Y@GdI!;kC$+%uP}d_>XDT
zGQ^G96VPSdB{C&%lM$pgjH{Hc14dbxj6j!l-<yo!*afMDa7mY@NawC8Oa`Q%Tf|*d
zc9%H?K~k_ojD@(1s<5Z}(y0p4P@;z$!@#UN2bi!R6%-{0_|fv9cuv-=dq@AO5j#~u
zZd&IT=qNYr5N6TwjJ;&tb>B^tRw=Kaq#$2+T(^X-dRjKd#s0JI_NbeeAg$|Hh-2YH
zXdAdDIqSym+-07E)c0uJSQi%QE~@KWG+#kl_iEi(n-U2jE#etH1!?uMLLBF!lCo~Z
zBQy%Kqo0r)vq(%Np<i7xyC|!I!tdj=8*}%ixF}bO@3XpOc7oXY++$1_cz?e_V%ClL
zf(8nLk8i#Ed(cEt$N!?K{vNF$U(DfHNPEVB40{{+^2=J<Xp>^OIiw&B&Uh9B%j9x@
zDF>IaPkII6F$nT1?egsG?6(<!-2X!kg_$^q6y%Szr5N)2P%#>$pPzELkoIOK%Ao{#
zl6D~m{MB^<HnWh0>4Eh5Ce4Xbn7IOdl;u9+(fJDasaf0V>m}vGkM4~)M;m2j0ZKs>
z{e)%%Ez*mLD^L)<An3P9;=v>U-Dsg8&=vi*ahZNnc#H68nf-i7g>)=Va6V-8C=0cF
zGCrfe4qWQOVt3tJ$N7cp0}169iNapxaA|zBcX~iMLZEj~|6LMvGmC{u1RpEQC+)Jf
zSDnNbD*Q7DI>KVaBc&m$P8!iqS`deYf7@fxlWHaq@vR2#+_gyr$~9e67DPjd9uX6C
z<@Lhs5uB(X&Zt9H8LlGzCuR4_XCJ*FjSsen<J?oyEZ~mkE)jQO3zM0n7o<(ZNZH?7
z=rZuaWCRo4LFKj&SFJZS**z(r_ZShS#N2jJ?V|qYN14R~_ZS`@h`TT+SW<y<>lqY8
z3w(K|L>TT<9~;C&V+;P0!?-|~-QOzvawG2=9c3UxbU;_?F9P>F5uzm^L;8WZ3#+i%
zxup_;f(!(o7f@_t`-sru-H<fUe>F;{2-y4}CVz8rD2QkGT~zS<A1Oj^5YO%@!q_1E
z%hnX(5MYztI}uhCfe=CnA%qY@2qA<JLI@#*5JG0pU-ZAwFfZjQ=>Px#07*qoM6N<$
Ef=h`V$^ZZW

literal 0
HcmV?d00001

diff --git a/Resources/Images/trenchbroom_icon.png b/Resources/Images/trenchbroom_icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..722d8e786c3f533a522c29270c646e814277cccc
GIT binary patch
literal 546
zcmeAS@N?(olHy`uVBq!ia0vp^DIm<j1|$m}O$`B3oCO|{#S9GG!XV7ZFl&wkP>``W
z$lZxy-8q?;Kn_c~qpu?a!^VE@KZ&eBx$T}Vjv*C{Z*O1BJ!Bwo?Bn8B)sl+J8yu~j
z%oj*c;awnnf!B&j*=25npb?XD%y}<44X+cHH`tE+SC3rq;6s7@#haZ1j6icy!2yZT
z*c&TyWwvbHzENaKdTaglMEj<qH4m;{3^hzqJ+Yp9@x{We3ijGx{N}P$M)sP&Di?T?
z%=+(wg>~cnZF?2|JUSe-^<vr2UA)KHpY@r344!)6c-K~|;0FaYl_uA3AE`cnoJ0HC
z_RSkk=k43wS$;5-$zJ=0)uIE2iC4^?HC0SpSh0q6x~B-&U!}HfXRX&Pdd56|ed#W@
zm*RE5_E#?FTN?JO)n6kdd_(X`r^Lh0mp-m;3t4!<{8+@qdsnv4R-1BXOYS|xpq8Qw
z((jc0i(>VK(i0cI(|(a-_IuOx-pAI5cFu3Av&!9C@^b1Xah}Vc7Me7D-jbtXv+V1I
zqJ=rEc2R0mydEsCbbiS9USyWK$e|rAYJ9Am0;hPDrbwHZia6Q{J1y*dE+)v8IOP#X
zYqavxxtvP_%N||7D9n`@bK6s6ebMuIPtUcgx8C}D{Mfz!pa@3=2a<m>f1Av??$-C%
P{~#GpS3j3^P6<r_<tpF4

literal 0
HcmV?d00001


From bd77025ed021c1eef7da419df1270ccac220bb46 Mon Sep 17 00:00:00 2001
From: antopilo <antoinepilote1@hotmail.com>
Date: Mon, 16 Sep 2024 20:55:24 -0400
Subject: [PATCH 4/7] Added script icon in scene hierarchy

---
 Editor/src/Windows/EditorInterface.cpp | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp
index f008d3a3..bad5a282 100644
--- a/Editor/src/Windows/EditorInterface.cpp
+++ b/Editor/src/Windows/EditorInterface.cpp
@@ -736,6 +736,7 @@ namespace Nuake {
 
 		NameComponent& nameComponent = e.GetComponent<NameComponent>();
 		std::string name = nameComponent.Name;
+
         ParentComponent& parent = e.GetComponent<ParentComponent>();
 
         if (Selection.Type == EditorSelectionType::Entity && Selection.Entity == e)
@@ -767,9 +768,7 @@ namespace Nuake {
         }
 
         auto cursorPos = ImGui::GetCursorPos();
-
         ImGui::SetNextItemAllowOverlap();
-
         bool open = ImGui::TreeNodeEx(name.c_str(), base_flags);
 
         if (m_IsRenaming)
@@ -904,6 +903,25 @@ namespace Nuake {
 
         ImGui::TextColored(ImVec4(0.5, 0.5, 0.5, 1.0), GetEntityTypeName(e).c_str());
 
+        ImGui::TableNextColumn();
+        {
+            bool hasScript = e.HasComponent<NetScriptComponent>();
+            if (hasScript)
+            {
+                std::string scrollIcon = std::string(ICON_FA_SCROLL) + "##" + name;
+                ImGui::PushStyleColor(ImGuiCol_Button, { 0, 0, 0, 0 });
+                if (ImGui::Button(scrollIcon.c_str(), { 40, 0 }))
+                {
+                    auto& scriptComponent = e.GetComponent<NetScriptComponent>();
+                    if (!scriptComponent.ScriptPath.empty() && FileSystem::FileExists(scriptComponent.ScriptPath))
+                    {
+                        OS::OpenIn(FileSystem::RelativeToAbsolute(scriptComponent.ScriptPath));
+                    }
+                }
+                ImGui::PopStyleColor();
+            }
+        }
+
         ImGui::TableNextColumn();
         {
             bool& isVisible = e.GetComponent<VisibilityComponent>().Visible;
@@ -2139,10 +2157,11 @@ namespace Nuake {
             ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { 4, 4 });
             if (ImGui::BeginChild("Scene tree", ImGui::GetContentRegionAvail(), false))
             {
-                if (ImGui::BeginTable("entity_table", 3, ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_SizingStretchProp))
+                if (ImGui::BeginTable("entity_table", 4, ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_SizingStretchProp))
                 {
                     ImGui::TableSetupColumn("   Label", ImGuiTableColumnFlags_IndentEnable | ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_WidthStretch);
                     ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_IndentDisable | ImGuiTableColumnFlags_WidthFixed);
+                    ImGui::TableSetupColumn("Script", ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_IndentDisable | ImGuiTableColumnFlags_WidthFixed);
                     ImGui::TableSetupColumn("Visibility   ", ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_IndentDisable | ImGuiTableColumnFlags_WidthFixed);
                     ImGui::TableHeadersRow();
 

From f58e09cfc3c8549a90a73798719f26be225abb75 Mon Sep 17 00:00:00 2001
From: antopilo <antoinepilote1@hotmail.com>
Date: Mon, 16 Sep 2024 21:31:51 -0400
Subject: [PATCH 5/7] Removed overlay when in play mode

---
 Editor/src/Windows/EditorInterface.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp
index bad5a282..331efda5 100644
--- a/Editor/src/Windows/EditorInterface.cpp
+++ b/Editor/src/Windows/EditorInterface.cpp
@@ -2446,6 +2446,11 @@ namespace Nuake {
 
     void EditorInterface::Overlay()
     {
+        if (Engine::GetGameState() == GameState::Playing)
+        {
+            return;
+        }
+         
         // FIXME-VIEWPORT: Select a default viewport
         const float DISTANCE = 10.0f;
         int corner = 0;

From 7ed37d0bbba928e6e9c7ce0f7fd0575ff0ab7d02 Mon Sep 17 00:00:00 2001
From: antopilo <antoinepilote1@hotmail.com>
Date: Mon, 16 Sep 2024 21:32:17 -0400
Subject: [PATCH 6/7] Fixed crash when canvas parser fails + added resolution
 settings for worldspace UI

---
 Nuake/src/Resource/UI.cpp                | 13 ++++++++++---
 Nuake/src/Scene/Components/UIComponent.h | 18 ++++++++++++++++++
 Nuake/src/Scene/Systems/UISystem.cpp     |  5 +++++
 3 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/Nuake/src/Resource/UI.cpp b/Nuake/src/Resource/UI.cpp
index c6f2de17..24fdbe1f 100644
--- a/Nuake/src/Resource/UI.cpp
+++ b/Nuake/src/Resource/UI.cpp
@@ -27,8 +27,12 @@ UIResource::UIResource(const std::string& path) :
 	canvas = Canvas::New();
 	canvas->uuid = this->ID;
 	canvas = CanvasParser::Get().Parse(canvas, FileSystem::RelativeToAbsolute(path));
-	canvas->SetInputManager(inputManager);
-	canvas->ComputeLayout(defaultSize);
+
+	if (!canvas)
+	{
+		canvas->SetInputManager(inputManager);
+		canvas->ComputeLayout(defaultSize);
+	}
 }
 
 void UIResource::Tick()
@@ -57,7 +61,10 @@ void UIResource::Draw()
 void UIResource::Resize(const Vector2& size)
 {
 	framebuffer->QueueResize(size);
-	canvas->ComputeLayout(size);
+	if (canvas)
+	{
+		canvas->ComputeLayout(size);
+	}
 }
 
 void UIResource::Reload()
diff --git a/Nuake/src/Scene/Components/UIComponent.h b/Nuake/src/Scene/Components/UIComponent.h
index 55188105..254d6980 100644
--- a/Nuake/src/Scene/Components/UIComponent.h
+++ b/Nuake/src/Scene/Components/UIComponent.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Component.h"
+#include "src/Core/Maths.h"
 #include "FieldTypes.h"
 #include "src/Core/Logger.h"
 #include "src/FileSystem/File.h"
@@ -22,19 +23,32 @@ namespace Nuake
             
             BindComponentField<&UIComponent::UIFilePath>("UIFilePath", "File Path");
             BindComponentField<&UIComponent::IsWorldSpace>("IsWorldspace", "Is Worldspace");
+            BindComponentProperty<&UIComponent::SetResolution, &UIComponent::GetResolution>("Resolution", "Resolution");
         }
 
     public:
         UUID UIResource = UUID(0);
         ResourceFile UIFilePath;
         bool IsWorldSpace;
+        Vector3 Resolution = Vector3(1920, 1080, 0);
         // TODO: Z-Ordering
 
+        void SetResolution(const Vector3& newSize)
+        {
+            Resolution = newSize;
+        }
+
+        Vector3 GetResolution()
+        {
+            return Resolution;
+        }
+
         json Serialize()
         {
             BEGIN_SERIALIZE();
             SERIALIZE_RES_FILE(UIFilePath);
             SERIALIZE_VAL(IsWorldSpace);
+            SERIALIZE_VEC3(Resolution)
             END_SERIALIZE();
         }
 
@@ -42,6 +56,10 @@ namespace Nuake
         {
             DESERIALIZE_RES_FILE(UIFilePath);
             DESERIALIZE_VAL(IsWorldSpace);
+            if (j.contains("Resolution"))
+            {
+                DESERIALIZE_VEC3(j["Resolution"], Resolution);
+            }
             return true;
         }
     };
diff --git a/Nuake/src/Scene/Systems/UISystem.cpp b/Nuake/src/Scene/Systems/UISystem.cpp
index 99dd7fbb..aa301723 100644
--- a/Nuake/src/Scene/Systems/UISystem.cpp
+++ b/Nuake/src/Scene/Systems/UISystem.cpp
@@ -73,6 +73,11 @@ namespace Nuake
 						uis[uiViewComponent.UIResource]->Tick();
 					}
 
+					if (uiViewComponent.IsWorldSpace)
+					{
+						uis[uiViewComponent.UIResource]->Resize(uiViewComponent.GetResolution());
+					}
+
 					uis[uiViewComponent.UIResource]->Draw();
 				}
 			}

From c6a2d916a8e4962b22fecdf8a2db765f42ea4a93 Mon Sep 17 00:00:00 2001
From: antopilo <antoinepilote1@hotmail.com>
Date: Mon, 16 Sep 2024 21:42:35 -0400
Subject: [PATCH 7/7] Fixed crash when html file is empty and when canvas fails
 to aprse

---
 Nuake/src/Resource/UI.cpp            | 10 +++++-----
 Nuake/src/Scene/Systems/UISystem.cpp | 29 +++++++++++++++++++---------
 Nuake/src/UI/Inspector.h             |  5 +++++
 Nuake/src/UI/Nodes/Canvas.cpp        |  6 +-----
 4 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/Nuake/src/Resource/UI.cpp b/Nuake/src/Resource/UI.cpp
index 24fdbe1f..d2c44f64 100644
--- a/Nuake/src/Resource/UI.cpp
+++ b/Nuake/src/Resource/UI.cpp
@@ -28,7 +28,7 @@ UIResource::UIResource(const std::string& path) :
 	canvas->uuid = this->ID;
 	canvas = CanvasParser::Get().Parse(canvas, FileSystem::RelativeToAbsolute(path));
 
-	if (!canvas)
+	if (canvas != nullptr)
 	{
 		canvas->SetInputManager(inputManager);
 		canvas->ComputeLayout(defaultSize);
@@ -37,7 +37,7 @@ UIResource::UIResource(const std::string& path) :
 
 void UIResource::Tick()
 {
-	if (canvas)
+	if (canvas != nullptr)
 	{
 		canvas->Tick();
 	}
@@ -50,7 +50,7 @@ void UIResource::Draw()
 		RenderCommand::SetClearColor({ 0, 0, 0, 0 });
 		RenderCommand::Clear();
 
-		if (canvas)
+		if (canvas != nullptr)
 		{
 			canvas->Draw();
 		}
@@ -61,7 +61,7 @@ void UIResource::Draw()
 void UIResource::Resize(const Vector2& size)
 {
 	framebuffer->QueueResize(size);
-	if (canvas)
+	if (canvas != nullptr)
 	{
 		canvas->ComputeLayout(size);
 	}
@@ -75,7 +75,7 @@ void UIResource::Reload()
 	}
 
 	canvas = CanvasParser::Get().Parse(canvas, FileSystem::RelativeToAbsolute(filePath));
-	if (canvas)
+	if (canvas != nullptr)
 	{
 		canvas->SetInputManager(inputManager);
 		canvas->ComputeLayout(framebuffer->GetSize());
diff --git a/Nuake/src/Scene/Systems/UISystem.cpp b/Nuake/src/Scene/Systems/UISystem.cpp
index aa301723..000f9572 100644
--- a/Nuake/src/Scene/Systems/UISystem.cpp
+++ b/Nuake/src/Scene/Systems/UISystem.cpp
@@ -48,18 +48,29 @@ namespace Nuake
 				{
 					auto ui = ResourceManager::GetResource<UIResource>(uiViewComponent.UIResource);
 					bool sourceHasChanged = false;
-					for (auto& fileAssociated : ui->GetCanvas()->GetSourceFiles())
+					if (ui->GetCanvas() == nullptr)
 					{
-						if (!fileAssociated)
-						{
-							continue;
-						}
-
-						// Re-fetching the file object because the Scan might have invalided the pointer.
-						if (FileSystem::GetFile(fileAssociated->GetRelativePath())->GetHasBeenModified())
+						if (FileSystem::GetFile(uiViewComponent.UIFilePath.file->GetRelativePath())->GetHasBeenModified())
 						{
 							sourceHasChanged = true;
-							FileSystem::GetFile(fileAssociated->GetRelativePath())->SetHasBeenModified(false);
+							FileSystem::GetFile(uiViewComponent.UIFilePath.file->GetRelativePath())->SetHasBeenModified(false);
+						}
+					}
+					else
+					{
+						for (auto& fileAssociated : ui->GetCanvas()->GetSourceFiles())
+						{
+							if (!fileAssociated)
+							{
+								continue;
+							}
+
+							// Re-fetching the file object because the Scan might have invalided the pointer.
+							if (FileSystem::GetFile(fileAssociated->GetRelativePath())->GetHasBeenModified())
+							{
+								sourceHasChanged = true;
+								FileSystem::GetFile(fileAssociated->GetRelativePath())->SetHasBeenModified(false);
+							}
 						}
 					}
 
diff --git a/Nuake/src/UI/Inspector.h b/Nuake/src/UI/Inspector.h
index 05443e39..0e907bd7 100644
--- a/Nuake/src/UI/Inspector.h
+++ b/Nuake/src/UI/Inspector.h
@@ -96,6 +96,11 @@ namespace NuakeUI
 
 	static void DrawInspector(std::shared_ptr<Canvas> canvas)
 	{
+		if (canvas == nullptr)
+		{
+			return;
+		}
+
 		if (ImGui::Begin("Inspector"))
 		{
 			if (ImGui::BeginTabBar("MyTabBar"))
diff --git a/Nuake/src/UI/Nodes/Canvas.cpp b/Nuake/src/UI/Nodes/Canvas.cpp
index 3d36d836..a1aaf676 100644
--- a/Nuake/src/UI/Nodes/Canvas.cpp
+++ b/Nuake/src/UI/Nodes/Canvas.cpp
@@ -55,15 +55,11 @@ namespace NuakeUI
 	
 	void Canvas::ComputeLayout(Vector2 size)
 	{
-		if (!mRootNode)
+		if (!mRootNode || mInputManager)
 			return;
 		
 		Renderer::Get().SetViewportSize(size);
 
-		float x, y;
-		x = mInputManager->GetMouseX();
-		y = mInputManager->GetMouseY();
-
 		auto root = mRootNode->GetYogaNode();
 
 		// Recompute the node tree.