feat(engine): add fixedStep plugin

engine/CMakeLists.txt

@@ -90,6 +90,8 @@ set(CUBOS_ENGINE_SOURCE
 
 	"src/screen_picker/plugin.cpp"
 	"src/screen_picker/screen_picker.cpp"
+
+	"src/fixedstep/plugin.cpp"
 )
 
 # Create cubos engine

engine/include/cubos/engine/fixedstep/accumulated_time.hpp

@@ -0,0 +1,16 @@
+/// @file
+/// @brief Resource @ref cubos::engine::AccumulatedTime.
+/// @ingroup fixedstep-plugin
+
+#pragma once
+
+namespace cubos::engine
+{
+    /// @brief Resource which holds the time passed without running fixedStep systems, incremented every frame
+    /// by deltaTime and decremented once the systems run.
+    /// @ingroup fixedstep-plugin
+    struct AccumulatedTime
+    {
+        float value = 0.0F;
+    };
+} // namespace cubos::engine

engine/include/cubos/engine/fixedstep/plugin.hpp

@@ -0,0 +1,23 @@
+/// @dir
+/// @brief @ref fixedstep-plugin plugin directory.
+
+/// @file
+/// @brief Plugin entry point.
+/// @ingroup fixedstep-plugin
+
+#pragma once
+
+#include <cubos/engine/prelude.hpp>
+
+namespace cubos::engine
+{
+    /// @defgroup fixedstep-plugin FixedStep
+    /// @ingroup engine
+    /// @brief Adds cubos.fixedStep tag which makes its systems run at a fixed framerate.
+    ///
+
+    /// @brief Plugin entry function.
+    /// @param cubos @b CUBOS. main class
+    /// @ingroup fixedstep-plugin
+    void fixedStepPlugin(Cubos& cubos);
+} // namespace cubos::engine

engine/src/fixedstep/plugin.cpp

@@ -0,0 +1,26 @@
+#include <cubos/engine/fixedstep/plugin.hpp>
+#include <cubos/engine/fixedstep/accumulated_time.hpp>
+
+
+using namespace cubos::engine;
+
+const float frametime = 1/60;
+
+
+
+void cubos::engine::fixedStepPlugin(Cubos& cubos)
+{
+    cubos.addResource<AccumulatedTime>();
+
+    cubos.system("accumulate time resource").call([](AccumulatedTime& timer, const DeltaTime& dt) {
+            timer.value += dt.value;
+        });
+
+    cubos.tag("cubos.fixedStep").repeatWhile([](AccumulatedTime& timer) {
+            if (timer.value >= frametime) {
+                timer.value -= frametime;
+                return true;
+            }
+            return false;
+        });
+}

engine/src/physics/plugin.cpp

@@ -5,6 +5,7 @@
 #include <cubos/engine/physics/solver/solver.hpp>
 #include <cubos/engine/settings/plugin.hpp>
 #include <cubos/engine/transform/plugin.hpp>
+#include <cubos/engine/fixedstep/plugin.hpp>
 
 #include "physics_accumulator.hpp"
 
@@ -61,10 +62,6 @@ CUBOS_REFLECT_IMPL(PhysicsBundle)
         .build();
 }
 
-static bool simulatePhysicsStep(PhysicsAccumulator& accumulator, const FixedDeltaTime& fixedDeltaTime)
-{
-    return accumulator.value >= fixedDeltaTime.value;
-}
 
 void cubos::engine::physicsPlugin(Cubos& cubos)
 {
@@ -84,6 +81,7 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
     cubos.addPlugin(collisionsPlugin);
     cubos.addPlugin(gravityPlugin);
     cubos.addPlugin(solverPlugin);
+    cubos.addPlugin(fixedStepPlugin);
 
     // add components to entities created with PhysicsBundle
     cubos.system("unpack PhysicsBundle's")
@@ -108,22 +106,16 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
             }
         });
 
-    // executed every frame
-    cubos.system("increase fixed-step accumulator")
-        .tagged("cubos.physics.simulation.prepare")
-        .call(
-            [](PhysicsAccumulator& accumulator, const DeltaTime& deltaTime) { accumulator.value += deltaTime.value; });
 
     cubos.tag("cubos.physics.apply_forces")
         .after("cubos.physics.simulation.prepare")
-        .before("cubos.physics.simulation.substeps.integrate")
-        .runIf(simulatePhysicsStep);
+        .before("cubos.physics.simulation.substeps.integrate");
 
     cubos.system("apply impulses")
         .tagged("cubos.physics.simulation.apply_impulses")
         .after("cubos.physics.apply_forces")
         .before("cubos.physics.simulation.substeps.integrate")
-        .onlyIf(simulatePhysicsStep)
+        .tagged("cubos.fixedStep")
         .call([](Query<Velocity&, const Impulse&, const Mass&> query) {
             for (auto [velocity, impulse, mass] : query)
             {
@@ -134,7 +126,7 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
     cubos.system("integrate position")
         .tagged("cubos.physics.simulation.substeps.integrate")
         .after("cubos.physics.simulation.prepare")
-        .onlyIf(simulatePhysicsStep)
+        .tagged("cubos.fixedStep")
         .call([](Query<Position&, PreviousPosition&, Velocity&, const Force&, const Mass&> query,
                  const Damping& damping, const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps) {
             float subDeltaTime = fixedDeltaTime.value / (float)substeps.value;
@@ -162,7 +154,7 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
     cubos.system("apply corrections to positions")
         .tagged("cubos.physics.simulation.substeps.correct_position")
         .after("cubos.physics.simulation.substeps.integrate")
-        .onlyIf(simulatePhysicsStep)
+        .tagged("cubos.fixedStep")
         .call([](Query<Position&, AccumulatedCorrection&, Mass&> query) {
             for (auto [position, correction, mass] : query)
             {
@@ -178,7 +170,7 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
     cubos.system("update velocities")
         .tagged("cubos.physics.simulation.substeps.update_velocity")
         .after("cubos.physics.simulation.substeps.correct_position")
-        .onlyIf(simulatePhysicsStep)
+        .tagged("cubos.fixedStep")
         .call([](Query<const Position&, const PreviousPosition&, Velocity&> query, const FixedDeltaTime& fixedDeltaTime,
                  const Substeps& substeps) {
             float subDeltaTime = fixedDeltaTime.value / (float)substeps.value;
@@ -192,7 +184,7 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
     cubos.system("clear forces")
         .tagged("cubos.physics.simulation.clear_forces")
         .after("cubos.physics.simulation.substeps.update_velocity")
-        .onlyIf(simulatePhysicsStep)
+        .tagged("cubos.fixedStep")
         .call([](Query<Force&> query) {
             for (auto [force] : query)
             {
@@ -203,7 +195,7 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
     cubos.system("clear impulses")
         .tagged("cubos.physics.simulation.clear_forces")
         .after("cubos.physics.simulation.substeps.update_velocity")
-        .onlyIf(simulatePhysicsStep)
+        .tagged("cubos.fixedStep")
         .call([](Query<Impulse&> query) {
             for (auto [impulse] : query)
             {
@@ -214,7 +206,7 @@ void cubos::engine::physicsPlugin(Cubos& cubos)
     cubos.system("decrease fixed-step accumulator")
         .tagged("cubos.physics.simulation.decrease_accumulator")
         .after("cubos.physics.simulation.clear_forces")
-        .onlyIf(simulatePhysicsStep)
+        .tagged("cubos.fixedStep")
         .call([](PhysicsAccumulator& accumulator, const FixedDeltaTime& fixedDeltaTime) {
             accumulator.value -= fixedDeltaTime.value;
         });