PhysX 3.4.1, APEX 1.4.1 Release @22845541v3.4.1

17 files changed, 287 insertions, 259 deletions

diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.cpp
index 9591fdde..8955cf25 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.cpp
@@ -85,12 +85,15 @@ static void setupFinalizeSolverConstraints(Sc::ShapeInteraction* shapeInteractio
 							PxReal invMassScale1, PxReal invInertiaScale1, 
 							bool hasForceThreshold, bool staticOrKinematicBody,
 							const PxReal restDist, PxU8* frictionDataPtr,
-							const PxReal maxCCDSeparation)	
+							const PxReal maxCCDSeparation,
+							const PxReal solverOffsetSlopF32)
 {
 	// NOTE II: the friction patches are sparse (some of them have no contact patches, and
 	// therefore did not get written back to the cache) but the patch addresses are dense,
 	// corresponding to valid patches
 
+	const Vec3V solverOffsetSlop = V3Load(solverOffsetSlopF32);
+
 	const FloatV ccdMaxSeparation = FLoad(maxCCDSeparation);
 
 	PxU8 flags = PxU8(hasForceThreshold ? SolverContactHeader::eHAS_FORCE_THRESHOLDS : 0);
@@ -101,6 +104,7 @@ static void setupFinalizeSolverConstraints(Sc::ShapeInteraction* shapeInteractio
 									                 : DY_SC_TYPE_RB_CONTACT);
 
 	const FloatV zero=FZero();
+	const Vec3V v3Zero = V3Zero();
 
 	const FloatV d0 = FLoad(invMassScale0);
 	const FloatV d1 = FLoad(invMassScale1);
@@ -224,7 +228,7 @@ static void setupFinalizeSolverConstraints(Sc::ShapeInteraction* shapeInteractio
 					normal, norVel, norCross, angVel0, angVel1,
 					invDt, invDtp8, restDistance, maxPenBias,  restitution,
 					bounceThreshold, contact, *solverContact,
-					ccdMaxSeparation);
+					ccdMaxSeparation, solverOffsetSlop);
 			}
 
 			ptr = p;
@@ -307,20 +311,26 @@ static void setupFinalizeSolverConstraints(Sc::ShapeInteraction* shapeInteractio
 				Vec3V body0Anchor = V3LoadU(frictionPatch.body0Anchors[j]);
 				Vec3V body1Anchor = V3LoadU(frictionPatch.body1Anchors[j]);
 
-				Vec3V ra = QuatRotate(bodyFrame0q, body0Anchor);
-				Vec3V rb = QuatRotate(bodyFrame1q, body1Anchor);
-				Vec3V error =V3Sub(V3Add(ra, bodyFrame0p), V3Add(rb, bodyFrame1p));
+				const Vec3V ra = QuatRotate(bodyFrame0q, body0Anchor);
+				const Vec3V rb = QuatRotate(bodyFrame1q, body1Anchor);
 
+				//ra = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(ra)), v3Zero, ra);
+				//rb = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(rb)), v3Zero, rb);
 
 				PxU32 index = c.contactID[i][j];
+				const Vec3V error = V3Sub(V3Add(ra, bodyFrame0p), V3Add(rb, bodyFrame1p));
+				//error = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(error)), v3Zero, error);
 
 				index = index == 0xFFFF ? c.contactPatches[c.correlationListHeads[i]].start : index;
 
 				const Vec3V tvel = V3LoadA(buffer[index].targetVel);
 				
 				{
-					const Vec3V raXn = V3Cross(ra, t0Cross);
-					const Vec3V rbXn = V3Cross(rb, t0Cross);
+					Vec3V raXn = V3Cross(ra, t0Cross);
+					Vec3V rbXn = V3Cross(rb, t0Cross);
+
+					raXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(raXn)), v3Zero, raXn);
+					rbXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(rbXn)), v3Zero, rbXn);
 
 					const Vec3V raXnSqrtInertia = M33MulV3(invSqrtInertia0, raXn);
 					const Vec3V rbXnSqrtInertia = M33MulV3(invSqrtInertia1, rbXn);	
@@ -348,8 +358,11 @@ static void setupFinalizeSolverConstraints(Sc::ShapeInteraction* shapeInteractio
 
 				{
 
-					const Vec3V raXn = V3Cross(ra, t1Cross);
-					const Vec3V rbXn = V3Cross(rb, t1Cross);
+					Vec3V raXn = V3Cross(ra, t1Cross);
+					Vec3V rbXn = V3Cross(rb, t1Cross);
+
+					raXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(raXn)), v3Zero, raXn);
+					rbXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(rbXn)), v3Zero, rbXn);
 
 					const Vec3V raXnSqrtInertia = M33MulV3(invSqrtInertia0, raXn);
 					const Vec3V rbXnSqrtInertia = M33MulV3(invSqrtInertia1, rbXn);	
@@ -533,6 +546,7 @@ bool createFinalizeSolverContacts(
 	PxReal bounceThresholdF32,
 	PxReal frictionOffsetThreshold,
 	PxReal correlationDistance,
+	PxReal solverOffsetSlop,
 	PxConstraintAllocator& constraintAllocator)
 {
 	Ps::prefetchLine(contactDesc.body0);
@@ -658,7 +672,7 @@ bool createFinalizeSolverContacts(
 				setupFinalizeSolverConstraints(contactDesc.shapeInteraction, contactDesc.contacts, c, contactDesc.bodyFrame0, contactDesc.bodyFrame1, solverConstraint,
 					data0, data1, invDtF32, bounceThresholdF32,
 					contactDesc.mInvMassScales.linear0, contactDesc.mInvMassScales.angular0, contactDesc.mInvMassScales.linear1, contactDesc.mInvMassScales.angular1, 
-					hasForceThreshold, staticOrKinematicBody, contactDesc.restDistance, frictionDataPtr, contactDesc.maxCCDSeparation);
+					hasForceThreshold, staticOrKinematicBody, contactDesc.restDistance, frictionDataPtr, contactDesc.maxCCDSeparation, solverOffsetSlop);
 			}
 			//KS - set to 0 so we have a counter for the number of times we solved the constraint
 			//only going to be used on SPU but might as well set on all platforms because this code is shared
