OpenGL + Cloth simulation physics isn't working - c++

Question

I am attempting to implement a cloth simulation using a spring-particle system but something isn't quite right with my physics. When I run the simulation the cloth draws as expected but over time the force of gravity pulls the cloth downward indefinitely. In other words the forces caused by the springs are not accumulating properly to overcome the downward pull of gravity and I end up with this...:
It continues to droop downwards indefinitely. From all of the debugging I have done what I have seen is that the accumulation of forces on a particle caused by all of the springs attached to it is not properly summing when the force of gravity causes increased stretch. I can not figure out what I have overlooked in my physics.
My cloth updates every time step using this function
void Cloth::updateGeometry(atlas::utils::Time const& t) {
for (int i = 0; i < mSprings.size(); ++i) {
mSprings[i].calculateForces();
}
for (int i = 0; i < mParticles.size(); ++i) {
mParticles[i].updateGeometry(t);
}
}
My springs update using the below function where p1 and p2 are pointers to each particle that this spring is attached to.
void Spring::calculateForces() {
glm::vec3 springVector = normalize((p2->getCurrentPosition() - p1->getCurrentPosition()));
GLfloat stretchLength = length(p2->getCurrentPosition(), p1->getCurrentPosition());
GLfloat displacementFromRest = restLength - stretchLength;
glm::vec3 springForce = -k * displacementFromRest * normalize(springVector);
//Multiply the displacements by the spring constant to get
//A vector which represents the force on each spring
p1->addToSumOfSpringForces(springForce);
p2->addToSumOfSpringForces(-springForce);
}
Finally my particles update using.
void Particle::updateGeometry(atlas::utils::Time const& t) {
if (!stationary) {
previousPosition = currentPosition;
glm::vec3 forceOfGravity = mass * gravity;
glm::vec3 totalForce = forceOfGravity + (mass * totalSpringForces) - velocity*Damping;
acceleration = totalForce / mass;
//Perform Euler Integration
currentPosition += t.deltaTime * velocity;
velocity += t.deltaTime * acceleration;
//============== End Euler==============//
//Reset the forces acting on the particle from all of the springs
//So that a new accumulated total can be calculated.
totalSpringForces = glm::vec3{ 0.0f, 0.0f, 0.0f };
}
}
The totalSpringForces variable is updated by the call to addToSumOfSpringForces(springForce); in the spring update function. The idea is that each spring is evaluated first according to the current position of each particle then each particle's totalSpringForcevariable is accumulated each iteration using
void Particle::addToSumOfSpringForces(glm::vec3 force) {
totalSpringForces += force;
}
Just to add clarification the cloth is constructed using structural, bend and shear springs in accordance with this description. This may be unneccesary but I've included my cloth constructor below.
Cloth::Cloth(GLfloat width_, GLfloat height_, GLuint numParticlesWide_, GLuint numParticlesHigh_) :
width(width_),
height(height_),
numParticlesHigh(numParticlesHigh_),
numParticlesWide(numParticlesWide_),
clothRotationVector{0.0f, 0.0f, 0.0f},
clothPosition{ 0.0f, 5.0f, 0.0f },
clothRotationAngle(0.0f)
{
USING_ATLAS_MATH_NS;
USING_ATLAS_GL_NS;
glm::vec3 clothColour{1.0f, 0.5f, 0.2f};
//Create Particles
GLuint count = 0;
restLength = (width * (1 / (float)numParticlesWide));
for (GLuint y = 0; y < numParticlesHigh; ++y) {
for (GLuint x = 0; x < numParticlesWide; ++x) {
glm::vec3 pos = {(width * (x / (float)numParticlesWide)), (-height * (y / (float)numParticlesHigh)), 0.0f};
mParticles.push_back(Particle(pos, count, clothColour));
++count;
}
}
//Create Springs
for (GLuint x = 0; x < numParticlesWide; ++x) {
for (GLuint y = 0; y < numParticlesHigh; ++y) {
//============ Structural springs ==========//
//Connect to the particle to the immediate right of the current particle
if (x < numParticlesWide - 1) mSprings.push_back(Spring(getParticle(x,y), getParticle(x+1,y)));
//Connect to the particle that is immediately below the current particle
if (y < numParticlesHigh - 1) mSprings.push_back(Spring(getParticle(x,y), getParticle(x,y+1)));
//============ Shear Springs ================//
//Connect the shear springs to make the X pattern
if (x < numParticlesWide - 1 && y < numParticlesHigh - 1) {
mSprings.push_back(Spring(getParticle(x, y), getParticle(x + 1, y + 1)));
mSprings.push_back(Spring(getParticle(x+1, y), getParticle(x, y+1)));
}
//============ Bend Springs ===============//
//Connect the current particle to the second particle over to the right
if (x < numParticlesWide - 2) mSprings.push_back(Spring(getParticle(x,y), getParticle(x+2,y)));
//Connect the current particle to the particle two below
if (y < numParticlesHigh - 2) mSprings.push_back(Spring(getParticle(x,y), getParticle(x, y+2)));
////Create the X pattern
//if (x < numParticlesWide - 2 && y < numParticlesHigh - 2) {
// mSprings.push_back(Spring(getParticle(x, y), getParticle(x+2,y+2)));
// mSprings.push_back(Spring(getParticle(x+2,y), getParticle(x,y+2)));
//};
}
}
//Set the top left and right as stationary
getParticle(0, 0)->makeStationary();
getParticle(numParticlesWide - 1, 0)->makeStationary();
//Make Indices for Particles
for (GLuint row = 0; row < numParticlesWide - 1; ++row) {
for (GLuint col = 0; col < numParticlesHigh - 1; ++col) {
//Triangle one
mParticleIndices.push_back(getParticle(row,col)->getIndex());
mParticleIndices.push_back(getParticle(row,col+1)->getIndex());
mParticleIndices.push_back(getParticle(row+1, col)->getIndex());
//Triangle two
mParticleIndices.push_back(getParticle(row, col+1)->getIndex());
mParticleIndices.push_back(getParticle(row+1, col+1)->getIndex());
mParticleIndices.push_back(getParticle(row+1, col)->getIndex());
}
}
glGenBuffers(1, &clothVertexBufferID);
glGenBuffers(1, &clothIndexBufferID);
sendDataToGPU();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, clothIndexBufferID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, mParticleIndices.size() * sizeof(GLushort), &mParticleIndices[0], GL_STATIC_DRAW);
defineVAO();
std::string shaderDir = generated::ShaderPaths::getShaderDirectory();
std::vector<ShaderInfo> shaders
{
{ GL_VERTEX_SHADER, shaderDir + "Cloth.vs.glsl" },
{ GL_FRAGMENT_SHADER, shaderDir + "Cloth.fs.glsl" }
};
mModel = glm::translate(Matrix4(1.0f), clothPosition);
mShaders.push_back(ShaderPointer(new Shader));
mShaders[0]->compileShaders(shaders);
mShaders[0]->linkShaders();
mUniforms.insert(UniformKey("mvpMat",mShaders[0]->getUniformVariable("mvpMat")));
mShaders[0]->disableShaders();
}
EDIT
I have verified that the totalSpringForcesvariable is indeed changing. I added a print statement in my Particle update function which you can see in the image below. The selected the totalSpringForces for only particle #55 which in this case is the particle immediately under particle 0 which is stationary and not allowed to move. Also the printout is after about 20-25 iterations. As you can see the totalSpringForcesin the y direction has positive value of 0.7037 (i.e. is counteracting gravity). I let it run for half an hour and it only got to 5.
Currently my constants are
k = 2.0f
mass = 0.1f
damping = 0.55f
gravity{ 0.0f, -9.81f, 0.0f },