Merge pull request #20 from adriengivry/feature/actor_picking

Scene actor picking implemented

Author: maxbrundev

Sources/Overload/OvEditor/include/OvEditor/Core/EditorRenderer.h

@@ -38,12 +38,29 @@ namespace OvEditor::Core
 		*/
 		void InitMaterials();
 
+		/**
+		* Prepare the picking material by send it the color corresponding to the given actor
+		* @param p_actor
+		*/
+		void PreparePickingMaterial(OvCore::ECS::Actor& p_actor);
+
+		/**
+		* Calculate the model matrix for a camera attached to the given actor
+		* @param p_actor
+		*/
+		OvMaths::FMatrix4 CalculateCameraModelMatrix(OvCore::ECS::Actor& p_actor);
+
 		/**
 		* Render the scene
 		* @param p_cameraPosition
 		*/
 		void RenderScene(const OvMaths::FVector3& p_cameraPosition);
 
+		/**
+		* Render the scene for actor picking (Unlit version of the scene with colors indicating actor IDs)
+		*/
+		void RenderSceneForActorPicking();
+
 		/**
 		* Render the User Interface
 		*/
@@ -131,5 +148,6 @@ namespace OvEditor::Core
 		OvCore::Resources::Material m_cameraMaterial;
 		OvCore::Resources::Material m_guizmoArrowMaterial;
 		OvCore::Resources::Material m_guizmoBallMaterial;
+		OvCore::Resources::Material m_actorPickingMaterial;
 	};
 }

Sources/Overload/OvEditor/include/OvEditor/Panels/AView.h

@@ -42,16 +42,6 @@ namespace OvEditor::Panels
 		*/
 		virtual void Update(float p_deltaTime);
 
-		/**
-		* Bind the FBO attached to the view
-		*/
-		void Bind();
-
-		/**
-		* Unbind the FBO attached to the view
-		*/
-		void Unbind();
-
 		/**
 		* Custom implementation of the draw method
 		*/
@@ -112,7 +102,6 @@ namespace OvEditor::Panels
 
 		OvMaths::FVector3 m_gridColor = OvMaths::FVector3::One;
 
-	private:
 		OvRendering::Buffers::Framebuffer m_fbo;
 	};
 }

Sources/Overload/OvEditor/include/OvEditor/Panels/SceneView.h

@@ -27,17 +27,23 @@ namespace OvEditor::Panels
 		);
 
 		/**
-		* Update the scene view (Inputs logic)
-		* @param p_deltaTime
+		* Custom implementation of the render method
 		*/
-		virtual void Update(float p_deltaTime) override;
+		virtual void _Render_Impl() override;
 
 		/**
-		* Custom implementation of the render method
+		* Render the actual scene
+		* @param p_defaultRenderState
 		*/
-		virtual void _Render_Impl() override;
+		void RenderScene(uint8_t p_defaultRenderState);
+
+		/**
+		* Render the scene for actor picking and handle the logic behind it
+		*/
+		void HandleActorPicking();
 
 	private:
 		OvCore::SceneSystem::SceneManager& m_sceneManager;
+		OvRendering::Buffers::Framebuffer m_actorPickingFramebuffer;
 	};
 }

Sources/Overload/OvEditor/src/OvEditor/Core/Editor.cpp

