Feat/fullscreen

common/math/Light.cpp

@@ -17,9 +17,10 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "Light.hpp"
+#include <cmath>
 
 namespace nexo::math {
-	std::pair<float, float> computeAttenuationFromDistance(float distance)
+	std::pair<float, float> computeAttenuationFromDistance(const float distance)
 	{
 		// Clamp distance to the min/max of the table
 		if (distance <= s_attenuationTable[0].distance)
@@ -56,4 +57,26 @@ namespace nexo::math {
 
 		return { linear, quadratic };
 	}
+
+    float computeDistanceFromAttenuation(const float linear, const float quadratic)
+    {
+        // Find the closest matching entry in the table
+        float closestDistance = s_attenuationTable[0].distance;
+        float minDiff = std::abs(s_attenuationTable[0].linear - linear) +
+                        std::abs(s_attenuationTable[0].quadratic - quadratic);
+
+        for (int i = 1; i < s_attenuationCount; ++i)
+        {
+            const float diff = std::abs(s_attenuationTable[i].linear - linear) +
+                         std::abs(s_attenuationTable[i].quadratic - quadratic);
+            if (diff < minDiff)
+            {
+                minDiff = diff;
+                closestDistance = s_attenuationTable[i].distance;
+            }
+        }
+
+        return closestDistance;
+    }
+
 }

common/math/Light.hpp

@@ -58,4 +58,16 @@ namespace nexo::math {
      * @return A pair of floats where the first is the linear attenuation factor and the second is the quadratic attenuation factor.
      */
 	std::pair<float, float> computeAttenuationFromDistance(float distance);
+
+	/**
+     * @brief Estimates the distance at which a light would have the specified linear and quadratic attenuation factors.
+     *
+     * The function searches the attenuation table for the entry that best matches the provided linear and
+     * quadratic factors and returns the corresponding distance.
+     *
+     * @param linear The linear attenuation factor.
+     * @param quadratic The quadratic attenuation factor.
+     * @return The estimated distance from the light source.
+     */
+	float computeDistanceFromAttenuation(float linear, float quadratic);
 }

editor/CMakeLists.txt

@@ -118,6 +118,7 @@ set(SRCS
         editor/src/DocumentWindows/GameWindow/Setup.cpp
         editor/src/DocumentWindows/GameWindow/Show.cpp
         editor/src/DocumentWindows/GameWindow/Update.cpp
+        editor/src/DocumentWindows/PerformanceWindow/PerformanceWindow.cpp
 )
 
 # Windows App Icon

editor/main.cpp

@@ -23,6 +23,7 @@
 #include "src/DocumentWindows/MaterialInspector/MaterialInspector.hpp"
 #include "src/DocumentWindows/PrimitiveWindow/PrimitiveWindow.hpp"
 #include "src/DocumentWindows/SceneTreeWindow/SceneTreeWindow.hpp"
+#include "src/DocumentWindows/PerformanceWindow/PerformanceWindow.hpp"
 #include "src/Editor.hpp"
 
 #include <core/exceptions/Exceptions.hpp>
@@ -46,6 +47,7 @@ try {
     editor.registerWindow<nexo::editor::MaterialInspector>(NEXO_WND_USTRID_MATERIAL_INSPECTOR);
     editor.registerWindow<nexo::editor::PrimitiveWindow>(NEXO_WND_USTRID_PRIMITIVE_WINDOW);
     editor.registerWindow<nexo::editor::AssetManagerWindow>(NEXO_WND_USTRID_ASSET_MANAGER);
+    editor.registerWindow<nexo::editor::PerformanceMonitorWindow>(NEXO_WND_USTRID_PERFORMANCE_MONITOR);
 
     if (const auto defaultScene = editor
                                       .getWindow<nexo::editor::EditorScene>(

editor/src/ADocumentWindow.hpp

@@ -38,6 +38,7 @@ namespace nexo::editor {
 #define NEXO_WND_USTRID_BOTTOM_BAR "###CommandsBar"
 #define NEXO_WND_USTRID_TEST "###TestWindow"
 #define NEXO_WND_USTRID_GAME_WINDOW "###GameWindow"
+#define NEXO_WND_USTRID_PERFORMANCE_MONITOR "###Performance Monitor"
 
     class ADocumentWindow : public IDocumentWindow {
        public:

editor/src/DocumentWindows/EditorScene/EditorScene.hpp

@@ -60,6 +60,7 @@ namespace nexo::editor {
          * Finally, it renders both the scene view and transformation gizmos within the window.
          */
         void show() override;
+        void showFullscreen(bool fullscreen);
 
         bool showToolbar      = true;
         bool isPhysicsRunning = false;
@@ -271,10 +272,10 @@ namespace nexo::editor {
         /**
          * @brief Populates the scene with default entities.
          *
-         * Creates standard light sources (ambient, directional, point, spot)
-         * and a simple ground plane in the scene.
+         *
+         * @param offset A glm::vec3 representing the positional offset to apply to all spheres.
          */
-        static void loadDefaultEntities();
+        void loadDefaultEntities(const glm::vec3& offset = {0.0f, 0.0f, 0.0f}) const;
 
         /**
          * @brief Creates a physics-enabled entity in the scene.
@@ -460,21 +461,6 @@ namespace nexo::editor {
          */
         static void captureInitialTransformStates(const std::vector<int>& entities);
 
-        /**  * @brief Applies a world transformation delta to multiple entities.
-         *
-         * This function takes a source entity's old and new world transformation matrices,
-         * computes the delta transformation, and applies this delta to a list of target entities.
-         * Each target entity's TransformComponent is updated to reflect the new world position,
-         * rotation, and scale based on the computed delta.
-         *
-         * @param sourceEntity The entity whose transformation change is the basis for the delta.
-         * @param oldWorldMatrix The original world transformation matrix of the source entity.
-         * @param newWorldMatrix The new world transformation matrix of the source entity.
-         * @param targetEntities A vector of entity IDs to which the delta transformation will be applied.
-         */
-        static void applyTransformToEntities(ecs::Entity sourceEntity, const glm::mat4& oldWorldMatrix,
-                                             const glm::mat4& newWorldMatrix, const std::vector<int>& targetEntities);
-
         /**  * @brief Creates undo actions for transform changes on multiple entities.
          *
          * This method generates and records undo actions for a set of entities that have undergone
@@ -674,16 +660,6 @@ namespace nexo::editor {
          */
         void createOrFocusGameWindow();
 
-        /** @brief Spawns a scene with multiple balls for physics testing.
-         *
-         * Creates a grid of sphere entities with physics properties, arranged in
-         * a 5x5x5 formation. Each sphere is given a random color and positioned
-         * based on the provided offset.
-         *
-         * @param offset A glm::vec3 representing the positional offset to apply to all spheres.
-         */
-        void spawnBallsScene(const glm::vec3& offset = {0.0f, 0.0f, 0.0f}) const;
-
         /**
          * @brief Creates a scene with multiple light sources.
          *
@@ -723,6 +699,7 @@ namespace nexo::editor {
          * @param offset Position offset to apply to all forest elements.
          */
         void forestScene(const glm::vec3& offset = {0.0f, 0.0f, 0.0f}) const;
+        void spawnBallsScene(const glm::vec3& offset = {0.0f, 0.0f, 0.0f}) const;
 
         enum class EditorState { GLOBAL, GIZMO, GIZMO_TRANSLATE, GIZMO_ROTATE, GIZMO_SCALE, NB_STATE };
 

editor/src/DocumentWindows/EditorScene/Gizmo.cpp

@@ -198,15 +198,36 @@ namespace nexo::editor {
     {
         const glm::mat4 parentWorldMatrix = getEntityParentWorldMatrix(entity);
 
-        // Calculate local matrix by inverting parent world matrix and multiplying by entity's world matrix
-        const glm::mat4 localMatrix = glm::inverse(parentWorldMatrix) * worldMatrix;
+        // Calculate what the local matrix should be to achieve the desired world matrix
+        const glm::mat4 desiredLocalMatrix = glm::inverse(parentWorldMatrix) * worldMatrix;
 
+        // Decompose the desired local matrix back to local transform properties
         glm::vec3 skew;
         glm::vec4 perspective;
-        glm::decompose(localMatrix, transform.size, transform.quat, transform.pos, skew, perspective);
+        glm::decompose(desiredLocalMatrix, transform.size, transform.quat, transform.pos, skew, perspective);
 
-        transform.quat        = glm::normalize(transform.quat);
+        transform.quat = glm::normalize(transform.quat);
         transform.worldMatrix = worldMatrix;
+        transform.dirty = true;
+        Application::getInstance().markHierarchyDirty(entity);
+    }
+
+    static glm::mat4 getCurrentWorldMatrix(const ecs::Entity entity)
+    {
+        const auto& coord = nexo::Application::m_coordinator;
+        const auto transform = coord->tryGetComponent<components::TransformComponent>(entity);
+
+        if (!transform) return glm::mat4(1.0f);
+
+        // If the transform is dirty, we need to compute what the world matrix would be
+        if (transform->get().dirty) {
+            const glm::mat4 parentWorldMatrix = getEntityParentWorldMatrix(entity);
+            const glm::mat4 localMatrix = calculateWorldMatrix(transform->get());
+            return parentWorldMatrix * localMatrix;
+        }
+
+        // Use the cached world matrix if it's up to date
+        return transform->get().worldMatrix;
     }
 
     float* EditorScene::getSnapSettingsForOperation(const ImGuizmo::OPERATION operation)
@@ -231,26 +252,6 @@ namespace nexo::editor {
         }
     }
 
-    void EditorScene::applyTransformToEntities(const ecs::Entity sourceEntity, const glm::mat4& oldWorldMatrix,
-                                               const glm::mat4& newWorldMatrix, const std::vector<int>& targetEntities)
-    {
-        const auto& coord = Application::m_coordinator;
-
-        const glm::mat4 deltaMatrix = newWorldMatrix * glm::inverse(oldWorldMatrix);
-
-        // Apply to all selected entities except the source
-        for (const auto& entity : targetEntities) {
-            if (entity == static_cast<int>(sourceEntity)) continue;
-
-            const auto entityTransform = coord->tryGetComponent<components::TransformComponent>(entity);
-            if (!entityTransform) continue;
-
-            // Apply world space delta and convert back to local space
-            glm::mat4 newEntityWorldMatrix = deltaMatrix * entityTransform->get().worldMatrix;
-            updateLocalTransformFromWorld(entityTransform->get(), newEntityWorldMatrix, entity);
-        }
-    }
-
     /**
      * @brief Compares two TransformComponent states to determine if any properties have changed.
      *
@@ -359,18 +360,14 @@ namespace nexo::editor {
 
         // 1) M₀ = parentWorld * T(pos) * R(quat) * S(size)
         const glm::mat4 parentWorld = getEntityParentWorldMatrix(primaryEntity);
-        const glm::mat4 Tpos        = glm::translate(glm::mat4(1.0f), primaryTransform->get().pos);
-        const glm::mat4 Rrot        = glm::toMat4(primaryTransform->get().quat);
-        const glm::mat4 Sscale      = glm::scale(glm::mat4(1.0f), primaryTransform->get().size);
-        const glm::mat4 M0          = parentWorld * Tpos * Rrot * Sscale;
+        const glm::mat4 localMatrix = calculateWorldMatrix(primaryTransform->get());
+        const glm::mat4 M0 = parentWorld * localMatrix;
 
-        // 2) “centroid offset” = T(centroidLocal)
+        // 2) Apply centroid offset for gizmo display
         const glm::mat4 C_offset = glm::translate(glm::mat4(1.0f), primaryTransform->get().localCenter);
-
-        // 3) M1 = M0 * C_offset
         glm::mat4 worldTransformMatrix = M0 * C_offset;
 
-        // (We’ll need “M₀” again after manipulation for decomposing back.)
+        // Store original for delta calculation
         const glm::mat4 originalWorldMatrix_ModelOrigin = M0;
 
         if (!ImGuizmo::IsUsing()) s_lastOperation = getActiveGuizmoOperation();
@@ -386,30 +383,30 @@ namespace nexo::editor {
         const bool isUsingGizmo = ImGuizmo::IsUsing();
 
         if (isUsingGizmo) {
-            // Disable camera movement during manipulation
             camera.active = false;
 
-            const glm::mat4 newWorldMatrix_Centroid    = worldTransformMatrix;
-            const glm::mat4 invCentroidOffset          = glm::inverse(C_offset);
+            const glm::mat4 newWorldMatrix_Centroid = worldTransformMatrix;
+            const glm::mat4 invCentroidOffset = glm::inverse(C_offset);
             const glm::mat4 newWorldMatrix_ModelOrigin = newWorldMatrix_Centroid * invCentroidOffset;
 
-            // Update the primary entity's local transform based on the new world transform
+            // Update local transform properties (NOT world matrix)
             updateLocalTransformFromWorld(primaryTransform->get(), newWorldMatrix_ModelOrigin, primaryEntity);
 
+            // Apply same transformation to other selected entities
             const glm::mat4 deltaMatrix = newWorldMatrix_ModelOrigin * glm::inverse(originalWorldMatrix_ModelOrigin);
 
             for (const auto entity : selectedEntities) {
                 if (static_cast<unsigned int>(entity) == primaryEntity) continue;
+
                 const auto tComp = coord->tryGetComponent<components::TransformComponent>(entity);
                 if (!tComp) continue;
 
-                // “OtherEntity_world₀” = tComp->worldMatrix
-                glm::mat4 otherWorldMatrix_0 = tComp->get().worldMatrix;
-                // “OtherEntity_world₁” = deltaMatrix * otherWorldMatrix_0
-                glm::mat4 otherWorldMatrix_1 = deltaMatrix * otherWorldMatrix_0;
+                // Get the current world matrix for this entity
+                const glm::mat4 otherCurrentWorld = getCurrentWorldMatrix(entity);
+                const glm::mat4 otherNewWorld = deltaMatrix * otherCurrentWorld;
 
-                // Now convert that new world matrix back to local space of “entity”:
-                updateLocalTransformFromWorld(tComp->get(), otherWorldMatrix_1, entity);
+                // Update local properties only
+                updateLocalTransformFromWorld(tComp->get(), otherNewWorld, entity);
             }
         } else if (s_wasUsingGizmo) {
             // Re-enable camera when done