added material editing in mesh panel. Renamed mesh component to model component.

Editor/src/ComponentsPanel/MaterialEditor.cpp

@@ -0,0 +1,249 @@
+#include "MaterialEditor.h"
+#include <imgui/imgui.h>
+#include <src/Resource/FontAwesome5.h>
+#include <src/Vendors/imgui/imgui_internal.h>
+#include "../Misc/InterfaceFonts.h"
+
+void MaterialEditor::Draw(Ref<Nuake::Material> material)
+{
+	using namespace Nuake;
+
+	std::string materialTitle = material->Path;
+	{
+		UIFont boldfont = UIFont(Fonts::SubTitle);
+		ImGui::Text(material->Path.c_str());
+
+	}
+	ImGui::SameLine();
+	{
+		UIFont boldfont = UIFont(Fonts::Icons);
+		if (ImGui::Button(ICON_FA_SAVE))
+		{
+			std::string fileData = material->Serialize().dump(4);
+
+			FileSystem::BeginWriteFile(FileSystem::Root + material->Path);
+			FileSystem::WriteLine(fileData);
+			FileSystem::EndWriteFile();
+		}
+	}
+
+	bool flagsHeaderOpened;
+	{
+		UIFont boldfont = UIFont(Fonts::Bold);
+		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.f, 0.f));
+		ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.f, 8.f));
+		flagsHeaderOpened = ImGui::CollapsingHeader(" FLAGS", ImGuiTreeNodeFlags_DefaultOpen);
+		ImGui::PopStyleVar(2);
+	}
+
+	if (flagsHeaderOpened)
+	{
+		ImGui::BeginTable("##Flags", 3, ImGuiTableFlags_BordersInner);
+		{
+			ImGui::TableSetupColumn("name", 0, 0.3f);
+			ImGui::TableSetupColumn("set", 0, 0.6f);
+			ImGui::TableSetupColumn("reset", 0, 0.1f);
+			ImGui::TableNextColumn();
+
+			ImGui::Text("Unlit");
+			ImGui::TableNextColumn();
+
+			bool unlit = material->data.u_Unlit == 1;
+			ImGui::Checkbox("Unlit", &unlit);
+			material->data.u_Unlit = (int)unlit;
+		}
+		ImGui::EndTable();
+	}
+
+	const auto TexturePanelHeight = 100;
+	const ImVec2 TexturePanelSize = ImVec2(0, TexturePanelHeight);
+	bool AlbedoOpened;
+	{
+		UIFont boldfont = UIFont(Fonts::Bold);
+		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.f, 0.f));
+		ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0.f, 8.f));
+		AlbedoOpened = ImGui::CollapsingHeader("Albedo", ImGuiTreeNodeFlags_DefaultOpen);
+		ImGui::PopStyleVar(2);
+	}
+
+	if (AlbedoOpened)
+	{
+		ImGui::BeginChild("##albedo", TexturePanelSize, true);
+		{
+			uint32_t textureID = 0;
+			if (material->HasAlbedo())
+			{
+				textureID = material->m_Albedo->GetID();
+			}
+			else
+			{
+				textureID = TextureManager::Get()->GetTexture("default")->GetID();
+			}
+
+			if (ImGui::ImageButtonEx(ImGui::GetCurrentWindow()->GetID("#image1"), (void*)textureID, ImVec2(80, 80), ImVec2(0, 1), ImVec2(1, 0), ImVec2(2, 2), ImVec4(0, 0, 0, 0), ImVec4(1, 1, 1, 1)))
+			{
+				std::string texture = FileDialog::OpenFile("*.png | *.jpg");
+				if (texture != "")
+				{
+					material->SetAlbedo(TextureManager::Get()->GetTexture(texture));
+				}
+			}
+
+			if (ImGui::BeginPopupContextWindow())
+			{
+				if (ImGui::MenuItem("Clear Texture"))
+				{
+					material->m_Albedo = nullptr;
+				}
+				ImGui::EndPopup();
+			}
+
+			ImGui::SameLine();
+			ImGui::ColorEdit3("Color", &material->data.m_AlbedoColor.r);
+		}
+		ImGui::EndChild();
+	}
+
+	if (ImGui::CollapsingHeader("Normal", ImGuiTreeNodeFlags_DefaultOpen))
+	{
+		ImGui::BeginChild("##normal", TexturePanelSize, true);
+		{
+			uint32_t textureID = 0;
+			if (material->HasNormal())
+			{
+				textureID = material->m_Normal->GetID();
+			}
+			else
+			{
+				textureID = TextureManager::Get()->GetTexture("default")->GetID();
+			}
+
+			if (ImGui::ImageButtonEx(ImGui::GetCurrentWindow()->GetID("#image3"), (void*)textureID, ImVec2(80, 80), ImVec2(0, 1), ImVec2(1, 0), ImVec2(2, 2), ImVec4(0, 0, 0, 1), ImVec4(1, 1, 1, 1)))
+			{
+				std::string texture = FileDialog::OpenFile("*.png | *.jpg");
+				if (texture != "")
+				{
+					material->SetNormal(TextureManager::Get()->GetTexture(texture));
+				}
+			}
+
+			if (ImGui::BeginPopupContextWindow())
+			{
+				if (ImGui::MenuItem("Clear Texture"))
+				{
+					material->m_Normal = nullptr;
+				}
+				ImGui::EndPopup();
+			}
+		}
+		ImGui::EndChild();
+	}
+
+	if (ImGui::CollapsingHeader("AO", ImGuiTreeNodeFlags_DefaultOpen))
+	{
+		ImGui::BeginChild("##ao", TexturePanelSize, true);
+		{
+			uint32_t textureID = 0;
+			if (material->HasAO())
+			{
+				textureID = material->m_AO->GetID();
+			}
+			else
+			{
+				textureID = TextureManager::Get()->GetTexture("default")->GetID();
+			}
+
+			if (ImGui::ImageButtonEx(ImGui::GetCurrentWindow()->GetID("#image2"), (void*)textureID, ImVec2(80, 80), ImVec2(0, 1), ImVec2(1, 0), ImVec2(2, 2), ImVec4(1, 1, 1, 1), ImVec4(1, 1, 1, 1)))
+			{
+				std::string texture = FileDialog::OpenFile("Image files (*.png) | *.png | Image files (*.jpg) | *.jpg");
+				if (texture != "")
+				{
+					material->SetAO(TextureManager::Get()->GetTexture(texture));
+				}
+			}
+
+			if (ImGui::BeginPopupContextWindow())
+			{
+				if (ImGui::MenuItem("Clear Texture"))
+				{
+					material->m_AO = nullptr;
+				}
+				ImGui::EndPopup();
+			}
+		}
+		ImGui::EndChild();
+	}
+
+	if (ImGui::CollapsingHeader("Metalness", ImGuiTreeNodeFlags_DefaultOpen))
+	{
+		ImGui::BeginChild("##metalness", TexturePanelSize, true);
+		{
+			uint32_t textureID = 0;
+			if (material->HasMetalness())
+			{
+				textureID = material->m_Metalness->GetID();
+			}
+			else
+			{
+				textureID = TextureManager::Get()->GetTexture("default")->GetID();
+			}
+
+			if (ImGui::ImageButtonEx(ImGui::GetCurrentWindow()->GetID("#image4"), (void*)textureID, ImVec2(80, 80), ImVec2(0, 1), ImVec2(1, 0), ImVec2(2, 2), ImVec4(0, 0, 0, 1), ImVec4(1, 1, 1, 1)))
+			{
+				std::string texture = FileDialog::OpenFile("*.png | *.jpg");
+				if (texture != "")
+				{
+					material->SetMetalness(TextureManager::Get()->GetTexture(texture));
+				}
+			}
+
+			if (ImGui::BeginPopupContextWindow())
+			{
+				if (ImGui::MenuItem("Clear Texture"))
+				{
+					material->m_Metalness = nullptr;
+				}
+				ImGui::EndPopup();
+			}
+
+			ImGui::SameLine();
+			ImGui::DragFloat("Value##4", &material->data.u_MetalnessValue, 0.01f, 0.0f, 1.0f);
+		}
+		ImGui::EndChild();
+	}
+
+	if (ImGui::CollapsingHeader("Roughness", ImGuiTreeNodeFlags_DefaultOpen))
+	{
+		ImGui::BeginChild("##roughness", TexturePanelSize, true);
+		{
+			uint32_t textureID = 0;
+			if (material->HasRoughness())
+			{
+				textureID = material->m_Roughness->GetID();
+			}
+			else
+			{
+				textureID = TextureManager::Get()->GetTexture("default")->GetID();
+			}
+
+			if (ImGui::ImageButtonEx(ImGui::GetCurrentWindow()->GetID("#image5"), (void*)textureID, ImVec2(80, 80), ImVec2(0, 1), ImVec2(1, 0), ImVec2(2, 2), ImVec4(0, 0, 0, 0), ImVec4(1, 1, 1, 1)))
+			{
+				std::string texture = FileDialog::OpenFile("*.png | *.jpg");
+				if (texture != "")
+				{
+					material->SetRoughness(TextureManager::Get()->GetTexture(texture));
+				}
+			}
+
+			if (ImGui::BeginPopupContextWindow())
+			{
+				if (ImGui::MenuItem("Clear Texture"))
+				{
+					material->m_Roughness = nullptr;
+				}
+				ImGui::EndPopup();
+			}
+		}
+		ImGui::EndChild();
+	}
+}

