Created a solver class which will house the cloth simulation, modified and refactored the existing classes in preparation for this, now need to modify the solver to accept multiple input meshes.

Author: nitronoid

Project.pro

@@ -47,8 +47,9 @@ HEADERS += \
     include/CSBmesh.h \
     include/MaterialEnvMap.h \
     include/CSBconstraint.h \
-    include/csbpoint.h \
-    include/MaterialCSBpbr.h
+    include/MaterialCSBpbr.h \
+    include/CSBsolver.h \
+    include/CSBparticle.h
 
 SOURCES += \
     src/main.cpp \
@@ -69,7 +70,8 @@ SOURCES += \
     src/CSBmesh.cpp \
     src/MaterialEnvMap.cpp \
     src/CSBconstraint.cpp \
-    src/MaterialCSBpbr.cpp
+    src/MaterialCSBpbr.cpp \
+    src/CSBsolver.cpp
 
 OTHER_FILES += \
     $$files(shaders/*, true) \

include/CSBconstraint.h

@@ -4,7 +4,7 @@
 #include <vector>
 #include <array>
 #include "vec3.hpp"
-#include "csbpoint.h"
+#include "CSBparticle.h"
 
 class CSBconstraint
 {
@@ -15,7 +15,7 @@ class CSBconstraint
   CSBconstraint(CSBconstraint&&) = default;
   CSBconstraint& operator=(CSBconstraint&&) = default;
   virtual ~CSBconstraint();
-  virtual void project(std::vector<CSBpoint> &_positions) = 0;
+  virtual void project(std::vector<CSBparticle> &_positions) = 0;
 };
 
 class DistanceConstraint : public CSBconstraint
@@ -31,7 +31,7 @@ class DistanceConstraint : public CSBconstraint
   DistanceConstraint(DistanceConstraint&&) = default;
   DistanceConstraint& operator=(DistanceConstraint&&) = default;
   virtual ~DistanceConstraint() override = default;
-  virtual void project(std::vector<CSBpoint> &_positions) override;
+  virtual void project(std::vector<CSBparticle> &_positions) override;
 
 private:
   float m_rest;
@@ -43,7 +43,7 @@ class DistanceConstraint : public CSBconstraint
 class BendingConstraint : public CSBconstraint
 {
 public:
-  BendingConstraint(const size_t _p1, const size_t _p2, const size_t _p3, float _rest, const std::vector<CSBpoint>&_points) :
+  BendingConstraint(const size_t _p1, const size_t _p2, const size_t _p3, float _rest, const std::vector<CSBparticle>&_points) :
     m_p({{_p1, _p2, _p3}}),
     m_rest(_rest)
   {
@@ -57,7 +57,7 @@ class BendingConstraint : public CSBconstraint
   BendingConstraint(BendingConstraint&&) = default;
   BendingConstraint& operator=(BendingConstraint&&) = default;
   virtual ~BendingConstraint() override = default;
-  virtual void project(std::vector<CSBpoint> &_positions) override;
+  virtual void project(std::vector<CSBparticle> &_positions) override;
 
 private:
   std::array<size_t, 3> m_p;
@@ -77,7 +77,7 @@ class PinConstraint : public CSBconstraint
   PinConstraint(PinConstraint&&) = default;
   PinConstraint& operator=(PinConstraint&&) = default;
   virtual ~PinConstraint() override = default;
-  virtual void project(std::vector<CSBpoint> &_positions) override;
+  virtual void project(std::vector<CSBparticle> &_positions) override;
 
 private:
   glm::vec3 m_pin;
@@ -88,7 +88,7 @@ class PinConstraint : public CSBconstraint
 class SelfCollisionConstraint : public CSBconstraint
 {
 public:
-  SelfCollisionConstraint(const glm::vec3 &_intersectionP, const size_t &_p, const size_t &_t0, const size_t &_t1, const size_t &_t2, const std::vector<CSBpoint>&_points) :
+  SelfCollisionConstraint(const glm::vec3 &_intersectionP, const size_t &_p, const size_t &_t0, const size_t &_t1, const size_t &_t2, const std::vector<CSBparticle>&_points) :
     m_t({{_t0, _t1, _t2}}),
     m_intersectionP(_intersectionP),
     m_p(_p)
@@ -104,7 +104,7 @@ class SelfCollisionConstraint : public CSBconstraint
   SelfCollisionConstraint(SelfCollisionConstraint&&) = default;
   SelfCollisionConstraint& operator=(SelfCollisionConstraint&&) = default;
   virtual ~SelfCollisionConstraint() override = default;
-  virtual void project(std::vector<CSBpoint> &_positions) override;
+  virtual void project(std::vector<CSBparticle> &_positions) override;
 
 private:
   std::array<size_t, 3> m_t;

include/CSBmesh.h

@@ -6,7 +6,7 @@
 #include <tuple>
 #include <unordered_map>
 #include <unordered_set>
-#include "csbpoint.h"
+#include "CSBparticle.h"
 #include "CSBconstraint.h"
 
 class CSBmesh : public Mesh
@@ -34,12 +34,12 @@ class CSBmesh : public Mesh
   std::unordered_set<EdgePair> getEdges();
   std::vector<GLushort> getConnectedVertices(const GLushort _vert);
 
-  std::vector<CSBpoint> m_points;
+  std::vector<CSBparticle> m_particles;
   std::vector<std::unique_ptr<CSBconstraint>> m_constraints;
 
   glm::ivec3 calcCell(const glm::vec3& _coord) const;
   size_t hashCell (const glm::ivec3& _cell) const;
-  size_t hashPoint(const glm::vec3& _coord) const;
+  size_t hashParticle(const glm::vec3& _coord) const;
   void resolveSelfCollision_rays();
 
   void resolveSelfCollision_spheres();

include/csbpoint.h renamed to include/CSBparticle.h

@@ -3,9 +3,9 @@
 
 #include "vec3.hpp"
 
-struct CSBpoint
+struct CSBparticle
 {
-  CSBpoint(glm::vec3 &_pos, const float &_invMass) :
+  CSBparticle(glm::vec3 &_pos, const float &_invMass) :
       m_pos(_pos),
       m_prevPos(_pos),
       m_invMass(_invMass)

include/CSBscene.h

@@ -5,6 +5,7 @@
 #include "Material.h"
 #include "ShaderLib.h"
 #include "CSBmesh.h"
+#include "CSBsolver.h"
 
 
 class CSBscene : public Scene
@@ -95,11 +96,11 @@ public slots:
   virtual void renderScene() override;
 
 private:
-
+  CSBsolver m_solver;
   //-----------------------------------------------------------------------------------------------------
   /// @brief Holds our test meshes.
   //-----------------------------------------------------------------------------------------------------
-  std::array<CSBmesh, 1> m_meshes;
+  std::array<Mesh, 1> m_meshes;
   //-----------------------------------------------------------------------------------------------------
   /// @brief Wraps up our OpenGL buffers and VAO.
   //-----------------------------------------------------------------------------------------------------

include/CSBsolver.h

@@ -0,0 +1,72 @@
+#ifndef CSBSOLVER_H
+#define CSBSOLVER_H
+
+#include <QOpenGLFunctions>
+#include "glm/common.hpp"
+#include <tuple>
+#include <unordered_map>
+#include <unordered_set>
+#include <memory>
+#include "CSBparticle.h"
+#include "CSBconstraint.h"
+#include "Mesh.h"
+
+class CSBsolver
+{
+public:
+  void addTriangleMesh(Mesh& _mesh);
+  void update(const float _time);
+
+private:
+  struct EdgePair
+  {
+    EdgePair(const GLushort _a, const GLushort _b) :
+      p(std::min(_a, _b), std::max(_a, _b))
+    {}
+    friend bool operator==(const EdgePair &_a, const EdgePair &_b)
+    {
+      return _a.p == _b.p;
+    }
+    std::pair<GLushort, GLushort> p;
+  };
+  friend struct std::hash<CSBsolver::EdgePair>;
+
+  void hashVerts();
+  void hashTris();
+  std::unordered_set<EdgePair> getEdges(Mesh* _meshRef);
+  std::vector<GLushort> getConnectedVertices(Mesh* _meshRef, const GLushort _vert);
+
+  std::vector<CSBparticle> m_particles;
+  std::vector<std::unique_ptr<CSBconstraint>> m_constraints;
+  std::vector<Mesh*> m_referencedMeshes;
+
+  glm::ivec3 calcCell(const glm::vec3& _coord) const;
+  size_t hashCell (const glm::ivec3& _cell) const;
+  size_t hashParticle(const glm::vec3& _coord) const;
+  void resolveSelfCollision_rays();
+
+  void resolveSelfCollision_spheres();
+
+  std::vector<std::vector<GLushort>> m_hashTable;
+  std::vector<std::vector<size_t>> m_triangleVertHash;
+  std::vector<GLushort> m_indices;
+
+  float m_shortestEdgeDist = 0.0f;
+  float m_avgEdgeLength = 0.0f;
+};
+
+
+namespace std
+{
+template <>
+struct hash<CSBsolver::EdgePair>
+{
+  size_t operator()(const CSBsolver::EdgePair &_key) const
+  {
+    return std::hash<size_t>()(std::hash<GLushort>()(_key.p.first)) ^ std::hash<GLushort>()(_key.p.second);
+  }
+};
+}
+
+
+#endif // CSBSOLVER_H

include/Mesh.h

@@ -52,31 +52,42 @@ class Mesh
   //-----------------------------------------------------------------------------------------------------
   const GLfloat* getAttribData(const MeshAttributes::Attribute _attrib) const noexcept;
   //-----------------------------------------------------------------------------------------------------
-  /// @brief Used to the the amount of face indices.
+  /// @brief Used to the number of vertices.
+  /// @return The size of our vertex array.
+  //-----------------------------------------------------------------------------------------------------
+  size_t getNVerts() const noexcept;
+  //-----------------------------------------------------------------------------------------------------
+  /// @brief Used to the amount of face indices.
   /// @return The size of our indices array.
   //-----------------------------------------------------------------------------------------------------
   int getNIndicesData() const noexcept;
   //-----------------------------------------------------------------------------------------------------
-  /// @brief Used to the the amount of vertex data elements.
+  /// @brief Used to the amount of vertex data elements.
   /// @return The size of our vertex array.
   //-----------------------------------------------------------------------------------------------------
   int getNVertData() const noexcept;
   //-----------------------------------------------------------------------------------------------------
-  /// @brief Used to the the amount of normal data elements.
+  /// @brief Used to the amount of normal data elements.
   /// @return The size of our normal array.
   //-----------------------------------------------------------------------------------------------------
   int getNNormData() const noexcept;
   //-----------------------------------------------------------------------------------------------------
-  /// @brief Used to the the amount of UV data elements.
+  /// @brief Used to the amount of UV data elements.
   /// @return The size of our UV array.
   //-----------------------------------------------------------------------------------------------------
   int getNUVData() const noexcept;
   //-----------------------------------------------------------------------------------------------------
-  /// @brief Used to the the amount of data elements across all arrays.
+  /// @brief Used to the amount of data elements across all arrays.
   /// @return The size of our data arrays combined.
   //-----------------------------------------------------------------------------------------------------
   int getNData() const noexcept;
 
+  std::vector<glm::vec3>& getVertices() noexcept;
+
+  const std::vector<GLushort>& getIndices() const noexcept;
+
+  const std::vector<std::vector<GLushort>>& getAdjacencyInfo() const noexcept;
+
 protected:
   //-----------------------------------------------------------------------------------------------------
   /// @brief m_vertices contains the vertices

src/CSBconstraint.cpp

@@ -5,7 +5,7 @@
 
 CSBconstraint::~CSBconstraint() = default;
 
-void DistanceConstraint::project(std::vector<CSBpoint> &_positions)
+void DistanceConstraint::project(std::vector<CSBparticle> &_positions)
 {
   auto& p1 = _positions[m_p1];
   auto& p2 = _positions[m_p2];
@@ -18,7 +18,7 @@ void DistanceConstraint::project(std::vector<CSBpoint> &_positions)
   p2.m_pos -= (delta * p2.m_invMass);
 }
 
-void BendingConstraint::project(std::vector<CSBpoint> &_positions)
+void BendingConstraint::project(std::vector<CSBparticle> &_positions)
 {
   auto& p1 = _positions[m_p[0]];
   auto& p2 = _positions[m_p[1]];
@@ -42,12 +42,12 @@ void BendingConstraint::project(std::vector<CSBpoint> &_positions)
   p3.m_pos += (k * m_w[2] * -4.f * force);
 }
 
-void PinConstraint::project(std::vector<CSBpoint> &_positions)
+void PinConstraint::project(std::vector<CSBparticle> &_positions)
 {
   _positions[m_p].m_pos = m_pin;
 }
 
-void SelfCollisionConstraint::project(std::vector<CSBpoint> &_positions)
+void SelfCollisionConstraint::project(std::vector<CSBparticle> &_positions)
 {
   auto& T0 = _positions[m_t[0]].m_pos;
   auto& T1 = _positions[m_t[1]].m_pos;