Merge branch 'develop' into feature/light_3d_icons

Author: Adrien GIVRY

Diff for: Sources/Overload/OvEditor/include/OvEditor/Core/GizmoBehaviour.h

@@ -27,6 +27,11 @@ namespace OvEditor::Core
 			Y,
 			Z
 		};
+		
+		/**
+		* Returns true if the snapping behaviour is enabled
+		*/
+		bool IsSnappedBehaviourEnabled() const;
 
 		/**
 		* Starts the gizmo picking behaviour for the given target in the given direction

Diff for: Sources/Overload/OvEditor/include/OvEditor/Settings/EditorSettings.h

@@ -78,5 +78,8 @@ namespace OvEditor::Settings
 		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/src/OvEditor/Core/CameraController.cpp

@@ -35,7 +35,7 @@ OvEditor::Core::CameraController::CameraController
 
 float GetActorFocusDist(OvCore::ECS::Actor& p_actor)
 {
-	float distance = 5.0f;
+	float distance = 4.0f;
 
 	if (p_actor.IsActive())
 	{
@@ -80,33 +80,14 @@ float GetActorFocusDist(OvCore::ECS::Actor& p_actor)
 
 		if (auto modelRenderer = p_actor.GetComponent<OvCore::ECS::Components::CModelRenderer>())
 		{
-			distance = std::max(distance, 10.0f);
-		}
-
-		if (auto ambientBoxLight = p_actor.GetComponent<OvCore::ECS::Components::CAmbientBoxLight>())
-		{
-			distance = std::max(distance, std::max
-			(
-				std::max
-				(
-					ambientBoxLight->GetSize().x,
-					ambientBoxLight->GetSize().y
-				),
-				ambientBoxLight->GetSize().z
-			) * 1.5f);
-		}
-
-		if (auto ambientSphereLight = p_actor.GetComponent<OvCore::ECS::Components::CAmbientSphereLight>())
-		{
-			distance = std::max(distance, std::max
-			(
-				std::max
-				(
-					ambientSphereLight->GetRadius(),
-					ambientSphereLight->GetRadius()
-				),
-				ambientSphereLight->GetRadius()
-			) * 1.5f);
+			const bool hasCustomBoundingSphere = modelRenderer->GetFrustumBehaviour() == OvCore::ECS::Components::CModelRenderer::EFrustumBehaviour::CULL_CUSTOM;
+			const bool hasModel = modelRenderer->GetModel();
+			const auto boundingSphere = hasCustomBoundingSphere ? &modelRenderer->GetCustomBoundingSphere() : hasModel ? &modelRenderer->GetModel()->GetBoundingSphere() : nullptr;
+			const auto& actorPosition = p_actor.transform.GetWorldPosition();
+			const auto& actorScale = p_actor.transform.GetWorldScale();
+			const auto scaleFactor = std::max(std::max(actorScale.x, actorScale.y), actorScale.z);
+
+			distance = std::max(distance, boundingSphere ? (boundingSphere->radius + OvMaths::FVector3::Length(boundingSphere->position)) * scaleFactor * 2.0f : 10.0f);
 		}
 
 		for (auto child : p_actor.GetChildren())

Diff for: Sources/Overload/OvEditor/src/OvEditor/Core/GizmoBehaviour.cpp

@@ -5,6 +5,20 @@
 */
 
 #include "OvEditor/Core/GizmoBehaviour.h"
