XCEngine/engine/third_party/physx/source/gpusimulationcontroller/src/CUDA/FEMClothUtil.cuh

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2025 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  

#ifndef __CU_FEMCLOTHUTIL_CUH__
#define __CU_FEMCLOTHUTIL_CUH__

#include "PxgFEMCloth.h"
#include "vector_types.h"
#include "foundation/PxVec3.h"
#include "foundation/PxVec4.h"
#include "foundation/PxBounds3.h"
#include "copy.cuh"
#include "shuffle.cuh"
#include "assert.h"
#include "stdio.h"
#include "PxgFEMClothCoreKernelIndices.h"
#include "atomic.cuh"
#include "PxsDeformableSurfaceMaterialCore.h"
#include "femMidphaseScratch.cuh"
#include "GuBV32.h"
#include "deformableUtils.cuh"
#include "particleSystem.cuh"
#include "utils.cuh"


using namespace physx;


/*******************************************************************************
 *
 * 
 * Definitions
 * 
 * 
 ******************************************************************************/
 
#define FEMCLOTH_SQRT2		1.4142135623730950488016887242097f
#define FEMCLOTH_SQRT3		1.7320508075688772935274463415059f

#define FEMCLOTH_THRESHOLD	1.0e-14f
#define FEMCLOTH_PI			3.14159265358979323846f
#define FEMCLOTH_HALF_PI	1.57079632679489661923f
#define FEMCLOTH_2PI		6.28318530717958647692f
#define FEMCLOTH_2PI_INV	0.15915494309189533576888376337251f





/*******************************************************************************
 *
 *
 * Math functions
 *
 *
 ******************************************************************************/

//! 
//! \brief    : Extract rotation R [r0, r1] from F [f0, f1] in 2D 
//! \reference: https://en.wikipedia.org/wiki/Square_root_of_a_2_by_2_matrix
//! 

static PX_FORCE_INLINE __device__ void extractRotation2D(PxVec2& r0, PxVec2& r1, const PxVec2& f0, const PxVec2& f1)
{
	// R: rotation part of F (by polar decopmosition)
	// F^T * F = [S2[0], S2[2]]
	//           [S2[2], S2[1]]
	const PxVec3 S2(f0.dot(f0), f1.dot(f1), f0.dot(f1));
	const float det = S2[0] * S2[1] - S2[2] * S2[2];

	if (det < FEMCLOTH_THRESHOLD)
	{
		r0.x = 1.0f;
		r0.y = 0.0f;
		r1.x = 0.0f;
		r1.y = 1.0f;
		return;
	}

	const float s0 = sqrtf(det);
	const float t = sqrtf(S2[0] + S2[1] + 2.0f * s0);
	
	assert(t > 0.0f);
	if (t < FEMCLOTH_THRESHOLD)
	{
		r0.x = 1.0f;
		r0.y = 0.0f;
		r1.x = 0.0f;
		r1.y = 1.0f;
		return;
	}
	const float tInv = 1.0f / t;

	PxVec3 S(S2);
	S[0] += s0;
	S[1] += s0;
	S *= tInv;

	const float sDet = S[0] * S[1] - S[2] * S[2];
	assert(sDet > 0.0f);
	
	if (sDet < FEMCLOTH_THRESHOLD)
	{
		r0.x = 1.0f;
		r0.y = 0.0f;
		r1.x = 0.0f;
		r1.y = 1.0f;
		return;
	}

	const float sDetInv = 1.0f / sDet;

	PxVec3 SInv(S[1], S[0], -S[2]);
	SInv *= sDetInv;

	// R = [r0 r1]
	r0 = SInv[0] * f0 + SInv[2] * f1;
	r1 = SInv[2] * f0 + SInv[1] * f1;
}



//!
//! \brief    : Approximated atan2: max error of ~1/10000
//! \reference: https://mazzo.li/posts/vectorized-atan2.html
//!

