Adding orthographic camera mode

Previously, our camera was only supporting perspective projection.
However, it is sometimes convenient to use orthographic projection
(Shadow mapping, 2D graphics, isometric games...).

- A new method has been added to `OvMaths::FMatrix4` to create an
orthographic projection matrix.

- The rendering side camera has a new `m_projectionMode` setting and
is now considering this setting for the projection calculation.
An extra `m_size` setting has been added for orthographic camera.

- The camera component has been updated to expose and serialize these new settings.

- Lua binding has been updated to support these new methods.

- Frustum drawing (Editor) has been updated to support orthographic
projection.

Note: Adding a new serialized member to an Overload component is
currently a problem. When deserializing, we are not considering
the case when the XML file doesn't contain a certain entry, and thus, some
garbage values are sometimes loaded. A dirty check has been done in
order to prevent the camera projection setting to be a garbage value on
our old scenes (Retro-compatibility), but we should replace this by a
new safer deserialization solution.

Author: Adrien GIVRY

Sources/Overload/OvCore/include/OvCore/ECS/Components/CCamera.h

@@ -41,6 +41,12 @@ namespace OvCore::ECS::Components
 		*/
 		void SetFov(float p_value);
 
+        /**
+        * Sets the size of the camera to the given value
+        * @param p_value
+        */
+        void SetSize(float p_value);
+
 		/**
 		* Sets the near of the camera to the given value
 		* @param p_value
@@ -71,11 +77,22 @@ namespace OvCore::ECS::Components
 		*/
 		void SetFrustumLightCulling(bool p_enable);
 
+        /**
+        * Defines the projection mode the camera should adopt
+        * @param p_projectionMode
+        */
+        void SetProjectionMode(OvRendering::Settings::EProjectionMode p_projectionMode);
+
 		/**
 		* Returns the fov of the camera
 		*/
 		float GetFov() const;
 
+        /**
+        * Returns the size of the camera
+        */
+        float GetSize() const;
+
 		/**
 		* Returns the near of the camera
 		*/
@@ -101,6 +118,11 @@ namespace OvCore::ECS::Components
 		*/
 		bool HasFrustumLightCulling() const;
 
+        /**
+        * Returns the current projection mode
+        */
+        OvRendering::Settings::EProjectionMode GetProjectionMode() const;
+
 		/**
 		* Returns the OvRendering camera instance attached to this component
 		*/

Sources/Overload/OvCore/src/OvCore/ECS/Components/CCamera.cpp

@@ -5,6 +5,7 @@
 */
 
 #include <OvUI/Widgets/Drags/DragFloat.h>
+#include <OvUI/Widgets/Selection/ComboBox.h>
 #include <OvUI/Plugins/DataDispatcher.h>
 
 #include "OvCore/ECS/Components/CCamera.h"
@@ -26,6 +27,11 @@ void OvCore::ECS::Components::CCamera::SetFov(float p_value)
 	m_camera.SetFov(p_value);
 }
 
+void OvCore::ECS::Components::CCamera::SetSize(float p_value)
+{
+    m_camera.SetSize(p_value);
+}
+
 void OvCore::ECS::Components::CCamera::SetNear(float p_value)
 {
 	m_camera.SetNear(p_value);
@@ -46,11 +52,21 @@ void OvCore::ECS::Components::CCamera::SetFrustumLightCulling(bool p_enable)
 	m_camera.SetFrustumLightCulling(p_enable);
 }
 
+void OvCore::ECS::Components::CCamera::SetProjectionMode(OvRendering::Settings::EProjectionMode p_projectionMode)
+{
+    m_camera.SetProjectionMode(p_projectionMode);
+}
+
 float OvCore::ECS::Components::CCamera::GetFov() const
 {
 	return m_camera.GetFov();
 }
 
+float OvCore::ECS::Components::CCamera::GetSize() const
+{
+    return m_camera.GetSize();
+}
+
 float OvCore::ECS::Components::CCamera::GetNear() const
 {
 	return m_camera.GetNear();
@@ -81,6 +97,11 @@ bool OvCore::ECS::Components::CCamera::HasFrustumLightCulling() const
 	return m_camera.HasFrustumLightCulling();
 }
 