+#include "OvEditor/Settings/EditorSettings.h"
+
+float SnapValue(float p_value, float p_step)
+{
+	return p_value - std::fmod(p_value, p_step);
+}
+
+bool OvEditor::Core::GizmoBehaviour::IsSnappedBehaviourEnabled() const
+{
+	using namespace OvWindowing::Inputs;
+
+	const auto& inputManager = EDITOR_CONTEXT(inputManager);
+	return inputManager->GetKeyState(EKey::KEY_LEFT_CONTROL) == EKeyState::KEY_DOWN || inputManager->GetKeyState(EKey::KEY_RIGHT_CONTROL) == EKeyState::KEY_DOWN;
+}
 
 void OvEditor::Core::GizmoBehaviour::StartPicking(OvCore::ECS::Actor& p_target, const OvMaths::FVector3& p_cameraPosition, EGizmoOperation p_operation, EDirection p_direction)
 {
@@ -101,9 +115,14 @@ void OvEditor::Core::GizmoBehaviour::ApplyTranslation(const OvMaths::FMatrix4& p
 	auto screenDirection = GetScreenDirection(p_viewMatrix, p_projectionMatrix, p_viewSize);
 
 	auto totalDisplacement = m_currentMouse - m_originMouse;
-	auto translationCoefficient = OvMaths::FVector2::Dot(totalDisplacement, screenDirection);
+	auto translationCoefficient = OvMaths::FVector2::Dot(totalDisplacement, screenDirection) * unitsPerPixel;
+
+	if (IsSnappedBehaviourEnabled())
+	{
+		translationCoefficient = SnapValue(translationCoefficient, OvEditor::Settings::EditorSettings::TranslationSnapUnit);
+	}
 
-	m_target->transform.SetLocalPosition(originPosition + GetRealDirection() * translationCoefficient * unitsPerPixel);
+	m_target->transform.SetLocalPosition(originPosition + GetRealDirection() * translationCoefficient);
 }
 
 void OvEditor::Core::GizmoBehaviour::ApplyRotation(const OvMaths::FMatrix4& p_viewMatrix, const OvMaths::FMatrix4& p_projectionMatrix, const OvMaths::FVector2& p_viewSize) const
@@ -115,9 +134,14 @@ void OvEditor::Core::GizmoBehaviour::ApplyRotation(const OvMaths::FMatrix4& p_vi
 	screenDirection = OvMaths::FVector2(-screenDirection.y, screenDirection.x);
 
 	auto totalDisplacement = m_currentMouse - m_originMouse;
-	auto rotationCoefficient = OvMaths::FVector2::Dot(totalDisplacement, screenDirection);
+	auto rotationCoefficient = OvMaths::FVector2::Dot(totalDisplacement, screenDirection) * unitsPerPixel;
+
+	if (IsSnappedBehaviourEnabled())
+	{
+		rotationCoefficient = SnapValue(rotationCoefficient, OvEditor::Settings::EditorSettings::RotationSnapUnit);
+	}
 
-	auto rotationToApply = OvMaths::FQuaternion(OvMaths::FVector3(GetFakeDirection() * rotationCoefficient * unitsPerPixel));
+	auto rotationToApply = OvMaths::FQuaternion(OvMaths::FVector3(GetFakeDirection() * rotationCoefficient));
 	m_target->transform.SetLocalRotation(originRotation * rotationToApply);
 }
 
@@ -129,9 +153,14 @@ void OvEditor::Core::GizmoBehaviour::ApplyScale(const OvMaths::FMatrix4& p_viewM
 	auto screenDirection = GetScreenDirection(p_viewMatrix, p_projectionMatrix, p_viewSize);
 
 	auto totalDisplacement = m_currentMouse - m_originMouse;
-	auto scaleCoefficient = OvMaths::FVector2::Dot(totalDisplacement, screenDirection);
+	auto scaleCoefficient = OvMaths::FVector2::Dot(totalDisplacement, screenDirection) * unitsPerPixel;
+
+	if (IsSnappedBehaviourEnabled())
+	{
+		scaleCoefficient = SnapValue(scaleCoefficient, OvEditor::Settings::EditorSettings::ScalingSnapUnit);
+	}
 
-	auto newScale = originScale + GetFakeDirection() * scaleCoefficient * unitsPerPixel;
+	auto newScale = originScale + GetFakeDirection() * scaleCoefficient;
 
 	/* Prevent scale from being negative*/
 	newScale.x = std::max(newScale.x, 0.0001f);

Diff for: Sources/Overload/OvEditor/src/OvEditor/Panels/Hierarchy.cpp

@@ -174,13 +174,90 @@ class HierarchyActorContextualMenu : public OvUI::Plugins::ContextualMenu
 	OvUI::Widgets::Layout::TreeNode& m_treeNode;
 };
 
+void ExpandTreeNode(OvUI::Widgets::Layout::TreeNode& p_toExpand, const OvUI::Widgets::Layout::TreeNode* p_root)
+{
+	p_toExpand.Open();
+
+	if (&p_toExpand != p_root && p_toExpand.HasParent())
+	{
+		ExpandTreeNode(*static_cast<OvUI::Widgets::Layout::TreeNode*>(p_toExpand.GetParent()), p_root);
+	}
+}
+
+std::vector<OvUI::Widgets::Layout::TreeNode*> nodesToCollapse;
+std::vector<OvUI::Widgets::Layout::TreeNode*> founds;
+
+void ExpandTreeNodeAndEnable(OvUI::Widgets::Layout::TreeNode& p_toExpand, const OvUI::Widgets::Layout::TreeNode* p_root)
+{
+	if (!p_toExpand.IsOpened())
+	{
+		p_toExpand.Open();
+		nodesToCollapse.push_back(&p_toExpand);
+	}
+
+	p_toExpand.enabled = true;
+
+	if (&p_toExpand != p_root && p_toExpand.HasParent())
+	{
+		ExpandTreeNodeAndEnable(*static_cast<OvUI::Widgets::Layout::TreeNode*>(p_toExpand.GetParent()), p_root);
+	}
+}
+
 OvEditor::Panels::Hierarchy::Hierarchy
 (
 	const std::string & p_title,
 	bool p_opened,
 	const OvUI::Settings::PanelWindowSettings& p_windowSettings
 ) : PanelWindow(p_title, p_opened, p_windowSettings)
 {
+	auto& searchBar = CreateWidget<OvUI::Widgets::InputFields::InputText>();
+	searchBar.ContentChangedEvent += [this](const std::string& p_content)
+	{
+		founds.clear();
+		auto content = p_content;
+		std::transform(content.begin(), content.end(), content.begin(), ::tolower);
+
+		for (auto& [actor, item] : m_widgetActorLink)
+		{
+			if (!p_content.empty())
+			{
+				auto itemName = item->name;
+				std::transform(itemName.begin(), itemName.end(), itemName.begin(), ::tolower);
+
+				if (itemName.find(content) != std::string::npos)
+				{
+					founds.push_back(item);
+				}
+
+				item->enabled = false;
+			}
+			else
+			{
+				item->enabled = true;
+			}
+		}
+
+		for (auto node : founds)
+		{
+			node->enabled = true;
+
+			if (node->HasParent())
+			{
+				ExpandTreeNodeAndEnable(*static_cast<OvUI::Widgets::Layout::TreeNode*>(node->GetParent()), m_sceneRoot);
+			}
+		}
+
+		if (p_content.empty())
+		{
+			for (auto node : nodesToCollapse)
+			{
+				node->Close();
+			}
+
+			nodesToCollapse.clear();
+		}
+	};
+
 	m_sceneRoot = &CreateWidget<OvUI::Widgets::Layout::TreeNode>("Root", true);
 	static_cast<OvUI::Widgets::Layout::TreeNode*>(m_sceneRoot)->Open();
 	m_sceneRoot->AddPlugin<OvUI::Plugins::DDTarget<std::pair<OvCore::ECS::Actor*, OvUI::Widgets::Layout::TreeNode*>>>("Actor").DataReceivedEvent += [this](std::pair<OvCore::ECS::Actor*, OvUI::Widgets::Layout::TreeNode*> p_element)
@@ -223,16 +300,6 @@ void OvEditor::Panels::Hierarchy::SelectActorByInstance(OvCore::ECS::Actor& p_ac
 			SelectActorByWidget(*result->second);
 }
 
-void ExpandTreeNode(OvUI::Widgets::Layout::TreeNode& p_toExpand, const OvUI::Widgets::Layout::TreeNode* p_root)
-{
-	p_toExpand.Open();
-
-	if (&p_toExpand != p_root && p_toExpand.HasParent())
-	{
-		ExpandTreeNode(*static_cast<OvUI::Widgets::Layout::TreeNode*>(p_toExpand.GetParent()), p_root);
-	}
-}
-
 void OvEditor::Panels::Hierarchy::SelectActorByWidget(OvUI::Widgets::Layout::TreeNode & p_widget)
 {
 	UnselectActorsWidgets();
@@ -267,15 +334,14 @@ void OvEditor::Panels::Hierarchy::AttachActorToParent(OvCore::ECS::Actor & p_act
 
 void OvEditor::Panels::Hierarchy::DetachFromParent(OvCore::ECS::Actor & p_actor)
 {
-	auto actorWidget = m_widgetActorLink.find(&p_actor);
-
-	if (actorWidget != m_widgetActorLink.end())
+	if (auto actorWidget = m_widgetActorLink.find(&p_actor); actorWidget != m_widgetActorLink.end())
 	{
 		if (p_actor.HasParent() && p_actor.GetParent()->GetChildren().size() == 1)
 		{
-			auto parentWidget = m_widgetActorLink.at(p_actor.GetParent());
-			if (parentWidget)
-				parentWidget->leaf = true;
+			if (auto parentWidget = m_widgetActorLink.find(p_actor.GetParent()); parentWidget != m_widgetActorLink.end())
+			{
+				parentWidget->second->leaf = true;
+			}
 		}
 
 		auto widget = actorWidget->second;
@@ -290,8 +356,14 @@ void OvEditor::Panels::Hierarchy::DetachFromParent(OvCore::ECS::Actor & p_actor)
 void OvEditor::Panels::Hierarchy::DeleteActorByInstance(OvCore::ECS::Actor& p_actor)
 {
 	if (auto result = m_widgetActorLink.find(&p_actor); result != m_widgetActorLink.end())
+	{
 		if (result->second)
+		{
 			result->second->Destroy();
+		}
+
+		m_widgetActorLink.erase(result);
+	}
 }
 
 void OvEditor::Panels::Hierarchy::AddActorByInstance(OvCore::ECS::Actor & p_actor)

Diff for: Sources/Overload/OvEditor/src/OvEditor/Panels/MenuBar.cpp

@@ -21,6 +21,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>
 
 #include "OvEditor/Panels/MenuBar.h"
@@ -206,6 +207,11 @@ void OvEditor::Panels::MenuBar::CreateSettingsMenu()
 	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; };
+	snappingMenu.CreateWidget<Drags::DragFloat>(0.001f, 999999.0f, Settings::EditorSettings::ScalingSnapUnit, 0.05f, "Scaling Unit").ValueChangedEvent += [this](float p_value) { Settings::EditorSettings::ScalingSnapUnit = p_value; };
+
 	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; };

Diff for: Sources/Overload/OvRendering/src/OvRendering/Entities/Light.cpp

@@ -52,7 +52,7 @@ OvMaths::FMatrix4 OvRendering::Entities::Light::GenerateMatrix() const
 float CalculateLuminosity(float p_constant, float p_linear, float p_quadratic, float p_intensity, float p_distance)
 {
 	auto attenuation = (p_constant + p_linear * p_distance + p_quadratic * (p_distance * p_distance));
-	return (1.0f / attenuation) * p_intensity;
+	return (1.0f / attenuation) * std::abs(p_intensity);
 }
 
 float CalculatePointLightRadius(float p_constant, float p_linear, float p_quadratic, float p_intensity)

Diff for: Sources/Overload/OvUI/include/OvUI/Widgets/Layout/TreeNode.h

@@ -38,6 +38,11 @@ namespace OvUI::Widgets::Layout
 		*/
 		void Close();
 
+		/**
+		* Returns true if the TreeNode is currently opened
+		*/
+		bool IsOpened() const;
+
 	protected:
 		virtual void _Draw_Impl() override;
 

Diff for: Sources/Overload/OvUI/src/OvUI/Widgets/Layout/TreeNode.cpp

@@ -26,6 +26,11 @@ void OvUI::Widgets::Layout::TreeNode::Close()
 	m_shouldOpen = false;
 }
 
+bool OvUI::Widgets::Layout::TreeNode::IsOpened() const
+{
+	return m_opened;
+}
+
 void OvUI::Widgets::Layout::TreeNode::_Draw_Impl()
 {
 	bool prevOpened = m_opened;