Light 3D icons has been added to the scene view

Some texture has been added to the RawTexture.h file and are now
registered has editor resources. These texture are drawn as billboard
(Billboard raw shader has been added to the editor). We also render
lights as non-textured plane for actor picking using the color matching
with the actor ID as the diffuse.

Author: Adrien GIVRY

Resources/Editor/Models/Vertical_Plane.fbx

@@ -42,8 +42,9 @@ namespace OvEditor::Core
 		/**
 		* Prepare the picking material by send it the color corresponding to the given actor
 		* @param p_actor
+		* @param p_material
 		*/
-		void PreparePickingMaterial(OvCore::ECS::Actor& p_actor);
+		void PreparePickingMaterial(OvCore::ECS::Actor& p_actor, OvCore::Resources::Material& p_material);
 
 		/**
 		* Calculate the model matrix for a camera attached to the given actor
@@ -73,6 +74,11 @@ namespace OvEditor::Core
 		*/
 		void RenderCameras();
 
+		/**
+		* Render every scene lights as billboards
+		*/
+		void RenderLights();
+
 		/**
 		* Render a gizmo at position
 		* @param p_position
@@ -171,6 +177,7 @@ namespace OvEditor::Core
 		OvCore::Resources::Material m_emptyMaterial;
 		OvCore::Resources::Material m_defaultMaterial;
 		OvCore::Resources::Material m_cameraMaterial;
+		OvCore::Resources::Material m_lightMaterial;
 		OvCore::Resources::Material m_gizmoArrowMaterial;
 		OvCore::Resources::Material m_gizmoBallMaterial;
 		OvCore::Resources::Material m_gizmoPickingMaterial;

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

@@ -25,5 +25,10 @@ namespace OvEditor::Resources
 		* Returns the gizmo shader
 		*/
 		static std::pair<std::string, std::string> GetGizmo();
+
+		/**
+		* Returns the billboard shader
+		*/
+		static std::pair<std::string, std::string> GetBillboard();
 	};
 }

Sources/Overload/OvEditor/include/OvEditor/Resources/RawShaders.h

@@ -77,5 +77,6 @@ namespace OvEditor::Settings
 		inline static Property<bool> ShowLightBounds = { false };
 		inline static Property<bool> ShowGeometryFrustumCullingInSceneView = { false };
 		inline static Property<bool> ShowLightFrustumCullingInSceneView = { false };
+		inline static Property<float> LightBillboardScale = { 0.5f };
 	};
 }

Sources/Overload/OvEditor/include/OvEditor/Resources/RawTextures.h

@@ -88,6 +88,13 @@ void OvEditor::Core::EditorRenderer::InitMaterials()
 	m_cameraMaterial.Set("u_Diffuse", FVector4(0.0f, 0.3f, 0.7f, 1.0f));
 	m_cameraMaterial.Set<OvRendering::Resources::Texture*>("u_DiffuseMap", nullptr);
 
+	/* Light Material */
+	m_lightMaterial.SetShader(m_context.editorResources->GetShader("Billboard"));
+	m_lightMaterial.Set("u_Diffuse", FVector4(1.f, 1.f, 0.5f, 0.5f));
+	m_lightMaterial.SetBackfaceCulling(false);
+	m_lightMaterial.SetBlendable(true);
+	m_lightMaterial.SetDepthTest(false);
+
 	/* Stencil Fill Material */
 	m_stencilFillMaterial.SetShader(m_context.shaderManager[":Shaders\\Unlit.glsl"]);
 	m_stencilFillMaterial.SetBackfaceCulling(true);
@@ -133,14 +140,14 @@ void OvEditor::Core::EditorRenderer::InitMaterials()
 	m_actorPickingMaterial.SetBackfaceCulling(false);
 }
 
-void OvEditor::Core::EditorRenderer::PreparePickingMaterial(OvCore::ECS::Actor& p_actor)
+void OvEditor::Core::EditorRenderer::PreparePickingMaterial(OvCore::ECS::Actor& p_actor, OvCore::Resources::Material& p_material)
 {
 	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);
+	p_material.Set("u_Diffuse", color);
 }
 
 OvMaths::FMatrix4 OvEditor::Core::EditorRenderer::CalculateCameraModelMatrix(OvCore::ECS::Actor& p_actor)
@@ -178,7 +185,7 @@ void OvEditor::Core::EditorRenderer::RenderSceneForActorPicking()
 					const OvCore::ECS::Components::CMaterialRenderer::MaterialList& materials = materialRenderer->GetMaterials();
 					const auto& modelMatrix = actor.transform.GetWorldMatrix();
 