static PX_FORCE_INLINE __device__ PxReal atanApprox(PxReal x)
{
	PxReal x2 = x * x;
	return x * (0.99997726f + x2 * (-0.33262347f + x2 * (0.19354346f + x2 * (-0.11643287f + x2 * (0.05265332f + x2 * (-0.01172120f))))));
}

static PX_FORCE_INLINE __device__ PxReal atan2Approx(PxReal y, PxReal x)
{
	bool swap = PxAbs(x) < PxAbs(y);
	PxReal input = swap ? (x / y) : (y / x);
	PxReal output = atanApprox(input);

	output = swap ? (input >= 0.f ? FEMCLOTH_HALF_PI : -FEMCLOTH_HALF_PI) - output : output;

	if(x < 0.f)
	{
		output += (y >= 0.f ? FEMCLOTH_PI : -FEMCLOTH_PI);
	}

	return output;
}

static PX_FORCE_INLINE __device__ bool velocityClamping(float4& pos, float4& vel, float4& accumDelta, PxReal maxVel, PxReal dt,
														const float4& prevPos)
{
	const PxReal maxVelSq = maxVel * maxVel;
	const PxReal velMagSq = PxLoad3(vel).magnitudeSquared();
	if (velMagSq > maxVelSq)
	{
		vel *= maxVel / PxSqrt(velMagSq);
		float4 newPos = prevPos + vel * dt;
		newPos.w = pos.w;
		vel.w = pos.w;

		const float4 delta = newPos - pos;
		pos = newPos;
		accumDelta += delta;
		return true; // Velocity is clamped.
	}

	return false; // Velocity is not clamped.
}




/*******************************************************************************
 *
 *
 * Delta lambda updates
 *
 *
 ******************************************************************************/

//! 
//! \brief    : Returns the delta lambda in XPBD when a constraint has three vertex degrees of freedom, applicable in both 2D and 3D but without damping.
//! 

template <typename PxVec2Or3>
static PX_FORCE_INLINE __device__ float queryDeltaLambda(float C, const PxVec2Or3& dCdx0, const PxVec2Or3& dCdx1, const PxVec2Or3& dCdx2,
														 float alphaTilde, float lambda, float massInv0, float massInv1, float massInv2)
{
	const float denom =
		(massInv0 * dCdx0.magnitudeSquared() + massInv1 * dCdx1.magnitudeSquared() + massInv2 * dCdx2.magnitudeSquared()) + alphaTilde;
	assert(denom != 0.0f);

	if (denom < FEMCLOTH_THRESHOLD)
		return 0.0f;

	return (-C - alphaTilde * lambda) / denom;
}

//! 
//! \brief    : Returns the delta lambda in XPBD when a constraint has three vertex degrees of freedom, applicable in both 2D and 3D with damping.
//! 

template <typename PxVec2Or3>
static PX_FORCE_INLINE __device__ float queryDeltaLambda(float C, const PxVec2Or3& dCdx0, const PxVec2Or3& dCdx1, const PxVec2Or3& dCdx2,
														 float alphaTilde, float lambda, float massInv0, float massInv1, float massInv2,
														 float damping, float dtInv, float dCdT)
{
	const float denom = (1.0f + damping * dtInv) * (massInv0 * dCdx0.magnitudeSquared() + massInv1 * dCdx1.magnitudeSquared() +
													massInv2 * dCdx2.magnitudeSquared()) +
						alphaTilde;
	assert(denom != 0.0f);

	if (denom < FEMCLOTH_THRESHOLD)
		return 0.0f;

	return -(C + alphaTilde * lambda + damping * dCdT) / denom;
}

//! 
//! \brief    : Returns the delta lambda in XPBD when a constraint has four vertex degrees of freedom, applicable in 3D but without damping.
//! 

