p.Chaos.JointConstraint.JointStiffness

p.Chaos.JointConstraint.JointStiffness

#Overview

name: p.Chaos.JointConstraint.JointStiffness

This variable is created as a Console Variable (cvar).

It is referenced in 30 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of p.Chaos.JointConstraint.JointStiffness is to control the stiffness of hard joints in the Chaos physics solver within Unreal Engine 5. This setting variable is used in the joint constraint system, which is part of the physics simulation subsystem.

Key points about this variable:

  1. It’s part of the Chaos physics engine, which is the new physics system in Unreal Engine 5.

  2. The variable is used in the PhysicsCore module and the Experimental Chaos module.

  3. It’s primarily used in the PBDJointSolver (Position Based Dynamics Joint Solver) class, which handles solving joint constraints in the physics simulation.

  4. The value is set via a console variable, allowing it to be adjusted at runtime.

  5. It affects both linear and angular constraints in various joint types (spherical, cylindrical, planar).

  6. The variable is used to scale the stiffness of hard joint constraints. A higher value will make joints more rigid, while a lower value will make them more flexible.

  7. It’s used in conjunction with other joint-related variables like damping and soft constraints.

Developers should be aware that:

  1. Changing this value will affect the behavior of all hard joint constraints in the simulation.

  2. It’s a global setting, so it will impact all joints unless overridden locally.

  3. Extreme values may lead to instability in the physics simulation.

  4. It interacts with other joint settings, so it should be tuned in conjunction with those.

Best practices:

  1. Start with the default value and adjust gradually.

  2. Test changes thoroughly across different scenarios and joint types.

  3. Consider performance implications when increasing stiffness, as it may require more iterations to solve constraints.

  4. Use in combination with damping settings for more natural joint behavior.

  5. For fine-tuning specific joints, consider using per-joint settings rather than this global variable.

The associated variable JointStiffness in the ConstraintSettings class serves as an accessor for the console variable. It’s used throughout the codebase to retrieve the current joint stiffness value, allowing for consistent use of the setting across different parts of the physics system.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Runtime/PhysicsCore/Private/ChaosConstraintSettings.cpp:26

Scope (from outer to inner):

file
namespace    Chaos
namespace    JointConstraintDefaults

Source code excerpt:

		float AngularBreakScale = 1.0f;

		FAutoConsoleVariableRef CVarJointStiffness(TEXT("p.Chaos.JointConstraint.JointStiffness"), JointStiffness, TEXT("Hard-joint solver stiffness."));
		FAutoConsoleVariableRef CVarLinearDriveStiffnessScale(TEXT("p.Chaos.JointConstraint.LinearDriveStiffnessScale"), LinearDriveStiffnessScale, TEXT("Conversion factor for Linear drive stiffness."));
		FAutoConsoleVariableRef CVarLinearDriveDampingScale(TEXT("p.Chaos.JointConstraint.LinaearDriveDampingScale"), LinearDriveDampingScale, TEXT("Conversion factor for Linear drive damping."));
		FAutoConsoleVariableRef CVarAngularDriveStiffnessScale(TEXT("p.Chaos.JointConstraint.AngularDriveStiffnessScale"), AngularDriveStiffnessScale, TEXT("Conversion factor for Angular drive stiffness."));
		FAutoConsoleVariableRef CVarAngularDriveDampingScale(TEXT("p.Chaos.JointConstraint.AngularDriveDampingScale"), AngularDriveDampingScale, TEXT("Conversion factor for Angular drive damping."));
		FAutoConsoleVariableRef CVarSoftLinearStiffnessScale(TEXT("p.Chaos.JointConstraint.SoftLinearStiffnessScale"), SoftLinearStiffnessScale, TEXT("Conversion factor for soft-joint stiffness."));
		FAutoConsoleVariableRef CVarSoftLinearDampingScale(TEXT("p.Chaos.JointConstraint.SoftLinearDampingScale"), SoftLinearDampingScale, TEXT("Conversion factor for soft-joint damping."));

#Associated Variable and Callsites

