added constraint energy computation logging to debug window

Author: frederic-hallein

src/ImGuiWindow.cpp

@@ -204,7 +204,7 @@ void DebugWindow::displayXPBDParameters(
 
     float& alpha = scene.getAlpha();
     float alpha_min = 0.0f;
-    if (scene.getName() == "Test Scene 2") alpha_min = 0.1f;
+    if (scene.getName() == "Test Scene 2") alpha_min = 0.1f; // TODO: create icosphere with a lot of triangles
     float alpha_max = 1.0f;
     ImGui::Text("Compliance:");
     ImGui::PushItemWidth(ImGui::GetContentRegionAvail().x - 1);
@@ -346,6 +346,13 @@ void DebugWindow::displaySceneObjects(
             continue;
         }
 
+        float distanceEnergy = object->getDistanceConstraintEnergy();
+        ImGui::Text("Distance Constraint Energy: %.2f J", distanceEnergy);
+
+        float volumeEnergy = object->getVolumeConstraintEnergy();
+        ImGui::Text("Volume Constraint Energy: %.2f J", volumeEnergy);
+        ImGui::Dummy(ImVec2(0.0f, 5.0f));
+
         displayVertexTransforms(i, object);
         displayPolygonMode(i, object);
         displayNormalShaders(i, object);

src/Object.hpp

@@ -14,8 +14,7 @@
 #include "Light.hpp"
 #include "Texture.hpp"
 
-class Object
-{
+class Object {
 public:
     Object() = default;
     Object(
@@ -47,6 +46,12 @@ class Object
     Mesh& getMesh() { return m_mesh; }
     const std::vector<float>& getMass() const { return m_M; }
 
+    float getDistanceConstraintEnergy() const { return m_distanceEnergy; }
+    void setDistanceConstraintEnergy(float energy) { m_distanceEnergy = energy; }
+
+    float getVolumeConstraintEnergy() const { return m_volumeEnergy; }
+    void setVolumeConstraintEnergy(float energy) { m_volumeEnergy = energy; }
+
     void resetVertexTransforms();
 
     void setProjectionViewUniforms(const Shader& shader);
@@ -60,6 +65,7 @@ class Object
     static void setVertexNormalShader(const Shader& shader) { s_vertexNormalShader = shader; }
     static void setFaceNormalShader(const Shader& shader)   { s_faceNormalShader   = shader; }
 
+
 private:
     std::string m_name;
     Transform m_transform;
@@ -79,4 +85,7 @@ class Object
     std::vector<Transform> m_vertexTransforms;
     std::vector<float> m_M;
 
+    float m_distanceEnergy;
+    float m_volumeEnergy;
+
 };

src/Scene.cpp

@@ -473,6 +473,25 @@ void Scene::solveMouseConstraints(
     }
 }
 
+float Scene::computeConstraintEnergy(
+    float alpha,
+    const std::vector<Constraint>& constraints,
+    const std::vector<glm::vec3>& x
+)
+{
+    if (alpha == 0.0f) {
+        return 0.0f;
+    }
+
+    float totalEnergy = 0.0f;
+    for (const auto& constraint : constraints) {
+        float C = constraint(x);
+        totalEnergy += (0.5f / alpha) * (C * C);
+    }
+
+    return totalEnergy;
+}
+
 void Scene::solveDistanceConstraints(
     std::vector<glm::vec3>& x,
     const std::vector<glm::vec3>& posDiff,
@@ -503,6 +522,17 @@ void Scene::solveDistanceConstraints(
     }
 }
 
+void Scene::computeDistanceConstraintEnergy(
+    Object& object,
+    const std::vector<glm::vec3>& x,
+    float alpha,
+    const Mesh::DistanceConstraints& distanceConstraints
+)
+{
+    float energy = computeConstraintEnergy(alpha, distanceConstraints.C, x);
+    object.setDistanceConstraintEnergy(energy);
+}
+
 void Scene::solveVolumeConstraints(
     std::vector<glm::vec3>& x,
     const std::vector<glm::vec3>& posDiff,
@@ -536,6 +566,17 @@ void Scene::solveVolumeConstraints(
     updateConstraintPositions(x, deltaX);
 }
 
+void Scene::computeVolumeConstraintEnergy(
+    Object& object,
+    const std::vector<glm::vec3>& x,
+    float alpha,
+    const Mesh::VolumeConstraints& volumeConstraints
+)
+{
+    float energy = computeConstraintEnergy(alpha, volumeConstraints.C, x);
+    object.setVolumeConstraintEnergy(energy);
+}
+
 // TODO : fixme
 void Scene::solveEnvCollisionConstraints(
     std::vector<glm::vec3>& x,
@@ -650,18 +691,6 @@ void Scene::applyXPBD(
             );
         }
 
-        // Environment Collision constraints
-        if (m_enableEnvCollisionConstraints) {
-            solveEnvCollisionConstraints(
-                x,
-                posDiff,
-                M,
-                alphaTilde,
-                gamma,
-                perEnvCollisionConstraints
-            );
-        }
-
         // Distance constraints
         if (m_enableDistanceConstraints) {
             solveDistanceConstraints(
@@ -672,6 +701,13 @@ void Scene::applyXPBD(
                 gamma,
                 distanceConstraints
             );
+
+            computeDistanceConstraintEnergy(
+                object,
+                x,
+                m_alpha,
+                distanceConstraints
+            );
         }
 
         // Volume constraints
@@ -684,6 +720,25 @@ void Scene::applyXPBD(
                 gamma,
                 volumeConstraints
             );
+
+            computeVolumeConstraintEnergy(
+                object,
+                x,
+                m_alpha,
+                volumeConstraints
+            );
+        }
+
+        // Environment Collision constraints
+        if (m_enableEnvCollisionConstraints) {
+            solveEnvCollisionConstraints(
+                x,
+                posDiff,
+                M,
+                alphaTilde,
+                gamma,
+                perEnvCollisionConstraints
+            );
         }
 
         // Update positions and velocities

src/Scene.hpp

@@ -84,6 +84,12 @@ class Scene
         float deltaTime_s
     );
 
+    float computeConstraintEnergy(
+        float alpha,
+        const std::vector<std::function<float(const std::vector<glm::vec3>&)>>& constraintFunctions,
+        const std::vector<glm::vec3>& x
+    );
+
     bool& enableDistanceConstraints() { return m_enableDistanceConstraints; }
     void solveDistanceConstraints(
         std::vector<glm::vec3>& x,
@@ -93,6 +99,12 @@ class Scene
         float gamma,
         const Mesh::DistanceConstraints& distanceConstraints
     );
+    void computeDistanceConstraintEnergy(
+        Object& object,
+        const std::vector<glm::vec3>& x,
+        float alpha,
+        const Mesh::DistanceConstraints& distanceConstraints
+    );
 
     bool& enableVolumeConstraints() { return m_enableVolumeConstraints; }
     void solveVolumeConstraints(
@@ -103,6 +115,12 @@ class Scene
         float gamma,
         const Mesh::VolumeConstraints& volumeConstraints
     );
+    void computeVolumeConstraintEnergy(
+        Object& object,
+        const std::vector<glm::vec3>& x,
+        float alpha,
+        const Mesh::VolumeConstraints& volumeConstraints
+    );
 
     bool& enableEnvCollisionConstraints() { return m_enableEnvCollisionConstraints; }
     void solveEnvCollisionConstraints(