-					PreparePickingMaterial(actor);
+					PreparePickingMaterial(actor, m_actorPickingMaterial);
 
 					for (auto mesh : model->GetMeshes())
 					{
@@ -214,13 +221,36 @@ void OvEditor::Core::EditorRenderer::RenderSceneForActorPicking()
 
 		if (actor.IsActive())
 		{
-			PreparePickingMaterial(actor);
+			PreparePickingMaterial(actor, m_actorPickingMaterial);
 			auto& model = *m_context.editorResources->GetModel("Camera");
 			auto modelMatrix = CalculateCameraModelMatrix(actor);
 
 			m_context.renderer->DrawModelWithSingleMaterial(model, m_actorPickingMaterial, &modelMatrix);
 		}
 	}
+
+	/* Render lights */
+	if (Settings::EditorSettings::LightBillboardScale > 0.001f)
+	{
+		m_context.renderer->Clear(false, true, false);
+
+		m_lightMaterial.SetDepthTest(true);
+		m_lightMaterial.Set<float>("u_Scale", Settings::EditorSettings::LightBillboardScale * 0.1f);
+		m_lightMaterial.Set<OvRendering::Resources::Texture*>("u_DiffuseMap", nullptr);
+
+		for (auto light : m_context.sceneManager.GetCurrentScene()->GetFastAccessComponents().lights)
+		{
+			auto& actor = light->owner;
+
+			if (actor.IsActive())
+			{
+				PreparePickingMaterial(actor, m_lightMaterial);
+				auto& model = *m_context.editorResources->GetModel("Vertical_Plane");
+				auto modelMatrix = FMatrix4::Translation(actor.transform.GetWorldPosition());
+				m_context.renderer->DrawModelWithSingleMaterial(model, m_lightMaterial, &modelMatrix);
+			}
+		}
+	}
 }
 
 void OvEditor::Core::EditorRenderer::RenderUI()
@@ -246,6 +276,41 @@ void OvEditor::Core::EditorRenderer::RenderCameras()
 	}
 }
 