Editor/src/ComponentsPanel/MaterialEditor.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <src/Core/Core.h>
+#include <src/Rendering/Textures/Material.h>
+
+class MaterialEditor
+{
+public:
+	MaterialEditor() = default;
+	~MaterialEditor() = default;
+
+	void Draw(Ref<Nuake::Material> material);
+};

Editor/src/ComponentsPanel/MeshPanel.h

@@ -4,7 +4,7 @@
 #include "ModelResourceInspector.h"
 
 #include <src/Scene/Entities/ImGuiHelper.h>
-#include <src/Scene/Components/MeshComponent.h>
+#include <src/Scene/Components/ModelComponent.h>
 
 #include <src/Resource/ResourceLoader.h>
 #include <src/Core/String.h>
@@ -21,13 +21,14 @@ public:
 
     void Draw(Nuake::Entity entity) override
     {
-        if (!entity.HasComponent<Nuake::MeshComponent>())
+        using namespace Nuake;
+        if (!entity.HasComponent<ModelComponent>())
             return;
 
-        Nuake::MeshComponent& component = entity.GetComponent<Nuake::MeshComponent>();
-        BeginComponentTable(MESH, Nuake::MeshComponent);
+        ModelComponent& component = entity.GetComponent<ModelComponent>();
+        BeginComponentTable(MESH, ModelComponent);
         {
-            ImGui::Text("Mesh");
+            ImGui::Text("Model");
             ImGui::TableNextColumn();
 
             std::string label = std::to_string(component.ModelResource->ID);

Editor/src/ComponentsPanel/ModelResourceInspector.cpp

@@ -1,5 +1,6 @@
 #include "ModelResourceInspector.h"
 #include <imgui/imgui.h>
+#include "MaterialEditor.h"
 
 ModelResourceInspector::ModelResourceInspector(Ref<Nuake::Model> model)
 {
@@ -8,16 +9,23 @@ ModelResourceInspector::ModelResourceInspector(Ref<Nuake::Model> model)
 
 void ModelResourceInspector::Draw()
 {
-	ImGui::BeginChild("modelInspector",ImVec2(0,0), true);
+	ImGui::BeginChild("modelInspector", ImVec2(0, 0), true);
 	{
 		for (uint32_t i = 0; i < std::size(_model->GetMeshes()); i++)
 		{
 			std::string headerLabel = "Mesh " + std::to_string(i);
 			if (ImGui::CollapsingHeader(headerLabel.c_str()))
 			{
-
+				std::string childId = "materialEditor" + std::to_string(i);
+				ImGui::BeginChild(childId.c_str(), ImVec2(0, 0), false);
+				{
+					MaterialEditor editor;
+					editor.Draw(_model->GetMeshes().at(i)->GetMaterial());
+				}
+				ImGui::EndChild();
 			}
 		}
 	}
+
 	ImGui::EndChild();
 }

Editor/src/Windows/EditorInterface.cpp

@@ -1196,10 +1196,10 @@ namespace Nuake {
                         auto ent = Engine::GetCurrentScene()->CreateEntity("Trenchbroom map");
                         ent.AddComponent<QuakeMapComponent>();
                     }
-                    if (ImGui::MenuItem("Mesh"))
+                    if (ImGui::MenuItem("Model"))
                     {
-                        auto ent = Engine::GetCurrentScene()->CreateEntity("Mesh");
-                        ent.AddComponent<MeshComponent>();
+                        auto ent = Engine::GetCurrentScene()->CreateEntity("Model");
+                        ent.AddComponent<ModelComponent>();
                     }
                     ImGui::EndMenu();
                 }

Editor/src/Windows/EditorSelectionPanel.cpp

@@ -360,7 +360,7 @@ void EditorSelectionPanel::DrawAddComponentMenu(Nuake::Entity entity)
             MenuItemComponent("Wren Script", Nuake::WrenScriptComponent);
             MenuItemComponent("Camera", Nuake::CameraComponent);
             MenuItemComponent("Light", Nuake::LightComponent);
-            MenuItemComponent("Mesh", Nuake::MeshComponent);
+            MenuItemComponent("Model", Nuake::ModelComponent);
             MenuItemComponent("Rigid body", Nuake::RigidBodyComponent);
             MenuItemComponent("Box collider", Nuake::BoxColliderComponent);
             MenuItemComponent("Sphere collider", Nuake::SphereColliderComponent);

Nuake/src/Rendering/SceneRenderer.cpp

@@ -123,7 +123,7 @@ namespace Nuake {
 		RenderCommand::Disable(RendererEnum::FACE_CULL);
 		glCullFace(GL_BACK);
 
-		auto meshView = scene.m_Registry.view<TransformComponent, MeshComponent>();
+		auto meshView = scene.m_Registry.view<TransformComponent, ModelComponent>();
 		auto quakeView = scene.m_Registry.view<TransformComponent, BSPBrushComponent>();
 		auto view = scene.m_Registry.view<TransformComponent, LightComponent>();
 		for (auto l : view)
@@ -142,7 +142,7 @@ namespace Nuake {
 					shader->SetUniformMat4f("u_LightTransform", light.mViewProjections[i]);
 					for (auto e : meshView)
 					{
-						auto [transform, mesh] = meshView.get<TransformComponent, MeshComponent>(e);
+						auto [transform, mesh] = meshView.get<TransformComponent, ModelComponent>(e);
 						if (mesh.ModelResource != nullptr)
 						{
 							for (auto& m : mesh.ModelResource->GetMeshes())
@@ -181,10 +181,10 @@ namespace Nuake {
 			gBufferShader->SetUniformMat4f("u_Projection", mProjection);
 			gBufferShader->SetUniformMat4f("u_View", mView);
 
-			auto view = scene.m_Registry.view<TransformComponent, MeshComponent, ParentComponent>();
+			auto view = scene.m_Registry.view<TransformComponent, ModelComponent, ParentComponent>();
 			for (auto e : view)
 			{
-				auto [transform, mesh, parent] = view.get<TransformComponent, MeshComponent, ParentComponent>(e);
+				auto [transform, mesh, parent] = view.get<TransformComponent, ModelComponent, ParentComponent>(e);
 				
 				if (mesh.ModelResource)
 				{

Nuake/src/Scene/Components/Components.h

@@ -6,7 +6,7 @@
 #include "TransformComponent.h"
 #include "LightComponent.h"
 #include "CameraComponent.h"
-#include "MeshComponent.h"
+#include "ModelComponent.h"
 #include "QuakeMap.h"
 #include "RigidbodyComponent.h"
 #include "SphereCollider.h"

Nuake/src/Scene/Components/ModelComponent.cpp

@@ -1,5 +1,5 @@
 #include "src/Resource/ModelLoader.h"
-#include "MeshComponent.h"
+#include "ModelComponent.h"
 #include "src/Rendering/Mesh/Mesh.h"
 #include "src/Rendering/Textures/TextureManager.h"
 #include "src/Rendering/Textures/Material.h"
@@ -7,12 +7,12 @@
 #include <src/Rendering/Textures/MaterialManager.h>
 
 namespace Nuake {
-    MeshComponent::MeshComponent()
+    ModelComponent::ModelComponent()
     {
 
     }
 
-    void MeshComponent::LoadModel()
+    void ModelComponent::LoadModel()
     {
         auto loader = ModelLoader();
         this->ModelResource = loader.LoadModel(ModelPath);

Nuake/src/Scene/Components/ModelComponent.h

@@ -8,12 +8,12 @@
 
 namespace Nuake
 {
-    struct MeshComponent
+    struct ModelComponent
     {
         Ref<Model> ModelResource;
         std::string ModelPath;
 
-        MeshComponent();
+        ModelComponent();
 
         void LoadModel();
        

Nuake/src/Scene/Entities/Entity.cpp

@@ -9,8 +9,8 @@
 #include "../Components/WrenScriptComponent.h"
 #include "../Components/CharacterControllerComponent.h"
 
+#include "src/Scene/Components/Components.h"
 #include <src/Scene/Components/BoxCollider.h>
-#include <src/Scene/Components/MeshComponent.h>
 
 //#include <src/Scene/Components/BoxCollider.h>
 #include "src/Scene/Components/BSPBrushComponent.h"
@@ -47,8 +47,8 @@ namespace Nuake
 
 		if (HasComponent<BoxColliderComponent>())
 			SERIALIZE_OBJECT_REF_LBL("BoxColliderComponent", GetComponent<BoxColliderComponent>());
-		if (HasComponent<MeshComponent>())
-			SERIALIZE_OBJECT_REF_LBL("MeshComponent", GetComponent<MeshComponent>());
+		if (HasComponent<ModelComponent>())
+			SERIALIZE_OBJECT_REF_LBL("ModelComponent", GetComponent<ModelComponent>());
 		if (HasComponent<BSPBrushComponent>())
 			SERIALIZE_OBJECT_REF_LBL("BSPBrushComponent", GetComponent<BSPBrushComponent>());
 		END_SERIALIZE();
@@ -63,7 +63,7 @@ namespace Nuake
 		DESERIALIZE_COMPONENT(CameraComponent);
 		DESERIALIZE_COMPONENT(QuakeMapComponent);
 		DESERIALIZE_COMPONENT(LightComponent);
-		DESERIALIZE_COMPONENT(MeshComponent);
+		DESERIALIZE_COMPONENT(ModelComponent);
 		DESERIALIZE_COMPONENT(WrenScriptComponent);
 		DESERIALIZE_COMPONENT(CharacterControllerComponent);
 		//DESERIALIZE_COMPONENT(BSPBrushComponent);

Nuake/src/Scene/Scene.cpp

@@ -320,7 +320,7 @@ namespace Nuake {
 		CopyComponent<ParentComponent>(sceneCopy->m_Registry, this->m_Registry);
 		CopyComponent<TransformComponent>(sceneCopy->m_Registry, this->m_Registry);
 		CopyComponent<LightComponent>(sceneCopy->m_Registry, this->m_Registry);
-		CopyComponent<MeshComponent>(sceneCopy->m_Registry, this->m_Registry);
+		CopyComponent<ModelComponent>(sceneCopy->m_Registry, this->m_Registry);
 		CopyComponent<CameraComponent>(sceneCopy->m_Registry, this->m_Registry);
 
 		return sceneCopy;

Nuake/src/Scene/Systems/QuakeMapBuilder.cpp

@@ -23,7 +23,7 @@ extern "C" {
 #include "src/Resource/FGD/FGDClass.h"
 #include "src/Scene/Components/WrenScriptComponent.h"
 #include "src/Scene/Components/PrefabComponent.h"
-#include "src/Scene/Components/MeshComponent.h"
+#include "src/Scene/Components/ModelComponent.h"
 
 #include <vector>
 #include <map>
@@ -609,7 +609,7 @@ namespace Nuake {
                     //bsp.Meshes.push_back(mesh);
                 }
 
-                MeshComponent& modelComponent = brushEntity.AddComponent<MeshComponent>();
+                ModelComponent& modelComponent = brushEntity.AddComponent<ModelComponent>();
                 modelComponent.ModelResource = model;
             }