static PX_FORCE_INLINE __device__ float queryDeltaLambda(float C, const PxVec3& dCdx0, const PxVec3& dCdx1, const PxVec3& dCdx2,
														 const PxVec3& dCdx3, float alphaTilde, float lambda, float massInv0,
														 float massInv1, float massInv2, float massInv3)
{
	const float denom = (massInv0 * dCdx0.magnitudeSquared() + massInv1 * dCdx1.magnitudeSquared() + massInv2 * dCdx2.magnitudeSquared() +
						 massInv3 * dCdx3.magnitudeSquared()) +
						alphaTilde;
	assert(denom != 0.0f);

	if (denom < FEMCLOTH_THRESHOLD)
		return 0.0f;

	return (-C - alphaTilde * lambda) / denom;
}

//! 
//! \brief    : Returns the delta lambda in XPBD when a constraint has four vertex degrees of freedom, applicable in 3D with damping.
//! 

static PX_FORCE_INLINE __device__ float queryDeltaLambda(float C, const PxVec3& dCdx0, const PxVec3& dCdx1, const PxVec3& dCdx2,
														 const PxVec3& dCdx3, float alphaTilde, float lambda, float massInv0, float massInv1,
														 float massInv2, float massInv3, float damping, float dtInv, const float dCdT)
{
	const float denom = (1.0f + damping * dtInv) * (massInv0 * dCdx0.magnitudeSquared() + massInv1 * dCdx1.magnitudeSquared() +
													massInv2 * dCdx2.magnitudeSquared() + massInv3 * dCdx3.magnitudeSquared()) +
						alphaTilde;
	assert(denom != 0.0f);

	if (denom < FEMCLOTH_THRESHOLD)
		return 0.0f;

	return -(C + alphaTilde * lambda + damping * dCdT) / denom;
}





/*******************************************************************************
 *
 *
 * Deformation gradient and its derivatives
 *
 *
 ******************************************************************************/

//! 
//! \brief    : query deformation gradients (F \in R^{2x2})
//! 

static PX_FORCE_INLINE __device__ void queryDeformationGradient_F2x2(PxVec2& f0, PxVec2& f1, const float4& QInv, const PxVec2& xp01,
																	 const PxVec2& xp02)
{
	f0 = QInv.x * xp01 + QInv.y * xp02;
	f1 = QInv.z * xp01 + QInv.w * xp02;
}



//! 
//! \brief    : compute gradient of constraint (F \in R^{2x2})
//! 

static PX_FORCE_INLINE __device__ void queryConstraintGradient_F2x2(PxVec2& grad1, PxVec2& grad2, const float4& qInv, const PxVec2& pC_pF0,
																	const PxVec2& pC_pF1)
{
	grad1 = qInv.x * pC_pF0 + qInv.z * pC_pF1;
	grad2 = qInv.y * pC_pF0 + qInv.w * pC_pF1;
}





/*******************************************************************************
 *
 *
 * Constraint functions
 *
 *
 ******************************************************************************/

 //! 
 //! \brief    : As-Rigid-As-Possible constraint using {sqrt(||F - R||_F^2)}, F \in R^{2x2}
 //! 

static inline __device__ void ARAPConstraint_F2X2(float& lambda, PxVec2& dx0, PxVec2& dx1, PxVec2& dx2, float alphaTilde,
												  const float4& QInv, const PxVec2& x01, const PxVec2& x02, float massInv0, float massInv1,
												  float massInv2, const PxgFEMCloth& shFEMCloth)
{
	PxVec2 f0, f1, r0, r1;      // F = [f0 f1], R = [r0 r1]
	PxVec2 grad0, grad1, grad2; // gradient of constraint

	queryDeformationGradient_F2x2(f0, f1, QInv, x01, x02);
	extractRotation2D(r0, r1, f0, f1);

	PxVec2 FMinusR0 = f0 - r0;
	PxVec2 FMinusR1 = f1 - r1;

	const float C = sqrt(FMinusR0.dot(FMinusR0) + FMinusR1.dot(FMinusR1)); // ARAP constraint

	if(C > FEMCLOTH_THRESHOLD)
	{
		const float CInv = 1.0f / C;

		// pC/pF = [pCA_pF0 pCA_pF1]
		const PxVec2 pC_pF0 = CInv * FMinusR0;
		const PxVec2 pC_pF1 = CInv * FMinusR1;

		queryConstraintGradient_F2x2(grad1, grad2, QInv, pC_pF0, pC_pF1);
		grad0 = -grad1 - grad2;

		const float deltaLambda = queryDeltaLambda(C, grad0, grad1, grad2, alphaTilde, lambda, massInv0, massInv1, massInv2);
		lambda += deltaLambda;

		dx0 += massInv0 * deltaLambda * grad0;
		dx1 += massInv1 * deltaLambda * grad1;
		dx2 += massInv2 * deltaLambda * grad2;
	}
}