@@ -678,6 +692,7 @@ bool createFinalizeSolverContacts(PxSolverContactDesc& contactDesc,
 								 PxReal bounceThresholdF32,
 								 PxReal frictionOffsetThreshold,
 								 PxReal correlationDistance,
+								 PxReal solverOffsetSlop,
 								 PxConstraintAllocator& constraintAllocator)
 {
 	ContactBuffer& buffer = threadContext.mContactBuffer;
@@ -714,7 +729,7 @@ bool createFinalizeSolverContacts(PxSolverContactDesc& contactDesc,
 	
 	CorrelationBuffer& c = threadContext.mCorrelationBuffer;
 
-	return createFinalizeSolverContacts(contactDesc, c,	invDtF32, bounceThresholdF32, frictionOffsetThreshold, correlationDistance, constraintAllocator);
+	return createFinalizeSolverContacts(contactDesc, c, invDtF32, bounceThresholdF32, frictionOffsetThreshold, correlationDistance, solverOffsetSlop, constraintAllocator);
 }
   
 PxU32 getContactManagerConstraintDesc(const PxsContactManagerOutput& cmOutput, const PxsContactManager& /*cm*/, PxSolverConstraintDesc& desc)
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.h b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.h
index 46c2af0b..b1a5adb0 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.h
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep.h
@@ -58,7 +58,8 @@ namespace Dy
 	const PxReal invDtF32,									\
 	PxReal bounceThresholdF32,								\
 	PxReal frictionOffsetThreshold,							\
-	PxReal	correlationDistance,							\
+	PxReal correlationDistance,								\
+	PxReal solverOffsetSlop,								\
 	PxConstraintAllocator& constraintAllocator				
 
 #define CREATE_FINALIZE_SOVLER_CONTACT_METHOD_ARGS_4									\
@@ -69,6 +70,7 @@ namespace Dy
 								 PxReal bounceThresholdF32,								\
 								 PxReal	frictionThresholdF32,							\
 								 PxReal	correlationDistanceF32,							\
+								 PxReal solverOffsetSlopF32,							\
 								 PxConstraintAllocator& constraintAllocator				
 
 	
@@ -92,6 +94,7 @@ bool createFinalizeSolverContacts(	PxSolverContactDesc& contactDesc,
 									PxReal bounceThresholdF32,
 									PxReal frictionOffsetThreshold,
 									PxReal correlationDistance,
+									PxReal solverOffsetSlop,
 									PxConstraintAllocator& constraintAllocator);
 
 bool createFinalizeSolverContacts(	PxSolverContactDesc& contactDesc,
@@ -100,6 +103,7 @@ bool createFinalizeSolverContacts(	PxSolverContactDesc& contactDesc,
 									PxReal bounceThresholdF32,
 									PxReal frictionOffsetThreshold,
 									PxReal correlationDistance,
+									PxReal solverOffsetSlop,
 									PxConstraintAllocator& constraintAllocator);
 
 SolverConstraintPrepState::Enum createFinalizeSolverContacts4(	PxsContactManagerOutput** outputs,
@@ -109,6 +113,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4(	PxsContactManager
 																 PxReal bounceThresholdF32,
 																 PxReal frictionOffsetThreshold,
 																 PxReal correlationDistance,
+																 PxReal solverOffsetSlop,
 																 PxConstraintAllocator& constraintAllocator);
 
 SolverConstraintPrepState::Enum createFinalizeSolverContacts4(	Dy::CorrelationBuffer& c,
@@ -117,6 +122,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4(	Dy::CorrelationBu
 																PxReal bounceThresholdF32,
 																PxReal	frictionOffsetThreshold,
 																PxReal correlationDistance,
+																PxReal solverOffsetSlop,
 																PxConstraintAllocator& constraintAllocator);
 
 
@@ -128,6 +134,7 @@ bool createFinalizeSolverContactsCoulomb1D(PxSolverContactDesc& contactDesc,
 											 PxReal bounceThresholdF32,
 											 PxReal frictionOffsetThreshold,
 											 PxReal correlationDistance,
+											 PxReal solverOffsetSlop,
 											 PxConstraintAllocator& constraintAllocator);
 
 bool createFinalizeSolverContactsCoulomb2D(PxSolverContactDesc& contactDesc,
@@ -137,6 +144,7 @@ bool createFinalizeSolverContactsCoulomb2D(PxSolverContactDesc& contactDesc,
 											PxReal bounceThresholdF32,
 											PxReal frictionOffsetThreshold,
 											PxReal correlationDistance,
+											PxReal solverOffsetSlop,
 											PxConstraintAllocator& constraintAllocator);
 
 
@@ -147,6 +155,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb1D(	PxsConta
 																		 PxReal bounceThresholdF32,
 																		 PxReal frictionOffsetThreshold,
 																		 PxReal correlationDistance,
+																		 PxReal solverOffsetSlop,
 																		 PxConstraintAllocator& constraintAllocator);
 
 SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb2D(PxsContactManagerOutput** outputs,
@@ -156,6 +165,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb2D(PxsContac
 																		PxReal bounceThresholdF32,
 																		PxReal frictionOffsetThreshold,
 																		PxReal correlationDistance,
+																		PxReal solverOffsetSlop,
 																		PxConstraintAllocator& constraintAllocator);
 
 
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4.cpp
index 569e6996..70d57a77 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4.cpp
@@ -78,7 +78,7 @@ inline bool ValidateVec4(const Vec4V v)
 }
 
 static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT descs, CorrelationBuffer& c, PxU8* PX_RESTRICT workspace,
-											const PxReal invDtF32, PxReal bounceThresholdF32,
+											const PxReal invDtF32, PxReal bounceThresholdF32, const PxReal solverOffsetSlopF32,
 											const Ps::aos::Vec4VArg invMassScale0, const Ps::aos::Vec4VArg invInertiaScale0, 
 											const Ps::aos::Vec4VArg invMassScale1, const Ps::aos::Vec4VArg invInertiaScale1)
 {
@@ -86,6 +86,7 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 	//OK, we have a workspace of pre-allocated space to store all 4 descs in. We now need to create the constraints in it
 
 	const Vec4V ccdMaxSeparation = Ps::aos::V4LoadXYZW(descs[0].maxCCDSeparation, descs[1].maxCCDSeparation, descs[2].maxCCDSeparation, descs[3].maxCCDSeparation);
+	const Vec4V solverOffsetSlop = V4Load(solverOffsetSlopF32);
 
 	const Vec4V zero = V4Zero();
 	const BoolV bFalse = BFFFF();
@@ -96,16 +97,16 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 						PxU8(descs[2].hasForceThresholds ? SolverContactHeader::eHAS_FORCE_THRESHOLDS : 0),
 						PxU8(descs[3].hasForceThresholds ? SolverContactHeader::eHAS_FORCE_THRESHOLDS : 0) };
 
-	bool hasMaxImpulse = descs[0].hasMaxImpulse || descs[1].hasMaxImpulse || descs[2].hasMaxImpulse || descs[3].hasMaxImpulse;
-
 	//The block is dynamic if **any** of the constraints have a non-static body B. This allows us to batch static and non-static constraints but we only get a memory/perf
 	//saving if all 4 are static. This simplifies the constraint partitioning such that it only needs to care about separating contacts and 1D constraints (which it already does)
 	bool isDynamic = false;
 	bool hasKinematic = false;
+	PxReal maxImpulse[4];
 	for(PxU32 a = 0; a < 4; ++a)
 	{
 		isDynamic = isDynamic || (descs[a].bodyState1 == PxSolverContactDesc::eDYNAMIC_BODY);
 		hasKinematic = hasKinematic || descs[a].bodyState1 == PxSolverContactDesc::eKINEMATIC_BODY;
+		maxImpulse[a] = PxMin(descs[a].data0->maxContactImpulse, descs[a].data1->maxContactImpulse);
 	}
 	
 	const PxU32 constraintSize = isDynamic ? sizeof(SolverContactBatchPointDynamic4) : sizeof(SolverContactBatchPointBase4);
@@ -294,8 +295,6 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 	PxU32 patch0 = 0, patch1 = 0, patch2 = 0, patch3 = 0;
 
 	PxU8 flag = 0;
-	if(hasMaxImpulse)
-		flag |= SolverContactHeader4::eHAS_MAX_IMPULSE;
 
 	for(PxU32 i=0;i<maxPatches;i++)
 	{
@@ -360,8 +359,6 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 		header->shapeInteraction[0] = descs[0].shapeInteraction; header->shapeInteraction[1] = descs[1].shapeInteraction; 
 		header->shapeInteraction[2] = descs[2].shapeInteraction; header->shapeInteraction[3] = descs[3].shapeInteraction;
 
-		Vec4V* maxImpulse = reinterpret_cast<Vec4V*>(ptr + constraintSize * totalContacts);
-
 		header->restitution = restitution;
 
 		Vec4V normal0 = V4LoadA(&contactBase0->normal.x);
@@ -418,9 +415,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 			((PxU32(hasFinished2 || !iter2.hasNextContact())) << 2) | 
 			((PxU32(hasFinished3 || !iter3.hasNextContact())) << 3);
 
+
+		PxReal patchMaxImpulse[4] = { maxImpulse[0], maxImpulse[1], maxImpulse[2], maxImpulse[3] };
+
+
 		while(finished != 0xf)
 		{
-			finished = newFinished;
+			
 			++contactCount;
 			Ps::prefetchLine(p, 384);
 			Ps::prefetchLine(p, 512);
@@ -442,6 +443,21 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 				Vec4V point2 = V4LoadA(&con2.point.x);
 				Vec4V point3 = V4LoadA(&con3.point.x);
 
+				if (descs[0].hasMaxImpulse)
+					patchMaxImpulse[0] = descs[0].contacts[c.contactPatches[patch0].start + contact0].maxImpulse;
+				if (descs[1].hasMaxImpulse)
+					patchMaxImpulse[1] = descs[1].contacts[c.contactPatches[patch1].start + contact1].maxImpulse;
+				if (descs[2].hasMaxImpulse)
+					patchMaxImpulse[2] = descs[2].contacts[c.contactPatches[patch2].start + contact2].maxImpulse;
+				if (descs[3].hasMaxImpulse)
+					patchMaxImpulse[3] = descs[3].contacts[c.contactPatches[patch3].start + contact3].maxImpulse;
+				for (PxU32 a = 0; a < 4; ++a)
+				{
+					if ((finished & (1 << a)))
+						patchMaxImpulse[a] = 0.f;
+				}
+				
+
 				Vec4V pointX, pointY, pointZ;
 				PX_TRANSPOSE_44_34(point0, point1, point2, point3, pointX, pointY, pointZ);
 
@@ -469,6 +485,14 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 				const Vec4V rbY = V4Sub(pointY, bodyFrame1pY);
 				const Vec4V rbZ = V4Sub(pointZ, bodyFrame1pZ);
 
+				/*raX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raX)), zero, raX);
+				raY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raY)), zero, raY);
+				raZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raZ)), zero, raZ);
+
+				rbX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbX)), zero, rbX);
+				rbY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbY)), zero, rbY);
+				rbZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbZ)), zero, rbZ);*/
+
 				PX_ASSERT(ValidateVec4(raX));
 				PX_ASSERT(ValidateVec4(raY));
 				PX_ASSERT(ValidateVec4(raZ));
@@ -480,9 +504,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 
 				//raXn = cross(ra, normal) which = Vec3V( a.y*b.z-a.z*b.y, a.z*b.x-a.x*b.z, a.x*b.y-a.y*b.x);
 
-				const Vec4V raXnX = V4NegMulSub(raZ, normalY, V4Mul(raY, normalZ));
-				const Vec4V raXnY = V4NegMulSub(raX, normalZ, V4Mul(raZ, normalX));
-				const Vec4V raXnZ = V4NegMulSub(raY, normalX, V4Mul(raX, normalY));
+				Vec4V raXnX = V4NegMulSub(raZ, normalY, V4Mul(raY, normalZ));
+				Vec4V raXnY = V4NegMulSub(raX, normalZ, V4Mul(raZ, normalX));
+				Vec4V raXnZ = V4NegMulSub(raY, normalX, V4Mul(raX, normalY));
+
+				raXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnX)), zero, raXnX);
+				raXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnY)), zero, raXnY);
+				raXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnZ)), zero, raXnZ);
 
 				Vec4V delAngVel0X = V4Mul(invInertia0X0, raXnX);
 				Vec4V delAngVel0Y = V4Mul(invInertia0X1, raXnX);
@@ -512,9 +540,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 				if(isDynamic)
 				{
 					SolverContactBatchPointDynamic4* PX_RESTRICT dynamicContact = static_cast<SolverContactBatchPointDynamic4*>(solverContact);
-					const Vec4V rbXnX = V4NegMulSub(rbZ, normalY, V4Mul(rbY, normalZ));
-					const Vec4V rbXnY = V4NegMulSub(rbX, normalZ, V4Mul(rbZ, normalX));
-					const Vec4V rbXnZ = V4NegMulSub(rbY, normalX, V4Mul(rbX, normalY));
+					Vec4V rbXnX = V4NegMulSub(rbZ, normalY, V4Mul(rbY, normalZ));
+					Vec4V rbXnY = V4NegMulSub(rbX, normalZ, V4Mul(rbZ, normalX));
+					Vec4V rbXnZ = V4NegMulSub(rbY, normalX, V4Mul(rbX, normalY));
+
+					rbXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnX)), zero, rbXnX);
+					rbXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnY)), zero, rbXnY);
+					rbXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnZ)), zero, rbXnZ);
 
 					Vec4V delAngVel1X = V4Mul(invInertia1X0, rbXnX);
 					Vec4V delAngVel1Y = V4Mul(invInertia1X1, rbXnX);
@@ -586,16 +618,14 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 				solverContact->raXnZ = delAngVel0Z;
 				solverContact->velMultiplier = velMultiplier;
 				solverContact->biasedErr = biasedErr;
+				solverContact->maxContactImpulse = V4LoadU(patchMaxImpulse);
 
 				//solverContact->scaledBias = V4Max(zero, scaledBias);
 				solverContact->scaledBias = V4Sel(isGreater2, scaledBias, V4Max(zero, scaledBias));
-
-				if(hasMaxImpulse)
-				{
-					maxImpulse[contactCount-1] = V4Merge(FLoad(con0.maxImpulse), FLoad(con1.maxImpulse), FLoad(con2.maxImpulse),
-						FLoad(con3.maxImpulse));					
-				}
 			}
+
+			finished = newFinished;
+
 			if(!(finished & 0x1))
 			{
 				iter0.nextContact(patch0, contact0);
@@ -621,10 +651,6 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 			}
 		}
 		ptr = p;
-		if(hasMaxImpulse)
-		{
-			ptr += sizeof(Vec4V) * totalContacts;
-		}
 
 		//OK...friction time :-)
 
@@ -811,9 +837,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 					const Vec4V rbWorldY = V4Add(rbY, bodyFrame1pY);
 					const Vec4V rbWorldZ = V4Add(rbZ, bodyFrame1pZ);
 
-					const Vec4V errorX = V4Sub(raWorldX, rbWorldX);
-					const Vec4V errorY = V4Sub(raWorldY, rbWorldY);
-					const Vec4V errorZ = V4Sub(raWorldZ, rbWorldZ);
+					Vec4V errorX = V4Sub(raWorldX, rbWorldX);
+					Vec4V errorY = V4Sub(raWorldY, rbWorldY);
+					Vec4V errorZ = V4Sub(raWorldZ, rbWorldZ);
+
+					errorX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(errorX)), zero, errorX);
+					errorY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(errorY)), zero, errorY);
+					errorZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(errorZ)), zero, errorZ);
 
 					//KS - todo - get this working with per-point friction
 					PxU32 contactIndex0 = c.contactID[frictionIndex0][index0];
