feat: physics integration (jolt physics)

# Summary of changes
- Add a new system PhysicsSystem inheriting from `ecs::QuerySystem`,
handling rigid body update

- Bound the physics system to Jolt Physics through our existing ECS
structure.

- Exposed 2 main API methods to create bodies:
`createStaticBody(entity, transform)`
`createDynamicBody(entity, transform)`

- Bodies are automatically tracked via the PhysicsBodyComponent, storing
the BodyID and motion type.

- Physics system automatically syncs Jolt positions back into the
TransformComponent every frame.

# New components
- `TransformComponent`: used to compute position, size and rotation for
body creation.

- `PhysicsBodyComponent`: stores the Jolt `BodyID` and its type
(`Static` or `Dynamic`).

# Usage
To assign physics to an entity:
```cpp
auto entity = app.createEntity();
components::TransformComponent transform{ /* init pos, rot, size */ };
app.m_coordinator->addComponent(entity, transform);

// For static objects
app.getPhysicsSystem()->createStaticBody(entity, transform);

// For dynamic objects
app.getPhysicsSystem()->createDynamicBody(entity, transform);
```
No need to manually update the transform after simulation; it's done by
the system at the end of each frame.

# Testing
Initial test coverage includes:
- Validation of rigid body creation.

- System-side updates and ECS sync.

- Regression tests for TransformComponent integration with the physics
update loop.

# Example 
PS: Actually i have a exemple scene that have been push that replace the
default editor scene, the scene include:
- A ground (static body)

- 2 cubes falling from the air (dynamic body) and colliding with each
other while falling

- **New Features**
- Introduced a physics system powered by Jolt Physics, enabling
simulation of dynamic and static bodies within scenes.
- Added default scene entities (ground and cubes) with physics
properties for immediate interaction.
- Provided a default window layout configuration for the graphical user
interface.
- **Bug Fixes**
- Improved exception handling with richer, formatted messages and
detailed source location information.
- **Chores**
- Integrated Jolt Physics as a dependency, including build scripts and
configuration updates.
- **Tests**
- Added unit tests for the new physics system and enhanced exception
tests with debug output.

Author: iMeaNz

CMakeLists.txt

@@ -20,7 +20,7 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
     set(NEXO_COMPILER_FLAGS_RELEASE -O3)
     set(NEXO_COVERAGE_FLAGS -O0 --coverage)
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    set(NEXO_COMPILER_FLAGS_ALL /std:c++${CMAKE_CXX_STANDARD} /Zc:preprocessor)
+    set(NEXO_COMPILER_FLAGS_ALL /std:c++${CMAKE_CXX_STANDARD} /Zc:preprocessor /utf-8)
     set(NEXO_COMPILER_FLAGS_DEBUG /Zi /Od /Zc:preprocessor /MDd /D_DEBUG /D_ITERATOR_DEBUG_LEVEL=2 /D_SECURE_SCL=1)
     set(NEXO_COMPILER_FLAGS_RELEASE /O2 /Zc:preprocessor)
     set(NEXO_COVERAGE_FLAGS "")  # MSVC doesn't support coverage in the same way

common/Exception.cpp

@@ -14,19 +14,41 @@
 
 #include "Exception.hpp"
 
-#include <sstream>
+#include <format>
 
 namespace nexo {
-    const char * Exception::what() const noexcept
+    const char *Exception::what() const noexcept
     {
-        formattedMessage = formatMessage();
-        return formattedMessage.c_str();
+        return m_formattedMessage.c_str();
     }
 
-    std::string Exception::formatMessage() const
+    const std::string& Exception::getMessage() const noexcept
     {
-        std::ostringstream oss;
-        oss << "Exception occurred in " << file << ":" << line << " - " << message;
-        return oss.str();
+        return m_unformattedMessage;
     }
-}
+
+    const std::string& Exception::getFormattedMessage() const noexcept
+    {
+        return m_formattedMessage;
+    }
+
+    const char* Exception::getFile() const noexcept
+    {
+        return m_location.file_name();
+    }
+
+    unsigned int Exception::getLine() const noexcept
+    {
+        return m_location.line();
+    }
+
+    const char* Exception::getFunction() const noexcept
+    {
+        return m_location.function_name();
+    }
+
+    const std::source_location& Exception::getSourceLocation() const noexcept
+    {
+        return m_location;
+    }
+}