//! 
//! \brief    : Area conservation constraint
//! 

static inline __device__ void areaConstraint_F2X2(float& lambda, PxVec2& dx0, PxVec2& dx1, PxVec2& dx2, float alphaTilde,
												  const float4& QInv, const PxVec2& x01, const PxVec2& x02, float massInv0, float massInv1,
												  float massInv2, float area, const PxgFEMCloth& shFEMCloth)
{
#if 1

	// Area constraints
	// C = |x01 X x02| / |u01 X u02| - 1.0
	const PxReal x01CrossX02 = x01.x * x02.y - x01.y * x02.x;
	const float undeformedAreaInv = 1.0f / area;

	const float C = 0.5f * x01CrossX02 * undeformedAreaInv - 1.0f;

	const PxVec2 grad1(0.5f * undeformedAreaInv * x02.y, -0.5f * undeformedAreaInv * x02.x);
	const PxVec2 grad2(-0.5f * undeformedAreaInv * x01.y, 0.5f * undeformedAreaInv * x01.x);
	const PxVec2 grad0 = -grad1 - grad2;

#else

	// Area constraints
	// C = det(F) - 1, F \in R^ { 2x2 }
	PxVec2 f0, f1, r0, r1;		// F = [f0 f1], R = [r0 r1]
	PxVec2 grad0, grad1, grad2; // gradient of constraint

	queryDeformationGradient_F2x2(f0, f1, QInv, x01, x02);

	const PxReal C = f0.x * f1.y - f0.y * f1.x - 1.0f;

	// pC/pF = [pCA_pF0 pCA_pF1]
	const PxVec2 pC_pF0(f1.y, -f0.y);
	const PxVec2 pC_pF1(-f1.x, f0.x);

	queryConstraintGradient_F2x2(grad1, grad2, QInv, pC_pF0, pC_pF1);
	grad0 = -grad1 - grad2;

#endif

	const float deltaLambda = queryDeltaLambda(C, grad0, grad1, grad2, alphaTilde, lambda, massInv0, massInv1, massInv2);
	lambda += deltaLambda;

	dx0 += massInv0 * deltaLambda * grad0;
	dx1 += massInv1 * deltaLambda * grad1;
	dx2 += massInv2 * deltaLambda * grad2;
}





/*******************************************************************************
 *
 *
 * Energy models
 *
 *
 ******************************************************************************/

//! 
//! \brief    : XPBD formulation of fixed corotated model 
//! 