@@ -82,8 +82,8 @@ void OvEditor::Core::Editor::PreUpdate()
 void OvEditor::Core::Editor::Update(float p_deltaTime)
 {
 	UpdateCurrentEditorMode(p_deltaTime);
-	UpdateEditorPanels(p_deltaTime);
 	PrepareRendering(p_deltaTime);
+	UpdateEditorPanels(p_deltaTime);
 	RenderViews(p_deltaTime);
 	RenderEditorUI(p_deltaTime);
 	m_editorActions.ExecuteDelayedActions();

Sources/Overload/OvEditor/src/OvEditor/Core/EditorRenderer.cpp

@@ -13,6 +13,8 @@
 #include <OvCore/ECS/Components/CDirectionalLight.h>
 #include <OvCore/ECS/Components/CSpotLight.h>
 
+#include <OvDebug/Utils/Assertion.h>
+
 #include "OvEditor/Core/EditorRenderer.h"
 #include "OvEditor/Core/EditorResources.h"
 #include "OvEditor/Panels/AView.h"
@@ -105,6 +107,32 @@ void OvEditor::Core::EditorRenderer::InitMaterials()
 	m_guizmoBallMaterial.SetShader(m_context.editorResources->GetShader("Guizmo"));
 	m_guizmoBallMaterial.SetShader(m_context.editorResources->GetShader("Guizmo"));
 	m_guizmoBallMaterial.Set("u_IsBall", true);
+
+	/* Picking Material */
+	m_actorPickingMaterial.SetShader(m_context.shaderManager[":Shaders\\Unlit.glsl"]);
+	m_actorPickingMaterial.Set("u_Diffuse", FVector4(1.f, 1.f, 1.f, 1.0f));
+	m_actorPickingMaterial.Set<OvRendering::Resources::Texture*>("u_DiffuseMap", nullptr);
+	m_actorPickingMaterial.SetFrontfaceCulling(false);
+	m_actorPickingMaterial.SetBackfaceCulling(false);
+}
+
+void OvEditor::Core::EditorRenderer::PreparePickingMaterial(OvCore::ECS::Actor& p_actor)
+{
+	uint32_t actorID = static_cast<uint32_t>(p_actor.GetID());
+
+	auto bytes = reinterpret_cast<uint8_t*>(&actorID);
+	auto color = FVector4{ bytes[0] / 255.0f, bytes[1] / 255.0f, bytes[2] / 255.0f, 1.0f };
+
+	m_actorPickingMaterial.Set("u_Diffuse", color);
+}
+
+OvMaths::FMatrix4 OvEditor::Core::EditorRenderer::CalculateCameraModelMatrix(OvCore::ECS::Actor& p_actor)
+{
+	auto translation = FMatrix4::Translation(p_actor.transform.GetWorldPosition());
+	auto rotation = FQuaternion::ToMatrix4(p_actor.transform.GetWorldRotation());
+	auto scale = FMatrix4::Scaling({ 0.4f, 0.4f, 0.4f });
+
+	return translation * rotation * scale;
 }
 
 void OvEditor::Core::EditorRenderer::RenderScene(const OvMaths::FVector3& p_cameraPosition)
@@ -115,6 +143,69 @@ void OvEditor::Core::EditorRenderer::RenderScene(const OvMaths::FVector3& p_came
 	m_context.lightSSBO->Unbind();
 }
 