+void OvEditor::Core::EditorRenderer::RenderLights()
+{
+	using namespace OvMaths;
+
+	m_lightMaterial.SetDepthTest(false);
+	m_lightMaterial.Set<float>("u_Scale", Settings::EditorSettings::LightBillboardScale * 0.1f);
+
+	for (auto light : m_context.sceneManager.GetCurrentScene()->GetFastAccessComponents().lights)
+	{
+		auto& actor = light->owner;
+
+		if (actor.IsActive())
+		{
+			auto& model = *m_context.editorResources->GetModel("Vertical_Plane");
+			auto modelMatrix = FMatrix4::Translation(actor.transform.GetWorldPosition());
+
+			OvRendering::Resources::Texture* texture = nullptr;
+
+			switch (static_cast<OvRendering::Entities::Light::Type>(static_cast<int>(light->GetData().type)))
+			{
+			case OvRendering::Entities::Light::Type::POINT:				texture = m_context.editorResources->GetTexture("Bill_Point_Light");			break;
+			case OvRendering::Entities::Light::Type::SPOT:				texture = m_context.editorResources->GetTexture("Bill_Spot_Light");				break;
+			case OvRendering::Entities::Light::Type::DIRECTIONAL:		texture = m_context.editorResources->GetTexture("Bill_Directional_Light");		break;
+			case OvRendering::Entities::Light::Type::AMBIENT_BOX:		texture = m_context.editorResources->GetTexture("Bill_Ambient_Box_Light");		break;
+			case OvRendering::Entities::Light::Type::AMBIENT_SPHERE:	texture = m_context.editorResources->GetTexture("Bill_Ambient_Sphere_Light");	break;
+			}
+
+			const auto& lightColor = light->GetColor();
+			m_lightMaterial.Set<OvRendering::Resources::Texture*>("u_DiffuseMap", texture);
+			m_lightMaterial.Set<OvMaths::FVector4>("u_Diffuse", OvMaths::FVector4(lightColor.x, lightColor.y, lightColor.z, 0.75f));
+			m_context.renderer->DrawModelWithSingleMaterial(model, m_lightMaterial, &modelMatrix);
+		}
+	}
+}
+
 void OvEditor::Core::EditorRenderer::RenderGizmo(const OvMaths::FVector3& p_position, const OvMaths::FQuaternion& p_rotation, OvEditor::Core::EGizmoOperation p_operation, bool p_pickable)
 {
 	using namespace OvMaths;

Sources/Overload/OvEditor/include/OvEditor/Settings/EditorSettings.h

@@ -41,6 +41,9 @@ OvEditor::Core::EditorResources::EditorResources(const std::string& p_editorAsse
 	OvRendering::Settings::ETextureFilteringMode firstFilterEditor = OvRendering::Settings::ETextureFilteringMode::LINEAR;
 	OvRendering::Settings::ETextureFilteringMode secondFilterEditor = OvRendering::Settings::ETextureFilteringMode::LINEAR;
 
+	OvRendering::Settings::ETextureFilteringMode firstFilterBillboard = OvRendering::Settings::ETextureFilteringMode::NEAREST;
+	OvRendering::Settings::ETextureFilteringMode secondFilterBillboard = OvRendering::Settings::ETextureFilteringMode::NEAREST;
+
 	/* Buttons */
 
 	{
@@ -119,10 +122,36 @@ OvEditor::Core::EditorResources::EditorResources(const std::string& p_editorAsse
 		m_textures["Icon_Font"] = TextureLoader::CreateFromMemory(reinterpret_cast<uint8_t*>(raw.data()), 16, 16, firstFilterEditor, secondFilterEditor, false);
 	}
 
+	{
+		std::vector<uint64_t> raw = BILL_PLIGHT;
+		m_textures["Bill_Point_Light"] = TextureLoader::CreateFromMemory(reinterpret_cast<uint8_t*>(raw.data()), 128, 128, firstFilterBillboard, secondFilterBillboard, false);
+	}
+
+	{
+		std::vector<uint64_t> raw = BILL_SLIGHT;
+		m_textures["Bill_Spot_Light"] = TextureLoader::CreateFromMemory(reinterpret_cast<uint8_t*>(raw.data()), 128, 128, firstFilterBillboard, secondFilterBillboard, false);
+	}
+
+	{
+		std::vector<uint64_t> raw = BILL_DLIGHT;
+		m_textures["Bill_Directional_Light"] = TextureLoader::CreateFromMemory(reinterpret_cast<uint8_t*>(raw.data()), 128, 128, firstFilterBillboard, secondFilterBillboard, false);
+	}
+
+	{
+		std::vector<uint64_t> raw = BILL_ABLIGHT;
+		m_textures["Bill_Ambient_Box_Light"] = TextureLoader::CreateFromMemory(reinterpret_cast<uint8_t*>(raw.data()), 128, 128, firstFilterBillboard, secondFilterBillboard, false);
+	}
+
+	{
+		std::vector<uint64_t> raw = BILL_ASLIGHT;
+		m_textures["Bill_Ambient_Sphere_Light"] = TextureLoader::CreateFromMemory(reinterpret_cast<uint8_t*>(raw.data()), 128, 128, firstFilterBillboard, secondFilterBillboard, false);
+	}
+
 	/* Models */
 	m_models["Cube"]			= ModelLoader::Create(modelsFolder + "Cube.fbx", modelParserFlags);
 	m_models["Cylinder"]		= ModelLoader::Create(modelsFolder + "Cylinder.fbx", modelParserFlags);
 	m_models["Plane"]			= ModelLoader::Create(modelsFolder + "Plane.fbx", modelParserFlags);
+	m_models["Vertical_Plane"]	= ModelLoader::Create(modelsFolder + "Vertical_Plane.fbx", modelParserFlags);
 	m_models["Roll"]			= ModelLoader::Create(modelsFolder + "Roll.fbx", modelParserFlags);
 	m_models["Sphere"]			= ModelLoader::Create(modelsFolder + "Sphere.fbx", modelParserFlags);
 	m_models["Arrow_Translate"]	= ModelLoader::Create(modelsFolder + "Arrow_Translate.fbx", modelParserFlags);
@@ -131,10 +160,12 @@ OvEditor::Core::EditorResources::EditorResources(const std::string& p_editorAsse
 	m_models["Camera"]			= ModelLoader::Create(modelsFolder + "Camera.fbx", modelParserFlags);
 
 	/* Shaders */
-	auto gridSource		= OvEditor::Resources::RawShaders::GetGrid();
-	auto gizmoSource	= OvEditor::Resources::RawShaders::GetGizmo();
+	auto gridSource			= OvEditor::Resources::RawShaders::GetGrid();
+	auto gizmoSource		= OvEditor::Resources::RawShaders::GetGizmo();
+	auto billboardSource	= OvEditor::Resources::RawShaders::GetBillboard();
 	m_shaders["Grid"]		= ShaderLoader::CreateFromSource(gridSource.first, gridSource.second);
 	m_shaders["Gizmo"]		= ShaderLoader::CreateFromSource(gizmoSource.first, gizmoSource.second);
+	m_shaders["Billboard"]	= ShaderLoader::CreateFromSource(billboardSource.first, billboardSource.second);
 
 	/* From memory */
 	{

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

@@ -20,6 +20,7 @@
 
 #include <OvUI/Widgets/Visual/Separator.h>
 #include <OvUI/Widgets/Sliders/SliderInt.h>
+#include <OvUI/Widgets/Sliders/SliderFloat.h>
 #include <OvUI/Widgets/Selection/ColorEdit.h>
 
 #include "OvEditor/Panels/MenuBar.h"
@@ -200,6 +201,11 @@ void OvEditor::Panels::MenuBar::CreateSettingsMenu()
 		assetViewGridPicker.color = OvUI::Types::Color::White;
 	};
 
+	auto& sceneViewBillboardScaleMenu = settingsMenu.CreateWidget<MenuList>("3D Icons Scales");
+	auto& lightBillboardScaleSlider = sceneViewBillboardScaleMenu.CreateWidget<Sliders::SliderInt>(0, 100, static_cast<int>(Settings::EditorSettings::LightBillboardScale * 100.0f), OvUI::Widgets::Sliders::ESliderOrientation::HORIZONTAL, "Lights");
+	lightBillboardScaleSlider.ValueChangedEvent += [this](int p_value) { Settings::EditorSettings::LightBillboardScale = p_value / 100.0f; };
+	lightBillboardScaleSlider.format = "%d %%";
+
 	auto& debuggingMenu = settingsMenu.CreateWidget<MenuList>("Debugging");
 	debuggingMenu.CreateWidget<MenuItem>("Show geometry bounds", "", true, Settings::EditorSettings::ShowGeometryBounds).ValueChangedEvent += [this](bool p_value) { Settings::EditorSettings::ShowGeometryBounds = p_value; };
 	debuggingMenu.CreateWidget<MenuItem>("Show lights bounds", "", true, Settings::EditorSettings::ShowLightBounds).ValueChangedEvent += [this](bool p_value) { Settings::EditorSettings::ShowLightBounds = p_value; };

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

@@ -112,6 +112,8 @@ void OvEditor::Panels::SceneView::RenderScene(uint8_t p_defaultRenderState)
 		m_editorRenderer.RenderScene(m_cameraPosition, m_camera);
 	}
 
+	m_editorRenderer.RenderLights();
+
 	if (EDITOR_EXEC(IsAnyActorSelected()))
 	{
 		auto& selectedActor = EDITOR_EXEC(GetSelectedActor());

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

@@ -227,4 +227,81 @@ void main()
 })";
 
 	return source;
-}
+}
+
+std::pair<std::string, std::string> OvEditor::Resources::RawShaders::GetBillboard()
+{
+	std::pair<std::string, std::string> source;
+
+	source.first = R"(
+#version 460 core
+
+layout (location = 0) in vec3 geo_Pos;
+layout (location = 1) in vec2 geo_TexCoords;
+layout (location = 2) in vec3 geo_Normal;
+
+layout (std140) uniform EngineUBO
+{
+    mat4    ubo_Model;
+    mat4    ubo_View;
+    mat4    ubo_Projection;
+    vec3    ubo_ViewPos;
+    float   ubo_Time;
+};
+
+out VS_OUT
+{
+    vec2 TexCoords;
+} vs_out;
+
+uniform float u_Scale = 1.0f;
+
+void main()
+{
+    vs_out.TexCoords = geo_TexCoords;
+
+    mat4 model = ubo_Model;
+	float distanceToCamera = distance(ubo_ViewPos, model[3].xyz);
+
+    mat4 modelView = ubo_View * model;
+
+    // Column 0:
+    modelView[0][0] = 1;
+    modelView[0][1] = 0;
+    modelView[0][2] = 0;
+
+    // Column 1:
+    modelView[1][0] = 0;
+    modelView[1][1] = 1;
+    modelView[1][2] = 0;
+
+    // Column 2:
+    modelView[2][0] = 0;
+    modelView[2][1] = 0;
+    modelView[2][2] = 1;
+
+    gl_Position = ubo_Projection * modelView * vec4(geo_Pos * distanceToCamera * u_Scale, 1.0);
+})";
+
+	source.second = R"(
+#version 460 core
+
+out vec4 FRAGMENT_COLOR;
+
+in VS_OUT
+{
+    vec2 TexCoords;
+} fs_in;
+
+uniform vec4        u_Diffuse = vec4(1.0, 1.0, 1.0, 1.0);
+uniform sampler2D   u_DiffuseMap;
+uniform vec2        u_TextureTiling = vec2(1.0, 1.0);
+uniform vec2        u_TextureOffset = vec2(0.0, 0.0);
+
+void main()
+{
+    FRAGMENT_COLOR = texture(u_DiffuseMap, u_TextureOffset + vec2(mod(fs_in.TexCoords.x * u_TextureTiling.x, 1), mod(fs_in.TexCoords.y * u_TextureTiling.y, 1))) * u_Diffuse;
+})";
+
+	return source;
+}