Merge pull request #51 from adriengivry/feature/light_3d_icons

Light 3D icons has been added to the scene view

Author: BenjaminViranin

Diff for: 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;

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

Diff for: Sources/Overload/OvEditor/include/OvEditor/Resources/RawShaders.h

@@ -77,6 +77,7 @@ 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 };
 		inline static Property<float> TranslationSnapUnit = { 1.0f };
 		inline static Property<float> RotationSnapUnit = { 15.0f };
 		inline static Property<float> ScalingSnapUnit = { 1.0f };

Diff for: 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;

Diff for: 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 */
 	{

Diff for: 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/Drags/DragFloat.h>
 #include <OvUI/Widgets/Selection/ColorEdit.h>
 
@@ -201,6 +202,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& snappingMenu = settingsMenu.CreateWidget<MenuList>("Snapping");
 	snappingMenu.CreateWidget<Drags::DragFloat>(0.001f, 999999.0f, Settings::EditorSettings::TranslationSnapUnit, 0.05f, "Translation Unit").ValueChangedEvent += [this](float p_value) { Settings::EditorSettings::TranslationSnapUnit = p_value; };
 	snappingMenu.CreateWidget<Drags::DragFloat>(0.001f, 999999.0f, Settings::EditorSettings::RotationSnapUnit, 1.0f, "Rotation Unit").ValueChangedEvent += [this](float p_value) { Settings::EditorSettings::RotationSnapUnit = p_value; };

Diff for: 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());

Diff for: 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;
+}