text: // MIT License
  
  // Copyright (c) 2019 Erin Catto
  
  // Permission is hereby granted, free of charge, to any person obtaining a copy
  // of this software and associated documentation files (the "Software"), to deal
  // in the Software without restriction, including without limitation the rights
  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  // copies of the Software, and to permit persons to whom the Software is
  // furnished to do so, subject to the following conditions:
  
  // The above copyright notice and this permission notice shall be included in all
  // copies or substantial portions of the Software.
  
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  // SOFTWARE.
  
  #include "box2d/b2_draw.h"
  #include "box2d/b2_rope.h"
  
  #include <stdio.h>
  
  struct b2RopeStretch
  {
  	int32 i1, i2;
  	float invMass1, invMass2;
  	float L;
  	float lambda;
  	float spring;
  	float damper;
  };
  
  struct b2RopeBend
  {
  	int32 i1, i2, i3;
  	float invMass1, invMass2, invMass3;
  	float invEffectiveMass;
  	float lambda;
  	float L1, L2;
  	float alpha1, alpha2;
  	float spring;
  	float damper;
  };
  
  b2Rope::b2Rope()
  {
  	m_position.SetZero();
  	m_count = 0;
  	m_stretchCount = 0;
  	m_bendCount = 0;
  	m_stretchConstraints = nullptr;
  	m_bendConstraints = nullptr;
  	m_bindPositions = nullptr;
  	m_ps = nullptr;
  	m_p0s = nullptr;
  	m_vs = nullptr;
  	m_invMasses = nullptr;
  	m_gravity.SetZero();
  }
  
  b2Rope::~b2Rope()
  {
  	b2Free(m_stretchConstraints);
  	b2Free(m_bendConstraints);
  	b2Free(m_bindPositions);
  	b2Free(m_ps);
  	b2Free(m_p0s);
  	b2Free(m_vs);
  	b2Free(m_invMasses);
  }
  
  void b2Rope::Create(const b2RopeDef& def)
  {
  	b2Assert(def.count >= 3);
  	m_position = def.position;
  	m_count = def.count;
  	m_bindPositions = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
  	m_ps = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
  	m_p0s = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
  	m_vs = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
  	m_invMasses = (float*)b2Alloc(m_count * sizeof(float));
  
  	for (int32 i = 0; i < m_count; ++i)
  	{
  		m_bindPositions[i] = def.vertices[i];
  		m_ps[i] = def.vertices[i] + m_position;
  		m_p0s[i] = def.vertices[i] + m_position;
  		m_vs[i].SetZero();
  
  		float m = def.masses[i];
  		if (m > 0.0f)
  		{
  			m_invMasses[i] = 1.0f / m;
  		}
  		else
  		{
  			m_invMasses[i] = 0.0f;
  		}
  	}
  
  	m_stretchCount = m_count - 1;
  	m_bendCount = m_count - 2;
  
  	m_stretchConstraints = (b2RopeStretch*)b2Alloc(m_stretchCount * sizeof(b2RopeStretch));
  	m_bendConstraints = (b2RopeBend*)b2Alloc(m_bendCount * sizeof(b2RopeBend));
  
  	for (int32 i = 0; i < m_stretchCount; ++i)
  	{
  		b2RopeStretch& c = m_stretchConstraints[i];
  
  		b2Vec2 p1 = m_ps[i];
  		b2Vec2 p2 = m_ps[i+1];
  
  		c.i1 = i;
  		c.i2 = i + 1;
  		c.L = b2Distance(p1, p2);
  		c.invMass1 = m_invMasses[i];
  		c.invMass2 = m_invMasses[i + 1];
  		c.lambda = 0.0f;
  		c.damper = 0.0f;
  		c.spring = 0.0f;
  	}
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		b2RopeBend& c = m_bendConstraints[i];
  
  		b2Vec2 p1 = m_ps[i];
  		b2Vec2 p2 = m_ps[i + 1];
  		b2Vec2 p3 = m_ps[i + 2];
  
  		c.i1 = i;
  		c.i2 = i + 1;
  		c.i3 = i + 2;
  		c.invMass1 = m_invMasses[i];
  		c.invMass2 = m_invMasses[i + 1];
  		c.invMass3 = m_invMasses[i + 2];
  		c.invEffectiveMass = 0.0f;
  		c.L1 = b2Distance(p1, p2);
  		c.L2 = b2Distance(p2, p3);
  		c.lambda = 0.0f;
  
  		// Pre-compute effective mass (TODO use flattened config)
  		b2Vec2 e1 = p2 - p1;
  		b2Vec2 e2 = p3 - p2;
  		float L1sqr = e1.LengthSquared();
  		float L2sqr = e2.LengthSquared();
  
  		if (L1sqr * L2sqr == 0.0f)
  		{
  			continue;
  		}
  
  		b2Vec2 Jd1 = (-1.0f / L1sqr) * e1.Skew();
  		b2Vec2 Jd2 = (1.0f / L2sqr) * e2.Skew();
  
  		b2Vec2 J1 = -Jd1;
  		b2Vec2 J2 = Jd1 - Jd2;
  		b2Vec2 J3 = Jd2;
  
  		c.invEffectiveMass = c.invMass1 * b2Dot(J1, J1) + c.invMass2 * b2Dot(J2, J2) + c.invMass3 * b2Dot(J3, J3);
  	
  		b2Vec2 r = p3 - p1;
  
  		float rr = r.LengthSquared();
  		if (rr == 0.0f)
  		{
  			continue;
  		}
  
  		// a1 = h2 / (h1 + h2)
  		// a2 = h1 / (h1 + h2)
  		c.alpha1 = b2Dot(e2, r) / rr;
  		c.alpha2 = b2Dot(e1, r) / rr;
  	}
  
  	m_gravity = def.gravity;
  
  	SetTuning(def.tuning);
  }
  
  void b2Rope::SetTuning(const b2RopeTuning& tuning)
  {
  	m_tuning = tuning;
  
  	// Pre-compute spring and damper values based on tuning
  
  	const float bendOmega = 2.0f * b2_pi * m_tuning.bendHertz;
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		b2RopeBend& c = m_bendConstraints[i];
  
  		float L1sqr = c.L1 * c.L1;
  		float L2sqr = c.L2 * c.L2;
  
  		if (L1sqr * L2sqr == 0.0f)
  		{
  			c.spring = 0.0f;
  			c.damper = 0.0f;
  			continue;
  		}
  
  		// Flatten the triangle formed by the two edges
  		float J2 = 1.0f / c.L1 + 1.0f / c.L2;
  		float sum = c.invMass1 / L1sqr + c.invMass2 * J2 * J2 + c.invMass3 / L2sqr;
  		if (sum == 0.0f)
  		{
  			c.spring = 0.0f;
  			c.damper = 0.0f;
  			continue;
  		}
  
  		float mass = 1.0f / sum;
  
  		c.spring = mass * bendOmega * bendOmega;
  		c.damper = 2.0f * mass * m_tuning.bendDamping * bendOmega;
  	}
  	
  	const float stretchOmega = 2.0f * b2_pi * m_tuning.stretchHertz;
  
  	for (int32 i = 0; i < m_stretchCount; ++i)
  	{
  		b2RopeStretch& c = m_stretchConstraints[i];
  
  		float sum = c.invMass1 + c.invMass2;
  		if (sum == 0.0f)
  		{
  			continue;
  		}
  
  		float mass = 1.0f / sum;
  
  		c.spring = mass * stretchOmega * stretchOmega;
  		c.damper = 2.0f * mass * m_tuning.stretchDamping * stretchOmega;
  	}
  }
  
  void b2Rope::Step(float dt, int32 iterations, const b2Vec2& position)
  {
  	if (dt == 0.0)
  	{
  		return;
  	}
  
  	const float inv_dt = 1.0f / dt;
  	float d = expf(- dt * m_tuning.damping);
  
  	// Apply gravity and damping
  	for (int32 i = 0; i < m_count; ++i)
  	{
  		if (m_invMasses[i] > 0.0f)
  		{
  			m_vs[i] *= d;
  			m_vs[i] += dt * m_gravity;
  		}
  		else
  		{
  			m_vs[i] = inv_dt * (m_bindPositions[i] + position - m_p0s[i]);
  		}
  	}
  
  	// Apply bending spring
  	if (m_tuning.bendingModel == b2_springAngleBendingModel)
  	{
  		ApplyBendForces(dt);
  	}
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		m_bendConstraints[i].lambda = 0.0f;
  	}
  
  	for (int32 i = 0; i < m_stretchCount; ++i)
  	{
  		m_stretchConstraints[i].lambda = 0.0f;
  	}
  
  	// Update position
  	for (int32 i = 0; i < m_count; ++i)
  	{
  		m_ps[i] += dt * m_vs[i];
  	}
  
  	// Solve constraints
  	for (int32 i = 0; i < iterations; ++i)
  	{
  		if (m_tuning.bendingModel == b2_pbdAngleBendingModel)
  		{
  			SolveBend_PBD_Angle();
  		}
  		else if (m_tuning.bendingModel == b2_xpbdAngleBendingModel)
  		{
  			SolveBend_XPBD_Angle(dt);
  		}
  		else if (m_tuning.bendingModel == b2_pbdDistanceBendingModel)
  		{
  			SolveBend_PBD_Distance();
  		}
  		else if (m_tuning.bendingModel == b2_pbdHeightBendingModel)
  		{
  			SolveBend_PBD_Height();
  		}
  		else if (m_tuning.bendingModel == b2_pbdTriangleBendingModel)
  		{
  			SolveBend_PBD_Triangle();
  		}
  
  		if (m_tuning.stretchingModel == b2_pbdStretchingModel)
  		{
  			SolveStretch_PBD();
  		}
  		else if (m_tuning.stretchingModel == b2_xpbdStretchingModel)
  		{
  			SolveStretch_XPBD(dt);
  		}
  	}
  
  	// Constrain velocity
  	for (int32 i = 0; i < m_count; ++i)
  	{
  		m_vs[i] = inv_dt * (m_ps[i] - m_p0s[i]);
  		m_p0s[i] = m_ps[i];
  	}
  }
  
  void b2Rope::Reset(const b2Vec2& position)
  {
  	m_position = position;
  
  	for (int32 i = 0; i < m_count; ++i)
  	{
  		m_ps[i] = m_bindPositions[i] + m_position;
  		m_p0s[i] = m_bindPositions[i] + m_position;
  		m_vs[i].SetZero();
  	}
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		m_bendConstraints[i].lambda = 0.0f;
  	}
  
  	for (int32 i = 0; i < m_stretchCount; ++i)
  	{
  		m_stretchConstraints[i].lambda = 0.0f;
  	}
  }
  
  void b2Rope::SolveStretch_PBD()
  {
  	const float stiffness = m_tuning.stretchStiffness;
  
  	for (int32 i = 0; i < m_stretchCount; ++i)
  	{
  		const b2RopeStretch& c = m_stretchConstraints[i];
  
  		b2Vec2 p1 = m_ps[c.i1];
  		b2Vec2 p2 = m_ps[c.i2];
  
  		b2Vec2 d = p2 - p1;
  		float L = d.Normalize();
  
  		float sum = c.invMass1 + c.invMass2;
  		if (sum == 0.0f)
  		{
  			continue;
  		}
  
  		float s1 = c.invMass1 / sum;
  		float s2 = c.invMass2 / sum;
  
  		p1 -= stiffness * s1 * (c.L - L) * d;
  		p2 += stiffness * s2 * (c.L - L) * d;
  
  		m_ps[c.i1] = p1;
  		m_ps[c.i2] = p2;
  	}
  }
  
  void b2Rope::SolveStretch_XPBD(float dt)
  {
  	b2Assert(dt > 0.0f);
  
  	for (int32 i = 0; i < m_stretchCount; ++i)
  	{
  		b2RopeStretch& c = m_stretchConstraints[i];
  
  		b2Vec2 p1 = m_ps[c.i1];
  		b2Vec2 p2 = m_ps[c.i2];
  
  		b2Vec2 dp1 = p1 - m_p0s[c.i1];
  		b2Vec2 dp2 = p2 - m_p0s[c.i2];
  
  		b2Vec2 u = p2 - p1;
  		float L = u.Normalize();
  
  		b2Vec2 J1 = -u;
  		b2Vec2 J2 = u;
  
  		float sum = c.invMass1 + c.invMass2;
  		if (sum == 0.0f)
  		{
  			continue;
  		}
  
  		const float alpha = 1.0f / (c.spring * dt * dt);	// 1 / kg
  		const float beta = dt * dt * c.damper;				// kg * s
  		const float sigma = alpha * beta / dt;				// non-dimensional
  		float C = L - c.L;
  
  		// This is using the initial velocities
  		float Cdot = b2Dot(J1, dp1) + b2Dot(J2, dp2);
  
  		float B = C + alpha * c.lambda + sigma * Cdot;
  		float sum2 = (1.0f + sigma) * sum + alpha;
  
  		float impulse = -B / sum2;
  
  		p1 += (c.invMass1 * impulse) * J1;
  		p2 += (c.invMass2 * impulse) * J2;
  
  		m_ps[c.i1] = p1;
  		m_ps[c.i2] = p2;
  		c.lambda += impulse;
  	}
  }
  
  void b2Rope::SolveBend_PBD_Angle()
  {
  	const float stiffness = m_tuning.bendStiffness;
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		const b2RopeBend& c = m_bendConstraints[i];
  
  		b2Vec2 p1 = m_ps[c.i1];
  		b2Vec2 p2 = m_ps[c.i2];
  		b2Vec2 p3 = m_ps[c.i3];
  
  		b2Vec2 d1 = p2 - p1;
  		b2Vec2 d2 = p3 - p2;
  		float a = b2Cross(d1, d2);
  		float b = b2Dot(d1, d2);
  
  		float angle = b2Atan2(a, b);
  
  		float L1sqr, L2sqr;
  		
  		if (m_tuning.isometric)
  		{
  			L1sqr = c.L1 * c.L1;
  			L2sqr = c.L2 * c.L2;
  		}
  		else
  		{
  			L1sqr = d1.LengthSquared();
  			L2sqr = d2.LengthSquared();
  		}
  
  		if (L1sqr * L2sqr == 0.0f)
  		{
  			continue;
  		}
  
  		b2Vec2 Jd1 = (-1.0f / L1sqr) * d1.Skew();
  		b2Vec2 Jd2 = (1.0f / L2sqr) * d2.Skew();
  
  		b2Vec2 J1 = -Jd1;
  		b2Vec2 J2 = Jd1 - Jd2;
  		b2Vec2 J3 = Jd2;
  
  		float sum;
  		if (m_tuning.fixedEffectiveMass)
  		{
  			sum = c.invEffectiveMass;
  		}
  		else
  		{
  			sum = c.invMass1 * b2Dot(J1, J1) + c.invMass2 * b2Dot(J2, J2) + c.invMass3 * b2Dot(J3, J3);
  		}
  
  		if (sum == 0.0f)
  		{
  			sum = c.invEffectiveMass;
  		}
  
  		float impulse = -stiffness * angle / sum;
  
  		p1 += (c.invMass1 * impulse) * J1;
  		p2 += (c.invMass2 * impulse) * J2;
  		p3 += (c.invMass3 * impulse) * J3;
  
  		m_ps[c.i1] = p1;
  		m_ps[c.i2] = p2;
  		m_ps[c.i3] = p3;
  	}
  }
  
  void b2Rope::SolveBend_XPBD_Angle(float dt)
  {
  	b2Assert(dt > 0.0f);
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		b2RopeBend& c = m_bendConstraints[i];
  
  		b2Vec2 p1 = m_ps[c.i1];
  		b2Vec2 p2 = m_ps[c.i2];
  		b2Vec2 p3 = m_ps[c.i3];
  
  		b2Vec2 dp1 = p1 - m_p0s[c.i1];
  		b2Vec2 dp2 = p2 - m_p0s[c.i2];
  		b2Vec2 dp3 = p3 - m_p0s[c.i3];
  
  		b2Vec2 d1 = p2 - p1;
  		b2Vec2 d2 = p3 - p2;
  
  		float L1sqr, L2sqr;
  
  		if (m_tuning.isometric)
  		{
  			L1sqr = c.L1 * c.L1;
  			L2sqr = c.L2 * c.L2;
  		}
  		else
  		{
  			L1sqr = d1.LengthSquared();
  			L2sqr = d2.LengthSquared();
  		}
  
  		if (L1sqr * L2sqr == 0.0f)
  		{
  			continue;
  		}
  
  		float a = b2Cross(d1, d2);
  		float b = b2Dot(d1, d2);
  
  		float angle = b2Atan2(a, b);
  
  		b2Vec2 Jd1 = (-1.0f / L1sqr) * d1.Skew();
  		b2Vec2 Jd2 = (1.0f / L2sqr) * d2.Skew();
  
  		b2Vec2 J1 = -Jd1;
  		b2Vec2 J2 = Jd1 - Jd2;
  		b2Vec2 J3 = Jd2;
  
  		float sum;
  		if (m_tuning.fixedEffectiveMass)
  		{
  			sum = c.invEffectiveMass;
  		}
  		else
  		{
  			sum = c.invMass1 * b2Dot(J1, J1) + c.invMass2 * b2Dot(J2, J2) + c.invMass3 * b2Dot(J3, J3);
  		}
  
  		if (sum == 0.0f)
  		{
  			continue;
  		}
  
  		const float alpha = 1.0f / (c.spring * dt * dt);
  		const float beta = dt * dt * c.damper;
  		const float sigma = alpha * beta / dt;
  		float C = angle;
  
  		// This is using the initial velocities
  		float Cdot = b2Dot(J1, dp1) + b2Dot(J2, dp2) + b2Dot(J3, dp3);
  
  		float B = C + alpha * c.lambda + sigma * Cdot;
  		float sum2 = (1.0f + sigma) * sum + alpha;
  
  		float impulse = -B / sum2;
  
  		p1 += (c.invMass1 * impulse) * J1;
  		p2 += (c.invMass2 * impulse) * J2;
  		p3 += (c.invMass3 * impulse) * J3;
  
  		m_ps[c.i1] = p1;
  		m_ps[c.i2] = p2;
  		m_ps[c.i3] = p3;
  		c.lambda += impulse;
  	}
  }
  
  void b2Rope::ApplyBendForces(float dt)
  {
  	// omega = 2 * pi * hz
  	const float omega = 2.0f * b2_pi * m_tuning.bendHertz;
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		const b2RopeBend& c = m_bendConstraints[i];
  
  		b2Vec2 p1 = m_ps[c.i1];
  		b2Vec2 p2 = m_ps[c.i2];
  		b2Vec2 p3 = m_ps[c.i3];
  
  		b2Vec2 v1 = m_vs[c.i1];
  		b2Vec2 v2 = m_vs[c.i2];
  		b2Vec2 v3 = m_vs[c.i3];
  
  		b2Vec2 d1 = p2 - p1;
  		b2Vec2 d2 = p3 - p2;
  
  		float L1sqr, L2sqr;
  
  		if (m_tuning.isometric)
  		{
  			L1sqr = c.L1 * c.L1;
  			L2sqr = c.L2 * c.L2;
  		}
  		else
  		{
  			L1sqr = d1.LengthSquared();
  			L2sqr = d2.LengthSquared();
  		}
  
  		if (L1sqr * L2sqr == 0.0f)
  		{
  			continue;
  		}
  
  		float a = b2Cross(d1, d2);
  		float b = b2Dot(d1, d2);
  
  		float angle = b2Atan2(a, b);
  
  		b2Vec2 Jd1 = (-1.0f / L1sqr) * d1.Skew();
  		b2Vec2 Jd2 = (1.0f / L2sqr) * d2.Skew();
  
  		b2Vec2 J1 = -Jd1;
  		b2Vec2 J2 = Jd1 - Jd2;
  		b2Vec2 J3 = Jd2;
  
  		float sum;
  		if (m_tuning.fixedEffectiveMass)
  		{
  			sum = c.invEffectiveMass;
  		}
  		else
  		{
  			sum = c.invMass1 * b2Dot(J1, J1) + c.invMass2 * b2Dot(J2, J2) + c.invMass3 * b2Dot(J3, J3);
  		}
  
  		if (sum == 0.0f)
  		{
  			continue;
  		}
  
  		float mass = 1.0f / sum;
  
  		const float spring = mass * omega * omega;
  		const float damper = 2.0f * mass * m_tuning.bendDamping * omega;
  
  		float C = angle;
  		float Cdot = b2Dot(J1, v1) + b2Dot(J2, v2) + b2Dot(J3, v3);
  
  		float impulse = -dt * (spring * C + damper * Cdot);
  
  		m_vs[c.i1] += (c.invMass1 * impulse) * J1;
  		m_vs[c.i2] += (c.invMass2 * impulse) * J2;
  		m_vs[c.i3] += (c.invMass3 * impulse) * J3;
  	}
  }
  
  void b2Rope::SolveBend_PBD_Distance()
  {
  	const float stiffness = m_tuning.bendStiffness;
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		const b2RopeBend& c = m_bendConstraints[i];
  
  		int32 i1 = c.i1;
  		int32 i2 = c.i3;
  
  		b2Vec2 p1 = m_ps[i1];
  		b2Vec2 p2 = m_ps[i2];
  
  		b2Vec2 d = p2 - p1;
  		float L = d.Normalize();
  
  		float sum = c.invMass1 + c.invMass3;
  		if (sum == 0.0f)
  		{
  			continue;
  		}
  
  		float s1 = c.invMass1 / sum;
  		float s2 = c.invMass3 / sum;
  
  		p1 -= stiffness * s1 * (c.L1 + c.L2 - L) * d;
  		p2 += stiffness * s2 * (c.L1 + c.L2 - L) * d;
  
  		m_ps[i1] = p1;
  		m_ps[i2] = p2;
  	}
  }
  
  // Constraint based implementation of:
  // P. Volino: Simple Linear Bending Stiffness in Particle Systems
  void b2Rope::SolveBend_PBD_Height()
  {
  	const float stiffness = m_tuning.bendStiffness;
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		const b2RopeBend& c = m_bendConstraints[i];
  
  		b2Vec2 p1 = m_ps[c.i1];
  		b2Vec2 p2 = m_ps[c.i2];
  		b2Vec2 p3 = m_ps[c.i3];
  
  		// Barycentric coordinates are held constant
  		b2Vec2 d = c.alpha1 * p1 + c.alpha2 * p3 - p2;
  		float dLen = d.Length();
  
  		if (dLen == 0.0f)
  		{
  			continue;
  		}
  
  		b2Vec2 dHat = (1.0f / dLen) * d;
  
  		b2Vec2 J1 = c.alpha1 * dHat;
  		b2Vec2 J2 = -dHat;
  		b2Vec2 J3 = c.alpha2 * dHat;
  
  		float sum = c.invMass1 * c.alpha1 * c.alpha1 + c.invMass2 + c.invMass3 * c.alpha2 * c.alpha2;
  
  		if (sum == 0.0f)
  		{
  			continue;
  		}
  
  		float C = dLen;
  		float mass = 1.0f / sum;
  		float impulse = -stiffness * mass * C;
  
  		p1 += (c.invMass1 * impulse) * J1;
  		p2 += (c.invMass2 * impulse) * J2;
  		p3 += (c.invMass3 * impulse) * J3;
  
  		m_ps[c.i1] = p1;
  		m_ps[c.i2] = p2;
  		m_ps[c.i3] = p3;
  	}
  }
  
  // M. Kelager: A Triangle Bending Constraint Model for PBD
  void b2Rope::SolveBend_PBD_Triangle()
  {
  	const float stiffness = m_tuning.bendStiffness;
  
  	for (int32 i = 0; i < m_bendCount; ++i)
  	{
  		const b2RopeBend& c = m_bendConstraints[i];
  
  		b2Vec2 b0 = m_ps[c.i1];
  		b2Vec2 v = m_ps[c.i2];
  		b2Vec2 b1 = m_ps[c.i3];
  
  		float wb0 = c.invMass1;
  		float wv = c.invMass2;
  		float wb1 = c.invMass3;
  
  		float W = wb0 + wb1 + 2.0f * wv;
  		float invW = stiffness / W;
  
  		b2Vec2 d = v - (1.0f / 3.0f) * (b0 + v + b1);
  
  		b2Vec2 db0 = 2.0f * wb0 * invW * d;
  		b2Vec2 dv = -4.0f * wv * invW * d;
  		b2Vec2 db1 = 2.0f * wb1 * invW * d;
  
  		b0 += db0;
  		v += dv;
  		b1 += db1;
  
  		m_ps[c.i1] = b0;
  		m_ps[c.i2] = v;
  		m_ps[c.i3] = b1;
  	}
  }
  
  void b2Rope::Draw(b2Draw* draw) const
  {
  	b2Color c(0.4f, 0.5f, 0.7f);
  	b2Color pg(0.1f, 0.8f, 0.1f);
  	b2Color pd(0.7f, 0.2f, 0.4f);
  
  	for (int32 i = 0; i < m_count - 1; ++i)
  	{
  		draw->DrawSegment(m_ps[i], m_ps[i+1], c);
  
  		const b2Color& pc = m_invMasses[i] > 0.0f ? pd : pg;
  		draw->DrawPoint(m_ps[i], 5.0f, pc);
  	}
  
  	const b2Color& pc = m_invMasses[m_count - 1] > 0.0f ? pd : pg;
  	draw->DrawPoint(m_ps[m_count - 1], 5.0f, pc);
  }
  