feat(engine): added resource to easily configure magic numbers in solver

engine/CMakeLists.txt

@@ -90,9 +90,11 @@ set(CUBOS_ENGINE_SOURCE
 	"src/physics/solver/plugin.cpp"
 	"src/physics/constraints/penetration_constraint.cpp"
 	"src/physics/solver/penetration_constraint/plugin.cpp"
+	"src/physics/solver/penetration_constraint/physics_constants_pc.cpp"
 	"src/physics/fixed_substep/plugin.cpp"
 	"src/physics/fixed_substep/substeps.cpp"
 	"src/physics/solver/integration/plugin.cpp"
+	"src/physics/solver/integration/physics_constants_integration.cpp"
 
 	"src/input/plugin.cpp"
 	"src/input/input.cpp"

engine/src/physics/solver/integration/physics_constants_integration.cpp

@@ -0,0 +1,12 @@
+#include "physics_constants_integration.hpp"
+
+#include <cubos/core/ecs/reflection.hpp>
+#include <cubos/core/reflection/external/primitives.hpp>
+
+CUBOS_REFLECT_IMPL(cubos::engine::PhysicsConstantsIntegration)
+{
+    return core::ecs::TypeBuilder<PhysicsConstantsIntegration>("cubos::engine::PhysicsConstantsIntegration")
+        .withField("minInvMass", &PhysicsConstantsIntegration::minInvMass)
+        .withField("minInvInertia", &PhysicsConstantsIntegration::minInvInertia)
+        .build();
+}

engine/src/physics/solver/integration/physics_constants_integration.hpp

@@ -0,0 +1,24 @@
+/// @file
+/// @brief Resource @ref cubos::engine::PhysicsConstantsIntegration.
+/// @ingroup physics-plugin
+
+#pragma once
+
+#include <cubos/core/reflection/reflect.hpp>
+
+#include <cubos/engine/api.hpp>
+
+namespace cubos::engine
+{
+    /// @brief Resource which allows configuration over constants in the integration plugin.
+    /// @ingroup physics-plugin
+    struct PhysicsConstantsIntegration
+    {
+        CUBOS_REFLECT;
+
+        float minInvMass = 0.0F;
+
+        float minInvInertia = 0.0F;
+    };
+
+} // namespace cubos::engine

engine/src/physics/solver/integration/plugin.cpp

@@ -22,6 +22,8 @@ void cubos::engine::physicsIntegrationPlugin(Cubos& cubos)
     cubos.depends(physicsPlugin);
     cubos.depends(physicsSolverPlugin);
 
+    cubos.resource<PhysicsConstantsIntegration>();
+
     cubos.tag(physicsApplyImpulsesTag);
     cubos.tag(physicsClearForcesTag).after(physicsFinalizePositionTag).tagged(fixedStepTag);
 
@@ -54,13 +56,14 @@ void cubos::engine::physicsIntegrationPlugin(Cubos& cubos)
         .call([](Query<Velocity&, AngularVelocity&, const Force&, const Torque&, const Mass&, const Inertia&,
                        const Rotation&>
                      query,
-                 const Damping& damping, const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps) {
+                 const Damping& damping, const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps,
+                 const PhysicsConstantsIntegration& physicsConstants) {
             float subDeltaTime = fixedDeltaTime.value / (float)substeps.value;
 
             for (auto [velocity, angVelocity, force, torque, mass, inertia, rotation] : query)
             {
                 // Linear velocity
-                if (mass.inverseMass <= 0.0F)
+                if (mass.inverseMass <= physicsConstants.minInvMass)
                 {
                     continue;
                 }
@@ -74,7 +77,7 @@ void cubos::engine::physicsIntegrationPlugin(Cubos& cubos)
                 velocity.vec += deltaLinearVelocity;
 
                 // Angular velocity
-                if (inertia.inverseInertia == glm::mat3(0.0F))
+                if (inertia.inverseInertia == glm::mat3(physicsConstants.minInvInertia))
                 {
                     continue;
                 }
@@ -97,21 +100,22 @@ void cubos::engine::physicsIntegrationPlugin(Cubos& cubos)
         .call([](Query<AccumulatedCorrection&, Rotation&, const Velocity&, const AngularVelocity&, const Mass&,
                        const Inertia&>
                      query,
-                 const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps) {
+                 const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps,
+                 const PhysicsConstantsIntegration& physicsConstants) {
             float subDeltaTime = fixedDeltaTime.value / (float)substeps.value;
 
             for (auto [correction, rotation, velocity, angVelocity, mass, inertia] : query)
             {
                 // Position
-                if (mass.inverseMass <= 0.0F)
+                if (mass.inverseMass <= physicsConstants.minInvMass)
                 {
                     continue;
                 }
 
                 correction.position += velocity.vec * subDeltaTime;
 
                 // Rotation
-                if (inertia.inverseInertia == glm::mat3(0.0F))
+                if (inertia.inverseInertia == glm::mat3(physicsConstants.minInvInertia))
                 {
                     continue;
                 }
@@ -124,10 +128,11 @@ void cubos::engine::physicsIntegrationPlugin(Cubos& cubos)
 
     cubos.system("finalize position")
         .tagged(physicsFinalizePositionTag)
-        .call([](Query<Position&, AccumulatedCorrection&, const Mass&> query) {
+        .call([](Query<Position&, AccumulatedCorrection&, const Mass&> query,
+                 const PhysicsConstantsIntegration& physicsConstants) {
             for (auto [position, correction, mass] : query)
             {
-                if (mass.inverseMass <= 0.0F)
+                if (mass.inverseMass <= physicsConstants.minInvMass)
                 {
                     continue;
                 }

engine/src/physics/solver/integration/plugin.hpp

@@ -6,10 +6,16 @@
 
 #include <cubos/engine/prelude.hpp>
 
+#include "physics_constants_integration.hpp"
+
 namespace cubos::engine
 {
     /// @ingroup physics-solver-plugin
     /// @brief Adds velocity and position integration.
+    ///
+    /// ## Resources
+    /// - @ref PhysicsConstantsIntegration - holds constants for integration plugin.
+    ///
 
     extern Tag physicsApplyImpulsesTag;
     extern Tag physicsClearForcesTag;

engine/src/physics/solver/penetration_constraint/physics_constants_pc.cpp

@@ -0,0 +1,18 @@
+#include "physics_constants_pc.hpp"
+
+#include <cubos/core/ecs/reflection.hpp>
+#include <cubos/core/reflection/external/primitives.hpp>
+
+CUBOS_REFLECT_IMPL(cubos::engine::PhysicsConstantsPC)
+{
+    return core::ecs::TypeBuilder<PhysicsConstantsPC>("cubos::engine::PhysicsConstantsPC")
+        .withField("maxBias", &PhysicsConstantsPC::maxBias)
+        .withField("minContactHertz", &PhysicsConstantsPC::minContactHertz)
+        .withField("minKNormal", &PhysicsConstantsPC::minKNormal)
+        .withField("minKFriction", &PhysicsConstantsPC::minKFriction)
+        .withField("minTangentLenSq", &PhysicsConstantsPC::minTangentLenSq)
+        .withField("minRestitution", &PhysicsConstantsPC::minRestitution)
+        .withField("minNormalSpeed", &PhysicsConstantsPC::minNormalSpeed)
+        .withField("minNormalImpulse", &PhysicsConstantsPC::minNormalImpulse)
+        .build();
+}

engine/src/physics/solver/penetration_constraint/physics_constants_pc.hpp

@@ -0,0 +1,36 @@
+/// @file
+/// @brief Resource @ref cubos::engine::PhysicsConstantsPC.
+/// @ingroup physics-plugin
+
+#pragma once
+
+#include <cubos/core/reflection/reflect.hpp>
+
+#include <cubos/engine/api.hpp>
+
+namespace cubos::engine
+{
+    /// @brief Resource which allows configuration over magic numbers in the solver plugin.
+    /// @ingroup physics-plugin
+    struct PhysicsConstantsPC
+    {
+        CUBOS_REFLECT;
+
+        float maxBias = -4.0F;
+
+        float minContactHertz = 30.0F;
+
+        float minKNormal = 0.0F;
+
+        float minKFriction = 0.0F;
+
+        float minTangentLenSq = 1e-6F * 1e-6F;
+
+        float minRestitution = 0.0F;
+
+        float minNormalSpeed = -0.01F;
+
+        float minNormalImpulse = 0.0F;
+    };
+
+} // namespace cubos::engine

engine/src/physics/solver/penetration_constraint/plugin.cpp

@@ -34,14 +34,14 @@ static void getPlaneSpace(const glm::vec3& n, glm::vec3& tangent1, glm::vec3& ta
 }
 
 static void getTangents(const glm::vec3& velocity1, const glm::vec3& velocity2, const glm::vec3& n, glm::vec3& tangent1,
-                        glm::vec3& tangent2)
+                        glm::vec3& tangent2, const PhysicsConstantsPC& physicsConstants)
 {
     // Use linear relative velocity for determining tangents.
     glm::vec3 linearVr = velocity2 - velocity1;
 
     tangent1 = linearVr - glm::dot(linearVr, n) * n;
     float tangentLenSq = glm::length2(tangent1);
-    if (tangentLenSq > 1e-6 * 1e-6) /// TODO: check this
+    if (tangentLenSq > physicsConstants.minTangentLenSq) /// TODO: check this
     {
         tangent1 = glm::normalize(tangent1);
         tangent2 = glm::cross(n, tangent1);
@@ -82,7 +82,8 @@ static void solvePenetrationConstraint(
           PenetrationConstraint&, Entity, const Mass&, const Inertia&, const Rotation&, AccumulatedCorrection&,
           Velocity&, AngularVelocity&>
         query,
-    const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps, const bool useBias)
+    const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps, const PhysicsConstantsPC& physicsConstants,
+    const bool useBias)
 {
     for (auto [ent1, mass1, inertia1, rotation1, correction1, velocity1, angVelocity1, constraint, ent2, mass2,
                inertia2, rotation2, correction2, velocity2, angVelocity2] : query)
@@ -120,7 +121,7 @@ static void solvePenetrationConstraint(
             }
             else if (useBias)
             {
-                bias = glm::max(constraint.biasCoefficient * separation, -4.0F);
+                bias = glm::max(constraint.biasCoefficient * separation, physicsConstants.maxBias);
                 massScale = constraint.massCoefficient;
                 impulseScale = constraint.impulseCoefficient;
             }
@@ -161,11 +162,11 @@ static void solvePenetrationConstraint(
         glm::vec3 tangent2;
         if (ent1 != constraint.entity)
         {
-            getTangents(v2, v1, constraint.normal, tangent1, tangent2);
+            getTangents(v2, v1, constraint.normal, tangent1, tangent2, physicsConstants);
         }
         else
         {
-            getTangents(v1, v2, constraint.normal, tangent1, tangent2);
+            getTangents(v1, v2, constraint.normal, tangent1, tangent2, physicsConstants);
         }
 
         // Friction
@@ -229,6 +230,8 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
 
     cubos.relation<PenetrationConstraint>();
 
+    cubos.resource<PhysicsConstantsPC>();
+
     cubos.tag(addPenetrationConstraintTag);
     cubos.tag(penetrationConstraintSolveTag);
     cubos.tag(penetrationConstraintSolveRelaxTag);
@@ -242,8 +245,10 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
                        AngularVelocity&, PenetrationConstraint&, Entity, const Mass&, const Inertia&, const Rotation&,
                        AccumulatedCorrection&, Velocity&, AngularVelocity&>
                      query,
-                 const FixedDeltaTime& fixedDeltaTime,
-                 const Substeps& substeps) { solvePenetrationConstraint(query, fixedDeltaTime, substeps, true); });
+                 const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps,
+                 const PhysicsConstantsPC& physicsConstants) {
+            solvePenetrationConstraint(query, fixedDeltaTime, substeps, physicsConstants, true);
+        });
 
     cubos.system("solve contacts no bias")
         .tagged(penetrationConstraintSolveRelaxTag)
@@ -252,8 +257,10 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
                        AngularVelocity&, PenetrationConstraint&, Entity, const Mass&, const Inertia&, const Rotation&,
                        AccumulatedCorrection&, Velocity&, AngularVelocity&>
                      query,
-                 const FixedDeltaTime& fixedDeltaTime,
-                 const Substeps& substeps) { solvePenetrationConstraint(query, fixedDeltaTime, substeps, false); });
+                 const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps,
+                 const PhysicsConstantsPC& physicsConstants) {
+            solvePenetrationConstraint(query, fixedDeltaTime, substeps, physicsConstants, false);
+        });
 
     cubos.system("add restitution")
         .tagged(penetrationConstraintRestitutionTag)
@@ -263,11 +270,12 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
         .call([](Query<Entity, const Mass&, const Inertia&, AccumulatedCorrection&, Velocity&, AngularVelocity&,
                        PenetrationConstraint&, Entity, const Mass&, const Inertia&, AccumulatedCorrection&, Velocity&,
                        AngularVelocity&>
-                     query) {
+                     query,
+                 const PhysicsConstantsPC& physicsConstants) {
             for (auto [ent1, mass1, inertia1, correction1, velocity1, angVelocity1, constraint, ent2, mass2, inertia2,
                        correction2, velocity2, angVelocity2] : query)
             {
-                if (constraint.restitution == 0.0F)
+                if (constraint.restitution == physicsConstants.minRestitution)
                 {
                     continue;
                 }
@@ -279,7 +287,8 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
 
                 for (auto point : constraint.points)
                 {
-                    if (point.normalSpeed > -0.01F || point.normalImpulse == 0.0F)
+                    if (point.normalSpeed > physicsConstants.minNormalSpeed ||
+                        point.normalImpulse == physicsConstants.minNormalImpulse)
                     {
                         continue;
                     }
@@ -330,9 +339,10 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
                        const Inertia&, const CenterOfMass&, const Rotation&, const Velocity&, const AngularVelocity&,
                        const PhysicsMaterial&>
                      query,
-                 const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps) {
+                 const FixedDeltaTime& fixedDeltaTime, const Substeps& substeps,
+                 const PhysicsConstantsPC& physicsConstants) {
             float subDeltaTime = fixedDeltaTime.value / (float)substeps.value;
-            float contactHertz = glm::min(30.0F, 0.25F * (1.0F / subDeltaTime));
+            float contactHertz = glm::min(physicsConstants.minContactHertz, 0.25F * (1.0F / subDeltaTime));
 
             for (auto [ent1, mass1, inertia1, centerOfMass1, rotation1, velocity1, angVelocity1, material1, manifold,
                        ent2, mass2, inertia2, centerOfMass2, rotation2, velocity2, angVelocity2, material2] : query)
@@ -341,11 +351,11 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
                 glm::vec3 tangent2;
                 if (ent1 != manifold.entity)
                 {
-                    getTangents(velocity2.vec, velocity1.vec, manifold.normal, tangent1, tangent2);
+                    getTangents(velocity2.vec, velocity1.vec, manifold.normal, tangent1, tangent2, physicsConstants);
                 }
                 else
                 {
-                    getTangents(velocity1.vec, velocity2.vec, manifold.normal, tangent1, tangent2);
+                    getTangents(velocity1.vec, velocity2.vec, manifold.normal, tangent1, tangent2, physicsConstants);
                 }
 
                 std::vector<PenetrationConstraintPointData> points;
@@ -386,7 +396,7 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
                     float kNormal = mass1.inverseMass + mass2.inverseMass +
                                     glm::dot(inertia1.inverseInertia * rn1, rn1) +
                                     glm::dot(inertia2.inverseInertia * rn2, rn2);
-                    pointData.normalMass = kNormal > 0.0F ? 1.0F / kNormal : 0.0F;
+                    pointData.normalMass = kNormal > physicsConstants.minKNormal ? 1.0F / kNormal : 0.0F;
 
                     // friction mass
                     glm::vec3 rt11 = glm::cross(r1, tangent1);
@@ -406,8 +416,8 @@ void cubos::engine::penetrationConstraintPlugin(Cubos& cubos)
                         mass1.inverseMass + mass2.inverseMass + glm::dot(i1Rt21, rt21) + glm::dot(i2Rt22, rt22);
 
                     /// TODO: these could be an array in the point
-                    pointData.frictionMass1 = kFriction1 > 0.0F ? 1.0F / kFriction1 : 0.0F;
-                    pointData.frictionMass2 = kFriction2 > 0.0F ? 1.0F / kFriction2 : 0.0F;
+                    pointData.frictionMass1 = kFriction1 > physicsConstants.minKFriction ? 1.0F / kFriction1 : 0.0F;
+                    pointData.frictionMass2 = kFriction2 > physicsConstants.minKFriction ? 1.0F / kFriction2 : 0.0F;
 
                     points.push_back(pointData);
                 }

engine/src/physics/solver/penetration_constraint/plugin.hpp

@@ -7,11 +7,16 @@
 #include <cubos/engine/prelude.hpp>
 
 #include "../../constraints/penetration_constraint.hpp"
+#include "physics_constants_pc.hpp"
 
 namespace cubos::engine
 {
     /// @ingroup physics-solver-plugin
     /// @brief Adds solver for penetration constraint.
+    ///
+    /// ## Resources
+    /// - @ref PhysicsConstantsPC - holds constants for penetration constraint plugin.
+    ///
 
     extern Tag addPenetrationConstraintTag;
     extern Tag penetrationConstraintCleanTag;