static __device__ inline void membraneEnergySolvePerTriangle(PxgFEMCloth& shFEMCloth, float4& xx0, float4& xx1, float4& xx2, PxReal dt,
															 const PxsDeformableSurfaceMaterialData& material, const float4& QInv,
															 float vertexScale0, float vertexScale1, float vertexScale2, PxU32 lambdaIndex,
															 bool isShared, bool isTGS)
{
	if (material.youngs < FEMCLOTH_THRESHOLD)
	{
		return;
	}

	PxVec3 x0 = PxLoad3(xx0);
	PxVec3 x1 = PxLoad3(xx1);
	PxVec3 x2 = PxLoad3(xx2);

	const PxVec3 x01 = x1 - x0;
	const PxVec3 x02 = x2 - x0;

	const PxVec3 axis0 = x01.getNormalized();
	PxVec3 normal = x01.cross(x02);
	const PxVec3 axis1 = (normal.cross(axis0)).getNormalized();

	const PxReal dt2 = dt * dt;

	const PxReal det = QInv.x * QInv.w - QInv.y * QInv.z;
	const PxReal area = 1.0f / (2.0f * det);
	const PxReal volume = area * material.thickness;

	PxVec2 dx0(0.0f), dx1(0.0f), dx2(0.0f);
	float lambda0 = 0.0f, lambda1 = 0.0f;

	if (!isTGS)
	{
		lambda0 = isShared ? shFEMCloth.mOrderedSharedTriangleLambdas[lambdaIndex].x : shFEMCloth.mOrderedNonSharedTriangleLambdas[lambdaIndex].x;
		lambda1 = isShared ? shFEMCloth.mOrderedSharedTriangleLambdas[lambdaIndex].y : shFEMCloth.mOrderedNonSharedTriangleLambdas[lambdaIndex].y;
	}

	// Lame's parameters
	const PxPair<PxReal, PxReal> lames = lameParameters(material.youngs, material.poissons);

	// 1) enforcing ARAP constraint
	PxVec2 xp01(axis0.dot(x01), axis1.dot(x01));
	PxVec2 xp02(axis0.dot(x02), axis1.dot(x02));

	// Lame's second parameters
	const PxReal mu = lames.second; 
	const PxReal alphaTilde0 = 1.0f / (2.0f * mu * volume * dt2);

	ARAPConstraint_F2X2(lambda0, dx0, dx1, dx2, alphaTilde0, QInv, xp01, xp02, vertexScale0 * xx0.w, vertexScale1 * xx1.w,
						vertexScale2 * xx2.w, shFEMCloth);

	// 2) enforcing area constraint
	if (material.poissons > FEMCLOTH_THRESHOLD)
	{
		PxReal alphaTilde1 = 0.0f;

		if(material.poissons < 0.5f - FEMCLOTH_THRESHOLD)
		{
			// Lame's first parameters
			const PxReal lambda = lames.first;
			alphaTilde1 = 1.0f / (lambda * volume * dt2);
		}

		xp01 += dx1 - dx0;
		xp02 += dx2 - dx0;

		areaConstraint_F2X2(lambda1, dx0, dx1, dx2, alphaTilde1, QInv, xp01, xp02, vertexScale0 * xx0.w, vertexScale1 * xx1.w,
							vertexScale2 * xx2.w, area, shFEMCloth);
	}

	x0 += dx0.x * axis0 + dx0.y * axis1;
	x1 += dx1.x * axis0 + dx1.y * axis1;
	x2 += dx2.x * axis0 + dx2.y * axis1;

	if (!isTGS)
	{
		if (isShared)
		{
			shFEMCloth.mOrderedSharedTriangleLambdas[lambdaIndex].x = lambda0;
			shFEMCloth.mOrderedSharedTriangleLambdas[lambdaIndex].y = lambda1;
		}
		else
		{
			shFEMCloth.mOrderedNonSharedTriangleLambdas[lambdaIndex].x = lambda0;
			shFEMCloth.mOrderedNonSharedTriangleLambdas[lambdaIndex].y = lambda1;
		}
	}

	xx0.x = x0.x;
	xx0.y = x0.y;
	xx0.z = x0.z;

	xx1.x = x1.x;
	xx1.y = x1.y;
	xx1.z = x1.z;

	xx2.x = x2.x;
	xx2.y = x2.y;
	xx2.z = x2.z;
}



//! 
//! \brief    : XPBD formulation of "Discrete Shells" 
//! 