@@ -837,9 +867,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 
 					
 					{
-						const Vec4V raXnX = V4NegMulSub(raZ, t0Y, V4Mul(raY, t0Z));
-						const Vec4V raXnY = V4NegMulSub(raX, t0Z, V4Mul(raZ, t0X));
-						const Vec4V raXnZ = V4NegMulSub(raY, t0X, V4Mul(raX, t0Y));
+						Vec4V raXnX = V4NegMulSub(raZ, t0Y, V4Mul(raY, t0Z));
+						Vec4V raXnY = V4NegMulSub(raX, t0Z, V4Mul(raZ, t0X));
+						Vec4V raXnZ = V4NegMulSub(raY, t0X, V4Mul(raX, t0Y));
+
+						raXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnX)), zero, raXnX);
+						raXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnY)), zero, raXnY);
+						raXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnZ)), zero, raXnZ);
 
 						Vec4V delAngVel0X = V4Mul(invInertia0X0, raXnX);
 						Vec4V delAngVel0Y = V4Mul(invInertia0X1, raXnX);
@@ -864,9 +898,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 						{
 							SolverContactFrictionDynamic4* PX_RESTRICT dynamicF0 = static_cast<SolverContactFrictionDynamic4*>(f0);
 
-							const Vec4V rbXnX = V4NegMulSub(rbZ, t0Y, V4Mul(rbY, t0Z));
-							const Vec4V rbXnY = V4NegMulSub(rbX, t0Z, V4Mul(rbZ, t0X));
-							const Vec4V rbXnZ = V4NegMulSub(rbY, t0X, V4Mul(rbX, t0Y));
+							Vec4V rbXnX = V4NegMulSub(rbZ, t0Y, V4Mul(rbY, t0Z));
+							Vec4V rbXnY = V4NegMulSub(rbX, t0Z, V4Mul(rbZ, t0X));
+							Vec4V rbXnZ = V4NegMulSub(rbY, t0X, V4Mul(rbX, t0Y));
+
+							rbXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnX)), zero, rbXnX);
+							rbXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnY)), zero, rbXnY);
+							rbXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnZ)), zero, rbXnZ);
 
 							Vec4V delAngVel1X = V4Mul(invInertia1X0, rbXnX);
 							Vec4V delAngVel1Y = V4Mul(invInertia1X1, rbXnX);
@@ -925,9 +963,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 					}
 
 					{
-						const Vec4V raXnX = V4NegMulSub(raZ, t1Y, V4Mul(raY, t1Z));
-						const Vec4V raXnY = V4NegMulSub(raX, t1Z, V4Mul(raZ, t1X));
-						const Vec4V raXnZ = V4NegMulSub(raY, t1X, V4Mul(raX, t1Y));
+						Vec4V raXnX = V4NegMulSub(raZ, t1Y, V4Mul(raY, t1Z));
+						Vec4V raXnY = V4NegMulSub(raX, t1Z, V4Mul(raZ, t1X));
+						Vec4V raXnZ = V4NegMulSub(raY, t1X, V4Mul(raX, t1Y));
+
+						raXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnX)), zero, raXnX);
+						raXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnY)), zero, raXnY);
+						raXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnZ)), zero, raXnZ);
 
 						Vec4V delAngVel0X = V4Mul(invInertia0X0, raXnX);
 						Vec4V delAngVel0Y = V4Mul(invInertia0X1, raXnX);
@@ -952,9 +994,13 @@ static void setupFinalizeSolverConstraints4(PxSolverContactDesc* PX_RESTRICT des
 						{
 							SolverContactFrictionDynamic4* PX_RESTRICT dynamicF1 = static_cast<SolverContactFrictionDynamic4*>(f1);
 
-							const Vec4V rbXnX = V4NegMulSub(rbZ, t1Y, V4Mul(rbY, t1Z));
-							const Vec4V rbXnY = V4NegMulSub(rbX, t1Z, V4Mul(rbZ, t1X));
-							const Vec4V rbXnZ = V4NegMulSub(rbY, t1X, V4Mul(rbX, t1Y));
+							Vec4V rbXnX = V4NegMulSub(rbZ, t1Y, V4Mul(rbY, t1Z));
+							Vec4V rbXnY = V4NegMulSub(rbX, t1Z, V4Mul(rbZ, t1X));
+							Vec4V rbXnZ = V4NegMulSub(rbY, t1X, V4Mul(rbX, t1Y));
+
+							rbXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnX)), zero, rbXnX);
+							rbXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnY)), zero, rbXnY);
+							rbXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnZ)), zero, rbXnZ);
 
 							Vec4V delAngVel1X = V4Mul(invInertia1X0, rbXnX);
 							Vec4V delAngVel1Y = V4Mul(invInertia1X1, rbXnX);
@@ -1101,12 +1147,10 @@ void computeBlockStreamByteSizes4(PxSolverContactDesc* descs,
 	PxU32 maxFrictionCount[CorrelationBuffer::MAX_FRICTION_PATCHES];
 	PxMemZero(maxContactCount, sizeof(maxContactCount));
 	PxMemZero(maxFrictionCount, sizeof(maxFrictionCount));
-	bool hasMaxImpulse = false;
 
 	for(PxU32 a = 0; a < 4; ++a)
 	{
 		PxU32 axisConstraintCount = 0;
-		hasMaxImpulse = hasMaxImpulse || descs[a].hasMaxImpulse;
 		for(PxU32 i = 0; i < descs[a].numFrictionPatches; i++)
 		{
 			PxU32 ind = i + descs[a].startFrictionPatchIndex;
@@ -1168,8 +1212,6 @@ void computeBlockStreamByteSizes4(PxSolverContactDesc* descs,
 	constraintSize += sizeof(Vec4V)*(totalContacts+totalFriction);
 
 	//If we have max impulse, reserve a buffer for it
-	if(hasMaxImpulse)
-		constraintSize += sizeof(Ps::aos::Vec4V) * totalContacts;
 
 	_solverConstraintByteSize =  ((constraintSize + headerSize + 0x0f) & ~0x0f);
 	PX_ASSERT(0 == (_solverConstraintByteSize & 0x0f));
@@ -1238,6 +1280,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4(
 	PxReal bounceThresholdF32,
 	PxReal	frictionOffsetThreshold,
 	PxReal correlationDistance,
+	PxReal solverOffsetSlop,
 	PxConstraintAllocator& constraintAllocator)
 {
 	PX_ALIGN(16, PxReal invMassScale0[4]);
@@ -1379,7 +1422,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4(
 		const Vec4V iMassScale1 = V4LoadA(invMassScale1);
 		const Vec4V iInertiaScale1 = V4LoadA(invInertiaScale1);
 
-		setupFinalizeSolverConstraints4(blockDescs, c, solverConstraint, invDtF32, bounceThresholdF32,
+		setupFinalizeSolverConstraints4(blockDescs, c, solverConstraint, invDtF32, bounceThresholdF32, solverOffsetSlop,
 			iMassScale0, iInertiaScale0, iMassScale1, iInertiaScale1);
 
 		PX_ASSERT((*solverConstraint == DY_SC_TYPE_BLOCK_RB_CONTACT) || (*solverConstraint == DY_SC_TYPE_BLOCK_STATIC_RB_CONTACT));
@@ -1400,6 +1443,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4(
 	PxReal bounceThresholdF32,
 	PxReal	frictionOffsetThreshold,
 	PxReal correlationDistance,
+	PxReal solverOffsetSlop,
 	PxConstraintAllocator& constraintAllocator)
 {
 
@@ -1475,7 +1519,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4(
 	}
 	return createFinalizeSolverContacts4(c, blockDescs,
 		invDtF32, bounceThresholdF32,	frictionOffsetThreshold,
-		correlationDistance, constraintAllocator);
+		correlationDistance, solverOffsetSlop, constraintAllocator);
 }
 
 
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4PF.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4PF.cpp
index 3d931f0f..ca5880f1 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4PF.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrep4PF.cpp
@@ -72,11 +72,12 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb(
 		PxReal bounceThresholdF32,
 		PxReal frictionOffsetThreshold,
 		PxReal correlationDistance,
+		PxReal solverOffsetSlop,
 		PxConstraintAllocator& constraintAllocator,
 		PxFrictionType::Enum frictionType);
 
 static bool setupFinalizeSolverConstraintsCoulomb4(PxSolverContactDesc* PX_RESTRICT descs, PxU8* PX_RESTRICT workspace, 
-											const PxReal invDtF32, PxReal bounceThresholdF32, CorrelationBuffer& c, const PxU32 numFrictionPerPoint,
+											const PxReal invDtF32, PxReal bounceThresholdF32, PxReal solverOffsetSlopF32, CorrelationBuffer& c, const PxU32 numFrictionPerPoint,
 											const PxU32 numContactPoints4, const PxU32 /*solverConstraintByteSize*/,
 											const Ps::aos::Vec4VArg invMassScale0, const Ps::aos::Vec4VArg invInertiaScale0, 
 											const Ps::aos::Vec4VArg invMassScale1, const Ps::aos::Vec4VArg invInertiaScale1)
@@ -84,6 +85,7 @@ static bool setupFinalizeSolverConstraintsCoulomb4(PxSolverContactDesc* PX_RESTR
 	//KS - final step. Create the constraints in the place we pre-allocated...
 
 	const Vec4V ccdMaxSeparation = Ps::aos::V4LoadXYZW(descs[0].maxCCDSeparation, descs[1].maxCCDSeparation, descs[2].maxCCDSeparation, descs[3].maxCCDSeparation);
+	const Vec4V solverOffsetSlop = V4Load(solverOffsetSlopF32);
 
 	const Vec4V zero = V4Zero();
 
@@ -483,6 +485,14 @@ static bool setupFinalizeSolverConstraintsCoulomb4(PxSolverContactDesc* PX_RESTR
 				const Vec4V rbY = V4Sub(pointY, bodyFrame1pY);
 				const Vec4V rbZ = V4Sub(pointZ, bodyFrame1pZ);
 
+				/*raX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raX)), zero, raX);
+				raY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raY)), zero, raY);
+				raZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raZ)), zero, raZ);
+
+				rbX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbX)), zero, rbX);
+				rbY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbY)), zero, rbY);
+				rbZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbZ)), zero, rbZ);*/
+
 				{
 					const Vec4V separation = V4Merge(FLoad(con0.separation), FLoad(con1.separation), FLoad(con2.separation),
 						FLoad(con3.separation));
@@ -492,9 +502,13 @@ static bool setupFinalizeSolverConstraintsCoulomb4(PxSolverContactDesc* PX_RESTR
 					const Vec4V cTargetVel = V4MulAdd(normalX, targetVelX, V4MulAdd(normalY, targetVelY, V4Mul(normalZ, targetVelZ)));
 
 					//raXn = cross(ra, normal) which = Vec3V( a.y*b.z-a.z*b.y, a.z*b.x-a.x*b.z, a.x*b.y-a.y*b.x);
-					const Vec4V raXnX = V4NegMulSub(raZ, normalY, V4Mul(raY, normalZ));
-					const Vec4V raXnY = V4NegMulSub(raX, normalZ, V4Mul(raZ, normalX));
-					const Vec4V raXnZ = V4NegMulSub(raY, normalX, V4Mul(raX, normalY));
+					Vec4V raXnX = V4NegMulSub(raZ, normalY, V4Mul(raY, normalZ));
+					Vec4V raXnY = V4NegMulSub(raX, normalZ, V4Mul(raZ, normalX));
+					Vec4V raXnZ = V4NegMulSub(raY, normalX, V4Mul(raX, normalY));
+
+					raXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnX)), zero, raXnX);
+					raXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnY)), zero, raXnY);
+					raXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnZ)), zero, raXnZ);
 
 					const Vec4V v0a0 = V4Mul(invInertia0X0, raXnX);
 					const Vec4V v0a1 = V4Mul(invInertia0X1, raXnX);
@@ -519,9 +533,13 @@ static bool setupFinalizeSolverConstraintsCoulomb4(PxSolverContactDesc* PX_RESTR
 					if(isDynamic)
 					{
 						SolverContact4Dynamic* PX_RESTRICT dynamicContact = static_cast<SolverContact4Dynamic*>(solverContact);
-						const Vec4V rbXnX = V4NegMulSub(rbZ, normalY, V4Mul(rbY, normalZ));
-						const Vec4V rbXnY = V4NegMulSub(rbX, normalZ, V4Mul(rbZ, normalX));
-						const Vec4V rbXnZ = V4NegMulSub(rbY, normalX, V4Mul(rbX, normalY));
+						Vec4V rbXnX = V4NegMulSub(rbZ, normalY, V4Mul(rbY, normalZ));
+						Vec4V rbXnY = V4NegMulSub(rbX, normalZ, V4Mul(rbZ, normalX));
+						Vec4V rbXnZ = V4NegMulSub(rbY, normalX, V4Mul(rbX, normalY));
+
+						rbXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnX)), zero, rbXnX);
+						rbXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnY)), zero, rbXnY);
+						rbXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnZ)), zero, rbXnZ);
 
 						const Vec4V v0b0 = V4Mul(invInertia1X0, rbXnX);
 						const Vec4V v0b1 = V4Mul(invInertia1X1, rbXnX);