This variable is associated with another variable named JointStiffness. They share the same value. See the following C++ source code.

#Loc: <Workspace>/Engine/Plugins/Experimental/PhysicsControl/Source/PhysicsControl/Private/RigidBodyWithControl.cpp:956

Scope (from outer to inner):

file
function     void FAnimNode_RigidBodyWithControl::ApplyCurrentConstraintProfile

Source code excerpt:

					// one of those.

					JointSettings.Stiffness = ConstraintSettings::JointStiffness();
					JointSettings.LinearProjection = Profile.bEnableProjection ? Profile.ProjectionLinearAlpha : 0.0f;
					JointSettings.AngularProjection = Profile.bEnableProjection ? Profile.ProjectionAngularAlpha : 0.0f;
					JointSettings.ShockPropagation = Profile.bEnableShockPropagation ? Profile.ShockPropagationAlpha : 0.0f;
					JointSettings.TeleportDistance = Profile.bEnableProjection ? Profile.ProjectionLinearTolerance : -1.0f;
					JointSettings.TeleportAngle = Profile.bEnableProjection ? 
						FMath::DegreesToRadians(Profile.ProjectionAngularTolerance) : -1.0f;

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Private/PhysicsEngine/ImmediatePhysics/ImmediatePhysicsChaos/ImmediatePhysicsJointHandle_Chaos.cpp:28

Scope (from outer to inner):

file
namespace    ImmediatePhysics_Chaos
function     void TransferJointSettings