common/Exception.hpp

@@ -13,29 +13,38 @@
 ///////////////////////////////////////////////////////////////////////////////
 #pragma once
 
+#include <format>
 #include <string>
 #include <source_location>
+#include <exception>
 
 namespace nexo {
     class Exception : public std::exception {
         public:
-            explicit Exception(std::string message, const std::source_location loc)
-                : message(std::move(message)), file(loc.file_name()), line(loc.line()) {}
+            explicit Exception(const std::string& message, const std::source_location& loc)
+                :
+                m_unformattedMessage(message),
+                m_formattedMessage(std::format("Exception occurred in {} : {} - {}", loc.file_name(), loc.line(), message)),
+                m_location(loc)
+            {
+            }
 
-            const char *what() const noexcept override;
+            ~Exception() override = default;
 
-            const std::string &getMessage() const noexcept { return message; }
-            const char *getFile() const noexcept { return file; }
-            unsigned int getLine() const noexcept { return line; }
+            [[nodiscard]] const char *what() const noexcept override;
 
-            protected:
-            std::string formatMessage() const;
+            [[nodiscard]] const std::string& getMessage() const noexcept;
+            [[nodiscard]] const std::string& getFormattedMessage() const noexcept;
+
+            [[nodiscard]] const char *getFile() const noexcept;
+            [[nodiscard]] unsigned int getLine() const noexcept;
+            [[nodiscard]] const char *getFunction() const noexcept;
+            [[nodiscard]] const std::source_location& getSourceLocation() const noexcept;
 
         private:
-            std::string message;
-            const char *file;
-            unsigned int line;
-            mutable std::string formattedMessage;
+            std::string m_unformattedMessage;
+            std::string m_formattedMessage;
+            std::source_location m_location;
     };
 }
 

editor/src/DocumentWindows/EditorScene/Init.cpp