@@ -610,9 +628,13 @@ static bool setupFinalizeSolverConstraintsCoulomb4(PxSolverContactDesc* PX_RESTR
 
 					fricIndex = 1 - fricIndex;
 
-					const Vec4V raXnX = V4NegMulSub(raZ, tY, V4Mul(raY, tZ));
-					const Vec4V raXnY = V4NegMulSub(raX, tZ, V4Mul(raZ, tX));
-					const Vec4V raXnZ = V4NegMulSub(raY, tX, V4Mul(raX, tY));
+					Vec4V raXnX = V4NegMulSub(raZ, tY, V4Mul(raY, tZ));
+					Vec4V raXnY = V4NegMulSub(raX, tZ, V4Mul(raZ, tX));
+					Vec4V raXnZ = V4NegMulSub(raY, tX, V4Mul(raX, tY));
+
+					raXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnX)), zero, raXnX);
+					raXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnY)), zero, raXnY);
+					raXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(raXnZ)), zero, raXnZ);
 
 					const Vec4V v0a0 = V4Mul(invInertia0X0, raXnX);
 					const Vec4V v0a1 = V4Mul(invInertia0X1, raXnX);
@@ -638,9 +660,13 @@ static bool setupFinalizeSolverConstraintsCoulomb4(PxSolverContactDesc* PX_RESTR
 					{
 						SolverFriction4Dynamic* PX_RESTRICT dFric = static_cast<SolverFriction4Dynamic*>(friction);
 
-						const Vec4V rbXnX = V4NegMulSub(rbZ, tY, V4Mul(rbY, tZ));
-						const Vec4V rbXnY = V4NegMulSub(rbX, tZ, V4Mul(rbZ, tX));
-						const Vec4V rbXnZ = V4NegMulSub(rbY, tX, V4Mul(rbX, tY));
+						Vec4V rbXnX = V4NegMulSub(rbZ, tY, V4Mul(rbY, tZ));
+						Vec4V rbXnY = V4NegMulSub(rbX, tZ, V4Mul(rbZ, tX));
+						Vec4V rbXnZ = V4NegMulSub(rbY, tX, V4Mul(rbX, tY));
+
+						rbXnX = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnX)), zero, rbXnX);
+						rbXnY = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnY)), zero, rbXnY);
+						rbXnZ = V4Sel(V4IsGrtr(solverOffsetSlop, V4Abs(rbXnZ)), zero, rbXnZ);
 						
 						const Vec4V v0b0 = V4Mul(invInertia1X0, rbXnX);
 						const Vec4V v0b1 = V4Mul(invInertia1X1, rbXnX);
@@ -850,10 +876,11 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb1D(
 	PxReal bounceThresholdF32,
 	PxReal frictionOffsetThreshold,
 	PxReal correlationDistance,
+	PxReal solverOffsetSlop,
 	PxConstraintAllocator& constraintAllocator)
 {
 	return createFinalizeSolverContacts4Coulomb(outputs, threadContext, blockDescs, invDtF32, bounceThresholdF32, 
-		frictionOffsetThreshold, correlationDistance, constraintAllocator, PxFrictionType::eONE_DIRECTIONAL);
+		frictionOffsetThreshold, correlationDistance, solverOffsetSlop, constraintAllocator, PxFrictionType::eONE_DIRECTIONAL);
 }
 
 SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb2D(
@@ -864,10 +891,11 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb2D(
 	PxReal bounceThresholdF32,
 	PxReal frictionOffsetThreshold,
 	PxReal correlationDistance,
+	PxReal solverOffsetSlop,
 	PxConstraintAllocator& constraintAllocator)
 {
 	return createFinalizeSolverContacts4Coulomb(outputs, threadContext, blockDescs, invDtF32, bounceThresholdF32,
-		frictionOffsetThreshold, correlationDistance, constraintAllocator, PxFrictionType::eTWO_DIRECTIONAL);
+		frictionOffsetThreshold, correlationDistance, solverOffsetSlop, constraintAllocator, PxFrictionType::eTWO_DIRECTIONAL);
 }
 
 
@@ -879,6 +907,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb(
 								 PxReal bounceThresholdF32,
 								 PxReal frictionOffsetThreshold,
 								 PxReal correlationDistance,
+								 PxReal solverOffsetSlop,
 								 PxConstraintAllocator& constraintAllocator,
 								 PxFrictionType::Enum frictionType)
 {
@@ -1001,7 +1030,7 @@ SolverConstraintPrepState::Enum createFinalizeSolverContacts4Coulomb(
 
 
 	bool hasFriction = setupFinalizeSolverConstraintsCoulomb4(blockDescs, solverConstraint, 
-											invDtF32, bounceThresholdF32, c, numFrictionPerPoint, numContactPoints4, solverConstraintByteSize,
+											invDtF32, bounceThresholdF32, solverOffsetSlop, c, numFrictionPerPoint, numContactPoints4, solverConstraintByteSize,
 											iMassScale0, iInertiaScale0, iMassScale1, iInertiaScale1);
 
 	*(reinterpret_cast<PxU32*>(solverConstraint + solverConstraintByteSize)) = 0;
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepPF.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepPF.cpp
index e45d4eda..61ec9aae 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepPF.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepPF.cpp
@@ -72,6 +72,7 @@ bool createFinalizeSolverContactsCoulomb(PxSolverContactDesc& contactDesc,
 		PxReal bounceThresholdF32,
 		PxReal frictionOffsetThreshold,
 		PxReal correlationDistance,
+		PxReal solverOffsetSlop,
 		PxConstraintAllocator& constraintAllocator,
 		PxFrictionType::Enum frictionType);
 
@@ -92,9 +93,11 @@ static bool setupFinalizeSolverConstraintsCoulomb(
 							PxReal invMassScale0, PxReal invInertiaScale0, 
 							PxReal invMassScale1, PxReal invInertiaScale1,
 							PxReal restDist,
-							const PxReal maxCCDSeparation)
+							const PxReal maxCCDSeparation,
+							const PxReal solverOffsetSlopF32)
 {   
 	const FloatV ccdMaxSeparation = FLoad(maxCCDSeparation);
+	const Vec3V solverOffsetSlop = V3Load(solverOffsetSlopF32);
 	PxU8* PX_RESTRICT ptr = workspace;
 	const FloatV zero=FZero();
 
@@ -227,7 +230,7 @@ static bool setupFinalizeSolverConstraintsCoulomb(
 					invMassNorLenSq1, angD0, angD1, bodyFrame0p, bodyFrame1p,
 					normal, norVel, norCross, angVel0, angVel1,
 					invDt, invDtp8, restDistance, maxPenBias,  restitution,
-					bounceThreshold, contact, *solverContact, ccdMaxSeparation);
+					bounceThreshold, contact, *solverContact, ccdMaxSeparation, solverOffsetSlop);
 			}			
 			ptr = p;
 		}
@@ -315,6 +318,8 @@ static bool setupFinalizeSolverConstraintsCoulomb(
 					const Vec3V point = V3LoadU(contact.point);
 					const Vec3V ra = V3Sub(point, bodyFrame0p);
 					const Vec3V rb = V3Sub(point, bodyFrame1p);
+					//ra = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(ra)), V3Zero(), ra);
+					//rb = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(rb)), V3Zero(), rb);
 					const Vec3V targetVel = V3LoadU(contact.targetVel);
 
 					for(PxU32 k = 0; k < frictionPerPointCount; ++k)
@@ -327,8 +332,11 @@ static bool setupFinalizeSolverConstraintsCoulomb(
 						p += frictionStride;
 						//f0->brokenOrContactIndex = contactId;
 
-						const Vec3V raXn = V3Cross(ra, t0);
-						const Vec3V rbXn = V3Cross(rb, t0);
+						Vec3V raXn = V3Cross(ra, t0);
+						Vec3V rbXn = V3Cross(rb, t0);
+
+						raXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(raXn)), V3Zero(), raXn);
+						rbXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(rbXn)), V3Zero(), rbXn);
 
 						const Vec3V delAngVel0 = M33MulV3(invSqrtInertia0, raXn);
 						const Vec3V delAngVel1 = M33MulV3(invSqrtInertia1, rbXn);