+OvRendering::Settings::EProjectionMode OvCore::ECS::Components::CCamera::GetProjectionMode() const
+{
+    return m_camera.GetProjectionMode();
+}
+
 OvRendering::LowRenderer::Camera & OvCore::ECS::Components::CCamera::GetCamera()
 {
 	return m_camera;
@@ -89,29 +110,63 @@ OvRendering::LowRenderer::Camera & OvCore::ECS::Components::CCamera::GetCamera()
 void OvCore::ECS::Components::CCamera::OnSerialize(tinyxml2::XMLDocument & p_doc, tinyxml2::XMLNode * p_node)
 {
 	OvCore::Helpers::Serializer::SerializeFloat(p_doc, p_node, "fov", m_camera.GetFov());
+	OvCore::Helpers::Serializer::SerializeFloat(p_doc, p_node, "size", m_camera.GetSize());
 	OvCore::Helpers::Serializer::SerializeFloat(p_doc, p_node, "near", m_camera.GetNear());
 	OvCore::Helpers::Serializer::SerializeFloat(p_doc, p_node, "far", m_camera.GetFar());
 	OvCore::Helpers::Serializer::SerializeVec3(p_doc, p_node, "clear_color", m_camera.GetClearColor());
 	OvCore::Helpers::Serializer::SerializeBoolean(p_doc, p_node, "frustum_geometry_culling", m_camera.HasFrustumGeometryCulling());
 	OvCore::Helpers::Serializer::SerializeBoolean(p_doc, p_node, "frustum_light_culling", m_camera.HasFrustumLightCulling());
+	OvCore::Helpers::Serializer::SerializeInt(p_doc, p_node, "projection_mode", static_cast<int>(m_camera.GetProjectionMode()));
 }
 
 void OvCore::ECS::Components::CCamera::OnDeserialize(tinyxml2::XMLDocument & p_doc, tinyxml2::XMLNode * p_node)
 {
 	m_camera.SetFov(OvCore::Helpers::Serializer::DeserializeFloat(p_doc, p_node, "fov"));
+	m_camera.SetSize(OvCore::Helpers::Serializer::DeserializeFloat(p_doc, p_node, "size"));
 	m_camera.SetNear(OvCore::Helpers::Serializer::DeserializeFloat(p_doc, p_node, "near"));
 	m_camera.SetFar(OvCore::Helpers::Serializer::DeserializeFloat(p_doc, p_node, "far"));
 	m_camera.SetClearColor(OvCore::Helpers::Serializer::DeserializeVec3(p_doc, p_node, "clear_color"));
 	m_camera.SetFrustumGeometryCulling(OvCore::Helpers::Serializer::DeserializeBoolean(p_doc, p_node, "frustum_geometry_culling"));
 	m_camera.SetFrustumLightCulling(OvCore::Helpers::Serializer::DeserializeBoolean(p_doc, p_node, "frustum_light_culling"));
+
+    // We have to make sure the "projection_mode" exists in the serialized component, otherwise we do not want to modify the default setting (Perspective).
+    // This is a bad practice to have each components calling setters in `OnDeserialize` even if no XML node hasn't been found for a given property.
+    // We should rework this system later. As it is out of the scope of the orthographic projection scope, this will be left as is for now.
+    if (p_node->FirstChildElement("projection_mode"))
+    {
+        m_camera.SetProjectionMode(static_cast<OvRendering::Settings::EProjectionMode>(OvCore::Helpers::Serializer::DeserializeInt(p_doc, p_node, "projection_mode")));
+    }
 }
 
 void OvCore::ECS::Components::CCamera::OnInspector(OvUI::Internal::WidgetContainer& p_root)
 {
+    auto currentProjectionMode = GetProjectionMode();
+
 	OvCore::Helpers::GUIDrawer::DrawScalar<float>(p_root, "Field of view", std::bind(&CCamera::GetFov, this), std::bind(&CCamera::SetFov, this, std::placeholders::_1));
+    auto& fovWidget = *p_root.GetWidgets()[p_root.GetWidgets().size() - 1].first;
+    auto& fovWidgetLabel = *p_root.GetWidgets()[p_root.GetWidgets().size() - 2].first;
+    fovWidget.enabled = fovWidgetLabel.enabled = currentProjectionMode == OvRendering::Settings::EProjectionMode::PERSPECTIVE;
+
+	OvCore::Helpers::GUIDrawer::DrawScalar<float>(p_root, "Size", std::bind(&CCamera::GetSize, this), std::bind(&CCamera::SetSize, this, std::placeholders::_1));
+    auto& sizeWidget = *p_root.GetWidgets()[p_root.GetWidgets().size() - 1].first;
+    auto& sizeWidgetLabel = *p_root.GetWidgets()[p_root.GetWidgets().size() - 2].first;
+    sizeWidget.enabled = sizeWidgetLabel.enabled = currentProjectionMode == OvRendering::Settings::EProjectionMode::ORTHOGRAPHIC;
+
 	OvCore::Helpers::GUIDrawer::DrawScalar<float>(p_root, "Near", std::bind(&CCamera::GetNear, this), std::bind(&CCamera::SetNear, this, std::placeholders::_1));
 	OvCore::Helpers::GUIDrawer::DrawScalar<float>(p_root, "Far", std::bind(&CCamera::GetFar, this), std::bind(&CCamera::SetFar, this, std::placeholders::_1));
 	OvCore::Helpers::GUIDrawer::DrawColor(p_root, "Clear color", [this]() {return reinterpret_cast<const OvUI::Types::Color&>(GetClearColor()); }, [this](OvUI::Types::Color p_color) { SetClearColor({ p_color.r, p_color.g, p_color.b }); }, false);
 	OvCore::Helpers::GUIDrawer::DrawBoolean(p_root, "Frustum Geometry Culling", std::bind(&CCamera::HasFrustumGeometryCulling, this), std::bind(&CCamera::SetFrustumGeometryCulling, this, std::placeholders::_1));
 	OvCore::Helpers::GUIDrawer::DrawBoolean(p_root, "Frustum Light Culling", std::bind(&CCamera::HasFrustumLightCulling, this), std::bind(&CCamera::SetFrustumLightCulling, this, std::placeholders::_1));
+
+    Helpers::GUIDrawer::CreateTitle(p_root, "Projection Mode");
+    auto& projectionMode = p_root.CreateWidget<OvUI::Widgets::Selection::ComboBox>(static_cast<int>(GetProjectionMode()));
+    projectionMode.choices.emplace(0, "Orthographic");
+    projectionMode.choices.emplace(1, "Perspective");
+    projectionMode.ValueChangedEvent += [this, &fovWidget, &fovWidgetLabel, &sizeWidget, &sizeWidgetLabel](int p_choice)
+    {
+        const auto newProjectionMode = static_cast<OvRendering::Settings::EProjectionMode>(p_choice);
+        SetProjectionMode(newProjectionMode);
+        fovWidget.enabled = fovWidgetLabel.enabled = newProjectionMode == OvRendering::Settings::EProjectionMode::PERSPECTIVE;
+        sizeWidget.enabled = sizeWidgetLabel.enabled = newProjectionMode == OvRendering::Settings::EProjectionMode::ORTHOGRAPHIC;
+    };
 }

Sources/Overload/OvCore/src/OvCore/Scripting/LuaComponentBinder.cpp

@@ -137,20 +137,30 @@ void OvCore::Scripting::LuaComponentBinder::BindComponent(sol::state & p_luaStat
 		"SetHeight", &CPhysicalCapsule::SetHeight
 		);
 
+    p_luaState.new_enum<OvRendering::Settings::EProjectionMode>("ProjectionMode",
+    {
+        {"ORTHOGRAPHIC",	OvRendering::Settings::EProjectionMode::ORTHOGRAPHIC},
+        {"PERSPECTIVE",		OvRendering::Settings::EProjectionMode::PERSPECTIVE}
+    });
+
 	p_luaState.new_usertype<CCamera>("Camera",
 		sol::base_classes, sol::bases<AComponent>(),
 		"GetFov", &CCamera::GetFov,
+		"GetSize", &CCamera::GetSize,
 		"GetNear", &CCamera::GetNear,
 		"GetFar", &CCamera::GetFar,
 		"GetClearColor", &CCamera::GetClearColor,
 		"SetFov", &CCamera::SetFov,
+		"SetSize", &CCamera::SetSize,
 		"SetNear", &CCamera::SetNear,
 		"SetFar", &CCamera::SetFar,
 		"SetClearColor", &CCamera::SetClearColor,
         "HasFrustumGeometryCulling", &CCamera::HasFrustumGeometryCulling,
         "HasFrustumLightCulling", &CCamera::HasFrustumLightCulling,
+        "GetProjectionMode", &CCamera::GetProjectionMode,
         "SetFrustumGeometryCulling", &CCamera::SetFrustumGeometryCulling,
-        "SetFrustumLightCulling", &CCamera::SetFrustumLightCulling
+        "SetFrustumLightCulling", &CCamera::SetFrustumLightCulling,
+        "SetProjectionMode", &CCamera::SetProjectionMode
 		);
 
 	p_luaState.new_usertype<CLight>("Light",

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

@@ -110,6 +110,20 @@ namespace OvEditor::Core
 		*/
 		void RenderActorOutlinePass(OvCore::ECS::Actor& p_actor, bool p_toStencil, bool p_isSelected = false);
 
+        /**
+        * Render the camera perspective frustum
+        * @param p_size
+        * @param p_camera
+        */
+        void RenderCameraPerspectiveFrustum(std::pair<uint16_t, uint16_t>& p_size, OvCore::ECS::Components::CCamera& p_camera);
+
+        /**
+        * Render the camera orthographic frustum
+        * @param p_size
+        * @param p_camera
+        */
+        void RenderCameraOrthographicFrustum(std::pair<uint16_t, uint16_t>& p_size, OvCore::ECS::Components::CCamera& p_camera);
+
 		/**
 		* Render the camera frustum
 		*/