@@ -46,8 +46,8 @@ namespace nexo::editor {
         framebufferSpecs.width = static_cast<unsigned int>(m_contentSize.x);
         framebufferSpecs.height = static_cast<unsigned int>(m_contentSize.y);
         const auto renderTarget = renderer::NxFramebuffer::create(framebufferSpecs);
-        m_editorCamera = static_cast<int>(CameraFactory::createPerspectiveCamera({0.0f, 3.0f, -2.0f}, static_cast<unsigned int>(m_contentSize.x), static_cast<unsigned int>(m_contentSize.y), renderTarget));
-        auto &cameraComponent = Application::m_coordinator->getComponent<components::CameraComponent>(m_editorCamera);
+        m_editorCamera = CameraFactory::createPerspectiveCamera({0.0f, 4.0f, 10.0f}, static_cast<unsigned int>(m_contentSize.x), static_cast<unsigned int>(m_contentSize.y), renderTarget);
+        auto &cameraComponent = app.m_coordinator->getComponent<components::CameraComponent>(m_editorCamera);
         cameraComponent.render = true;
         auto maskPass = std::make_shared<renderer::MaskPass>(m_contentSize.x, m_contentSize.y);
         auto outlinePass = std::make_shared<renderer::OutlinePass>(m_contentSize.x, m_contentSize.y);
@@ -177,6 +177,33 @@ namespace nexo::editor {
         //                                                          {0.0f, 0.0f, 0.0f});
 
         app.getSceneManager().getScene(m_sceneId).addEntity(ModelAvocado);
+
+        const ecs::Entity ground = EntityFactory3D::createCube(
+            {0.0f, 0.25f, 0.0f}, // position
+            {20.0f, 0.5f, 20.0f}, // size
+            {0.0f, 0.0f, 0.0f},
+            {0.2f, 0.2f, 0.2f, 1.0f} // color
+        );
+        app.getPhysicsSystem()->createStaticBody(ground, app.m_coordinator->getComponent<components::TransformComponent>(ground));
+        scene.addEntity(ground);
+
+        const ecs::Entity fallingCube = EntityFactory3D::createCube(
+            {0.0f, 5.0f, 0.0f},
+            {1.0f, 1.0f, 1.0f},
+            {0.0f, 0.0f, 0.0f},
+            {1.0f, 0.2f, 0.2f, 1.0f}
+        );
+        app.getPhysicsSystem()->createDynamicBody(fallingCube, app.m_coordinator->getComponent<components::TransformComponent>(fallingCube));
+        scene.addEntity(fallingCube);
+
+        const ecs::Entity fallingCube2 = EntityFactory3D::createCube(
+            {0.5f, 7.0f, 0.0f},
+            {1.0f, 1.0f, 1.0f},
+            {0.0f, 0.0f, 0.0f},
+            {1.0f, 0.2f, 0.2f, 1.0f}
+        );
+        app.getPhysicsSystem()->createDynamicBody(fallingCube2, app.m_coordinator->getComponent<components::TransformComponent>(fallingCube2));
+        scene.addEntity(fallingCube2);
     }
 
     void EditorScene::setupWindow()

engine/CMakeLists.txt

@@ -57,6 +57,7 @@ set(COMMON_SOURCES
         engine/src/systems/RenderBillboardSystem.cpp
         engine/src/systems/LightSystem.cpp
         engine/src/systems/ScriptingSystem.cpp
+        engine/src/systems/PhysicsSystem.cpp
         engine/src/systems/lights/AmbientLightSystem.cpp
         engine/src/systems/lights/PointLightsSystem.cpp
         engine/src/systems/lights/DirectionalLightsSystem.cpp
@@ -131,6 +132,10 @@ target_link_libraries(nexoRenderer PRIVATE assimp::assimp)
 find_package(Boost CONFIG REQUIRED COMPONENTS dll)
 target_link_libraries(nexoRenderer PRIVATE Boost::dll)
 
+# joltphysics
+find_package(Jolt CONFIG REQUIRED)
+target_link_libraries(nexoRenderer PRIVATE Jolt::Jolt)
+
 ###########################################
 # Scripting
 ###########################################

engine/src/Application.cpp

@@ -108,6 +108,8 @@ namespace nexo {
         m_coordinator->registerComponent<components::MaterialComponent>();
         m_coordinator->registerComponent<components::NameComponent>();
         m_coordinator->registerSingletonComponent<components::RenderContext>();
+
+        m_coordinator->registerComponent<components::PhysicsBodyComponent>();
     }
 
     void Application::registerWindowCallbacks() const
@@ -205,6 +207,8 @@ namespace nexo {
         m_renderBillboardSystem = m_coordinator->registerGroupSystem<system::RenderBillboardSystem>();
         m_transformHierarchySystem = m_coordinator->registerGroupSystem<system::TransformHierarchySystem>();
         m_transformMatrixSystem = m_coordinator->registerQuerySystem<system::TransformMatrixSystem>();
+        m_physicsSystem = m_coordinator->registerQuerySystem<system::PhysicsSystem>();
+        m_physicsSystem->init();
 
         auto pointLightSystem = m_coordinator->registerGroupSystem<system::PointLightsSystem>();
         auto directionalLightSystem = m_coordinator->registerGroupSystem<system::DirectionalLightsSystem>();
@@ -297,6 +301,9 @@ namespace nexo {
 
         m_scriptingSystem->update();
 
+        constexpr float fixedTimestep = 1.0f / 60.0f;
+        static float physicsAccumulator = 0.0f;
+
         if (!m_isMinimized)
         {
          	renderContext.sceneRendered = static_cast<int>(sceneInfo.id);
@@ -312,6 +319,12 @@ namespace nexo {
                 m_transformHierarchySystem->update();
 				m_cameraContextSystem->update();
 				m_lightSystem->update();
+                physicsAccumulator += m_worldState.time.deltaTime;
+
+                while (physicsAccumulator >= fixedTimestep) {
+                    m_physicsSystem->update(fixedTimestep);
+                    physicsAccumulator -= fixedTimestep;
+                }
 				m_renderCommandSystem->update();
 				m_renderBillboardSystem->update();
 				for (auto &camera : renderContext.cameras)

engine/src/Application.hpp

@@ -28,13 +28,15 @@
 #include "Timer.hpp"
 #include "WorldState.hpp"
 #include "components/Light.hpp"
+#include "components/PhysicsBodyComponent.hpp"
 
 #include "systems/CameraSystem.hpp"
 #include "systems/LightSystem.hpp"
 #include "systems/RenderCommandSystem.hpp"
 #include "systems/RenderBillboardSystem.hpp"
 #include "systems/TransformHierarchySystem.hpp"
 #include "systems/TransformMatrixSystem.hpp"
+#include "systems/PhysicsSystem.hpp"
 
 #define NEXO_PROFILE(name) nexo::Timer timer##__LINE__(name, [&](ProfileResult profileResult) {m_profileResults.push_back(profileResult); })
 
@@ -188,6 +190,10 @@ namespace nexo {
              */
             ecs::Entity createEntity() const;
 
+            std::shared_ptr<system::PhysicsSystem> getPhysicsSystem() const {
+                return m_physicsSystem;
+            }
+
             /**
              * @brief Deletes an existing entity.
              *
@@ -270,7 +276,9 @@ namespace nexo {
             std::shared_ptr<system::ScriptingSystem> m_scriptingSystem;
             std::shared_ptr<system::RenderCommandSystem> m_renderCommandSystem;
             std::shared_ptr<system::RenderBillboardSystem> m_renderBillboardSystem;
+            std::shared_ptr<system::PhysicsSystem> m_physicsSystem;
 
             std::vector<ProfileResult> m_profilesResults;
+
     };
 }

engine/src/components/PhysicsBodyComponent.hpp

@@ -0,0 +1,26 @@
+//// PhysicsBodyComponent.hpp /////////////////////////////////////////////////
+//
+//  zzzzz       zzz  zzzzzzzzzzzzz    zzzz      zzzz       zzzzzz  zzzzz
+//  zzzzzzz     zzz  zzzz                    zzzz       zzzz           zzzz
+//  zzz   zzz   zzz  zzzzzzzzzzzzz         zzzz        zzzz             zzz
+//  zzz    zzz  zzz  z                  zzzz  zzzz      zzzz           zzzz
+//  zzz         zzz  zzzzzzzzzzzzz    zzzz       zzz      zzzzzzz  zzzzz
+//
+//  Author:      Thomas PARENTEAU
+//  Date:        21/03/2024
+//  Description: Header file for the Physics Body components
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <Jolt/Jolt.h>
+#include <Jolt/Physics/Body/BodyID.h>
+
+namespace nexo::components {
+    struct PhysicsBodyComponent {
+        enum class Type { Static, Dynamic };
+        JPH::BodyID bodyID;
+        Type type;
+    };
+}

engine/src/ecs/Coordinator.hpp

@@ -564,6 +564,36 @@ namespace nexo::ecs {
             void addComponentAny(Entity entity, const std::type_index& typeIndex, const std::any& component);
 
             Entity duplicateEntity(Entity sourceEntity) const;
+
+            /**
+            * @brief Retrieves all entities that have all the specified components.
+            *
+            * This method iterates over all entities and returns a list of those that possess
+            * each of the given component types. It uses the current signature of each entity
+            * to determine component ownership.
+            *
+            * @tparam ComponentTypes - A variadic list of component types to filter by.
+            * @return std::vector<Entity> - A list of entities matching all specified component types.
+            */
+            template<typename... ComponentTypes>
+            std::vector<Entity> getEntitiesWithComponents() const
+            {
+                std::vector<Entity> result;
+                std::span<const Entity> livingEntities = m_entityManager->getLivingEntities();
+                result.reserve(livingEntities.size());
+                for (Entity entity : livingEntities)
+                {
+                    bool hasAll = (entityHasComponent<ComponentTypes>(entity) && ...);
+                    if (hasAll)
+                    {
+                        result.push_back(entity);
+                    }
+                }
+                return result;
+            }
+
+        void updateSystemEntities() const;
+
         private:
             template<typename Component>
             void processComponentSignature(Signature& required, Signature& excluded) const {