+void OvEditor::Core::EditorRenderer::RenderSceneForActorPicking()
+{
+	auto& scene = *m_context.sceneManager.GetCurrentScene();
+
+	/* Render models */
+	for (auto modelRenderer : scene.GetFastAccessComponents().modelRenderers)
+	{
+		auto& actor = modelRenderer->owner;
+
+		if (actor.IsActive())
+		{
+			if (auto model = modelRenderer->GetModel())
+			{
+
+				if (auto materialRenderer = modelRenderer->owner.GetComponent<OvCore::ECS::Components::CMaterialRenderer>())
+				{
+					const OvCore::ECS::Components::CMaterialRenderer::MaterialList& materials = materialRenderer->GetMaterials();
+					auto modelMatrix = actor.transform.GetWorldMatrix();
+					PreparePickingMaterial(actor);
+
+					for (auto mesh : model->GetMeshes())
+					{
+						OvCore::Resources::Material* material = nullptr;
+
+						if (mesh->GetMaterialIndex() < MAX_MATERIAL_COUNT)
+						{
+							material = materials.at(mesh->GetMaterialIndex());
+							if (!material || !material->GetShader())
+								material = &m_emptyMaterial;
+						}
+
+						if (material)
+						{
+							m_actorPickingMaterial.SetBackfaceCulling(material->HasBackfaceCulling());
+							m_actorPickingMaterial.SetFrontfaceCulling(material->HasFrontfaceCulling());
+							m_actorPickingMaterial.SetColorWriting(material->HasColorWriting());
+							m_actorPickingMaterial.SetDepthTest(material->HasDepthTest());
+							m_actorPickingMaterial.SetDepthWriting(material->HasDepthWriting());
+
+							m_context.renderer->DrawMesh(*mesh, m_actorPickingMaterial, &modelMatrix);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/* Render cameras */
+	for (auto camera : m_context.sceneManager.GetCurrentScene()->GetFastAccessComponents().cameras)
+	{
+		auto& actor = camera->owner;
+
+		if (actor.IsActive())
+		{
+			PreparePickingMaterial(actor);
+			auto& model = *m_context.editorResources->GetModel("Camera");
+			auto modelMatrix = CalculateCameraModelMatrix(actor);
+
+			m_context.renderer->DrawModelWithSingleMaterial(model, m_actorPickingMaterial, &modelMatrix);
+		}
+	}
+}
+
 void OvEditor::Core::EditorRenderer::RenderUI()
 {
 	m_context.uiManager->Render();
@@ -124,10 +215,14 @@ void OvEditor::Core::EditorRenderer::RenderCameras()
 {
 	for (auto camera : m_context.sceneManager.GetCurrentScene()->GetFastAccessComponents().cameras)
 	{
-		if (camera->owner.IsActive())
+		auto& actor = camera->owner;
+
+		if (actor.IsActive())
 		{
-			auto modelMatrix = FMatrix4::Translation(camera->owner.transform.GetWorldPosition()) * FQuaternion::ToMatrix4(camera->owner.transform.GetWorldRotation()) * FMatrix4::Scaling({ 0.4f, 0.4f, 0.4f });
-			m_context.renderer->DrawModelWithSingleMaterial(*m_context.editorResources->GetModel("Camera"), m_cameraMaterial, &modelMatrix);
+			auto& model = *m_context.editorResources->GetModel("Camera");
+			auto modelMatrix = CalculateCameraModelMatrix(actor);
+			
+			m_context.renderer->DrawModelWithSingleMaterial(model, m_cameraMaterial, &modelMatrix);
 		}
 	}
 }

Sources/Overload/OvEditor/src/OvEditor/Panels/AView.cpp

@@ -25,29 +25,11 @@ OvEditor::Panels::AView::AView
 
 void OvEditor::Panels::AView::Update(float p_deltaTime)
 {
-	Bind();
-
 	auto[winWidth, winHeight] = GetSafeSize();
 
 	m_image->size = OvMaths::FVector2(static_cast<float>(winWidth), static_cast<float>(winHeight));
 
 	m_fbo.Resize(winWidth, winHeight);
-
-	Unbind();
-}
-
-void OvEditor::Panels::AView::Bind()
-{
-	auto[winWidth, winHeight] = GetSafeSize();
-
-	glViewport(0, 0, winWidth, winHeight);
-
-	m_fbo.Bind();
-}
-
-void OvEditor::Panels::AView::Unbind()
-{
-	m_fbo.Unbind();
 }
 
 void OvEditor::Panels::AView::_Draw_Impl()
@@ -67,10 +49,9 @@ void OvEditor::Panels::AView::Render()
 	auto projection = m_camera.GetProjectionMatrix(winWidth, winHeight);
 	auto view = m_camera.GetViewMatrix(m_cameraPosition);
 	EDITOR_CONTEXT(shapeDrawer)->SetViewProjection(projection * view);
+	glViewport(0, 0, winWidth, winHeight); // TODO: Move this OpenGL call to OvRendering
 
-	Bind();
 	_Render_Impl();
-	Unbind();
 }
 
 void OvEditor::Panels::AView::SetCameraPosition(const OvMaths::FVector3 & p_position)

Sources/Overload/OvEditor/src/OvEditor/Panels/AssetView.cpp

@@ -49,6 +49,8 @@ void OvEditor::Panels::AssetView::_Render_Impl()
 {
 	auto& baseRenderer = *EDITOR_CONTEXT(renderer).get();
 
+	m_fbo.Bind();
+
 	baseRenderer.SetStencilMask(0xFF);
 	baseRenderer.Clear(m_camera);
 	baseRenderer.SetStencilMask(0x00);
@@ -68,6 +70,8 @@ void OvEditor::Panels::AssetView::_Render_Impl()
 		m_editorRenderer.RenderMaterialAsset(**pval);
 
 	baseRenderer.ApplyStateMask(glState);
+
+	m_fbo.Unbind();
 }
 
 void OvEditor::Panels::AssetView::SetResource(ViewableResource p_resource)

Sources/Overload/OvEditor/src/OvEditor/Panels/GameView.cpp

@@ -45,6 +45,8 @@ void OvEditor::Panels::GameView::Update(float p_deltaTime)
 void OvEditor::Panels::GameView::_Render_Impl()
 {
 	auto& baseRenderer = *EDITOR_CONTEXT(renderer).get();
+	
+	m_fbo.Bind();
 
 	baseRenderer.Clear(m_camera);
 
@@ -54,5 +56,8 @@ void OvEditor::Panels::GameView::_Render_Impl()
 	if (m_hasCamera)
 		m_editorRenderer.RenderScene(m_cameraPosition);
 
+
 	baseRenderer.ApplyStateMask(glState);
+
+	m_fbo.Unbind();
 }