static __device__ inline void bendingEnergySolvePerTrianglePair(PxgFEMCloth& shFEMCloth, float4& x0, float4& x1, float4& x2, float4& x3,
																const float4& vertexReferenceCounts, float dt, PxU32 trianglePairIndex,
																bool isSharedTrianglePartition, bool isTGS)
{
	const PxVec3 x02 = PxLoad3(x2 - x0);
	const PxVec3 x03 = PxLoad3(x3 - x0);
	const PxVec3 x13 = PxLoad3(x3 - x1);
	const PxVec3 x12 = PxLoad3(x2 - x1);
	const PxVec3 x23 = PxLoad3(x3 - x2);
	const PxReal x23Len = x23.magnitude();

	if(x23Len < FEMCLOTH_THRESHOLD)
		return;

	const PxReal x23LenInv = 1.f / x23Len;
	const PxVec3 x23Normalized = x23 * x23LenInv;

	const float4 restBendingAngle_flexuralStiffness_damping =
		isSharedTrianglePartition ? shFEMCloth.mOrderedSharedRestBendingAngle_flexuralStiffness_damping[trianglePairIndex]
								  : shFEMCloth.mOrderedNonSharedRestBendingAngle_flexuralStiffness_damping[trianglePairIndex];

	const PxReal restBendingAngle = restBendingAngle_flexuralStiffness_damping.x;
	const PxReal kInv = restBendingAngle_flexuralStiffness_damping.y;

	if (kInv <= 0.f)
		return;

	//const PxReal damping = restBendingAngle_flexuralStiffness_damping.z;

	const PxVec3 scaledN0 = x02.cross(x03);
	const PxVec3 scaledN1 = x13.cross(x12);

	const PxReal n0LenInv = 1.f / scaledN0.magnitude();
	const PxReal n1LenInv = 1.f / scaledN1.magnitude();

	const PxVec3 n0 = scaledN0 * n0LenInv;
	PxVec3 n1 = scaledN1 * n1LenInv;

	const PxReal cosAngle = n0.dot(n1);
	const PxReal sinAngle = n0.cross(n1).dot(x23Normalized);
	PxReal angle = atan2f(sinAngle, cosAngle);

	PxReal C = 0.f;
	PxReal alphaTilde = 0.f;
	float dtInv = 1.0f / dt;

	alphaTilde = kInv * dtInv * dtInv;
	C = angle - restBendingAngle;

	if(PxAbs(C + FEMCLOTH_2PI) < PxAbs(C))
	{
		C += FEMCLOTH_2PI;
	}
	else if(PxAbs(C - FEMCLOTH_2PI) < PxAbs(C))
	{
		C -= FEMCLOTH_2PI;
	}

	// Bending constraint clamped.
	C = PxClamp(C, -FEMCLOTH_HALF_PI, FEMCLOTH_HALF_PI);
	const PxVec3 temp0 = n0 * n0LenInv;
	const PxVec3 temp1 = n1 * n1LenInv;
	const PxVec3 dCdx0 = -x23Len * temp0;
	const PxVec3 dCdx1 = -x23Len * temp1;
	const PxVec3 dCdx2 = x03.dot(x23Normalized) * temp0 + x13.dot(x23Normalized) * temp1;
	const PxVec3 dCdx3 = -(x02.dot(x23Normalized) * temp0 + x12.dot(x23Normalized) * temp1);

	PxReal lambda = 0.0f;

	if (!isTGS)
	{
		lambda = isSharedTrianglePartition ? shFEMCloth.mSharedBendingLambdas[trianglePairIndex] :
			shFEMCloth.mNonSharedBendingLambdas[trianglePairIndex];
	}

	float deltaLambda =
		queryDeltaLambda(C, dCdx0, dCdx1, dCdx2, dCdx3, alphaTilde, lambda, vertexReferenceCounts.x * x0.w, vertexReferenceCounts.y * x1.w,
						 vertexReferenceCounts.z * x2.w, vertexReferenceCounts.w * x3.w);

	if (!isTGS)
	{
		if (isSharedTrianglePartition)
		{
			shFEMCloth.mSharedBendingLambdas[trianglePairIndex] = lambda + deltaLambda;
		}
		else
		{
			shFEMCloth.mNonSharedBendingLambdas[trianglePairIndex] = lambda + deltaLambda;
		}
	}

	PxReal scale0 = vertexReferenceCounts.x * x0.w * deltaLambda;
	x0.x += scale0 * dCdx0.x;
	x0.y += scale0 * dCdx0.y;
	x0.z += scale0 * dCdx0.z;

	PxReal scale1 = vertexReferenceCounts.y * x1.w * deltaLambda;
	x1.x += scale1 * dCdx1.x;
	x1.y += scale1 * dCdx1.y;
	x1.z += scale1 * dCdx1.z;

	PxReal scale2 = vertexReferenceCounts.z * x2.w * deltaLambda;
	x2.x += scale2 * dCdx2.x;
	x2.y += scale2 * dCdx2.y;
	x2.z += scale2 * dCdx2.z;

	PxReal scale3 = vertexReferenceCounts.w * x3.w * deltaLambda;
	x3.x += scale3 * dCdx3.x;
	x3.y += scale3 * dCdx3.y;
	x3.z += scale3 * dCdx3.z;

	return;
}