@@ -494,9 +502,11 @@ bool createFinalizeSolverContactsCoulomb1D(PxSolverContactDesc& contactDesc,
 	PxReal bounceThresholdF32,
 	PxReal frictionOffsetThreshold,
 	PxReal correlationDistance,
+	PxReal solverOffsetSlop,
 	PxConstraintAllocator& constraintAllocator)
 {
-	return createFinalizeSolverContactsCoulomb(contactDesc, output, threadContext, invDtF32, bounceThresholdF32, frictionOffsetThreshold, correlationDistance, constraintAllocator, PxFrictionType::eONE_DIRECTIONAL);
+	return createFinalizeSolverContactsCoulomb(contactDesc, output, threadContext, invDtF32, bounceThresholdF32, frictionOffsetThreshold, correlationDistance, solverOffsetSlop,
+		constraintAllocator, PxFrictionType::eONE_DIRECTIONAL);
 }
 
 bool createFinalizeSolverContactsCoulomb2D(PxSolverContactDesc& contactDesc,
@@ -506,10 +516,12 @@ bool createFinalizeSolverContactsCoulomb2D(PxSolverContactDesc& contactDesc,
 	PxReal bounceThresholdF32,
 	PxReal frictionOffsetThreshold,
 	PxReal correlationDistance,
+	PxReal solverOffsetSlop,
 	PxConstraintAllocator& constraintAllocator)
 
 {
-	return createFinalizeSolverContactsCoulomb(contactDesc, output, threadContext, invDtF32, bounceThresholdF32, frictionOffsetThreshold, correlationDistance, constraintAllocator, PxFrictionType::eTWO_DIRECTIONAL);
+	return createFinalizeSolverContactsCoulomb(contactDesc, output, threadContext, invDtF32, bounceThresholdF32, frictionOffsetThreshold, correlationDistance, solverOffsetSlop,
+		constraintAllocator, PxFrictionType::eTWO_DIRECTIONAL);
 }
 
 bool createFinalizeSolverContactsCoulomb(PxSolverContactDesc& contactDesc,
@@ -519,6 +531,7 @@ bool createFinalizeSolverContactsCoulomb(PxSolverContactDesc& contactDesc,
 								 PxReal bounceThresholdF32,
 								 PxReal frictionOffsetThreshold,
 								 PxReal correlationDistance,
+								 PxReal solverOffsetSlop,
 								 PxConstraintAllocator& constraintAllocator,
 								 PxFrictionType::Enum frictionType)
 {
@@ -634,7 +647,7 @@ bool createFinalizeSolverContactsCoulomb(PxSolverContactDesc& contactDesc,
 
 				hasFriction = setupFinalizeSolverConstraintsCoulomb(contactDesc.shapeInteraction, buffer, c, contactDesc.bodyFrame0, contactDesc.bodyFrame1, solverConstraint,
 					data0, data1, invDtF32, bounceThresholdF32, numFrictionPerPatch, contactDesc.hasForceThresholds, contactDesc.bodyState1 == PxSolverContactDesc::eSTATIC_BODY,
-					invMassScale0, invInertiaScale0, invMassScale1, invInertiaScale1, contactDesc.restDistance, contactDesc.maxCCDSeparation);
+					invMassScale0, invInertiaScale0, invMassScale1, invInertiaScale1, contactDesc.restDistance, contactDesc.maxCCDSeparation, solverOffsetSlop);
 			}
 			*(reinterpret_cast<PxU32*>(solverConstraint + solverConstraintByteSize)) = 0;
 			*(reinterpret_cast<PxU32*>(solverConstraint + solverConstraintByteSize + 4)) = hasFriction ? 0xFFFFFFFF : 0;
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepShared.h b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepShared.h
index 67ed680b..c973f1cf 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepShared.h
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyContactPrepShared.h
@@ -234,7 +234,7 @@ private:
 		const Vec3VArg normal, const FloatVArg norVel, const VecCrossV& norCross, const Vec3VArg angVel0, const Vec3VArg angVel1,
 		const FloatVArg invDt, const FloatVArg invDtp8, const FloatVArg restDistance, const FloatVArg maxPenBias,  const FloatVArg restitution,
 		const FloatVArg bounceThreshold, const Gu::ContactPoint& contact, SolverContactPoint& solverContact,
-		const FloatVArg ccdMaxSeparation)
+		const FloatVArg ccdMaxSeparation, const Vec3VArg solverOffsetSlop)
 	{
 		const FloatV zero = FZero();
 		const Vec3V point = V3LoadA(contact.point);
@@ -245,8 +245,14 @@ private:
 		const Vec3V ra = V3Sub(point, bodyFrame0p);
 		const Vec3V rb = V3Sub(point, bodyFrame1p);
 
-		const Vec3V raXn = V3Cross(ra, norCross);
-		const Vec3V rbXn = V3Cross(rb, norCross);
+		//ra = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(ra)), V3Zero(), ra);
+		//rb = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(rb)), V3Zero(), rb);
+
+		Vec3V raXn = V3Cross(ra, norCross);
+		Vec3V rbXn = V3Cross(rb, norCross);
+
+		raXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(raXn)), V3Zero(), raXn);
+		rbXn = V3Sel(V3IsGrtr(solverOffsetSlop, V3Abs(rbXn)), V3Zero(), rbXn);
 
 		const Vec3V raXnSqrtInertia = M33MulV3(invSqrtInertia0, raXn);
 		const Vec3V rbXnSqrtInertia = M33MulV3(invSqrtInertia1, rbXn);				
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.cpp
index 7bf839f3..97e5ffe0 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.cpp
@@ -102,13 +102,14 @@ struct SolverIslandObjects
 
 Context* createDynamicsContext(	PxcNpMemBlockPool* memBlockPool,
 								PxcScratchAllocator& scratchAllocator, Cm::FlushPool& taskPool,
-								PxvSimStats& simStats, PxTaskManager* taskManager, Ps::VirtualAllocatorCallback* allocatorCallback, PxsMaterialManager* materialManager,
-								IG::IslandSim* accurateIslandSim, PxU64 contextID,
-								const bool enableStabilization, const bool useEnhancedDeterminism, const bool useAdaptiveForce
+								PxvSimStats& simStats, PxTaskManager* taskManager, Ps::VirtualAllocatorCallback* allocatorCallback, 
+								PxsMaterialManager* materialManager, IG::IslandSim* accurateIslandSim, PxU64 contextID,
+								const bool enableStabilization, const bool useEnhancedDeterminism, const bool useAdaptiveForce,
+								const PxReal maxBiasCoefficient
 								)
 {
 	return DynamicsContext::create(	memBlockPool, scratchAllocator, taskPool, simStats, taskManager, allocatorCallback, materialManager, accurateIslandSim,
-									contextID, enableStabilization, useEnhancedDeterminism, useAdaptiveForce);
+									contextID, enableStabilization, useEnhancedDeterminism, useAdaptiveForce, maxBiasCoefficient);
 }
 
 // PT: TODO: consider removing this function. We already have "createDynamicsContext".
@@ -123,14 +124,16 @@ DynamicsContext* DynamicsContext::create(	PxcNpMemBlockPool* memBlockPool,
 											PxU64 contextID,
 											const bool enableStabilization,
 											const bool useEnhancedDeterminism,
-											const bool useAdaptiveForce
+											const bool useAdaptiveForce,
+											const PxReal maxBiasCoefficient
 											)
 {
 	// PT: TODO: inherit from UserAllocated, remove placement new
 	DynamicsContext* dc = reinterpret_cast<DynamicsContext*>(PX_ALLOC(sizeof(DynamicsContext), "DynamicsContext"));
 	if(dc)
 	{
-		new(dc)DynamicsContext(memBlockPool, scratchAllocator, taskPool, simStats, taskManager, allocatorCallback, materialManager, accurateIslandSim, contextID, enableStabilization, useEnhancedDeterminism, useAdaptiveForce);
+		new(dc)DynamicsContext(memBlockPool, scratchAllocator, taskPool, simStats, taskManager, allocatorCallback, materialManager, accurateIslandSim, contextID, 
+			enableStabilization, useEnhancedDeterminism, useAdaptiveForce, maxBiasCoefficient);
 	}
 	return dc;
 }
@@ -169,9 +172,10 @@ DynamicsContext::DynamicsContext(	PxcNpMemBlockPool* memBlockPool,
 									PxU64 contextID,
 									const bool enableStabilization,
 									const bool useEnhancedDeterminism,
-									const bool useAdaptiveForce
+									const bool useAdaptiveForce,
+									const PxReal maxBiasCoefficient
 									) : 
-	Dy::Context			(accurateIslandSim, allocatorCallback, simStats, enableStabilization, useEnhancedDeterminism, useAdaptiveForce),
+	Dy::Context			(accurateIslandSim, allocatorCallback, simStats, enableStabilization, useEnhancedDeterminism, useAdaptiveForce, maxBiasCoefficient),
 	mThreadContextPool	(memBlockPool),
 	mMaterialManager	(materialManager),
 	mScratchAllocator	(scratchAllocator),
@@ -265,8 +269,8 @@ void DynamicsContext::setDescFromIndices(PxSolverConstraintDesc& desc, const Pxs
 
 		desc.bodyA = constraint.indexType0 == PxsIndexedInteraction::eWORLD ? &mWorldSolverBody
 																			: &mSolverBodyPool[PxU32(constraint.solverBody0) + offsetMap[constraint.indexType0]];
-		desc.bodyADataIndex = PxU16(constraint.indexType0 == PxsIndexedInteraction::eWORLD ? 0
-																			: PxU16(constraint.solverBody0) + 1 + offsetMap[constraint.indexType0]);
+		desc.bodyADataIndex = constraint.indexType0 == PxsIndexedInteraction::eWORLD ? 0
+																			: PxU32(constraint.solverBody0) + 1 + offsetMap[constraint.indexType0];
 	}
 
 	if(constraint.indexType1 == PxsIndexedInteraction::eARTICULATION)
@@ -283,8 +287,8 @@ void DynamicsContext::setDescFromIndices(PxSolverConstraintDesc& desc, const Pxs
 		//desc.articulationBLength = 0; //this is unioned with bodyBDataIndex
 		desc.bodyB = constraint.indexType1 == PxsIndexedInteraction::eWORLD ? &mWorldSolverBody
 																			: &mSolverBodyPool[PxU32(constraint.solverBody1) + offsetMap[constraint.indexType1]];
-		desc.bodyBDataIndex = PxU16(constraint.indexType1 == PxsIndexedInteraction::eWORLD ? 0
-																			: PxU16(constraint.solverBody1) + 1 + offsetMap[constraint.indexType1]);
+		desc.bodyBDataIndex = constraint.indexType1 == PxsIndexedInteraction::eWORLD ? 0
+																			: PxU32(constraint.solverBody1) + 1 + offsetMap[constraint.indexType1];
 	}
 }
 
@@ -891,34 +895,47 @@ public:
 			const IG::IslandSim& islandSim = mIslandManager.getAccurateIslandSim();
 
 			PxU32 bodyIndex = 0, articIndex = 0;
-			for(PxU32 i = 0; i < nbIslands; ++i)
+			for (PxU32 i = 0; i < nbIslands; ++i)
 			{
 				const IG::Island& island = islandSim.getIsland(islandIds[i]);
 
 				IG::NodeIndex currentIndex = island.mRootNode;
 
-				while(currentIndex.isValid())
+				while (currentIndex.isValid())
 				{
 					const IG::Node& node = islandSim.getNode(currentIndex);
 
-					if(node.getNodeType() == IG::Node::eARTICULATION_TYPE)
+					if (node.getNodeType() == IG::Node::eARTICULATION_TYPE)
 					{
 						articulationPtr[articIndex++] = node.getArticulation();
 					}
 					else
 					{
-						PxsRigidBody* rigid = node.getRigidBody();
 						PX_ASSERT(bodyIndex < (mIslandContext.mCounts.bodies + mContext.mKinematicCount + 1));
-						rigidBodyPtr[bodyIndex] = rigid;
-						bodyArrayPtr[bodyIndex] = &rigid->getCore();
-						nodeIndexArray[bodyIndex] = currentIndex.index();
-						bodyRemapTable[islandSim.getActiveNodeIndex(currentIndex)] = bodyIndex++;
+						nodeIndexArray[bodyIndex++] = currentIndex.index();
 					}
 
 					currentIndex = node.mNextNode;
 				}
 			}
 