Source code excerpt:

		const FConstraintProfileProperties& Profile = ConstraintInstance->ProfileInstance;

		ConstraintSettings.Stiffness = ConstraintSettings::JointStiffness();

		ConstraintSettings.LinearMotionTypes =
		{
			static_cast<EJointMotionType>(ConstraintInstance->GetLinearXMotion()),
			static_cast<EJointMotionType>(ConstraintInstance->GetLinearYMotion()),
			static_cast<EJointMotionType>(ConstraintInstance->GetLinearZMotion()),

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1216

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyPositionConstraint

Source code excerpt:


	void FPBDJointSolver::ApplyPositionConstraint(
		const FReal JointStiffness,
		const FVec3& Axis,
		const FReal Delta,
		const FVec3& Connector0Correction,
		const int32 LinearHardLambdaIndex)
	{
		const FReal Stiffness = SolverStiffness * JointStiffness;
		// Project ConnectorXs[1] to the feasible space and apply impulse at the projected location. ConnectorXs[0] + Connector0Correction is the Projected location. The results are more stable this way.
		const FVec3 Arm0 = ConnectorXs[0] + Connector0Correction - P(0);
		const FVec3 Arm1 = ConnectorXs[1] - P(1);
		const FVec3 AngularAxis0 = FVec3::CrossProduct(Arm0, Axis);
		const FVec3 AngularAxis1 = FVec3::CrossProduct(Arm1, Axis);
		const FVec3 IA0 = Utilities::Multiply(InvI(0), AngularAxis0);

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1258

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyPositionConstraintSoft

Source code excerpt:

	void FPBDJointSolver::ApplyPositionConstraintSoft(
		const FReal Dt,
		const FReal JointStiffness,
		const FReal JointDamping,
		const bool bAccelerationMode,
		const FVec3& Axis,
		const FReal Delta,
		const FReal TargetVel,
		FReal& Lambda)

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1270

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyPositionConstraintSoft

Source code excerpt:

#if INTEL_ISPC
			FReal ReturnedLambda = Lambda;
			ispc::ApplyPositionConstraintSoft((ispc::FPBDJointSolver*)this, Dt, JointStiffness, JointDamping, bAccelerationMode, (ispc::FVector&)Axis, Delta, TargetVel, ReturnedLambda);
			Lambda = ReturnedLambda;
#endif
		}
		else
		{
			// Joint-space inverse mass

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1294

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyPositionConstraintSoft

Source code excerpt:

	
			const FReal SpringMassScale = (bAccelerationMode) ? 1.0f / (InvM(0) + InvM(1)) : 1.0f;
			const FReal S = SpringMassScale * JointStiffness * Dt * Dt;
			const FReal D = SpringMassScale * JointDamping * Dt;
			const FReal Multiplier = (FReal)1 / ((S + D) * II + (FReal)1);
			const FReal DLambda = SolverStiffness * Multiplier * (S * Delta - D * VelDt - Lambda);
	
			const FVec3 DP0 = (InvM(0) * DLambda) * Axis;
			const FVec3 DP1 = (-InvM(1) * DLambda) * Axis;

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1316

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintKD

Source code excerpt:

		const int32 KIndex,
		const int32 DIndex,
		const FReal JointStiffness,
		const FVec3& Axis,
		const FReal Angle,
		const int32 AngularHardLambdaIndex)
	{
		const FReal Stiffness = SolverStiffness * JointStiffness;

		const FVec3 IA1 = Utilities::Multiply(InvI(DIndex), Axis);
		const FReal II1 = FVec3::DotProduct(Axis, IA1);
		const FReal DR = Stiffness * (Angle / II1);
		const FVec3 DR1 = IA1 * -DR;
		ApplyRotationDelta(DIndex, DR1);

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1338

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintDD

Source code excerpt:


	void FPBDJointSolver::ApplyRotationConstraintDD(
		const FReal JointStiffness,
		const FVec3& Axis,
		const FReal Angle,
		const int32 AngularHardLambdaIndex)
	{
		const FReal Stiffness = SolverStiffness * JointStiffness;

		// Joint-space inverse mass
		const FVec3 IA0 = Utilities::Multiply(InvI(0), Axis);
		const FVec3 IA1 = Utilities::Multiply(InvI(1), Axis);
		const FReal II0 = FVec3::DotProduct(Axis, IA0);
		const FReal II1 = FVec3::DotProduct(Axis, IA1);

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1366

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraint

Source code excerpt:


	void FPBDJointSolver::ApplyRotationConstraint(
		const FReal JointStiffness,
		const FVec3& Axis,
		const FReal Angle,
		const int32 AngularHardLambdaIndex)
	{
		if (!IsDynamic(0))
		{
			ApplyRotationConstraintKD(0, 1, JointStiffness, Axis, Angle, AngularHardLambdaIndex);
		}
		else if (!IsDynamic(1))
		{
			ApplyRotationConstraintKD(1, 0, JointStiffness, Axis, -Angle, AngularHardLambdaIndex);
		}
		else
		{
			ApplyRotationConstraintDD(JointStiffness, Axis, Angle, AngularHardLambdaIndex);
		}
	}


	// See "XPBD: Position-Based Simulation of Compliant Constrained Dynamics"
	void FPBDJointSolver::ApplyRotationConstraintSoftKD(

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1391

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoftKD

Source code excerpt:

		const int32 DIndex,
		const FReal Dt,
		const FReal JointStiffness,
		const FReal JointDamping,
		const bool bAccelerationMode,
		const FVec3& Axis,
		const FReal Angle,
		const FReal AngVelTarget,
		FReal& Lambda)

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1406

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoftKD

Source code excerpt:

#if INTEL_ISPC
			FReal ReturnedLambda = Lambda;
			ispc::ApplyRotationConstraintSoftKD((ispc::FPBDJointSolver*)this, KIndex, DIndex, Dt, JointStiffness, JointDamping, bAccelerationMode, (ispc::FVector&) Axis, Angle, AngVelTarget, ReturnedLambda);
			Lambda = ReturnedLambda;
#endif
		}
		else
		{
			// World-space inverse mass

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1429

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoftKD

Source code excerpt:


			const FReal SpringMassScale = (bAccelerationMode) ? 1.0f / II : 1.0f;
			const FReal S = SpringMassScale * JointStiffness * Dt * Dt;
			const FReal D = SpringMassScale * JointDamping * Dt;
			const FReal Multiplier = (FReal)1 / ((S + D) * II + (FReal)1);
			const FReal DLambda = SolverStiffness * Multiplier * (S * Angle - D * AngVelDt - Lambda);

			//const FVec3 DR1 = IA1 * -DLambda;
			const FVec3 DR1 = Axis * -(DLambda * II1);

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1447

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoftDD

Source code excerpt:

	void FPBDJointSolver::ApplyRotationConstraintSoftDD(
		const FReal Dt,
		const FReal JointStiffness,
		const FReal JointDamping,
		const bool bAccelerationMode,
		const FVec3& Axis,
		const FReal Angle,
		const FReal AngVelTarget,
		FReal& Lambda)

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1462

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoftDD

Source code excerpt:

#if INTEL_ISPC
			FReal ReturnedLambda = Lambda;
			ispc::ApplyRotationConstraintSoftDD((ispc::FPBDJointSolver*)this, Dt, JointStiffness, JointDamping, bAccelerationMode, (ispc::FVector&) Axis, Angle, AngVelTarget, ReturnedLambda);
			Lambda = ReturnedLambda;
#endif
		}
		else
		{
			// World-space inverse mass

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1487

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoftDD

Source code excerpt:


			const FReal SpringMassScale = (bAccelerationMode) ? 1.0f / II : 1.0f;
			const FReal S = SpringMassScale * JointStiffness * Dt * Dt;
			const FReal D = SpringMassScale * JointDamping * Dt;
			const FReal Multiplier = (FReal)1 / ((S + D) * II + (FReal)1);
			const FReal DLambda = SolverStiffness * Multiplier * (S * Angle - D * AngVelDt - Lambda);

			//const FVec3 DR0 = IA0 * DLambda;
			//const FVec3 DR1 = IA1 * -DLambda;

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1506

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoft

Source code excerpt:

	void FPBDJointSolver::ApplyRotationConstraintSoft(
		const FReal Dt,
		const FReal JointStiffness,
		const FReal JointDamping,
		const bool bAccelerationMode,
		const FVec3& Axis,
		const FReal Angle,
		const FReal AngVelTarget,
		FReal& Lambda)

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1516

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyRotationConstraintSoft

Source code excerpt:

		if (!IsDynamic(0))
		{
			ApplyRotationConstraintSoftKD(0, 1, Dt, JointStiffness, JointDamping, bAccelerationMode, Axis, Angle, AngVelTarget, Lambda);
		}
		else if (!IsDynamic(1))
		{
			ApplyRotationConstraintSoftKD(1, 0, Dt, JointStiffness, JointDamping, bAccelerationMode, Axis, -Angle, -AngVelTarget, Lambda);
		}
		else
		{
			ApplyRotationConstraintSoftDD(Dt, JointStiffness, JointDamping, bAccelerationMode, Axis, Angle, AngVelTarget, Lambda);
		}
	}

	//
	//
	//////////////////////////////////////////////////////////////////////////

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:1963

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplySphericalPositionConstraint

Source code excerpt:

			if (!FPBDJointUtilities::GetSoftLinearLimitEnabled(SolverSettings, JointSettings))
			{
				const FReal JointStiffness = FPBDJointUtilities::GetLinearStiffness(SolverSettings, JointSettings);
				const FVec3 Connector0Correction = Axis * Limit;
				ApplyPositionConstraint(JointStiffness, Axis, Error, Connector0Correction);
			}
			else
			{
				const FReal JointStiffness = FPBDJointUtilities::GetSoftLinearStiffness(SolverSettings, JointSettings);
				const FReal JointDamping = FPBDJointUtilities::GetSoftLinearDamping(SolverSettings, JointSettings);
				const bool bAccelerationMode = FPBDJointUtilities::GetLinearSoftAccelerationMode(SolverSettings, JointSettings);
				ApplyPositionConstraintSoft(Dt, JointStiffness, JointDamping, bAccelerationMode, Axis, Error, 0.0f, LinearSoftLambda);
			}
		}
	}


	void FPBDJointSolver::ApplyCylindricalPositionConstraint(

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:2006

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyCylindricalPositionConstraint

Source code excerpt:

			{
				// Soft Axial constraint
				const FReal JointStiffness = FPBDJointUtilities::GetSoftLinearStiffness(SolverSettings, JointSettings);
				const FReal JointDamping = FPBDJointUtilities::GetSoftLinearDamping(SolverSettings, JointSettings);
				const bool bAccelerationMode = FPBDJointUtilities::GetLinearSoftAccelerationMode(SolverSettings, JointSettings);
				ApplyPositionConstraintSoft(Dt, JointStiffness, JointDamping, bAccelerationMode, Axis, AxialError, 0.0f, LinearSoftLambda);
			}
			else if (AxialMotion != EJointMotionType::Free)
			{
				// Hard Axial constraint
	
				const FReal JointStiffness = FPBDJointUtilities::GetLinearStiffness(SolverSettings, JointSettings);
				const FVec3 Connector0Correction = ConnectorXs[1] - ConnectorXs[0] - AxialError * Axis;
				ApplyPositionConstraint(JointStiffness, Axis, AxialError, Connector0Correction, (int32)EJointCylindricalPositionConstraintType::Axial);
			}
		}

		const FReal RadialLimit = (RadialMotion == EJointMotionType::Locked) ? 0.0f : JointSettings.LinearLimit;
		FReal RadialError = RadialDelta - RadialLimit;

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:2029

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyCylindricalPositionConstraint

Source code excerpt:

			{
				// Soft Radial constraint
				const FReal JointStiffness = FPBDJointUtilities::GetSoftLinearStiffness(SolverSettings, JointSettings);
				const FReal JointDamping = FPBDJointUtilities::GetSoftLinearDamping(SolverSettings, JointSettings);
				const bool bAccelerationMode = FPBDJointUtilities::GetLinearSoftAccelerationMode(SolverSettings, JointSettings);
				ApplyPositionConstraintSoft(Dt, JointStiffness, JointDamping, bAccelerationMode, RadialAxis, RadialError, 0.0f, LinearSoftLambda);
			}
			else if (RadialMotion != EJointMotionType::Free)
			{
				// Hard Radial constraint
				const FReal JointStiffness = FPBDJointUtilities::GetLinearStiffness(SolverSettings, JointSettings);
				const FVec3 Connector0Correction = ConnectorXs[1] - ConnectorXs[0] - RadialError * RadialAxis;
				ApplyPositionConstraint(JointStiffness, RadialAxis, RadialError, Connector0Correction, (int32)EJointCylindricalPositionConstraintType::Radial);
			}
		}
	}


	void FPBDJointSolver::ApplyPlanarPositionConstraint(

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:2068

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyPlanarPositionConstraint

Source code excerpt:

			if ((AxialMotion == EJointMotionType::Limited) && FPBDJointUtilities::GetSoftLinearLimitEnabled(SolverSettings, JointSettings))
			{
				const FReal JointStiffness = FPBDJointUtilities::GetSoftLinearStiffness(SolverSettings, JointSettings);
				const FReal JointDamping = FPBDJointUtilities::GetSoftLinearDamping(SolverSettings, JointSettings);
				const bool bAccelerationMode = FPBDJointUtilities::GetLinearSoftAccelerationMode(SolverSettings, JointSettings);
				ApplyPositionConstraintSoft(Dt, JointStiffness, JointDamping, bAccelerationMode, Axis, Error, 0.0f, LinearSoftLambda);
			}
			else
			{
				const FReal JointStiffness = FPBDJointUtilities::GetLinearStiffness(SolverSettings, JointSettings);
				const FVec3 Connector0Correction = ConnectorXs[1] - ConnectorXs[0] - Axis * Error;
				ApplyPositionConstraint(JointStiffness, Axis, Error, Connector0Correction);
			}
		}
	}


	void FPBDJointSolver::ApplyPositionDrive(

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Private/Chaos/Joint/PBDJointSolverGaussSeidel.cpp:2092

Scope (from outer to inner):

file
namespace    Chaos
function     void FPBDJointSolver::ApplyPositionDrive

Source code excerpt:

		const FReal DeltaVel)
	{
		const FReal JointStiffness = FPBDJointUtilities::GetLinearDriveStiffness(SolverSettings, JointSettings, AxisIndex);
		const FReal JointDamping = FPBDJointUtilities::GetLinearDriveDamping(SolverSettings, JointSettings, AxisIndex);
		const bool bAccelerationMode = FPBDJointUtilities::GetLinearDriveAccelerationMode(SolverSettings, JointSettings);

		if ((FMath::Abs(DeltaPos) > PositionTolerance) || (JointDamping > 0.0f))
		{
			FReal ReturnedLambda = LinearDriveLambdas[AxisIndex];
			ApplyPositionConstraintSoft(Dt, JointStiffness, JointDamping, bAccelerationMode, Axis, DeltaPos, DeltaVel, ReturnedLambda);
			LinearDriveLambdas[AxisIndex] = ReturnedLambda;
		}
	}


	void FPBDJointSolver::ApplyPointProjection(

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Public/Chaos/Joint/PBDJointSolverGaussSeidel.h:278

Scope (from outer to inner):

file
namespace    Chaos
class        class FPBDJointSolver

Source code excerpt:


		void ApplyPositionConstraint(
			const FReal JointStiffness,
			const FVec3& Axis,
			const FReal Delta,
			const FVec3& Connector0Correction = FVec3(0),
			const int32 LinearHardLambdaIndex = -1);

		void ApplyPositionConstraintSoft(
			const FReal Dt,
			const FReal JointStiffness,
			const FReal JointDamping,
			const bool bAccelerationMode,
			const FVec3& Axis,
			const FReal Delta,
			const FReal TargetVel,
			FReal& Lambda);

		void ApplyRotationConstraint(
			const FReal JointStiffness,
			const FVec3& Axis,
			const FReal Angle,
			const int32 AngularHardLambdaIndex = -1);

		void ApplyRotationConstraintKD(
			const int32 KIndex,
			const int32 DIndex,
			const FReal JointStiffness,
			const FVec3& Axis,
			const FReal Angle,
			const int32 AngularHardLambdaIndex = -1);

		void ApplyRotationConstraintDD(
			const FReal JointStiffness,
			const FVec3& Axis,
			const FReal Angle,
			const int32 AngularHardLambdaIndex = -1);

		void ApplyRotationConstraintSoft(
			const FReal Dt,
			const FReal JointStiffness,
			const FReal JointDamping,
			const bool bAccelerationMode,
			const FVec3& Axis,
			const FReal Angle,
			const FReal AngVelTarget,
			FReal& Lambda);

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Public/Chaos/Joint/PBDJointSolverGaussSeidel.h:328

Scope (from outer to inner):

file
namespace    Chaos
class        class FPBDJointSolver

Source code excerpt:

			const int32 DIndex,
			const FReal Dt,
			const FReal JointStiffness,
			const FReal JointDamping,
			const bool bAccelerationMode,
			const FVec3& Axis,
			const FReal Angle,
			const FReal AngVelTarget,
			FReal& Lambda);

