Scene actor picking implemented

The current system only consider models and camera (Only pickable
elements). As it is render based, we can't pick colliders and lights for
now. We can add billboard later. The current system is limited to 255 *
255 * 255 - 1 actors (16,581,374 actors) due to the fact that our
framebuffer elements are 24 bits (3 * color components).

Author: Adrien GIVRY

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();
 }