+			//Bodies can come in a slightly jumbled order from islandGen. It's deterministic if the scene is 
+			//identical but can vary if there are additional bodies in the scene in a different island.
+			if (mEnhancedDeterminism)
+			{
+				Ps::sort(nodeIndexArray, bodyIndex);
+			}
+
+			for (PxU32 a = 0; a < bodyIndex; ++a)
+			{
+				IG::NodeIndex currentIndex(nodeIndexArray[a]);
+				const IG::Node& node = islandSim.getNode(currentIndex);
+				PxsRigidBody* rigid = node.getRigidBody();
+				rigidBodyPtr[a] = rigid;
+				bodyArrayPtr[a] = &rigid->getCore();
+				bodyRemapTable[islandSim.getActiveNodeIndex(currentIndex)] = a;
+			}
+
 
 			PxsIndexedContactManager* indexedManagers = mObjects.contactManagers;
 
@@ -2610,7 +2627,7 @@ static PxU32 createFinalizeContacts_Parallel(PxSolverBodyData* solverBodyData, T
 	const PxReal bounceThreshold = context.getBounceThreshold();
 	const PxReal frictionOffsetThreshold = context.getFrictionOffsetThreshold();
 	const PxReal dt = context.getDt();
-	const PxReal invDt = context.getInvDt();
+	const PxReal invDt = PxMin(context.getMaxBiasCoefficient(), context.getInvDt());
 
 	PxSolverConstraintDesc* contactDescPtr = mThreadContext.orderedContactConstraints;
 
@@ -2697,6 +2714,7 @@ static PxU32 createFinalizeContacts_Parallel(PxSolverBodyData* solverBodyData, T
 					 bounceThreshold,
 					 frictionOffsetThreshold,
 					 context.getCorrelationDistance(),
+					 context.getSolverOffsetSlop(),
 					 blockAllocator);
 
 			}
@@ -2712,7 +2730,7 @@ static PxU32 createFinalizeContacts_Parallel(PxSolverBodyData* solverBodyData, T
 					PxsContactManagerOutput& output = outputs.getContactManager(n.mNpIndex);
 					
 					createFinalizeMethods[frictionType](blockDescs[i], output, *threadContext,
-						invDt, bounceThreshold, frictionOffsetThreshold, context.getCorrelationDistance(), blockAllocator);
+						invDt, bounceThreshold, frictionOffsetThreshold, context.getCorrelationDistance(), context.getSolverOffsetSlop(), blockAllocator);
 			
 					getContactManagerConstraintDesc(output,*cm,desc);
 				}
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.h b/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.h
index e2c307b9..6946f76c 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.h
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DyDynamics.h
@@ -176,7 +176,8 @@ public:
 									PxU64 contextID,
 									const bool enableStabilization,
 									const bool useEnhancedDeterminism,