//! 
//! \brief    : Cloth shell energies in a triangle-pair (two adjacent triangles): in-plane + bending
//! 

static __device__ inline 
void
	clothSharedEnergySolvePerTrianglePair(PxgFEMCloth& shFEMCloth, float4& x0, float4& x1, float4& x2, float4& x3,
										  const float4& vertexReferenceCount, const PxsDeformableSurfaceMaterialData* PX_RESTRICT clothMaterials,
										  float dt, PxU32 trianglePairIndex, bool isTGS)
{
	// shared edge: the shared edge between two adjacent triangles (triangle0, triangle1).
	// edge0, edge1: non-shared edge in triangle0 and triangle1, respectively.
	// tri0Count, tri1Count: the number of references to triangle0 and triangle1 in the entire triangle pairs.
	const float4 restData0 = shFEMCloth.mOrderedSharedRestEdge0_edge1[trianglePairIndex];
	const float4 restData1 = shFEMCloth.mOrderedSharedRestEdgeLength_material0_material1[trianglePairIndex];

	const PxU32 globalMaterialIndex0 = static_cast<PxU32>(restData1.y);
	const PxU32 globalMaterialIndex1 = static_cast<PxU32>(restData1.z);

	const PxVec2 restEdge0(restData0.x, restData0.y);
	const PxVec2 restEdge1(restData0.z, restData0.w);
	const float restSharedEdgeLength = restData1.x;

	const float det0 = restSharedEdgeLength * restEdge0.y;
	const float det1 = restSharedEdgeLength * restEdge1.y;

	// In-plane constraint for triangle0 with vertex x2, x3, and x0.
	if(PxAbs(det0) > FEMCLOTH_THRESHOLD)
	{
		const PxU32 lambdaIndex = 2*trianglePairIndex;
		const float4 QInv0 = make_float4(restEdge0.y, 0.0f, -restEdge0.x, restSharedEdgeLength) / det0;
		membraneEnergySolvePerTriangle(shFEMCloth, x2, x3, x0, dt, clothMaterials[globalMaterialIndex0], QInv0, vertexReferenceCount.z,
									   vertexReferenceCount.w, vertexReferenceCount.x, lambdaIndex, true, isTGS);
	}

	// In-plane constraint for triangle1 with vertex x2, x3, and x1.
	if(PxAbs(det1) > FEMCLOTH_THRESHOLD)
	{
		const PxU32 lambdaIndex = 2 * trianglePairIndex + 1;
		const float4 QInv1 = make_float4(restEdge1.y, 0.0f, -restEdge1.x, restSharedEdgeLength) / det1;
		membraneEnergySolvePerTriangle(shFEMCloth, x2, x3, x1, dt, clothMaterials[globalMaterialIndex1], QInv1, vertexReferenceCount.z,
									   vertexReferenceCount.w, vertexReferenceCount.y, lambdaIndex, true, isTGS);
	}

	// Bending constraint for the triangle pair
	bendingEnergySolvePerTrianglePair(shFEMCloth, x0, x1, x2, x3, vertexReferenceCount, dt, trianglePairIndex, true, isTGS);
}

#endif  // FEMCLOTHUTIL