#Loc: <Workspace>/Engine/Source/Runtime/Experimental/Chaos/Public/Chaos/Joint/PBDJointSolverGaussSeidel.h:338

Scope (from outer to inner):

file
namespace    Chaos
class        class FPBDJointSolver

Source code excerpt:

		void ApplyRotationConstraintSoftDD(
			const FReal Dt,
			const FReal JointStiffness,
			const FReal JointDamping,
			const bool bAccelerationMode,
			const FVec3& Axis,
			const FReal Angle,
			const FReal AngVelTarget,
			FReal& Lambda);

#Loc: <Workspace>/Engine/Source/Runtime/PhysicsCore/Private/ChaosConstraintSettings.cpp:8

Scope (from outer to inner):

file
namespace    Chaos
namespace    JointConstraintDefaults

Source code excerpt:

	namespace JointConstraintDefaults
	{
		float JointStiffness = 1.0f;

		float LinearDriveStiffnessScale = 1.0f;
		float LinearDriveDampingScale = 1.0f;
		float AngularDriveStiffnessScale = 1.5f;
		float AngularDriveDampingScale = 1.5f;

#Loc: <Workspace>/Engine/Source/Runtime/PhysicsCore/Private/ChaosConstraintSettings.cpp:26

Scope (from outer to inner):

file
namespace    Chaos
namespace    JointConstraintDefaults

Source code excerpt:

		float AngularBreakScale = 1.0f;

		FAutoConsoleVariableRef CVarJointStiffness(TEXT("p.Chaos.JointConstraint.JointStiffness"), JointStiffness, TEXT("Hard-joint solver stiffness."));
		FAutoConsoleVariableRef CVarLinearDriveStiffnessScale(TEXT("p.Chaos.JointConstraint.LinearDriveStiffnessScale"), LinearDriveStiffnessScale, TEXT("Conversion factor for Linear drive stiffness."));
		FAutoConsoleVariableRef CVarLinearDriveDampingScale(TEXT("p.Chaos.JointConstraint.LinaearDriveDampingScale"), LinearDriveDampingScale, TEXT("Conversion factor for Linear drive damping."));
		FAutoConsoleVariableRef CVarAngularDriveStiffnessScale(TEXT("p.Chaos.JointConstraint.AngularDriveStiffnessScale"), AngularDriveStiffnessScale, TEXT("Conversion factor for Angular drive stiffness."));
		FAutoConsoleVariableRef CVarAngularDriveDampingScale(TEXT("p.Chaos.JointConstraint.AngularDriveDampingScale"), AngularDriveDampingScale, TEXT("Conversion factor for Angular drive damping."));
		FAutoConsoleVariableRef CVarSoftLinearStiffnessScale(TEXT("p.Chaos.JointConstraint.SoftLinearStiffnessScale"), SoftLinearStiffnessScale, TEXT("Conversion factor for soft-joint stiffness."));
		FAutoConsoleVariableRef CVarSoftLinearDampingScale(TEXT("p.Chaos.JointConstraint.SoftLinearDampingScale"), SoftLinearDampingScale, TEXT("Conversion factor for soft-joint damping."));

#Loc: <Workspace>/Engine/Source/Runtime/PhysicsCore/Private/ChaosConstraintSettings.cpp:41

Scope (from outer to inner):

file
namespace    Chaos
function     FReal ConstraintSettings::JointStiffness

Source code excerpt:

	}

	FReal ConstraintSettings::JointStiffness() { return JointConstraintDefaults::JointStiffness;}
	FReal ConstraintSettings::LinearDriveStiffnessScale() { return JointConstraintDefaults::LinearDriveStiffnessScale;}
	FReal ConstraintSettings::LinearDriveDampingScale() { return JointConstraintDefaults::LinearDriveDampingScale;}
	FReal ConstraintSettings::AngularDriveStiffnessScale() { return JointConstraintDefaults::AngularDriveStiffnessScale;}
	FReal ConstraintSettings::AngularDriveDampingScale() { return JointConstraintDefaults::AngularDriveDampingScale;}
	int ConstraintSettings::SoftLinearForceMode() { return JointConstraintDefaults::SoftLinearForceMode;}
	FReal ConstraintSettings::SoftLinearStiffnessScale() { return JointConstraintDefaults::SoftLinearStiffnessScale;}

#Loc: <Workspace>/Engine/Source/Runtime/PhysicsCore/Public/Chaos/ChaosConstraintSettings.h:17

Scope (from outer to inner):

file
namespace    Chaos
class        class ConstraintSettings

Source code excerpt:


	public:
		static PHYSICSCORE_API FReal JointStiffness();
		static PHYSICSCORE_API FReal LinearDriveStiffnessScale();
		static PHYSICSCORE_API FReal LinearDriveDampingScale();
		static PHYSICSCORE_API FReal AngularDriveStiffnessScale();
		static PHYSICSCORE_API FReal AngularDriveDampingScale();

		static PHYSICSCORE_API int SoftLinearForceMode();