-									const bool useAdaptiveForce
+									const bool useAdaptiveForce,
+									const PxReal maxBiasCoefficient
 									);
 	
 	/**
@@ -268,7 +269,8 @@ protected:
 														PxU64 contextID,
 														const bool enableStabilization,
 														const bool useEnhancedDeterminism,
-														const bool useAdaptiveForce
+														const bool useAdaptiveForce,
+														const PxReal maxBiasCoefficient
 														);
 	/**
 	\brief Destructor for DynamicsContext
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraints.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraints.cpp
index 0a33c778..5e397b98 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraints.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraints.cpp
@@ -31,8 +31,6 @@
 #include "foundation/PxPreprocessor.h"
 #include "PsVecMath.h"
 
-#ifdef PX_SUPPORT_SIMD
-
 #include "CmPhysXCommon.h"
 #include "DySolverBody.h"
 #include "DySolverContact.h"
@@ -1122,4 +1120,3 @@ void solveConcludeContact_BStatic	(const PxSolverConstraintDesc& desc, SolverCon
 
 }
 
-#endif
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsBlock.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsBlock.cpp
index 2d3d917c..5d238d0b 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsBlock.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsBlock.cpp
@@ -32,8 +32,6 @@
 #include "PsVecMath.h"
 #include "PsFPU.h"
 
-#ifdef PX_SUPPORT_SIMD
-
 #include "CmPhysXCommon.h"
 #include "DySolverBody.h"
 #include "DySolverContact.h"
@@ -105,7 +103,7 @@ static void solveContact4_Block(const PxSolverConstraintDesc* PX_RESTRICT desc,
 	//hopefully pointer aliasing doesn't bite.
 	PxU8* PX_RESTRICT currPtr = desc[0].constraint;
 
-	Vec4V vMax = V4Splat(FMax());
+	
 
 	const PxU8* PX_RESTRICT prefetchAddress = currPtr + sizeof(SolverContactHeader4) + sizeof(SolverContactBatchPointDynamic4);
 
@@ -129,26 +127,12 @@ static void solveContact4_Block(const PxSolverConstraintDesc* PX_RESTRICT desc,
 		const PxU32 numNormalConstr = hdr->numNormalConstr;
 		const PxU32	numFrictionConstr = hdr->numFrictionConstr;
 
-		bool hasMaxImpulse = (hdr->flag & SolverContactHeader4::eHAS_MAX_IMPULSE) != 0;
-
 		Vec4V* appliedForces = reinterpret_cast<Vec4V*>(currPtr);
 		currPtr += sizeof(Vec4V)*numNormalConstr;
 
 		SolverContactBatchPointDynamic4* PX_RESTRICT contacts = reinterpret_cast<SolverContactBatchPointDynamic4*>(currPtr);
 
-		Vec4V* maxImpulses;
 		currPtr = reinterpret_cast<PxU8*>(contacts + numNormalConstr);
-		PxU32 maxImpulseMask = 0;
-		if(hasMaxImpulse)
-		{
-			maxImpulseMask = 0xFFFFFFFF;
-			maxImpulses = reinterpret_cast<Vec4V*>(currPtr);
-			currPtr += sizeof(Vec4V) * numNormalConstr;
-		}
-		else
-		{
-			maxImpulses = &vMax;
-		}
 
 				
 		SolverFrictionSharedData4* PX_RESTRICT fd = reinterpret_cast<SolverFrictionSharedData4*>(currPtr);
@@ -192,7 +176,7 @@ static void solveContact4_Block(const PxSolverConstraintDesc* PX_RESTRICT desc,
 			prefetchAddress += offset;
 
 			const Vec4V appliedForce = appliedForces[i];
-			const Vec4V maxImpulse = maxImpulses[i & maxImpulseMask];			
+			const Vec4V maxImpulse = c.maxContactImpulse;			
 			
 			Vec4V contactNormalVel2 = V4Mul(c.raXnX, angState0T0);
 			Vec4V contactNormalVel4 = V4Mul(c.rbXnX, angState1T0);
@@ -426,7 +410,6 @@ static void solveContact4_StaticBlock(const PxSolverConstraintDesc* PX_RESTRICT
 
 	//We'll need this.
 	const Vec4V vZero	= V4Zero();
-	Vec4V vMax	= V4Splat(FMax());
 	
 	Vec4V linVel00 = V4LoadA(&b00.linearVelocity.x);
 	Vec4V angState00 = V4LoadA(&b00.angularState.x);
@@ -463,7 +446,6 @@ static void solveContact4_StaticBlock(const PxSolverConstraintDesc* PX_RESTRICT
 
 		const PxU32 numNormalConstr = hdr->numNormalConstr;
 		const PxU32	numFrictionConstr = hdr->numFrictionConstr;
-		bool hasMaxImpulse = (hdr->flag & SolverContactHeader4::eHAS_MAX_IMPULSE) != 0;
 
 		Vec4V* appliedForces = reinterpret_cast<Vec4V*>(currPtr);
 		currPtr += sizeof(Vec4V)*numNormalConstr;
@@ -472,20 +454,6 @@ static void solveContact4_StaticBlock(const PxSolverConstraintDesc* PX_RESTRICT
 
 		currPtr = reinterpret_cast<PxU8*>(contacts + numNormalConstr);
 
-		Vec4V* maxImpulses;
-		PxU32 maxImpulseMask;
-		if(hasMaxImpulse)
-		{
-			maxImpulseMask = 0xFFFFFFFF;
-			maxImpulses = reinterpret_cast<Vec4V*>(currPtr);
-			currPtr += sizeof(Vec4V) * numNormalConstr;
-		}
-		else
-		{
-			maxImpulseMask = 0;
-			maxImpulses = &vMax;
-		}
-
 		SolverFrictionSharedData4* PX_RESTRICT fd = reinterpret_cast<SolverFrictionSharedData4*>(currPtr);
 		if(numFrictionConstr)
 			currPtr += sizeof(SolverFrictionSharedData4);
@@ -523,7 +491,7 @@ static void solveContact4_StaticBlock(const PxSolverConstraintDesc* PX_RESTRICT
 			prefetchAddress += offset;
 
 			const Vec4V appliedForce = appliedForces[i];
-			const Vec4V maxImpulse = maxImpulses[i&maxImpulseMask];
+			const Vec4V maxImpulse = c.maxContactImpulse;
 			Vec4V contactNormalVel2 = V4MulAdd(c.raXnX, angState0T0, contactNormalVel1);
 			contactNormalVel2 = V4MulAdd(c.raXnY, angState0T1, contactNormalVel2);
 			const Vec4V normalVel = V4MulAdd(c.raXnZ, angState0T2, contactNormalVel2);
@@ -689,10 +657,6 @@ static void concludeContact4_Block(const PxSolverConstraintDesc* PX_RESTRICT des
 
 		SolverContactBatchPointBase4* PX_RESTRICT contacts = reinterpret_cast<SolverContactBatchPointBase4*>(currPtr);
 		currPtr += (numNormalConstr * contactSize);
-		bool hasMaxImpulse = (hdr->flag & SolverContactHeader4::eHAS_MAX_IMPULSE) != 0;
-
-		if(hasMaxImpulse)
-			currPtr += sizeof(Vec4V) * numNormalConstr;
 
 		currPtr += sizeof(Vec4V)*numFrictionConstr;
 
@@ -760,11 +724,6 @@ void writeBackContact4_Block(const PxSolverConstraintDesc* PX_RESTRICT desc, Sol
 		//SolverContactBatchPointBase4* PX_RESTRICT contacts = (SolverContactBatchPointBase4*)currPtr;
 		currPtr += (numNormalConstr * contactSize);
 
-		bool hasMaxImpulse = (hdr->flag & SolverContactHeader4::eHAS_MAX_IMPULSE) != 0;
-
-		if(hasMaxImpulse)
-			currPtr += sizeof(Vec4V) * numNormalConstr;
-
 		SolverFrictionSharedData4* PX_RESTRICT fd = reinterpret_cast<SolverFrictionSharedData4*>(currPtr);
 		if(numFrictionConstr)
 			currPtr += sizeof(SolverFrictionSharedData4);
@@ -1227,4 +1186,3 @@ void writeBack1D4Block(const PxSolverConstraintDesc* PX_RESTRICT desc, const PxU
 
 }
 
-#endif
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsShared.h b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsShared.h
index ae46b357..7eb0b2bd 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsShared.h
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverConstraintsShared.h
@@ -33,8 +33,6 @@
 #include "foundation/PxPreprocessor.h"
 #include "PsVecMath.h"
 
-#ifdef PX_SUPPORT_SIMD
-
 #include "CmPhysXCommon.h"
 #include "DySolverBody.h"
 #include "DySolverContact.h"
@@ -215,7 +213,5 @@ PX_FORCE_INLINE static FloatV solveExtContacts(SolverContactPointExt* contacts,
 
 }
 
-#endif //PX_SUPPORT_SIMD
-
 #endif //DY_SOLVER_CORE_SHARED_H
 
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact.h b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact.h
index c5b95886..55ab2a73 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact.h
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact.h
@@ -127,10 +127,8 @@ struct SolverContactPoint
 	PX_FORCE_INLINE FloatV getMaxImpulse() const			{return FLoad(maxImpulse);}
 
 
-#ifdef PX_SUPPORT_SIMD
 	PX_FORCE_INLINE Vec3V getRaXn() const					{return raXn;}
 	PX_FORCE_INLINE Vec3V getRbXn() const					{return rbXn;}
-#endif
 
 	PX_FORCE_INLINE void setRaXn(const PxVec3& v)			{V3WriteXYZ(raXn, v);}
 	PX_FORCE_INLINE void setRbXn(const PxVec3& v)			{V3WriteXYZ(rbXn, v);}
@@ -181,11 +179,9 @@ struct SolverContactFriction
 	PX_FORCE_INLINE FloatV getVelMultiplier() const			{return V4GetW(raXnXYZ_velMultiplierW);}
 	PX_FORCE_INLINE FloatV getBias() const					{return V4GetW(rbXnXYZ_biasW);}
 
-#ifdef PX_SUPPORT_SIMD
 	PX_FORCE_INLINE Vec3V getNormal() const					{return Vec3V_From_Vec4V(normalXYZ_appliedForceW);}
 	PX_FORCE_INLINE Vec3V getRaXn() const					{return Vec3V_From_Vec4V(raXnXYZ_velMultiplierW);}
 	PX_FORCE_INLINE Vec3V getRbXn() const					{return Vec3V_From_Vec4V(rbXnXYZ_biasW);}
-#endif	
 
 	PX_FORCE_INLINE void setNormal(const PxVec3& v)			{V4WriteXYZ(normalXYZ_appliedForceW, v);}
 	PX_FORCE_INLINE void setRaXn(const PxVec3& v)			{V4WriteXYZ(raXnXYZ_velMultiplierW, v);}
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact4.h b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact4.h
index 814f4cc1..c6222f0b 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact4.h
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverContact4.h
@@ -115,8 +115,9 @@ struct SolverContactBatchPointBase4
 	Vec4V velMultiplier;
 	Vec4V scaledBias;
 	Vec4V biasedErr;
+	Vec4V maxContactImpulse;
 };
-PX_COMPILE_TIME_ASSERT(sizeof(SolverContactBatchPointBase4) == 96);
+PX_COMPILE_TIME_ASSERT(sizeof(SolverContactBatchPointBase4) == 112);
 
 /**
 \brief Contains the additional data required to represent 4 contacts between 2 dynamic bodies
@@ -128,7 +129,7 @@ struct SolverContactBatchPointDynamic4 : public SolverContactBatchPointBase4
 	Vec4V rbXnY;
 	Vec4V rbXnZ;
 }; 
-PX_COMPILE_TIME_ASSERT(sizeof(SolverContactBatchPointDynamic4) == 144);
+PX_COMPILE_TIME_ASSERT(sizeof(SolverContactBatchPointDynamic4) == 160);
 
 /**
 \brief This represents the shared information of a batch of 4 friction constraints
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.cpp
index aa964099..bbb48efe 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.cpp
@@ -242,14 +242,13 @@ void SolverCoreGeneral::solveV_Blocks(SolverIslandParams& params) const
 
 	//0-(n-1) iterations
 	PxI32 normalIter = 0;
-	PxI32 frictionIter = 0;
 
 	for (PxU32 iteration = positionIterations; iteration > 0; iteration--)	//decreasing positive numbers == position iters
 	{
 		cache.doFriction = iteration<=3;
 
-		SolveBlockParallel<false>(constraintList, batchCount, normalIter * batchCount, batchCount, 
-			cache, contactIterator, iteration == 1 ? gVTableSolveConcludeBlock : gVTableSolveBlock, normalIter, frictionIter, normalIter);
+		SolveBlockParallel(constraintList, batchCount, normalIter * batchCount, batchCount, 
+			cache, contactIterator, iteration == 1 ? gVTableSolveConcludeBlock : gVTableSolveBlock, normalIter);
 
 		++normalIter;
 	}
@@ -274,8 +273,8 @@ void SolverCoreGeneral::solveV_Blocks(SolverIslandParams& params) const
 	for(; iteration < velItersMinOne; ++iteration)
 	{	
 
-		SolveBlockParallel<false>(constraintList, batchCount, normalIter * batchCount, batchCount, 
-			cache, contactIterator, gVTableSolveBlock, normalIter, frictionIter, normalIter);
+		SolveBlockParallel(constraintList, batchCount, normalIter * batchCount, batchCount, 
+			cache, contactIterator, gVTableSolveBlock, normalIter);
 		++normalIter;
 
 	}
@@ -291,8 +290,8 @@ void SolverCoreGeneral::solveV_Blocks(SolverIslandParams& params) const
 	for(; iteration < PxI32(velocityIterations); ++iteration)
 	{
 
-		SolveBlockParallel<false>(constraintList, batchCount, normalIter * batchCount, batchCount, 
-			cache, contactIterator, gVTableSolveWriteBackBlock, normalIter, frictionIter, normalIter);
+		SolveBlockParallel(constraintList, batchCount, normalIter * batchCount, batchCount, 
+			cache, contactIterator, gVTableSolveWriteBackBlock, normalIter);
 		++normalIter;
 
 	}	
@@ -363,7 +362,6 @@ PxI32 SolverCoreGeneral::solveVParallelAndWriteBack
 
 	PxI32 maxNormalIndex = 0;
 	PxI32 normalIteration = 0;
-	PxI32 frictionIteration = 0;
 	PxU32 a = 0;
 	PxI32 targetConstraintIndex = 0;
 	for(PxU32 i = 0; i < 2; ++i)
@@ -382,8 +380,8 @@ PxI32 SolverCoreGeneral::solveVParallelAndWriteBack
 				while(index < maxNormalIndex)
 				{
 					const PxI32 remainder = PxMin(maxNormalIndex - index, endIndexCount);
-					SolveBlockParallel<false>(constraintList, remainder, index, batchCount, cache, contactIter, solveTable, 
-						normalIteration, frictionIteration, normalIteration);
+					SolveBlockParallel(constraintList, remainder, index, batchCount, cache, contactIter, solveTable, 
+						normalIteration);
 					index += remainder;
 					endIndexCount -= remainder;
 					nbSolved += remainder;
@@ -489,8 +487,8 @@ PxI32 SolverCoreGeneral::solveVParallelAndWriteBack
 			while(index < maxNormalIndex)
 			{
 				const PxI32 remainder = PxMin(maxNormalIndex - index, endIndexCount);
-				SolveBlockParallel<false>(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveBlock, 
-					normalIteration, 0, normalIteration);
+				SolveBlockParallel(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveBlock, 
+					normalIteration);
 				index += remainder;
 				endIndexCount -= remainder;
 				nbSolved += remainder;
@@ -532,8 +530,8 @@ PxI32 SolverCoreGeneral::solveVParallelAndWriteBack
 			{
 				const PxI32 remainder = PxMin(maxNormalIndex - index, endIndexCount);
 
-				SolveBlockParallel<false>(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveWriteBackBlock, 
-					normalIteration, 0, normalIteration);
+				SolveBlockParallel(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveWriteBackBlock, 
+					normalIteration);
 
 				index += remainder;
 				endIndexCount -= remainder;
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.h b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.h
index 719eb445..6d7be4fe 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.h
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControl.h
@@ -62,45 +62,6 @@ inline void BusyWaitStates(volatile PxU32* stateA, volatile PxU32* stateB, const
 }
 
 
-PX_FORCE_INLINE void WaitBodyABodyBRequiredState(const PxSolverConstraintDesc& desc, const PxI32 iterationA, const PxI32 iterationB)
-{
-	PxSolverBody* PX_RESTRICT pBodyA = desc.bodyA;
-	PxSolverBody* PX_RESTRICT pBodyB = desc.bodyB;
-
-	const PxU32 requiredProgressA=(desc.bodyASolverProgress == 0xFFFF) ? 0xFFFF : PxU32(desc.bodyASolverProgress + iterationA * pBodyA->maxSolverNormalProgress + iterationB * pBodyA->maxSolverFrictionProgress);
-	const PxU32 requiredProgressB=(desc.bodyBSolverProgress == 0xFFFF) ? 0xFFFF : PxU32(desc.bodyBSolverProgress + iterationA * pBodyB->maxSolverNormalProgress + iterationB * pBodyB->maxSolverFrictionProgress);
-	PX_ASSERT(requiredProgressA!=0xFFFFFFFF || requiredProgressB!=0xFFFFFFFF);
-
-	const PxU32 solverProgressA = pBodyA->solverProgress;
-	const PxU32 solverProgressB = pBodyB->solverProgress;	
-
-	if(solverProgressA != requiredProgressA || solverProgressB != requiredProgressB)
-	{
-		BusyWaitStates(&pBodyA->solverProgress, &pBodyB->solverProgress, requiredProgressA, requiredProgressB);
-	}	
-}
-
-PX_FORCE_INLINE void IncrementBodyProgress(const PxSolverConstraintDesc& desc)
-{
-	PxSolverBody* PX_RESTRICT pBodyA = desc.bodyA;
-	PxSolverBody* PX_RESTRICT pBodyB = desc.bodyB;
-
-	const PxU32 maxProgressA = pBodyA->maxSolverNormalProgress;
-	const PxU32 maxProgressB = pBodyB->maxSolverNormalProgress;
-
-	//NB - this approach removes the need for an imul (which is a non-pipeline instruction on PPC chips)
-	const PxU32 requiredProgressA=(maxProgressA == 0xFFFF) ? 0xFFFF : pBodyA->solverProgress + 1;
-	const PxU32 requiredProgressB=(maxProgressB == 0xFFFF) ? 0xFFFF : pBodyB->solverProgress + 1;
-
-	volatile PxU32* solveProgressA = &pBodyA->solverProgress;
-	volatile PxU32* solveProgressB = &pBodyB->solverProgress;
-
-	*solveProgressA=requiredProgressA;
-	*solveProgressB=requiredProgressB;
-
-}
-
-
 class BatchIterator
 {
 public:
@@ -127,10 +88,9 @@ private:
 };
 
 
-template<bool bWaitIncrement>
-void SolveBlockParallel	(PxSolverConstraintDesc* PX_RESTRICT constraintList, const PxI32 batchCount, const PxI32 index,  
+inline void SolveBlockParallel	(PxSolverConstraintDesc* PX_RESTRICT constraintList, const PxI32 batchCount, const PxI32 index,  
 						 const PxI32 headerCount, SolverContext& cache, BatchIterator& iterator,
-						 SolveBlockMethod solveTable[], const PxI32 normalIteration, const PxI32 frictionIteration,
+						 SolveBlockMethod solveTable[],
 						 const PxI32 iteration
 						)
 {
@@ -152,22 +112,10 @@ void SolveBlockParallel	(PxSolverConstraintDesc* PX_RESTRICT constraintList, con
 		{
 			Ps::prefetchLine(block[b].bodyA);
 			Ps::prefetchLine(block[b].bodyB);
-			if(bWaitIncrement)
-				WaitBodyABodyBRequiredState(block[b], normalIteration, frictionIteration);
 		}
 
 		//OK. We have a number of constraints to run...
 		solveTable[header.mConstraintType](block, PxU32(numToGrab), cache);
-
-		//Increment body progresses
-		if(bWaitIncrement)
-		{
-			Ps::memoryBarrier();
-			for(PxI32 j = 0; j < numToGrab; ++j)
-			{
-				IncrementBodyProgress(block[j]);	
-			}
-		}
 	}
 }
 
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControlPF.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControlPF.cpp
index 45e01b1e..188bcf3d 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControlPF.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverControlPF.cpp
@@ -275,8 +275,8 @@ void SolverCoreGeneralPF::solveV_Blocks(SolverIslandParams& params) const
 	for (PxU32 iteration = positionIterations; iteration > 0; iteration--)	//decreasing positive numbers == position iters
 	{
 
-		SolveBlockParallel<false>(constraintList, batchCount, normalIter * batchCount, batchCount, 
-			cache, contactIterator, iteration == 1 ? gVTableSolveConcludeBlockCoulomb : gVTableSolveBlockCoulomb, normalIter, frictionIter, normalIter);
+		SolveBlockParallel(constraintList, batchCount, normalIter * batchCount, batchCount, 
+			cache, contactIterator, iteration == 1 ? gVTableSolveConcludeBlockCoulomb : gVTableSolveBlockCoulomb, normalIter);
 		++normalIter;
 	
 	}
@@ -286,8 +286,8 @@ void SolverCoreGeneralPF::solveV_Blocks(SolverIslandParams& params) const
 		const PxU32 numIterations = positionIterations * 2;
 		for (PxU32 iteration = numIterations; iteration > 0; iteration--)	//decreasing positive numbers == position iters
 		{
-			SolveBlockParallel<false>(frictionConstraintList, frictionBatchCount, frictionIter * frictionBatchCount, frictionBatchCount, 
-				cache, frictionIterator, iteration == 1 ? gVTableSolveConcludeBlockCoulomb : gVTableSolveBlockCoulomb, normalIter, frictionIter, frictionIter);
+			SolveBlockParallel(frictionConstraintList, frictionBatchCount, frictionIter * frictionBatchCount, frictionBatchCount, 
+				cache, frictionIterator, iteration == 1 ? gVTableSolveConcludeBlockCoulomb : gVTableSolveBlockCoulomb, frictionIter);
 			++frictionIter;
 		}
 	}
@@ -312,14 +312,14 @@ void SolverCoreGeneralPF::solveV_Blocks(SolverIslandParams& params) const
 	for(; iteration < velItersMinOne; ++iteration)
 	{	
 
-		SolveBlockParallel<false>(constraintList, batchCount, normalIter * batchCount, batchCount, 
-			cache, contactIterator, gVTableSolveBlockCoulomb, normalIter, frictionIter, normalIter);
+		SolveBlockParallel(constraintList, batchCount, normalIter * batchCount, batchCount, 
+			cache, contactIterator, gVTableSolveBlockCoulomb, normalIter);
 		++normalIter;
 
 		if(frictionBatchCount > 0)
 		{
-			SolveBlockParallel<false>(frictionConstraintList, frictionBatchCount, frictionIter * frictionBatchCount, frictionBatchCount, 
-				cache, frictionIterator, gVTableSolveBlockCoulomb, normalIter, frictionIter, frictionIter);
+			SolveBlockParallel(frictionConstraintList, frictionBatchCount, frictionIter * frictionBatchCount, frictionBatchCount, 
+				cache, frictionIterator, gVTableSolveBlockCoulomb, frictionIter);
 			++frictionIter;
 		}
 	}
@@ -336,14 +336,14 @@ void SolverCoreGeneralPF::solveV_Blocks(SolverIslandParams& params) const
 
 	for(; iteration < velocityIterations; ++iteration)
 	{
-		SolveBlockParallel<false>(constraintList, batchCount, normalIter * batchCount, batchCount, 
-			cache, contactIterator, gVTableSolveWriteBackBlockCoulomb, normalIter, frictionIter, normalIter);
+		SolveBlockParallel(constraintList, batchCount, normalIter * batchCount, batchCount, 
+			cache, contactIterator, gVTableSolveWriteBackBlockCoulomb, normalIter);
 		++normalIter;
 
 		if(frictionBatchCount > 0)
 		{
-			SolveBlockParallel<false>(frictionConstraintList, frictionBatchCount, frictionIter * frictionBatchCount, frictionBatchCount, 
-				cache, frictionIterator, gVTableSolveWriteBackBlockCoulomb, normalIter, frictionIter, frictionIter);
+			SolveBlockParallel(frictionConstraintList, frictionBatchCount, frictionIter * frictionBatchCount, frictionBatchCount, 
+				cache, frictionIterator, gVTableSolveWriteBackBlockCoulomb, frictionIter);
 				++frictionIter;
 		}
 	}
@@ -433,8 +433,8 @@ PxI32 SolverCoreGeneralPF::solveVParallelAndWriteBack(SolverIslandParams& params
 				while(index < maxNormalIndex)
 				{
 					const PxI32 remainder = PxMin(maxNormalIndex - index, endIndexCount);
-					SolveBlockParallel<false>(constraintList, remainder, index, batchCount, cache, contactIter, solveTable, 
-						normalIteration, frictionIteration, normalIteration);
+					SolveBlockParallel(constraintList, remainder, index, batchCount, cache, contactIter, solveTable, 
+						normalIteration);
 					index += remainder;
 					endIndexCount -= remainder;
 					nbSolved += remainder;
@@ -471,8 +471,8 @@ PxI32 SolverCoreGeneralPF::solveVParallelAndWriteBack(SolverIslandParams& params
 				while(frictionIndex < maxFrictionIndex)
 				{
 					const PxI32 remainder = PxMin(maxFrictionIndex - frictionIndex, frictionEndIndexCount);
-					SolveBlockParallel<false>(frictionConstraintList, remainder, frictionIndex, frictionBatchCount, cache, frictionIter, 
-						solveTable, normalIteration, frictionIteration, frictionIteration);
+					SolveBlockParallel(frictionConstraintList, remainder, frictionIndex, frictionBatchCount, cache, frictionIter, 
+						solveTable, frictionIteration);
 					frictionIndex += remainder;
 					frictionEndIndexCount -= remainder;
 					nbSolved += remainder;
@@ -582,7 +582,7 @@ PxI32 SolverCoreGeneralPF::solveVParallelAndWriteBack(SolverIslandParams& params
 			while(index < maxNormalIndex)
 			{
 				const PxI32 remainder = PxMin(maxNormalIndex - index, endIndexCount);
-				SolveBlockParallel<false>(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveBlockCoulomb, normalIteration, frictionIteration, normalIteration);
+				SolveBlockParallel(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveBlockCoulomb, normalIteration);
 				index += remainder;
 				endIndexCount -= remainder;
 				nbSolved += remainder;
@@ -610,8 +610,8 @@ PxI32 SolverCoreGeneralPF::solveVParallelAndWriteBack(SolverIslandParams& params
 			while(frictionIndex < maxFrictionIndex)
 			{
 				const PxI32 remainder = PxMin(maxFrictionIndex - frictionIndex, frictionEndIndexCount);
-				SolveBlockParallel<false>(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveBlockCoulomb, 
-					normalIteration, frictionIteration, normalIteration);
+				SolveBlockParallel(constraintList, remainder, index, batchCount, cache, contactIter, gVTableSolveBlockCoulomb, 
+					normalIteration);
 
 				frictionIndex += remainder;
 				frictionEndIndexCount -= remainder;
@@ -652,8 +652,8 @@ PxI32 SolverCoreGeneralPF::solveVParallelAndWriteBack(SolverIslandParams& params
 			{
 				const PxI32 remainder = PxMin(maxNormalIndex - index, endIndexCount);
 
-				SolveBlockParallel<false>(constraintList, remainder, normalIteration * batchCount, batchCount, 
-					cache, contactIter, gVTableSolveWriteBackBlockCoulomb, normalIteration, frictionIteration, normalIteration);
+				SolveBlockParallel(constraintList, remainder, normalIteration * batchCount, batchCount, 
+					cache, contactIter, gVTableSolveWriteBackBlockCoulomb, normalIteration);
 
 				index += remainder;
 				endIndexCount -= remainder;
@@ -688,8 +688,8 @@ PxI32 SolverCoreGeneralPF::solveVParallelAndWriteBack(SolverIslandParams& params
 			{
 				const PxI32 remainder = PxMin(maxFrictionIndex - frictionIndex, frictionEndIndexCount);
 
-				SolveBlockParallel<false>(frictionConstraintList, remainder, frictionIndex, frictionBatchCount, cache, frictionIter, 
-					gVTableSolveWriteBackBlockCoulomb, normalIteration, frictionIteration, frictionIteration);
+				SolveBlockParallel(frictionConstraintList, remainder, frictionIndex, frictionBatchCount, cache, frictionIter, 
+					gVTableSolveWriteBackBlockCoulomb, frictionIteration);
 
 				frictionIndex += remainder;
 				frictionEndIndexCount -= remainder;
diff --git a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverPFConstraints.cpp b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverPFConstraints.cpp
index 76fe8e7f..0ede719d 100644
--- a/PhysX_3.4/Source/LowLevelDynamics/src/DySolverPFConstraints.cpp
+++ b/PhysX_3.4/Source/LowLevelDynamics/src/DySolverPFConstraints.cpp
@@ -31,8 +31,6 @@
 #include "foundation/PxPreprocessor.h"
 #include "PsVecMath.h"
 
-#ifdef PX_SUPPORT_SIMD
-
 #include "CmPhysXCommon.h"
 #include "DySolverBody.h"
 #include "DySolverContact.h"
@@ -865,4 +863,3 @@ void solveConcludeContactCoulomb_BStatic	(const PxSolverConstraintDesc& desc, So
 
 }
 
-#endif //PX_SUPPORT_SIMD