Functions
bool	ForceDeepCopyOnModifyGeometry ()

FAutoConsoleVariableRef	CVarChaosInertiaConditioningInvMassTolerance (TEXT("p.Chaos.InertiaConditioning.InvMassTolerance"), ChaosInertiaConditioningTolerances.InvMassTolerance, TEXT("Inertia conditioning is disabled for objects with inverse mass less than this."), OnInertiaConditioningCVarChangedDelegate)

FAutoConsoleVariableRef	CVarChaosInertiaConditioningInvInertiaTolerance (TEXT("p.Chaos.InertiaConditioning.InvInertiaTolerance"), ChaosInertiaConditioningTolerances.InvInertiaTolerance, TEXT("Inertia conditioning is disabled for objects with inverse inertia less than this. The default value disables Inertia Conditioing for mediums to large objects."), OnInertiaConditioningCVarChangedDelegate)

FAutoConsoleVariableRef	CVarChaosInertiaConditioningExtentTolerance (TEXT("p.Chaos.InertiaConditioning.ExtentTolerance"), ChaosInertiaConditioningTolerances.ExtentTolerance, TEXT("Inertia conditioning is disabled for objects with dimensions smaller than this."), OnInertiaConditioningCVarChangedDelegate)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::AdvanceOneTimeStep"), STAT_Evolution_AdvanceOneTimeStep, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::UnclusterUnions"), STAT_Evolution_UnclusterUnions, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::Integrate"), STAT_Evolution_Integrate, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::KinematicTargets"), STAT_Evolution_KinematicTargets, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::PreIntegrateCallback"), STAT_Evolution_PreIntegrateCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::PostIntegrateCallback"), STAT_Evolution_PostIntegrateCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::PreSolveCallback"), STAT_Evolution_PreSolveCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::PostSolveCallback"), STAT_Evolution_PostSolveCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::CCDModifierCallback"), STAT_Evolution_CCDModifierCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::CollisionModifierCallback"), STAT_Evolution_CollisionModifierCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::MidPhaseModifierCallback"), STAT_Evolution_MidPhaseModifierCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::CCD"), STAT_Evolution_CCD, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::CCDCorrection"), STAT_Evolution_CCDCorrection, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::GraphColor"), STAT_Evolution_GraphColor, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::BuildGroups"), STAT_Evolution_BuildGroups, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::DetectCollisions"), STAT_Evolution_DetectCollisions, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::TransferJointCollisions"), STAT_Evolution_TransferJointCollisions, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::PostDetectCollisionsCallback"), STAT_Evolution_PostDetectCollisionsCallback, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::UpdateConstraintPositionBasedState"), STAT_Evolution_UpdateConstraintPositionBasedState, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::ComputeIntermediateSpatialAcceleration"), STAT_Evolution_ComputeIntermediateSpatialAcceleration, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::CreateConstraintGraph"), STAT_Evolution_CreateConstraintGraph, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::CreateIslands"), STAT_Evolution_CreateIslands, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::PruneCollisions"), STAT_Evolution_PruneCollisions, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::AddSleepingContacts"), STAT_Evolution_AddSleepingContacts, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::ParallelSolve"), STAT_Evolution_ParallelSolve, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::SaveParticlePostSolve"), STAT_Evolution_SavePostSolve, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::DeactivateSleep"), STAT_Evolution_DeactivateSleep, STATGROUP_Chaos)

	DECLARE_CYCLE_STAT (TEXT("FPBDRigidsEvolutionGBF::InertiaConditioning"), STAT_Evolution_InertiaConditioning, STATGROUP_Chaos)

Variables
CHAOS_API bool	bEnableAsyncInitBody = false

FAutoConsoleVariableRef	CVarEnableAsyncInitBody (TEXT("p.Chaos.EnableAsyncInitBody"), bEnableAsyncInitBody, TEXT("[Experimental] Allow body instances to be initialized outside of game thread (default is false)."), ECVF_ReadOnly)

bool	bClearNullCCDConstraintsOnApply = true

FAutoConsoleVariableRef	CVarClearNullCCDConstraintsOnApply (TEXT("p.Chaos.Collision.CCD.ClearNullConstraints"), bClearNullCCDConstraintsOnApply, TEXT("Remove null constraints encountered during correction application for CCD."))

bool	bChaosCollisionCCDEnableResweep = true

FAutoConsoleVariableRef	CVarChaosCollisionCCDEnableResweep (TEXT("p.Chaos.Collision.CCD.EnableResweep"), bChaosCollisionCCDEnableResweep, TEXT("Enable resweep for CCD. Resweeping allows CCD to catch more secondary collisions but also is more costly. Default is true."))

bool	bChaosCollisionCCDAllowClipping = true

FAutoConsoleVariableRef	CVarChaosCollisionCCDAllowClipping (TEXT("p.Chaos.Collision.CCD.AllowClipping"), bChaosCollisionCCDAllowClipping, TEXT("This will clip the CCD object at colliding positions when computation budgets run out. Default is true. Turning this option off might cause tunneling."))

int32	ChaosCollisionCCDConstraintMaxProcessCount = 1

FAutoConsoleVariableRef	CVarChaosCollisionCCDConstraintMaxProcessCount (TEXT("p.Chaos.Collision.CCD.ConstraintMaxProcessCount"), ChaosCollisionCCDConstraintMaxProcessCount, TEXT("The max number of times each constraint can be resolved when applying CCD constraints. Default is 2. The larger this number is, the more fully CCD constraints are resolved."))

FRealSingle	CCDEnableThresholdBoundsScale = 0.4f

FAutoConsoleVariableRef	CVarCCDEnableThresholdBoundsScale (TEXT("p.Chaos.CCD.EnableThresholdBoundsScale"), CCDEnableThresholdBoundsScale, TEXT("CCD is used when object position is changing > smallest bound's extent * BoundsScale. 0 will always Use CCD. Values < 0 disables CCD."))

Chaos::FRealSingle	CCDAllowedDepthBoundsScale = 0.2f

FAutoConsoleVariableRef	CVarCCDAllowedDepthBoundsScale (TEXT("p.Chaos.CCD.AllowedDepthBoundsScale"), CCDAllowedDepthBoundsScale, TEXT("When rolling back to TOI, allow (smallest bound's extent) * AllowedDepthBoundsScale, instead of rolling back to exact TOI w/ penetration = 0."))

bool	bCCDNewTargetDepthMode = true

FAutoConsoleVariableRef	CVarCCDNewTargetDepthMode (TEXT("p.Chaos.CCD.NewTargetDepthMode"), bCCDNewTargetDepthMode, TEXT("Find the first contact with that results in a penetration of (CCDAllowedDepthBoundsScale*Size) as opposed to the first contact"))

int32	CCDAxisThresholdMode = 2

FAutoConsoleVariableRef	CVarCCDAxisThresholdMode (TEXT("p.Chaos.CCD.AxisThresholdMode"), CCDAxisThresholdMode, TEXT("Change the mode used to generate CCD axis threshold bounds for particle geometries.\n0: Use object bounds\n1: Find the thinnest object bound on any axis and use it for all CCD axes\n2: On each axis, use the thinnest shape bound on that axis\n3: Find the thinnest shape bound on any axis and use this for all axes"))

bool	bCCDAxisThresholdUsesProbeShapes = false

FAutoConsoleVariableRef	CVarCCDAxisThresholdUsesProbeShapes (TEXT("p.Chaos.CCD.CCDAxisThresholdUsesProbeShapes"), bCCDAxisThresholdUsesProbeShapes, TEXT("When true, probe shapes are considered for CCD axis threshold computation, and can generate contacts in the initial CCD phase."))

bool	bCCDSweepsUseProbeShapes = false

FAutoConsoleVariableRef	CVarCCDSweepsUseProbeShapes (TEXT("p.Chaos.CCD.CCDSweepsUseProbeShapes"), bCCDSweepsUseProbeShapes, TEXT("When true, probe shapes can be swept for more accurate collision detection."))

int32	ChaosCollisionCCDCorrectionIterations = 4

FAutoConsoleVariableRef	CVarChaosCollisionCCDCorrectionIterations (TEXT("p.Chaos.Collision.CCD.CorrectionIterations"), ChaosCollisionCCDCorrectionIterations, TEXT("The number of post-solve CCD correction ietaryions to run."))

FRealSingle	ChaosCollisionCCDCorrectionPhiToleranceScale = 0.02f

FAutoConsoleVariableRef	CVarChaosCollisionCCDCorrectionPhiToleranceScale (TEXT("p.Chaos.Collision.CCD.CorrectionPhiToleranceScale"), ChaosCollisionCCDCorrectionPhiToleranceScale, TEXT("How much penetration we allow during the correction phase (multiplier on shape size)"))

int32	ChaosSolverDrawCCDInteractions

float	Chaos_CharacterGroundConstraint_InputMovementThreshold = 0.1f

FAutoConsoleVariableRef	CVarChaos_CharacterGroundConstraint_InputMovementThreshold (TEXT("p.Chaos.CharacterGroundConstraint.InputMovementThreshold"), Chaos_CharacterGroundConstraint_InputMovementThreshold, TEXT("Minimum per frame input movement distance in cm."))

float	Chaos_CharacterGroundConstraint_ExternalMovementThreshold = 2.0f

FAutoConsoleVariableRef	CVarChaos_CharacterGroundConstraint_ExternalMovementThreshold (TEXT("p.Chaos.CharacterGroundConstraint.ExternalMovementThreshold"), Chaos_CharacterGroundConstraint_ExternalMovementThreshold, TEXT("If distance moved is less than this then retain current movement target relative to ground."))

int32	ChaosSolverDebugDrawMeshContacts

bool	bMeshContactGeneratorFixContactNormalFixEnabled = true

FAutoConsoleVariableRef	CVarChaosMeshContactGeneratorFixContactNormalFixEnabled (TEXT("p.Chaos.MeshContactGenerator.FixContactNormal.FixEnabled"), bMeshContactGeneratorFixContactNormalFixEnabled, TEXT("Until new code path is well tested"))

FRealSingle	Chaos_Collision_CullDistanceScaleInverseSize = 0.01f

FRealSingle	Chaos_Collision_MinCullDistanceScale = 1.0f

FAutoConsoleVariableRef	CVarChaos_Collision_CullDistanceReferenceSize (TEXT("p.Chaos.Collision.CullDistanceReferenceSize"), Chaos_Collision_CullDistanceScaleInverseSize, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_Collision_MinCullDistanecScale (TEXT("p.Chaos.Collision.MinCullDistanceScale"), Chaos_Collision_MinCullDistanceScale, TEXT(""))

bool	bChaos_Collision_MidPhase_EnableShapePairs = true

int32	Chaos_Collision_MidPhase_MaxShapePairs = 100

FAutoConsoleVariableRef	CVarChaos_Collision_EnableShapePairs (TEXT("p.Chaos.Collision.EnableShapePairs"), bChaos_Collision_MidPhase_EnableShapePairs, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_Collision_MaxShapePairs (TEXT("p.Chaos.Collision.MaxShapePairs"), Chaos_Collision_MidPhase_MaxShapePairs, TEXT(""))

bool	bChaosMidPhaseActivateWakingConstraints = true

FAutoConsoleVariableRef	CVarChaosMidPhaseActivateWakingConstraints (TEXT("p.Chaos.Bugs.ActivateWakingConstraints"), bChaosMidPhaseActivateWakingConstraints, TEXT(""))

bool	bChaosMidPhaseModifierConvexOptimizerFix = true

FAutoConsoleVariableRef	CVarChaosMidPhaseModifierConvexOptimizerFix (TEXT("p.Chaos.Bugs.MidPhaseModifierConvexOptimizerFix"), bChaosMidPhaseModifierConvexOptimizerFix, TEXT(""))

FRealSingle	ChaosOneWayPairSphereRadiusAlpha = 1.0f

FAutoConsoleVariableRef	CVarChaosOneWayPairSphereRadiusAlpha (TEXT("p.Chaos.Solver.OneWayPairSphereRadiusAlpha"), ChaosOneWayPairSphereRadiusAlpha, TEXT("If one-way interactions are treated as spheres, the diameter is lerp(Size.Min, Size.Max, RadiusAlpha)"))

int32	ChaosOneWayInteractionPairCollisionMode = (int32)EOneWayInteractionPairCollisionMode::SphereCollision

bool	bChaosForceMACD = false

bool	bChaos_PBDCollisionSolver_Position_SolveEnabled = true

bool	bChaos_PBDCollisionSolver_Velocity_SolveEnabled = true

float	Chaos_PBDCollisionSolver_Position_MinInvMassScale = 0.77f

float	Chaos_PBDCollisionSolver_Velocity_MinInvMassScale = Chaos_PBDCollisionSolver_Position_MinInvMassScale

FRealSingle	Chaos_PBDCollisionSolver_AutoStiffness_MassRatio1 = 0

FRealSingle	Chaos_PBDCollisionSolver_AutoStiffness_MassRatio2 = 0

FAutoConsoleVariableRef	CVarChaosPBDCollisionSolverAutoStiffnessMassRatio1 (TEXT("p.Chaos.PBDCollisionSolver.AutoStiffness.MassRatio1"), Chaos_PBDCollisionSolver_AutoStiffness_MassRatio1, TEXT(""))

FAutoConsoleVariableRef	CVarChaosPBDCollisionSolverAutoStiffnessMassRatio2 (TEXT("p.Chaos.PBDCollisionSolver.AutoStiffness.MassRatio2"), Chaos_PBDCollisionSolver_AutoStiffness_MassRatio2, TEXT(""))

FRealSingle	Chaos_PBDCollisionSolver_JacobiStiffness = 0.5f

FAutoConsoleVariableRef	CVarChaosPBDCollisionSolverJacobiStiffness (TEXT("p.Chaos.PBDCollisionSolver.JacobiStiffness"), Chaos_PBDCollisionSolver_JacobiStiffness, TEXT(""))

FRealSingle	Chaos_PBDCollisionSolver_JacobiPositionTolerance = 1.e-6f

FAutoConsoleVariableRef	CVarChaosPBDCollisionSolverJacobiPositionTolerance (TEXT("p.Chaos.PBDCollisionSolver.JacobiPositionTolerance"), Chaos_PBDCollisionSolver_JacobiPositionTolerance, TEXT(""))

FRealSingle	Chaos_PBDCollisionSolver_JacobiRotationTolerance = 1.e-8f

FAutoConsoleVariableRef	CVarChaosPBDCollisionSolverJacobiRotationTolerance (TEXT("p.Chaos.PBDCollisionSolver.JacobiRotationTolerance"), Chaos_PBDCollisionSolver_JacobiRotationTolerance, TEXT(""))

bool	bChaos_Collision_EnableInitialDepenetration = true

FAutoConsoleVariableRef	CVarChaosCollisionEnableInitialDepentration (TEXT("p.Chaos.PBDCollisionSolver.EnableInitialDepenetration"), bChaos_Collision_EnableInitialDepenetration, TEXT(""))

int32	Chaos_Collision_MaxSolverManifoldPoints = -1

FAutoConsoleVariableRef	CVarChaosCollisionMaxSolverManifoldPoints (TEXT("p.Chaos.PBDCollisionSolver.MaxManifoldPoints"), Chaos_Collision_MaxSolverManifoldPoints, TEXT(""))

bool	bChaos_Collision_EnableSoftCollisions = true

FAutoConsoleVariableRef	CVarChaosCollisionEnableSoftCollisions (TEXT("p.Chaos.PBDCollisionSolver.EnableSoftCollisions"), bChaos_Collision_EnableSoftCollisions, TEXT(""))

float	Chaos_PBDCollisionSolver_Position_StaticFrictionStiffness = 0.5f

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Position_SolveEnabled (TEXT("p.Chaos.PBDCollisionSolver.Position.SolveEnabled"), bChaos_PBDCollisionSolver_Position_SolveEnabled, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Position_MinInvMassScale (TEXT("p.Chaos.PBDCollisionSolver.Position.MinInvMassScale"), Chaos_PBDCollisionSolver_Position_MinInvMassScale, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Position_StaticFrictionStiffness (TEXT("p.Chaos.PBDCollisionSolver.Position.StaticFriction.Stiffness"), Chaos_PBDCollisionSolver_Position_StaticFrictionStiffness, TEXT(""))

bool	bChaos_PBDCollisionSolver_Velocity_FrictionEnabled = true

float	Chaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness = 1.0f

bool	bChaos_PBDCollisionSolver_Velocity_AveragePointEnabled = false

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Velocity_SolveEnabled (TEXT("p.Chaos.PBDCollisionSolver.Velocity.SolveEnabled"), bChaos_PBDCollisionSolver_Velocity_SolveEnabled, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Velocity_MinInvMassScale (TEXT("p.Chaos.PBDCollisionSolver.Velocity.MinInvMassScale"), Chaos_PBDCollisionSolver_Velocity_MinInvMassScale, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Velocity_FrictionEnabled (TEXT("p.Chaos.PBDCollisionSolver.Velocity.FrictionEnabled"), bChaos_PBDCollisionSolver_Velocity_FrictionEnabled, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness (TEXT("p.Chaos.PBDCollisionSolver.Velocity.StaticFriction.Stiffness"), Chaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness, TEXT(""))

FAutoConsoleVariableRef	CVarChaos_PBDCollisionSolver_Velocity_AveragePointEnabled (TEXT("p.Chaos.PBDCollisionSolver.Velocity.AveragePointEnabled"), bChaos_PBDCollisionSolver_Velocity_AveragePointEnabled, TEXT(""))

int32	NumWorkerCollisionFactor = 2

FAutoConsoleVariableRef	CVarNumWorkerCollisionFactor (TEXT("p.Chaos.NumWorkerCollisionFactor"), NumWorkerCollisionFactor, TEXT("Set the number of tasks created for collision detection per worker."))

CHAOS_API bool	bChaosConvexSimplifyUnion = false

FAutoConsoleVariableRef	CVarChaosSimplifyUnion (TEXT("p.Chaos.Convex.SimplifyUnion"), bChaosConvexSimplifyUnion, TEXT("If true replace all the convexes within an implcit hierarchy with a simplified one (kdop18 tribox for now) for collision"))

int32	ChaosConvexKinematicMode = 2

FAutoConsoleVariableRef	CVarChaosConvexKinematicMode (TEXT("p.Chaos.Convex.KinematicMode"), ChaosConvexKinematicMode, TEXT("Simplification mode for the kinematic shapes (0: Single Convex, 1: One convex per children, 2: Merge connected children using the splitting threshold"))

int32	ChaosConvexDynamicMode = 2

FAutoConsoleVariableRef	CVarChaosConvexDynamicMode (TEXT("p.Chaos.Convex.DynamicMode"), ChaosConvexDynamicMode, TEXT("Simplification mode for the dynamic shapes (0: Single Convex, 1: One convex per children, 2: Merge connected children using the splitting threshold)"))

float	ChaosConvexSplittingThreshold = 1.0f

FAutoConsoleVariableRef	CVarChaosConvexSplittingThreshold (TEXT("p.Chaos.Convex.SplittingThreshold"), ChaosConvexSplittingThreshold, TEXT("Tribox volume / convex hull threshold to trigger a volume splitting during tree construction"))

float	ChaosConvexMinVolume = 10000.0f

FAutoConsoleVariableRef	CVarChaosConvexMinVolume (TEXT("p.Chaos.Convex.MinVolume"), ChaosConvexMinVolume, TEXT("Min volume of the simplified convexes"))

bool	ChaosConvexEnableMerging = true

FAutoConsoleVariableRef	CVarChaosConvexEnableMerging (TEXT("p.Chaos.Convex.EnableMerging"), ChaosConvexEnableMerging, TEXT("Boolean to check if we are merging (bottom-up) or splitting (top-bottom) the convexes"))

bool	ChaosConvexUseDirectOverlap = true

FAutoConsoleVariableRef	CVarChaosConvexUseDirectOverlap (TEXT("p.Chaos.Convex.UseDirectOverlap"), ChaosConvexUseDirectOverlap, TEXT("Boolean to check if we can use direct overlap test against the bounds"))

int32	ChaosUnionBVHMaxDepth = 14

int32	ChaosUnionBVHMinShapes = 10

FRealSingle	ChaosUnionBVHSplitBias = 0.1f

bool	bChaosImplicitBVHOptimizedCountLeafObjects = true

bool	bChaosUnionBVHEnabled = true

FAutoConsoleVariableRef	CVarChaosUnionBVHEnabled (TEXT("p.Chaos.Collision.UnionBVH.Enabled"), bChaosUnionBVHEnabled, TEXT("Set to false to disable use of BVH during collision detection (without affecting creations and serialization)"))

FAutoConsoleVariableRef	CVarChaosUnionBVHMinShapes (TEXT("p.Chaos.Collision.UnionBVH.NumShapes"), ChaosUnionBVHMinShapes, TEXT("If a geometry hierarchy has this many shapes, wrap it in a BVH for collision detection (negative to disable BVH)"))

FAutoConsoleVariableRef	CVarChaosUnionBVHMaxDepth (TEXT("p.Chaos.Collision.UnionBVH.MaxDepth"), ChaosUnionBVHMaxDepth, TEXT("The allowed depth of the BVH when used to wrap a shape hiererchy"))

FAutoConsoleVariableRef	CVarChaosUnionBVHSplitBias (TEXT("p.Chaos.Collision.UnionBVH.SplitBias"), ChaosUnionBVHSplitBias, TEXT(""))

FAutoConsoleVariableRef	CVarChaosImplicitBVHOptimizedCountLeafObjects (TEXT("p.Chaos.Collision.UnionBVH.UseOptimizedCountLeafObjects"), bChaosImplicitBVHOptimizedCountLeafObjects, TEXT(""))

int32	ChaosSolverPositionIterations = -1

int32	ChaosSolverVelocityIterations = -1

int32	ChaosSolverProjectionIterations = -1

int32	GIslandGroupsParallelMode = 2

FAutoConsoleVariableRef	GCVarIslandGroupsParallelMode (TEXT("p.Chaos.Solver.IslandGroups.ParallelMode"), GIslandGroupsParallelMode, TEXT("0: Single-Threaded; 1: Parallel-For; 2: Tasks"))

FRealSingle	GIslandGroupsWorkerMultiplier = 1

FAutoConsoleVariableRef	GCVarIslandGroupsWorkerThreadMultiplier (TEXT("p.Chaos.Solver.IslandGroups.WorkerMultiplier"), GIslandGroupsWorkerMultiplier, TEXT("Total number of island groups in the solver will be NumWorkerThreads * WorkerThreadMultiplier. [def:1]"))

int32	GIslandGroupsMaxWorkers = 0

FAutoConsoleVariableRef	GCVarIslandGroupsMaxWorkers (TEXT("p.Chaos.Solver.IslandGroups.MaxWorkers"), GIslandGroupsMaxWorkers, TEXT("The maximum number of worker threads to use (0 means unlimited)"))

int32	GIslandGroupsMinConstraintsPerWorker = 50

FAutoConsoleVariableRef	GCVarIslandGroupsMinConstraintsPerWorker (TEXT("p.Chaos.Solver.IslandGroups.MinConstraintsPerWorker"), GIslandGroupsMinConstraintsPerWorker, TEXT("The minimum number of constraints we want per worker thread"))

int32	GIslandGroupsMinBodiesPerWorker = 50

FAutoConsoleVariableRef	GCVarIslandGroupsMinBodiesPerWorker (TEXT("p.Chaos.Solver.IslandGroups.MinBodiesPerWorker"), GIslandGroupsMinBodiesPerWorker, TEXT("The minimum number of bodies we want per worker thread"))

int32	ChaosSolverCollisionPositionShockPropagationIterations = -1

int32	ChaosSolverCollisionVelocityShockPropagationIterations = -1

bool	bChaosSolverPersistentGraph = true

FRealSingle	SmoothedPositionLerpRate = 0.3f

bool	bChaosConstraintGraphValidate = (CHAOS_CONSTRAINTGRAPH_CHECK_ENABLED != 0)

FAutoConsoleVariableRef	CVarChaosConstraintGraphValidate (TEXT("p.Chaos.ConstraintGraph.Validate"), bChaosConstraintGraphValidate, TEXT("Enable per-tick ConstraintGraph validation checks/assertions"))

bool	bChaosSolverSleepEnabled = true

FAutoConsoleVariableRef	CVarChaosSolverSleepEnabled (TEXT("p.Chaos.Solver.Sleep.Enabled"), bChaosSolverSleepEnabled, TEXT("Islands of non - moving particles will be deactivated."))

bool	bChaosSolverPartialIslandSleep = false

FAutoConsoleVariableRef	CVarChaosSolverPartialIslandSleep (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep"), bChaosSolverPartialIslandSleep, TEXT("[EXPERIMENTAL] Single non-moving particles in islands will be deactivated even if they are connected to moving particles."))

bool	bChaosSolverPartialIslandWake = true

FAutoConsoleVariableRef	CVarChaosSolverPartialIslandWake (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PartialIslandWake"), bChaosSolverPartialIslandWake, TEXT("[EXPERIMENTAL] Safeguard only: New constraints and particle state changes will trigger partial wake events instead of waking up the entire island.[def:true]"))

bool	bChaosSolverForcePartialIslandWake = false

FAutoConsoleVariableRef	CVarChaosSolverForcePartialIslandWake (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.ForcePartialIslandWake"), bChaosSolverForcePartialIslandWake, TEXT("[EXPERIMENTAL] Safeguard only: We force partial wake events even if all particles in the island are already awake to guarantee resetting the particle sleep counter.[def:false]"))

bool	bChaosSolverWakeOnParticleStateChanged = false

FAutoConsoleVariableRef	CVarChaosSolverWakeOnParticleStateChanged (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.WakeOnParticleStateChanged"), bChaosSolverWakeOnParticleStateChanged, TEXT("[EXPERIMENTAL] Safeguard only: State changes of a particle will trigger the island to wake up entirely.[def:false]"))

bool	bChaosSolverWakeOnMovingOnly = true

FAutoConsoleVariableRef	CVarChaosSolverWakeOnMovingOnly (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.WakeOnMovingOnly"), bChaosSolverWakeOnMovingOnly, TEXT("[EXPERIMENTAL] Safeguard only: Only newly detected constraints connected to a moving particle will trigger wake-up event.[def:true]"))

FRealSingle	ChaosSolverPostStepWakeThreshold = 20.0f

FAutoConsoleVariableRef	CVarChaosSolverPostStepWakeThreshold (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PostStepWakeThreshold"), ChaosSolverPostStepWakeThreshold, TEXT("[EXPERIMENTAL] Post-solver waking of sleeping particles: Minimum squared change of velocity induced by the velocity-based collision solver (VBD, 0 to disable).[def:20]"))

FRealSingle	ChaosSolverMomentumPropagation = 0.3f

FAutoConsoleVariableRef	CVarChaosSolverMomentumPropagation (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.MomentumPropagation"), ChaosSolverMomentumPropagation, TEXT("[EXPERIMENTAL] Ratio of the impact momentum transferred from one sleeping particle to another through a constraint during partial wake event (0 to disable, 1 to propagate without dissipation).[def:0.3]"))

bool	bChaosSolverPartialSleepCollisionConstraintsOnly = true

FAutoConsoleVariableRef	CVarChaosSolverPartialSleepCollisionConstraintsOnly (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.CollisionConstraintsOnly"), bChaosSolverPartialSleepCollisionConstraintsOnly, TEXT("[EXPERIMENTAL] Safeguard only: Only collision constraints permit partial sleep, i.e. the sleep state of particles connect by other constraint types must match.[def:true]"))

bool	bChaosSolverPartialWakePreIntegration = true

FAutoConsoleVariableRef	CVarChaosSolverPartialWakePreIntegration (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PartialWakePreIntegration"), bChaosSolverPartialWakePreIntegration, TEXT("[EXPERIMENTAL] Safeguard only: Partial wake events also happen pre-integration when the user explicilty sets a particle transform or applies external impulses or forces.[def:true]"))

FRealSingle	ChaosSolverMinMotionlessRatio = 0.1f

FAutoConsoleVariableRef	CVarChaosSolverMinMotionlessRatio (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.MinimumMotionlessRatio"), ChaosSolverMinMotionlessRatio, TEXT("[EXPERIMENTAL] Ratio of the particles which need to be motionless in an island for partial island sleep to become active (0 to always activate partial island sleep).[def:0.1]"))

int32	ChaosSolverSleepModeSwitchThreshold = 10

FAutoConsoleVariableRef	CVarChaosSolverSleepModeSwitchThreshold (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.SleepModeSwitchCounterThreshold"), ChaosSolverSleepModeSwitchThreshold, TEXT("[EXPERIMENTAL] Safeguard only: Number of steps MinimumMotionlessRatio needs to be satisfied before switching the between full and partial island sleep.[def:10]"))

FRealSingle	LinearPartialWakeThresholdMultiplier = 10.0f

FAutoConsoleVariableRef	CVarChaosSolverLinearWakeThresholdMultiplier (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.LinearWakeThresholdMultiplier"), LinearPartialWakeThresholdMultiplier, TEXT("[EXPERIMENTAL] A multiplier applied to LinearSleepThreshold for particle waking.[def:10]"))

FRealSingle	AngularPartialWakeThresholdMultiplier = 10.0f

FAutoConsoleVariableRef	CVarChaosSolverAngularWakeThresholdMultiplier (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.AngularWakeThresholdMultiplier"), AngularPartialWakeThresholdMultiplier, TEXT("[EXPERIMENTAL] A multiplier applied to AngularSleepThreshold for particle waking.[def:10]"))

bool	bChaosSolverValidateConstraintSleepState = false

FAutoConsoleVariableRef	ChaosSolverValidateConstraintSleepState (TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.ValidateConstraintSleepState"), bChaosSolverValidateConstraintSleepState, TEXT("[EXPERIMENTAL] Debugging only: Enable constraint sleep state validation checks/assertions at the end of the tick.[def:false]"))

int32	ChaosSolverCollisionDefaultSleepCounterThreshold = 20

FAutoConsoleVariableRef	CVarChaosSolverCollisionDefaultSleepCounterThreshold (TEXT("p.Chaos.Solver.Sleep.Defaults.SleepCounterThreshold"), ChaosSolverCollisionDefaultSleepCounterThreshold, TEXT("Default counter threshold for sleeping.[def:20]"))

FRealSingle	ChaosSolverCollisionDefaultLinearSleepThreshold = 0.001f

FAutoConsoleVariableRef	CVarChaosSolverCollisionDefaultLinearSleepThreshold (TEXT("p.Chaos.Solver.Sleep.Defaults.LinearSleepThreshold"), ChaosSolverCollisionDefaultLinearSleepThreshold, TEXT("Default linear threshold for sleeping.[def:0.001]"))

FRealSingle	ChaosSolverCollisionDefaultAngularSleepThreshold = 0.0087f

FAutoConsoleVariableRef	CVarChaosSolverCollisionDefaultAngularSleepThreshold (TEXT("p.Chaos.Solver.Sleep.Defaults.AngularSleepThreshold"), ChaosSolverCollisionDefaultAngularSleepThreshold, TEXT("Default angular threshold for sleeping.[def:0.0087]"))

FRealSingle	ChaosSolverCollisionAngularSleepThresholdSize = 0

FAutoConsoleVariableRef	CVarChaosSolverCollisionAngularSleepThresholdSize (TEXT("p.Chaos.Solver.Sleep.AngularSleepThresholdSize"), ChaosSolverCollisionAngularSleepThresholdSize, TEXT("Scales the angular threshold based on size (0 to disable size based scaling)"))

int32	IsolatedParticleSleepCounterThresholdMultiplier = 1

FAutoConsoleVariableRef	CVarChaosSolverIsolatedParticleSleepCounterThresholdMultiplier (TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.CounterMultiplier"), IsolatedParticleSleepCounterThresholdMultiplier, TEXT("A multiplier applied to SleepCounterThreshold for floating particles"))

FRealSingle	IsolatedParticleSleepLinearThresholdMultiplier = 1.0f

FAutoConsoleVariableRef	CVarChaosSolverIsolatedParticleSleepLinearThresholdMultiplier (TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.LinearMultiplier"), IsolatedParticleSleepLinearThresholdMultiplier, TEXT("A multiplier applied to SleepLinearThreshold for floating particles"))

FRealSingle	IsolatedParticleSleepAngularThresholdMultiplier = 1.0f

FAutoConsoleVariableRef	CVarChaosSolverIsolatedParticleSleepAngularThresholdMultiplier (TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.AngularMultiplier"), IsolatedParticleSleepAngularThresholdMultiplier, TEXT("A multiplier applied to SleepAngularThreshold for floating particles"))

bool	bChaosSolverComputeIterationSettings = true

FAutoConsoleVariableRef	CVarChaosSolverComputeIterationSettingsEnabled (TEXT("p.Chaos.Solver.ComputeIterationSettings.Enabled"), bChaosSolverComputeIterationSettings, TEXT("Recompute iteration settings every time an island is changed"))

bool	bChaosRandomizeConstraintOrder = false

FAutoConsoleVariableRef	CVarChaosRandomizeConstraintOrder (TEXT("p.Chaos.Solver.RandomizeConstraintOrder"), bChaosRandomizeConstraintOrder, TEXT("Randomize constraint order for testing"))

FAutoConsoleVariableRef	CVarForceDeepCopyOnModifyGeometry (TEXT("p.Chaos.Geometry.ForceDeepCopyAccess"), GForceDeepCopyOnModifyGeometry, TEXT("Whether we always use a deep copy when modifying particle geometry"))

bool	bChaos_PBDCollisionSolver_UseJacobiPairSolver2

bool	bChaosEnableOverrideSingleParticleTypeToCluster = false

bool	bChaos_Solver_TestMode_Enabled = false

int32	Chaos_Solver_TestMode_Step = 0

bool	bChaosUseMACD = true

FRealSingle	HackMaxAngularVelocity = 1000.f

FAutoConsoleVariableRef	CVarHackMaxAngularVelocity (TEXT("p.HackMaxAngularVelocity"), HackMaxAngularVelocity, TEXT("Max cap on angular velocity: rad/s. This is only a temp solution and should not be relied on as a feature. -1.f to disable"))

FRealSingle	HackMaxVelocity = -1.f

FAutoConsoleVariableRef	CVarHackMaxVelocity (TEXT("p.HackMaxVelocity2"), HackMaxVelocity, TEXT("Max cap on velocity: cm/s. This is only a temp solution and should not be relied on as a feature. -1.f to disable"))

int	DisableThreshold = 5

FAutoConsoleVariableRef	CVarDisableThreshold (TEXT("p.DisableThreshold2"), DisableThreshold, TEXT("Disable threshold frames to transition to sleeping"))

int	CollisionDisableCulledContacts = 0

FAutoConsoleVariableRef	CVarDisableCulledContacts (TEXT("p.CollisionDisableCulledContacts"), CollisionDisableCulledContacts, TEXT("Allow the PBDRigidsEvolutionGBF collision constraints to throw out contacts mid solve if they are culled."))

FAutoConsoleVariableRef	CVarSmoothedPositionLerpRate (TEXT("p.Chaos.SmoothedPositionLerpRate"), SmoothedPositionLerpRate, TEXT("The interpolation rate for the smoothed position calculation. Used for sleeping."))

int	DisableParticleUpdateVelocityParallelFor = 0

FAutoConsoleVariableRef	CVarDisableParticleUpdateVelocityParallelFor (TEXT("p.DisableParticleUpdateVelocityParallelFor"), DisableParticleUpdateVelocityParallelFor, TEXT("Disable Particle Update Velocity ParallelFor and run the update on a single thread"))

bool	bChaosCollisionCCDUseTightBoundingBox = true

FAutoConsoleVariableRef	CVarChaosCollisionCCDUseTightBoundingBox (TEXT("p.Chaos.Collision.CCD.UseTightBoundingBox"), bChaosCollisionCCDUseTightBoundingBox, TEXT(""))

int32	ChaosSolverCollisionSolverType = -1

FAutoConsoleVariableRef	CVarChaosSolverCollisionSolverType (TEXT("p.Chaos.Solver.Collision.SolverType"), ChaosSolverCollisionSolverType, TEXT("-1: Use default (Gauss Seidel); 0: Gauss Seidel; 1: Gauss Seidel SOA 2: Partial Jacobi"))

int32	ChaosSolverCollisionPriority = 0

FAutoConsoleVariableRef	CVarChaosSolverCollisionPriority (TEXT("p.Chaos.Solver.Collision.Priority"), ChaosSolverCollisionPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))

int32	ChaosSolverJointPriority = 0

FAutoConsoleVariableRef	CVarChaosSolverJointPriority (TEXT("p.Chaos.Solver.Joint.Priority"), ChaosSolverJointPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))

int32	ChaosSolverSuspensionPriority = 0

FAutoConsoleVariableRef	CVarChaosSolverSuspensionPriority (TEXT("p.Chaos.Solver.Suspension.Priority"), ChaosSolverSuspensionPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))

int32	ChaosSolverCharacterGroundConstraintPriority = 0

FAutoConsoleVariableRef	CVarChaosSolverChaosCharacterGroundConstraintPriority (TEXT("p.Chaos.Solver.CharacterGroundConstraint.Priority"), ChaosSolverCharacterGroundConstraintPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))

bool	DoTransferJointConstraintCollisions = true

FAutoConsoleVariableRef	CVarDoTransferJointConstraintCollisions (TEXT("p.Chaos.Solver.Joint.TransferCollisions"), DoTransferJointConstraintCollisions, TEXT("Allows joints to apply collisions to the parent from the child when the Joints TransferCollisionScale is not 0 [def:true]"))

int32	TransferCollisionsLimit = INT_MAX

FAutoConsoleVariableRef	CVarTransferCollisionsMultiply (TEXT("p.Chaos.Solver.Joint.TransferCollisionsLimit"), TransferCollisionsLimit, TEXT("Maximum number of constraints that are allowed to transfer to the parent. Lowering this will improve performance but reduce accuracy. [def:INT_MAX]"))

FRealSingle	TransferCollisionsKinematicScale = 1.0f

FAutoConsoleVariableRef	CVarTransferCollisionsKinematicScale (TEXT("p.Chaos.Solver.Joint.TransferCollisionsKinematicScale"), TransferCollisionsKinematicScale, TEXT("Scale to apply to collision transfers between kinematic bodies [def:1.0]"))

FRealSingle	TransferCollisionsStiffnessClamp = 1.0f

FAutoConsoleVariableRef	CVarTransferCollisionsStiffnessClamp (TEXT("p.Chaos.Solver.Joint.TransferCollisionsStiffnessClamp"), TransferCollisionsStiffnessClamp, TEXT("Clamp of maximum value of the stiffness clamp[def:1.0]"))

bool	TransferCollisionsDebugTestAgainstMaxClamp = false

FAutoConsoleVariableRef	CVarTransferCollisionsDebugTestAgainstMaxClamp (TEXT("p.Chaos.Solver.Joint.TransferCollisionsDebugTestAgainstMaxClamp"), TransferCollisionsDebugTestAgainstMaxClamp, TEXT("Force all joint collision constraint settings to max clamp value to validate stability [def:false]"))

bool	DoFinalProbeNarrowPhase = true

FAutoConsoleVariableRef	CVarDoFinalProbeNarrowPhase (TEXT("p.Chaos.Solver.DoFinalProbeNarrowPhase"), DoFinalProbeNarrowPhase, TEXT(""))

int32	ChaosSolverInertiaConditioningEpoch = 0

FConsoleVariableDelegate	OnInertiaConditioningCVarChangedDelegate = FConsoleVariableDelegate::CreateLambda([](IConsoleVariable*) { ++ChaosSolverInertiaConditioningEpoch; })

bool	bChaosSolverInertiaConditioningEnabled = true

FAutoConsoleVariableRef	CVarChaosSolverInertiaConditioningEnabled (TEXT("p.Chaos.Solver.InertiaConditioning.Enabled"), bChaosSolverInertiaConditioningEnabled, TEXT("Enable/Disable constraint stabilization through inertia conditioning"), OnInertiaConditioningCVarChangedDelegate)

FRealSingle	ChaosSolverInertiaConditioningDistance = 20

FAutoConsoleVariableRef	CVarChaosSolverInertiaConditioningDistance (TEXT("p.Chaos.Solver.InertiaConditioning.Distance"), ChaosSolverInertiaConditioningDistance, TEXT("An input to inertia conditioning system. The joint distance error which needs to be stable (generate a low rotation)."), OnInertiaConditioningCVarChangedDelegate)

FRealSingle	ChaosSolverInertiaConditioningRotationRatio = 2.5f

FAutoConsoleVariableRef	CVarChaosSolverInertiaConditioningRotationRatio (TEXT("p.Chaos.Solver.InertiaConditioning.RotationRatio"), ChaosSolverInertiaConditioningRotationRatio, TEXT("An input to inertia conditioning system. The maximum ratio of joint correction from rotation versus translation"), OnInertiaConditioningCVarChangedDelegate)

FRealSingle	ChaosSolverMaxInvInertiaComponentRatio = 0

FAutoConsoleVariableRef	CVarChaosSolverInertiaConditioningMaxInvInertiaComponentRatio (TEXT("p.Chaos.Solver.InertiaConditioning.MaxInvInertiaComponentRatio"), ChaosSolverMaxInvInertiaComponentRatio, TEXT("An input to inertia conditioning system. The largest inertia component must be at least least multiple of the smallest component"), OnInertiaConditioningCVarChangedDelegate)

FInertiaConditioningTolerances	ChaosInertiaConditioningTolerances = FInertiaConditioningTolerances()

bool	bChaosCollisionModiferBeforeCCD = false

FAutoConsoleVariableRef	CVarChaosCollisionModiferBeforeCCD (TEXT("p.Chaos.Solver.CollisionModifiersBeforeCCD"), bChaosCollisionModiferBeforeCCD, TEXT("True: run the collision modifiers before CCD rewind is applied; False(default): run modifiers after CCD rewind. See comments in code."))

FAutoConsoleVariableRef	CVarChaosSolverPersistentGraph (TEXT("p.Chaos.Solver.PersistentGraph"), bChaosSolverPersistentGraph, TEXT(""))

FAutoConsoleVariableRef	CVarChaosIgnoreOneWayPairCollisions (TEXT("p.Chaos.Solver.OneWayPairCollisionMode"), ChaosOneWayInteractionPairCollisionMode, TEXT("How to treat collisions between two one-way interaction particles. See EOneWayInteractionPairCollisionMode (0: Ignore collisions; 1: Collide as normal; 2: Collide as spheres)"))

bool	bChaosRigids_UseSimdForJointsSolver = true

FAutoConsoleVariableRef	CVarChaosImmPhysUseSimdForLinearSolver (TEXT("p.Chaos.Solver.Joint.UseSimd"), bChaosRigids_UseSimdForJointsSolver, TEXT("Enable/Disable SIMD on the linear joint solver"))

int32	SerializeEvolution = 0

FAutoConsoleVariableRef	CVarSerializeEvolution (TEXT("p.SerializeEvolution"), SerializeEvolution, TEXT(""))

bool	bChaos_CollisionStore_Enabled = true

FAutoConsoleVariableRef	CVarCollisionStoreEnabled (TEXT("p.Chaos.CollisionStore.Enabled"), bChaos_CollisionStore_Enabled, TEXT(""))

FAutoConsoleVariableRef	CVarChaosSolverTestModeEnabled (TEXT("p.Chaos.Solver.TestMode.Enabled"), bChaos_Solver_TestMode_Enabled, TEXT(""))

bool	bChaos_Solver_TestMode_ShowInitialTransforms = false

FAutoConsoleVariableRef	CVarChaosSolverTestModeShowInitialTransforms (TEXT("p.Chaos.Solver.TestMode.ShowInitialTransforms"), bChaos_Solver_TestMode_ShowInitialTransforms, TEXT(""))

FAutoConsoleVariableRef	CVarChaosSolverTestModeStep (TEXT("p.Chaos.Solver.TestMode.Step"), Chaos_Solver_TestMode_Step, TEXT(""))

bool	bChaosSolverCheckParticleViews = false

FAutoConsoleVariableRef	CVarChaosSolverCheckParticleViews (TEXT("p.Chaos.Solver.CheckParticleViews"), bChaosSolverCheckParticleViews, TEXT(""))

bool	bChaosMidPhaseRedistributionEnabled = false

FAutoConsoleVariableRef	CVarChaosSolverMidPhaseRedistributionEnabled (TEXT("p.Chaos.BroadPhase.MidPhaseRedistributionEnabled"), bChaosMidPhaseRedistributionEnabled, TEXT(""))

bool	ChaosSolverUseParticlePool = true

FAutoConsoleVariableRef	CVarChaosSolverUseParticlePool (TEXT("p.Chaos.Solver.UseParticlePool"), ChaosSolverUseParticlePool, TEXT("Whether or not to use dirty particle pool (Optim)"))

int32	ChaosSolverParticlePoolNumFrameUntilShrink = 30

FAutoConsoleVariableRef	CVarChaosSolverParticlePoolNumFrameUntilShrink (TEXT("p.Chaos.Solver.ParticlePoolNumFrameUntilShrink"), ChaosSolverParticlePoolNumFrameUntilShrink, TEXT("Num Frame until we can potentially shrink the pool"))

bool	bChaosSolverCollisionEnabled = true

FAutoConsoleVariableRef	CVarChaosSolverCollisionDisable (TEXT("p.Chaos.Solver.Collision.Enabled"), bChaosSolverCollisionEnabled, TEXT("Enable/Disable collisions in the main scene."))

bool	bChaosSolverShrinkArrays = false

float	ChaosArrayCollectionMaxSlackFraction = 0.5f

int32	ChaosArrayCollectionMinSlack = 100

FAutoConsoleVariableRef	CVarChaosSolverShrinkArrays (TEXT("p.Chaos.Solver.ShrinkArrays"), bChaosSolverShrinkArrays, TEXT("Enable/Disable particle array shrinking in the main scene"))

FAutoConsoleVariableRef	CVarChaosSolverArrayCollectionMaxSlackFraction (TEXT("p.Chaos.ArrayCollection.MaxSlackFraction"), ChaosArrayCollectionMaxSlackFraction, TEXT("Shrink particle arrays if the number of slack elements exceeds the number of elements by this fraction"))

FAutoConsoleVariableRef	CVarChaosSolverArrayCollectionMinSlack (TEXT("p.Chaos.ArrayCollection.MinSlack"), ChaosArrayCollectionMinSlack, TEXT("Do not reduce the size of particle arrays if it would leave less slack than this"))

int32	ChaosSolverCollisionPositionFrictionIterations = -1

int32	ChaosSolverCollisionVelocityFrictionIterations = -1

FAutoConsoleVariableRef	CVarChaosSolverCollisionPositionFrictionIterations (TEXT("p.Chaos.Solver.Collision.PositionFrictionIterations"), ChaosSolverCollisionPositionFrictionIterations, TEXT("Override number of position iterations where friction is applied (if >= 0)"))

FAutoConsoleVariableRef	CVarChaosSolverCollisionVelocityFrictionIterations (TEXT("p.Chaos.Solver.Collision.VelocityFrictionIterations"), ChaosSolverCollisionVelocityFrictionIterations, TEXT("Override number of velocity iterations where friction is applied (if >= 0)"))

FAutoConsoleVariableRef	CVarChaosSolverCollisionPositionShockPropagationIterations (TEXT("p.Chaos.Solver.Collision.PositionShockPropagationIterations"), ChaosSolverCollisionPositionShockPropagationIterations, TEXT("Override number of position iterations where shock propagation is applied (if >= 0)"))

FAutoConsoleVariableRef	CVarChaosSolverCollisionVelocityShockPropagationIterations (TEXT("p.Chaos.Solver.Collision.VelocityShockPropagationIterations"), ChaosSolverCollisionVelocityShockPropagationIterations, TEXT("Override number of velocity iterations where shock propagation is applied (if >= 0)"))

FAutoConsoleVariableRef	CVarChaosSolverIterations (TEXT("p.Chaos.Solver.Iterations.Position"), ChaosSolverPositionIterations, TEXT("Override number of solver position iterations (-1 to use config)"))

FAutoConsoleVariableRef	CVarChaosSolverPushOutIterations (TEXT("p.Chaos.Solver.Iterations.Velocity"), ChaosSolverVelocityIterations, TEXT("Override number of solver velocity iterations (-1 to use config)"))

FAutoConsoleVariableRef	CVarChaosSolverProjectionIterations (TEXT("p.Chaos.Solver.Iterations.Projection"), ChaosSolverProjectionIterations, TEXT("Override number of solver projection iterations (-1 to use config)"))

int32	ChaosSolverDeterministic = -1

FAutoConsoleVariableRef	CVarChaosSolverDeterministic (TEXT("p.Chaos.Solver.Deterministic"), ChaosSolverDeterministic, TEXT("Override determinism. 0: disabled; 1: enabled; -1: use config"))

FRealSingle	ChaosSolverJointPositionTolerance = 0.025f

FAutoConsoleVariableRef	CVarChaosSolverJointPositionTolerance (TEXT("p.Chaos.Solver.Joint.PositionTolerance"), ChaosSolverJointPositionTolerance, TEXT("PositionTolerance."))

FRealSingle	ChaosSolverJointAngleTolerance = 0.001f

FAutoConsoleVariableRef	CVarChaosSolverJointAngleTolerance (TEXT("p.Chaos.Solver.Joint.AngleTolerance"), ChaosSolverJointAngleTolerance, TEXT("AngleTolerance."))

FRealSingle	ChaosSolverJointMinParentMassRatio = 0.2f

FAutoConsoleVariableRef	CVarChaosSolverJointMinParentMassRatio (TEXT("p.Chaos.Solver.Joint.MinParentMassRatio"), ChaosSolverJointMinParentMassRatio, TEXT("6Dof joint MinParentMassRatio (if > 0)"))

FRealSingle	ChaosSolverJointMaxInertiaRatio = 5.0f

FAutoConsoleVariableRef	CVarChaosSolverJointMaxInertiaRatio (TEXT("p.Chaos.Solver.Joint.MaxInertiaRatio"), ChaosSolverJointMaxInertiaRatio, TEXT("6Dof joint MaxInertiaRatio (if > 0)"))

bool	bChaosCollisionConfigChanged = false

FConsoleVariableDelegate	OnCollisionConfigCVarChanged = FConsoleVariableDelegate::CreateLambda([](IConsoleVariable* CVar) -> void { bChaosCollisionConfigChanged = true; })

FRealSingle	ChaosSolverCullDistance = -1.0f

FAutoConsoleVariableRef	CVarChaosSolverCullDistance (TEXT("p.Chaos.Solver.Collision.CullDistance"), ChaosSolverCullDistance, TEXT("Override cull distance (if >= 0)"), OnCollisionConfigCVarChanged)

FRealSingle	ChaosSolverVelocityBoundsMultiplier = 1.0f

FRealSingle	ChaosSolverMaxVelocityBoundsExpansion = 3.0f

FRealSingle	ChaosSolverVelocityBoundsMultiplierMACD = 1.0f

FRealSingle	ChaosSolverMaxVelocityBoundsExpansionMACD = 1000.0f

FAutoConsoleVariableRef	CVarChaosSolverVelocityBoundsMultiplier (TEXT("p.Chaos.Solver.Collision.VelocityBoundsMultiplier"), ChaosSolverVelocityBoundsMultiplier, TEXT("Override velocity bounds multiplier (if >= 0)"), OnCollisionConfigCVarChanged)

FAutoConsoleVariableRef	CVarChaosSolverMaxVelocityBoundsExpansion (TEXT("p.Chaos.Solver.Collision.MaxVelocityBoundsExpansion"), ChaosSolverMaxVelocityBoundsExpansion, TEXT("Override max velocity bounds expansion (if >= 0)"), OnCollisionConfigCVarChanged)

FAutoConsoleVariableRef	CVarChaosSolverVelocityBoundsMultiplierMACD (TEXT("p.Chaos.Solver.Collision.VelocityBoundsMultiplierMACD"), ChaosSolverVelocityBoundsMultiplierMACD, TEXT("Override velocity bounds multiplier for MACD (if >= 0)"), OnCollisionConfigCVarChanged)

FAutoConsoleVariableRef	CVarChaosSolverMaxVelocityBoundsExpansionMACD (TEXT("p.Chaos.Solver.Collision.MaxVelocityBoundsExpansionMACD"), ChaosSolverMaxVelocityBoundsExpansionMACD, TEXT("Override max velocity bounds expansion for MACD (if >= 0)"), OnCollisionConfigCVarChanged)

FRealSingle	ChaosSolverMaxPushOutVelocity = -1.0f

FAutoConsoleVariableRef	CVarChaosSolverMaxPushOutVelocity (TEXT("p.Chaos.Solver.Collision.MaxPushOutVelocity"), ChaosSolverMaxPushOutVelocity, TEXT("Override max pushout velocity (if >= 0)"), OnCollisionConfigCVarChanged)

FRealSingle	ChaosSolverDepenetrationVelocity = -1.0f

FAutoConsoleVariableRef	CVarChaosSolverInitialOverlapDepentrationVelocity (TEXT("p.Chaos.Solver.Collision.DepenetrationVelocity"), ChaosSolverDepenetrationVelocity, TEXT("Override initial overlap depenetration velocity (if >= 0)"), OnCollisionConfigCVarChanged)

int32	ChaosSolverCleanupCommandsOnDestruction = 1

FAutoConsoleVariableRef	CVarChaosSolverCleanupCommandsOnDestruction (TEXT("p.Chaos.Solver.CleanupCommandsOnDestruction"), ChaosSolverCleanupCommandsOnDestruction, TEXT("Whether or not to run internal command queue cleanup on solver destruction (0 = no cleanup, >0 = cleanup all commands)"))

int32	ChaosSolverCollisionDeferNarrowPhase = 0

FAutoConsoleVariableRef	CVarChaosSolverCollisionDeferNarrowPhase (TEXT("p.Chaos.Solver.Collision.DeferNarrowPhase"), ChaosSolverCollisionDeferNarrowPhase, TEXT("Create contacts for all broadphase pairs, perform NarrowPhase later."))

int32	ChaosSolverCollisionUseManifolds = 1

FAutoConsoleVariableRef	CVarChaosSolverCollisionUseManifolds (TEXT("p.Chaos.Solver.Collision.UseManifolds"), ChaosSolverCollisionUseManifolds, TEXT("Enable/Disable use of manifolds in collision."))

int32	ChaosSolverCollisionAllowManifoldUpdate = 1

FAutoConsoleVariableRef	CVarChaosSolverCollisionAllowManifoldUpdate (TEXT("p.Chaos.Solver.Collision.AllowManifoldUpdate"), ChaosSolverCollisionAllowManifoldUpdate, TEXT("Enable/Disable reuse of manifolds between ticks (for small movement)."))

bool	bChaosUseCCD = true

FAutoConsoleVariableRef	CVarChaosUseCCD (TEXT("p.Chaos.Solver.UseCCD"), bChaosUseCCD, TEXT("Global flag to turn CCD on or off. Default is true (on)"), OnCollisionConfigCVarChanged)

FAutoConsoleVariableRef	CVarChaos_Collision_UseMACD (TEXT("p.Chaos.Solver.UseMACD"), bChaosUseMACD, TEXT("Global flag to turn Movement-Aware Collision Detection (MACD) on or off. Default is true (on)"), OnCollisionConfigCVarChanged)

FAutoConsoleVariableRef	CVarChaos_Collision_ForceMACD (TEXT("p.Chaos.Solver.bChaosForceMACD"), bChaosForceMACD, TEXT("Force all collisions to use MACD for testing"), OnCollisionConfigCVarChanged)

float	ChaosSolverJointMinSolverStiffness = 1.0f

float	ChaosSolverJointMaxSolverStiffness = 1.0f

int32	ChaosSolverJointNumIterationsAtMaxSolverStiffness = 1

bool	bChaosSolverJointSolvePositionLast = true

bool	bChaosSolverJointUsePositionBasedDrives = true

int32	ChaosSolverJointNumShockProagationIterations = 0

FRealSingle	ChaosSolverJointShockPropagation = -1.0f

FAutoConsoleVariableRef	CVarChaosSolverJointMinSolverStiffness (TEXT("p.Chaos.Solver.Joint.MinSolverStiffness"), ChaosSolverJointMinSolverStiffness, TEXT("Solver stiffness on first iteration, increases each iteration toward MaxSolverStiffness."))

FAutoConsoleVariableRef	CVarChaosSolverJointMaxSolverStiffness (TEXT("p.Chaos.Solver.Joint.MaxSolverStiffness"), ChaosSolverJointMaxSolverStiffness, TEXT("Solver stiffness on last iteration, increases each iteration from MinSolverStiffness."))

FAutoConsoleVariableRef	CVarChaosSolverJointNumIterationsAtMaxSolverStiffness (TEXT("p.Chaos.Solver.Joint.NumIterationsAtMaxSolverStiffness"), ChaosSolverJointNumIterationsAtMaxSolverStiffness, TEXT("How many iterations we want at MaxSolverStiffness."))

FAutoConsoleVariableRef	CVarChaosSolverJointSolvePositionFirst (TEXT("p.Chaos.Solver.Joint.SolvePositionLast"), bChaosSolverJointSolvePositionLast, TEXT("Should we solve joints in position-then-rotation order (false) or rotation-then-position order (true, default)"))

FAutoConsoleVariableRef	CVarChaosSolverJointUsePBDVelocityDrives (TEXT("p.Chaos.Solver.Joint.UsePBDDrives"), bChaosSolverJointUsePositionBasedDrives, TEXT("Whether to solve drives in the position or velocity phase of the solver (default true"))

FAutoConsoleVariableRef	CVarChaosSolverJointNumShockPropagationIterations (TEXT("p.Chaos.Solver.Joint.NumShockPropagationIterations"), ChaosSolverJointNumShockProagationIterations, TEXT("How many iterations to enable SHockProagation for."))

FAutoConsoleVariableRef	CVarChaosSolverJointShockPropagation (TEXT("p.Chaos.Solver.Joint.ShockPropagation"), ChaosSolverJointShockPropagation, TEXT("6Dof joint shock propagation override (if >= 0)."))

int32	ChaosVisualDebuggerEnable = 1

FAutoConsoleVariableRef	CVarChaosVisualDebuggerEnable (TEXT("p.Chaos.VisualDebuggerEnable"), ChaosVisualDebuggerEnable, TEXT("Enable/Disable pushing/saving data to the visual debugger"))

FAutoConsoleVariableRef	CVarChaosEnableOverrideSingleParticleTypeToCluster (TEXT("p.Chaos.EnableOverrideSingleParticleTypeToCluster"), bChaosEnableOverrideSingleParticleTypeToCluster, TEXT("When enabled particles are promoted to cluster type so they may be used with cluster unions"))

bool	bRemoveParticleFromMovingKinematicsOnDisable = true

FAutoConsoleVariableRef	CVarChaosRemoveParticleFromMovingKinematicsOnDisable (TEXT("p.Chaos.RemoveParticleFromMovingKinematicsOnDisable"), bRemoveParticleFromMovingKinematicsOnDisable, TEXT(""))

bool	bSingleThreadPushData = false

FAutoConsoleVariableRef	CVarChaosSingleThreadPushData (TEXT("p.Chaos.SingleThreadPushData"), bSingleThreadPushData, TEXT("Run push Data in Single Thread."))

CHAOS_API int32	ChaosSolverDrawCCDThresholds

Function Documentation

◆ CVarChaosInertiaConditioningExtentTolerance()

FAutoConsoleVariableRef Chaos::CVars::CVarChaosInertiaConditioningExtentTolerance	(	TEXT("p.Chaos.InertiaConditioning.ExtentTolerance")	,
		ChaosInertiaConditioningTolerances.	ExtentTolerance,
		TEXT("Inertia conditioning is disabled for objects with dimensions smaller than this.")	,
		OnInertiaConditioningCVarChangedDelegate
	)

◆ CVarChaosInertiaConditioningInvInertiaTolerance()

FAutoConsoleVariableRef Chaos::CVars::CVarChaosInertiaConditioningInvInertiaTolerance	(	TEXT("p.Chaos.InertiaConditioning.InvInertiaTolerance")	,
		ChaosInertiaConditioningTolerances.	InvInertiaTolerance,
		TEXT("Inertia conditioning is disabled for objects with inverse inertia less than this. The default value disables Inertia Conditioing for mediums to large objects.")	,
		OnInertiaConditioningCVarChangedDelegate
	)

◆ CVarChaosInertiaConditioningInvMassTolerance()

FAutoConsoleVariableRef Chaos::CVars::CVarChaosInertiaConditioningInvMassTolerance	(	TEXT("p.Chaos.InertiaConditioning.InvMassTolerance")	,
		ChaosInertiaConditioningTolerances.	InvMassTolerance,
		TEXT("Inertia conditioning is disabled for objects with inverse mass less than this.")	,
		OnInertiaConditioningCVarChangedDelegate
	)

◆ DECLARE_CYCLE_STAT() [1/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::AddSleepingContacts")	,
		STAT_Evolution_AddSleepingContacts	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [2/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::AdvanceOneTimeStep")	,
		STAT_Evolution_AdvanceOneTimeStep	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [3/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::BuildGroups")	,
		STAT_Evolution_BuildGroups	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [4/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::CCD")	,
		STAT_Evolution_CCD	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [5/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::CCDCorrection")	,
		STAT_Evolution_CCDCorrection	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [6/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::CCDModifierCallback")	,
		STAT_Evolution_CCDModifierCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [7/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::CollisionModifierCallback")	,
		STAT_Evolution_CollisionModifierCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [8/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::ComputeIntermediateSpatialAcceleration")	,
		STAT_Evolution_ComputeIntermediateSpatialAcceleration	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [9/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::CreateConstraintGraph")	,
		STAT_Evolution_CreateConstraintGraph	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [10/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::CreateIslands")	,
		STAT_Evolution_CreateIslands	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [11/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::DeactivateSleep")	,
		STAT_Evolution_DeactivateSleep	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [12/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::DetectCollisions")	,
		STAT_Evolution_DetectCollisions	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [13/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::GraphColor")	,
		STAT_Evolution_GraphColor	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [14/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::InertiaConditioning")	,
		STAT_Evolution_InertiaConditioning	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [15/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::Integrate")	,
		STAT_Evolution_Integrate	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [16/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::KinematicTargets")	,
		STAT_Evolution_KinematicTargets	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [17/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::MidPhaseModifierCallback")	,
		STAT_Evolution_MidPhaseModifierCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [18/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::ParallelSolve")	,
		STAT_Evolution_ParallelSolve	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [19/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::PostDetectCollisionsCallback")	,
		STAT_Evolution_PostDetectCollisionsCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [20/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::PostIntegrateCallback")	,
		STAT_Evolution_PostIntegrateCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [21/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::PostSolveCallback")	,
		STAT_Evolution_PostSolveCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [22/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::PreIntegrateCallback")	,
		STAT_Evolution_PreIntegrateCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [23/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::PreSolveCallback")	,
		STAT_Evolution_PreSolveCallback	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [24/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::PruneCollisions")	,
		STAT_Evolution_PruneCollisions	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [25/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::SaveParticlePostSolve")	,
		STAT_Evolution_SavePostSolve	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [26/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::TransferJointCollisions")	,
		STAT_Evolution_TransferJointCollisions	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [27/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::UnclusterUnions")	,
		STAT_Evolution_UnclusterUnions	,
		STATGROUP_Chaos
	)

◆ DECLARE_CYCLE_STAT() [28/28]

Chaos::CVars::DECLARE_CYCLE_STAT	(	TEXT("FPBDRigidsEvolutionGBF::UpdateConstraintPositionBasedState")	,
		STAT_Evolution_UpdateConstraintPositionBasedState	,
		STATGROUP_Chaos
	)

◆ ForceDeepCopyOnModifyGeometry()

bool Chaos::CVars::ForceDeepCopyOnModifyGeometry ( )

Variable Documentation

◆ AngularPartialWakeThresholdMultiplier

FRealSingle Chaos::CVars::AngularPartialWakeThresholdMultiplier = 10.0f

Cvar to adjust the angular wake threshold for partial waking

◆ bCCDAxisThresholdUsesProbeShapes

CHAOS_API bool Chaos::CVars::bCCDAxisThresholdUsesProbeShapes = false

◆ bCCDNewTargetDepthMode

bool Chaos::CVars::bCCDNewTargetDepthMode = true

◆ bCCDSweepsUseProbeShapes

bool Chaos::CVars::bCCDSweepsUseProbeShapes = false

◆ bChaos_Collision_EnableInitialDepenetration

bool Chaos::CVars::bChaos_Collision_EnableInitialDepenetration = true

◆ bChaos_Collision_EnableSoftCollisions

bool Chaos::CVars::bChaos_Collision_EnableSoftCollisions = true

◆ bChaos_Collision_MidPhase_EnableShapePairs

bool Chaos::CVars::bChaos_Collision_MidPhase_EnableShapePairs = true

◆ bChaos_CollisionStore_Enabled

bool Chaos::CVars::bChaos_CollisionStore_Enabled = true

◆ bChaos_PBDCollisionSolver_Position_SolveEnabled

bool Chaos::CVars::bChaos_PBDCollisionSolver_Position_SolveEnabled = true

◆ bChaos_PBDCollisionSolver_UseJacobiPairSolver2

bool Chaos::CVars::bChaos_PBDCollisionSolver_UseJacobiPairSolver2

extern

◆ bChaos_PBDCollisionSolver_Velocity_AveragePointEnabled

bool Chaos::CVars::bChaos_PBDCollisionSolver_Velocity_AveragePointEnabled = false

◆ bChaos_PBDCollisionSolver_Velocity_FrictionEnabled

bool Chaos::CVars::bChaos_PBDCollisionSolver_Velocity_FrictionEnabled = true

◆ bChaos_PBDCollisionSolver_Velocity_SolveEnabled

bool Chaos::CVars::bChaos_PBDCollisionSolver_Velocity_SolveEnabled = true

◆ bChaos_Solver_TestMode_Enabled

bool Chaos::CVars::bChaos_Solver_TestMode_Enabled = false

◆ bChaos_Solver_TestMode_ShowInitialTransforms

bool Chaos::CVars::bChaos_Solver_TestMode_ShowInitialTransforms = false

◆ bChaosCollisionCCDAllowClipping

bool Chaos::CVars::bChaosCollisionCCDAllowClipping = true

◆ bChaosCollisionCCDEnableResweep

bool Chaos::CVars::bChaosCollisionCCDEnableResweep = true

◆ bChaosCollisionCCDUseTightBoundingBox

CHAOS_API bool Chaos::CVars::bChaosCollisionCCDUseTightBoundingBox = true

◆ bChaosCollisionConfigChanged

bool Chaos::CVars::bChaosCollisionConfigChanged = false

◆ bChaosCollisionModiferBeforeCCD

bool Chaos::CVars::bChaosCollisionModiferBeforeCCD = false

◆ bChaosConstraintGraphValidate

bool Chaos::CVars::bChaosConstraintGraphValidate = (CHAOS_CONSTRAINTGRAPH_CHECK_ENABLED != 0)

◆ bChaosConvexSimplifyUnion

CHAOS_API bool Chaos::CVars::bChaosConvexSimplifyUnion = false

◆ bChaosEnableOverrideSingleParticleTypeToCluster

bool Chaos::CVars::bChaosEnableOverrideSingleParticleTypeToCluster = false

◆ bChaosForceMACD

bool Chaos::CVars::bChaosForceMACD = false

◆ bChaosImplicitBVHOptimizedCountLeafObjects

bool Chaos::CVars::bChaosImplicitBVHOptimizedCountLeafObjects = true

◆ bChaosMidPhaseActivateWakingConstraints

bool Chaos::CVars::bChaosMidPhaseActivateWakingConstraints = true

◆ bChaosMidPhaseModifierConvexOptimizerFix

bool Chaos::CVars::bChaosMidPhaseModifierConvexOptimizerFix = true

◆ bChaosMidPhaseRedistributionEnabled

bool Chaos::CVars::bChaosMidPhaseRedistributionEnabled = false

◆ bChaosRandomizeConstraintOrder

bool Chaos::CVars::bChaosRandomizeConstraintOrder = false

◆ bChaosRigids_UseSimdForJointsSolver

bool Chaos::CVars::bChaosRigids_UseSimdForJointsSolver = true

◆ bChaosSolverCheckParticleViews

CHAOS_API bool Chaos::CVars::bChaosSolverCheckParticleViews = false

◆ bChaosSolverCollisionEnabled

bool Chaos::CVars::bChaosSolverCollisionEnabled = true

◆ bChaosSolverComputeIterationSettings

bool Chaos::CVars::bChaosSolverComputeIterationSettings = true

Cvar to enable/disable computing max iterations if island is dirty

◆ bChaosSolverForcePartialIslandWake

bool Chaos::CVars::bChaosSolverForcePartialIslandWake = false

Cvar to enable/disable forcing a partial island waking for all islands even if all particles are already awake. This is just a safeguard to force resetting the particle sleep counter when a new wake event occurs. It should generally be set to false.

◆ bChaosSolverInertiaConditioningEnabled

bool Chaos::CVars::bChaosSolverInertiaConditioningEnabled = true

◆ bChaosSolverJointSolvePositionLast

bool Chaos::CVars::bChaosSolverJointSolvePositionLast = true

◆ bChaosSolverJointUsePositionBasedDrives

bool Chaos::CVars::bChaosSolverJointUsePositionBasedDrives = true

◆ bChaosSolverPartialIslandSleep

bool Chaos::CVars::bChaosSolverPartialIslandSleep = false

Cvar to enable/disable partial island sleeping for all islands

◆ bChaosSolverPartialIslandWake

bool Chaos::CVars::bChaosSolverPartialIslandWake = true

Cvar to enable/disable partial island waking for all islands

◆ bChaosSolverPartialSleepCollisionConstraintsOnly

bool Chaos::CVars::bChaosSolverPartialSleepCollisionConstraintsOnly = true

Cvar to enable/disable partial sleep for collision constraints only, i.e. the sleep state of particles connect by other constraint types must match (partial island sleeping only)

◆ bChaosSolverPartialWakePreIntegration

bool Chaos::CVars::bChaosSolverPartialWakePreIntegration = true

Cvar to enable partial waking pre-integration (UpdateExplicitSleep).

◆ bChaosSolverPersistentGraph

bool Chaos::CVars::bChaosSolverPersistentGraph = true

◆ bChaosSolverShrinkArrays

bool Chaos::CVars::bChaosSolverShrinkArrays = false

◆ bChaosSolverSleepEnabled

bool Chaos::CVars::bChaosSolverSleepEnabled = true

Cvar to enable/disable the island sleeping

◆ bChaosSolverValidateConstraintSleepState

bool Chaos::CVars::bChaosSolverValidateConstraintSleepState = false

Cvar to enable validate constraint sleep state at the end of the step (debugging only)

◆ bChaosSolverWakeOnMovingOnly

bool Chaos::CVars::bChaosSolverWakeOnMovingOnly = true

Cvar to enable/disable triggering wake up for newly detected constraints with moving particles only (partial island sleeping only)

◆ bChaosSolverWakeOnParticleStateChanged

bool Chaos::CVars::bChaosSolverWakeOnParticleStateChanged = false

Cvar to enable/disable waking up the entire island if the state of any particle has changed (partial island sleeping only)

◆ bChaosUnionBVHEnabled

bool Chaos::CVars::bChaosUnionBVHEnabled = true

◆ bChaosUseCCD

bool Chaos::CVars::bChaosUseCCD = true

◆ bChaosUseMACD

bool Chaos::CVars::bChaosUseMACD = true

◆ bClearNullCCDConstraintsOnApply

bool Chaos::CVars::bClearNullCCDConstraintsOnApply = true

◆ bEnableAsyncInitBody

CHAOS_API bool Chaos::CVars::bEnableAsyncInitBody = false

◆ bMeshContactGeneratorFixContactNormalFixEnabled

bool Chaos::CVars::bMeshContactGeneratorFixContactNormalFixEnabled = true

◆ bRemoveParticleFromMovingKinematicsOnDisable

CHAOS_API bool Chaos::CVars::bRemoveParticleFromMovingKinematicsOnDisable = true

◆ bSingleThreadPushData

bool Chaos::CVars::bSingleThreadPushData = false

◆ CCDAllowedDepthBoundsScale

FRealSingle Chaos::CVars::CCDAllowedDepthBoundsScale = 0.2f

◆ CCDAxisThresholdMode

CHAOS_API int32 Chaos::CVars::CCDAxisThresholdMode = 2

◆ CCDEnableThresholdBoundsScale

FRealSingle Chaos::CVars::CCDEnableThresholdBoundsScale = 0.4f

◆ Chaos_CharacterGroundConstraint_ExternalMovementThreshold

CHAOS_API float Chaos::CVars::Chaos_CharacterGroundConstraint_ExternalMovementThreshold = 2.0f

◆ Chaos_CharacterGroundConstraint_InputMovementThreshold

CHAOS_API float Chaos::CVars::Chaos_CharacterGroundConstraint_InputMovementThreshold = 0.1f

◆ Chaos_Collision_CullDistanceScaleInverseSize

FRealSingle Chaos::CVars::Chaos_Collision_CullDistanceScaleInverseSize = 0.01f

◆ Chaos_Collision_MaxSolverManifoldPoints

int32 Chaos::CVars::Chaos_Collision_MaxSolverManifoldPoints = -1

◆ Chaos_Collision_MidPhase_MaxShapePairs

int32 Chaos::CVars::Chaos_Collision_MidPhase_MaxShapePairs = 100

◆ Chaos_Collision_MinCullDistanceScale

FRealSingle Chaos::CVars::Chaos_Collision_MinCullDistanceScale = 1.0f

◆ Chaos_PBDCollisionSolver_AutoStiffness_MassRatio1

FRealSingle Chaos::CVars::Chaos_PBDCollisionSolver_AutoStiffness_MassRatio1 = 0

◆ Chaos_PBDCollisionSolver_AutoStiffness_MassRatio2

FRealSingle Chaos::CVars::Chaos_PBDCollisionSolver_AutoStiffness_MassRatio2 = 0

◆ Chaos_PBDCollisionSolver_JacobiPositionTolerance

float Chaos::CVars::Chaos_PBDCollisionSolver_JacobiPositionTolerance = 1.e-6f

◆ Chaos_PBDCollisionSolver_JacobiRotationTolerance

float Chaos::CVars::Chaos_PBDCollisionSolver_JacobiRotationTolerance = 1.e-8f

◆ Chaos_PBDCollisionSolver_JacobiStiffness

float Chaos::CVars::Chaos_PBDCollisionSolver_JacobiStiffness = 0.5f

◆ Chaos_PBDCollisionSolver_Position_MinInvMassScale

float Chaos::CVars::Chaos_PBDCollisionSolver_Position_MinInvMassScale = 0.77f

◆ Chaos_PBDCollisionSolver_Position_StaticFrictionStiffness

float Chaos::CVars::Chaos_PBDCollisionSolver_Position_StaticFrictionStiffness = 0.5f

◆ Chaos_PBDCollisionSolver_Velocity_MinInvMassScale

float Chaos::CVars::Chaos_PBDCollisionSolver_Velocity_MinInvMassScale = Chaos_PBDCollisionSolver_Position_MinInvMassScale

◆ Chaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness

float Chaos::CVars::Chaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness = 1.0f

◆ Chaos_Solver_TestMode_Step

int32 Chaos::CVars::Chaos_Solver_TestMode_Step = 0

◆ ChaosArrayCollectionMaxSlackFraction

float Chaos::CVars::ChaosArrayCollectionMaxSlackFraction = 0.5f

◆ ChaosArrayCollectionMinSlack

int32 Chaos::CVars::ChaosArrayCollectionMinSlack = 100

◆ ChaosCollisionCCDConstraintMaxProcessCount

CHAOS_API int32 Chaos::CVars::ChaosCollisionCCDConstraintMaxProcessCount = 1

◆ ChaosCollisionCCDCorrectionIterations

int32 Chaos::CVars::ChaosCollisionCCDCorrectionIterations = 4

◆ ChaosCollisionCCDCorrectionPhiToleranceScale

FRealSingle Chaos::CVars::ChaosCollisionCCDCorrectionPhiToleranceScale = 0.02f

◆ ChaosConvexDynamicMode

int32 Chaos::CVars::ChaosConvexDynamicMode = 2

◆ ChaosConvexEnableMerging

bool Chaos::CVars::ChaosConvexEnableMerging = true

◆ ChaosConvexKinematicMode

int32 Chaos::CVars::ChaosConvexKinematicMode = 2

◆ ChaosConvexMinVolume

float Chaos::CVars::ChaosConvexMinVolume = 10000.0f

◆ ChaosConvexSplittingThreshold

float Chaos::CVars::ChaosConvexSplittingThreshold = 1.0f

◆ ChaosConvexUseDirectOverlap

bool Chaos::CVars::ChaosConvexUseDirectOverlap = true

◆ ChaosInertiaConditioningTolerances

FInertiaConditioningTolerances Chaos::CVars::ChaosInertiaConditioningTolerances = FInertiaConditioningTolerances()

◆ ChaosOneWayInteractionPairCollisionMode

int32 Chaos::CVars::ChaosOneWayInteractionPairCollisionMode = (int32)EOneWayInteractionPairCollisionMode::SphereCollision

◆ ChaosOneWayPairSphereRadiusAlpha

FRealSingle Chaos::CVars::ChaosOneWayPairSphereRadiusAlpha = 1.0f

◆ ChaosSolverCharacterGroundConstraintPriority

int32 Chaos::CVars::ChaosSolverCharacterGroundConstraintPriority = 0

◆ ChaosSolverCleanupCommandsOnDestruction

int32 Chaos::CVars::ChaosSolverCleanupCommandsOnDestruction = 1

◆ ChaosSolverCollisionAllowManifoldUpdate

int32 Chaos::CVars::ChaosSolverCollisionAllowManifoldUpdate = 1

◆ ChaosSolverCollisionAngularSleepThresholdSize

FRealSingle Chaos::CVars::ChaosSolverCollisionAngularSleepThresholdSize = 0

The size of object for which the angular sleep threshold is defined. Large objects reduce the threshold propertionally. 0 means do not apply size scale.

◆ ChaosSolverCollisionDefaultAngularSleepThreshold

FRealSingle Chaos::CVars::ChaosSolverCollisionDefaultAngularSleepThreshold = 0.0087f

Cvar to override the sleep angular threshold if necessary

◆ ChaosSolverCollisionDefaultLinearSleepThreshold

FRealSingle Chaos::CVars::ChaosSolverCollisionDefaultLinearSleepThreshold = 0.001f

Cvar to override the sleep linear threshold if necessary

◆ ChaosSolverCollisionDefaultSleepCounterThreshold

int32 Chaos::CVars::ChaosSolverCollisionDefaultSleepCounterThreshold = 20

Cvar to override the sleep counter threshold if necessary

◆ ChaosSolverCollisionDeferNarrowPhase

int32 Chaos::CVars::ChaosSolverCollisionDeferNarrowPhase = 0

◆ ChaosSolverCollisionPositionFrictionIterations

int32 Chaos::CVars::ChaosSolverCollisionPositionFrictionIterations = -1

◆ ChaosSolverCollisionPositionShockPropagationIterations

int32 Chaos::CVars::ChaosSolverCollisionPositionShockPropagationIterations = -1

◆ ChaosSolverCollisionPriority

int32 Chaos::CVars::ChaosSolverCollisionPriority = 0

◆ ChaosSolverCollisionSolverType

int32 Chaos::CVars::ChaosSolverCollisionSolverType = -1

◆ ChaosSolverCollisionUseManifolds

int32 Chaos::CVars::ChaosSolverCollisionUseManifolds = 1

◆ ChaosSolverCollisionVelocityFrictionIterations

int32 Chaos::CVars::ChaosSolverCollisionVelocityFrictionIterations = -1

◆ ChaosSolverCollisionVelocityShockPropagationIterations

int32 Chaos::CVars::ChaosSolverCollisionVelocityShockPropagationIterations = -1

◆ ChaosSolverCullDistance

FRealSingle Chaos::CVars::ChaosSolverCullDistance = -1.0f

◆ ChaosSolverDebugDrawMeshContacts

int32 Chaos::CVars::ChaosSolverDebugDrawMeshContacts

extern

◆ ChaosSolverDepenetrationVelocity

FRealSingle Chaos::CVars::ChaosSolverDepenetrationVelocity = -1.0f

◆ ChaosSolverDeterministic

int32 Chaos::CVars::ChaosSolverDeterministic = -1

◆ ChaosSolverDrawCCDInteractions

int32 Chaos::CVars::ChaosSolverDrawCCDInteractions

extern

◆ ChaosSolverDrawCCDThresholds

CHAOS_API int32 Chaos::CVars::ChaosSolverDrawCCDThresholds

extern

◆ ChaosSolverInertiaConditioningDistance

FRealSingle Chaos::CVars::ChaosSolverInertiaConditioningDistance = 20

◆ ChaosSolverInertiaConditioningEpoch

int32 Chaos::CVars::ChaosSolverInertiaConditioningEpoch = 0

◆ ChaosSolverInertiaConditioningRotationRatio

FRealSingle Chaos::CVars::ChaosSolverInertiaConditioningRotationRatio = 2.5f

◆ ChaosSolverJointAngleTolerance

FRealSingle Chaos::CVars::ChaosSolverJointAngleTolerance = 0.001f

◆ ChaosSolverJointMaxInertiaRatio

FRealSingle Chaos::CVars::ChaosSolverJointMaxInertiaRatio = 5.0f

◆ ChaosSolverJointMaxSolverStiffness

float Chaos::CVars::ChaosSolverJointMaxSolverStiffness = 1.0f

◆ ChaosSolverJointMinParentMassRatio

FRealSingle Chaos::CVars::ChaosSolverJointMinParentMassRatio = 0.2f

◆ ChaosSolverJointMinSolverStiffness

float Chaos::CVars::ChaosSolverJointMinSolverStiffness = 1.0f

◆ ChaosSolverJointNumIterationsAtMaxSolverStiffness

int32 Chaos::CVars::ChaosSolverJointNumIterationsAtMaxSolverStiffness = 1

◆ ChaosSolverJointNumShockProagationIterations

int32 Chaos::CVars::ChaosSolverJointNumShockProagationIterations = 0

◆ ChaosSolverJointPositionTolerance

FRealSingle Chaos::CVars::ChaosSolverJointPositionTolerance = 0.025f

◆ ChaosSolverJointPriority

int32 Chaos::CVars::ChaosSolverJointPriority = 0

◆ ChaosSolverJointShockPropagation

FRealSingle Chaos::CVars::ChaosSolverJointShockPropagation = -1.0f

◆ ChaosSolverMaxInvInertiaComponentRatio

FRealSingle Chaos::CVars::ChaosSolverMaxInvInertiaComponentRatio = 0

◆ ChaosSolverMaxPushOutVelocity

FRealSingle Chaos::CVars::ChaosSolverMaxPushOutVelocity = -1.0f

◆ ChaosSolverMaxVelocityBoundsExpansion

FRealSingle Chaos::CVars::ChaosSolverMaxVelocityBoundsExpansion = 3.0f

◆ ChaosSolverMaxVelocityBoundsExpansionMACD

FRealSingle Chaos::CVars::ChaosSolverMaxVelocityBoundsExpansionMACD = 1000.0f

◆ ChaosSolverMinMotionlessRatio

FRealSingle Chaos::CVars::ChaosSolverMinMotionlessRatio = 0.1f

Cvar to set the minimum ratio of particles which needs to be motionless to activate partial island sleep.

◆ ChaosSolverMomentumPropagation

FRealSingle Chaos::CVars::ChaosSolverMomentumPropagation = 0.3f

Cvar to enable/disable momentum propagation through the constraint graph (partial island sleeping only)

◆ ChaosSolverParticlePoolNumFrameUntilShrink

int32 Chaos::CVars::ChaosSolverParticlePoolNumFrameUntilShrink = 30

◆ ChaosSolverPositionIterations

int32 Chaos::CVars::ChaosSolverPositionIterations = -1

◆ ChaosSolverPostStepWakeThreshold

FRealSingle Chaos::CVars::ChaosSolverPostStepWakeThreshold = 20.0f

Cvar to adjust post-step waking triggered by velocity solver impulses. The solver impulse is converted to a change in velocity by division by the particle mass. Ideal setting = 20.0f, i.e. change in velocity > 20 will trigger wake of the sleeping particle.

◆ ChaosSolverProjectionIterations

int32 Chaos::CVars::ChaosSolverProjectionIterations = -1

◆ ChaosSolverSleepModeSwitchThreshold

int32 Chaos::CVars::ChaosSolverSleepModeSwitchThreshold = 10

Cvar to set the minimum number of ticks the ratio of motionless particles needs to be exceeded before switching between partial and full island sleep.

◆ ChaosSolverSuspensionPriority

int32 Chaos::CVars::ChaosSolverSuspensionPriority = 0

◆ ChaosSolverUseParticlePool

bool Chaos::CVars::ChaosSolverUseParticlePool = true

◆ ChaosSolverValidateConstraintSleepState

FAutoConsoleVariableRef Chaos::CVars::ChaosSolverValidateConstraintSleepState(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.ValidateConstraintSleepState"), bChaosSolverValidateConstraintSleepState, TEXT("[EXPERIMENTAL] Debugging only: Enable constraint sleep state validation checks/assertions at the end of the tick.[def:false]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.ValidateConstraintSleepState")	,
		bChaosSolverValidateConstraintSleepState	,
		TEXT("[EXPERIMENTAL] Debugging only: Enable constraint sleep state validation checks/assertions at the end of the tick.[def:false]")
	)

◆ ChaosSolverVelocityBoundsMultiplier

FRealSingle Chaos::CVars::ChaosSolverVelocityBoundsMultiplier = 1.0f

◆ ChaosSolverVelocityBoundsMultiplierMACD

FRealSingle Chaos::CVars::ChaosSolverVelocityBoundsMultiplierMACD = 1.0f

◆ ChaosSolverVelocityIterations

int32 Chaos::CVars::ChaosSolverVelocityIterations = -1

◆ ChaosUnionBVHMaxDepth

int32 Chaos::CVars::ChaosUnionBVHMaxDepth = 14

◆ ChaosUnionBVHMinShapes

int32 Chaos::CVars::ChaosUnionBVHMinShapes = 10

◆ ChaosUnionBVHSplitBias

FRealSingle Chaos::CVars::ChaosUnionBVHSplitBias = 0.1f

◆ ChaosVisualDebuggerEnable

int32 Chaos::CVars::ChaosVisualDebuggerEnable = 1

◆ CollisionDisableCulledContacts

int Chaos::CVars::CollisionDisableCulledContacts = 0

◆ CVarCCDAllowedDepthBoundsScale

FAutoConsoleVariableRef Chaos::CVars::CVarCCDAllowedDepthBoundsScale(TEXT("p.Chaos.CCD.AllowedDepthBoundsScale"), CCDAllowedDepthBoundsScale, TEXT("When rolling back to TOI, allow (smallest bound's extent) * AllowedDepthBoundsScale, instead of rolling back to exact TOI w/ penetration = 0."))	(	TEXT("p.Chaos.CCD.AllowedDepthBoundsScale")	,
		CCDAllowedDepthBoundsScale	,
		TEXT("When rolling back to TOI, allow (smallest bound's extent) * AllowedDepthBoundsScale, instead of rolling back to exact TOI w/ penetration = 0.")
	)

◆ CVarCCDAxisThresholdMode

FAutoConsoleVariableRef Chaos::CVars::CVarCCDAxisThresholdMode(TEXT("p.Chaos.CCD.AxisThresholdMode"), CCDAxisThresholdMode, TEXT("Change the mode used to generate CCD axis threshold bounds for particle geometries.\n0: Use object bounds\n1: Find the thinnest object bound on any axis and use it for all CCD axes\n2: On each axis, use the thinnest shape bound on that axis\n3: Find the thinnest shape bound on any axis and use this for all axes"))	(	TEXT("p.Chaos.CCD.AxisThresholdMode")	,
		CCDAxisThresholdMode	,
		TEXT("Change the mode used to generate CCD axis threshold bounds for particle geometries.\n0: Use object bounds\n1: Find the thinnest object bound on any axis and use it for all CCD axes\n2: On each axis, use the thinnest shape bound on that axis\n3: Find the thinnest shape bound on any axis and use this for all axes")
	)

◆ CVarCCDAxisThresholdUsesProbeShapes

FAutoConsoleVariableRef Chaos::CVars::CVarCCDAxisThresholdUsesProbeShapes(TEXT("p.Chaos.CCD.CCDAxisThresholdUsesProbeShapes"), bCCDAxisThresholdUsesProbeShapes, TEXT("When true, probe shapes are considered for CCD axis threshold computation, and can generate contacts in the initial CCD phase."))	(	TEXT("p.Chaos.CCD.CCDAxisThresholdUsesProbeShapes")	,
		bCCDAxisThresholdUsesProbeShapes	,
		TEXT("When true, probe shapes are considered for CCD axis threshold computation, and can generate contacts in the initial CCD phase.")
	)

◆ CVarCCDEnableThresholdBoundsScale

FAutoConsoleVariableRef Chaos::CVars::CVarCCDEnableThresholdBoundsScale(TEXT("p.Chaos.CCD.EnableThresholdBoundsScale"), CCDEnableThresholdBoundsScale, TEXT("CCD is used when object position is changing > smallest bound's extent * BoundsScale. 0 will always Use CCD. Values < 0 disables CCD."))	(	TEXT("p.Chaos.CCD.EnableThresholdBoundsScale")	,
		CCDEnableThresholdBoundsScale	,
		TEXT("CCD is used when object position is changing > smallest bound's extent * BoundsScale. 0 will always Use CCD. Values < 0 disables CCD.")
	)

◆ CVarCCDNewTargetDepthMode

FAutoConsoleVariableRef Chaos::CVars::CVarCCDNewTargetDepthMode(TEXT("p.Chaos.CCD.NewTargetDepthMode"), bCCDNewTargetDepthMode, TEXT("Find the first contact with that results in a penetration of (CCDAllowedDepthBoundsScale*Size) as opposed to the first contact"))	(	TEXT("p.Chaos.CCD.NewTargetDepthMode")	,
		bCCDNewTargetDepthMode	,
		TEXT("Find the first contact with that results in a penetration of (CCDAllowedDepthBoundsScale*Size) as opposed to the first contact")
	)

◆ CVarCCDSweepsUseProbeShapes

FAutoConsoleVariableRef Chaos::CVars::CVarCCDSweepsUseProbeShapes(TEXT("p.Chaos.CCD.CCDSweepsUseProbeShapes"), bCCDSweepsUseProbeShapes, TEXT("When true, probe shapes can be swept for more accurate collision detection."))	(	TEXT("p.Chaos.CCD.CCDSweepsUseProbeShapes")	,
		bCCDSweepsUseProbeShapes	,
		TEXT("When true, probe shapes can be swept for more accurate collision detection.")
	)

◆ CVarChaos_CharacterGroundConstraint_ExternalMovementThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_CharacterGroundConstraint_ExternalMovementThreshold(TEXT("p.Chaos.CharacterGroundConstraint.ExternalMovementThreshold"), Chaos_CharacterGroundConstraint_ExternalMovementThreshold, TEXT("If distance moved is less than this then retain current movement target relative to ground."))	(	TEXT("p.Chaos.CharacterGroundConstraint.ExternalMovementThreshold")	,
		Chaos_CharacterGroundConstraint_ExternalMovementThreshold	,
		TEXT("If distance moved is less than this then retain current movement target relative to ground.")
	)

◆ CVarChaos_CharacterGroundConstraint_InputMovementThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_CharacterGroundConstraint_InputMovementThreshold(TEXT("p.Chaos.CharacterGroundConstraint.InputMovementThreshold"), Chaos_CharacterGroundConstraint_InputMovementThreshold, TEXT("Minimum per frame input movement distance in cm."))	(	TEXT("p.Chaos.CharacterGroundConstraint.InputMovementThreshold")	,
		Chaos_CharacterGroundConstraint_InputMovementThreshold	,
		TEXT("Minimum per frame input movement distance in cm.")
	)

◆ CVarChaos_Collision_CullDistanceReferenceSize

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_Collision_CullDistanceReferenceSize(TEXT("p.Chaos.Collision.CullDistanceReferenceSize"), Chaos_Collision_CullDistanceScaleInverseSize, TEXT(""))	(	TEXT("p.Chaos.Collision.CullDistanceReferenceSize")	,
		Chaos_Collision_CullDistanceScaleInverseSize	,
		TEXT("")
	)

◆ CVarChaos_Collision_EnableShapePairs

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_Collision_EnableShapePairs(TEXT("p.Chaos.Collision.EnableShapePairs"), bChaos_Collision_MidPhase_EnableShapePairs, TEXT(""))	(	TEXT("p.Chaos.Collision.EnableShapePairs")	,
		bChaos_Collision_MidPhase_EnableShapePairs	,
		TEXT("")
	)

◆ CVarChaos_Collision_ForceMACD

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_Collision_ForceMACD(TEXT("p.Chaos.Solver.bChaosForceMACD"), bChaosForceMACD, TEXT("Force all collisions to use MACD for testing"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.bChaosForceMACD")	,
		bChaosForceMACD	,
		TEXT("Force all collisions to use MACD for testing")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaos_Collision_MaxShapePairs

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_Collision_MaxShapePairs(TEXT("p.Chaos.Collision.MaxShapePairs"), Chaos_Collision_MidPhase_MaxShapePairs, TEXT(""))	(	TEXT("p.Chaos.Collision.MaxShapePairs")	,
		Chaos_Collision_MidPhase_MaxShapePairs	,
		TEXT("")
	)

◆ CVarChaos_Collision_MinCullDistanecScale

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_Collision_MinCullDistanecScale(TEXT("p.Chaos.Collision.MinCullDistanceScale"), Chaos_Collision_MinCullDistanceScale, TEXT(""))	(	TEXT("p.Chaos.Collision.MinCullDistanceScale")	,
		Chaos_Collision_MinCullDistanceScale	,
		TEXT("")
	)

◆ CVarChaos_Collision_UseMACD

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_Collision_UseMACD(TEXT("p.Chaos.Solver.UseMACD"), bChaosUseMACD, TEXT("Global flag to turn Movement-Aware Collision Detection (MACD) on or off. Default is true (on)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.UseMACD")	,
		bChaosUseMACD	,
		TEXT("Global flag to turn Movement-Aware Collision Detection (MACD) on or off. Default is true (on)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaos_PBDCollisionSolver_Position_MinInvMassScale

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Position_MinInvMassScale(TEXT("p.Chaos.PBDCollisionSolver.Position.MinInvMassScale"), Chaos_PBDCollisionSolver_Position_MinInvMassScale, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Position.MinInvMassScale")	,
		Chaos_PBDCollisionSolver_Position_MinInvMassScale	,
		TEXT("")
	)

◆ CVarChaos_PBDCollisionSolver_Position_SolveEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Position_SolveEnabled(TEXT("p.Chaos.PBDCollisionSolver.Position.SolveEnabled"), bChaos_PBDCollisionSolver_Position_SolveEnabled, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Position.SolveEnabled")	,
		bChaos_PBDCollisionSolver_Position_SolveEnabled	,
		TEXT("")
	)

◆ CVarChaos_PBDCollisionSolver_Position_StaticFrictionStiffness

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Position_StaticFrictionStiffness(TEXT("p.Chaos.PBDCollisionSolver.Position.StaticFriction.Stiffness"), Chaos_PBDCollisionSolver_Position_StaticFrictionStiffness, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Position.StaticFriction.Stiffness")	,
		Chaos_PBDCollisionSolver_Position_StaticFrictionStiffness	,
		TEXT("")
	)

◆ CVarChaos_PBDCollisionSolver_Velocity_AveragePointEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Velocity_AveragePointEnabled(TEXT("p.Chaos.PBDCollisionSolver.Velocity.AveragePointEnabled"), bChaos_PBDCollisionSolver_Velocity_AveragePointEnabled, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Velocity.AveragePointEnabled")	,
		bChaos_PBDCollisionSolver_Velocity_AveragePointEnabled	,
		TEXT("")
	)

◆ CVarChaos_PBDCollisionSolver_Velocity_FrictionEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Velocity_FrictionEnabled(TEXT("p.Chaos.PBDCollisionSolver.Velocity.FrictionEnabled"), bChaos_PBDCollisionSolver_Velocity_FrictionEnabled, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Velocity.FrictionEnabled")	,
		bChaos_PBDCollisionSolver_Velocity_FrictionEnabled	,
		TEXT("")
	)

◆ CVarChaos_PBDCollisionSolver_Velocity_MinInvMassScale

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Velocity_MinInvMassScale(TEXT("p.Chaos.PBDCollisionSolver.Velocity.MinInvMassScale"), Chaos_PBDCollisionSolver_Velocity_MinInvMassScale, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Velocity.MinInvMassScale")	,
		Chaos_PBDCollisionSolver_Velocity_MinInvMassScale	,
		TEXT("")
	)

◆ CVarChaos_PBDCollisionSolver_Velocity_SolveEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Velocity_SolveEnabled(TEXT("p.Chaos.PBDCollisionSolver.Velocity.SolveEnabled"), bChaos_PBDCollisionSolver_Velocity_SolveEnabled, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Velocity.SolveEnabled")	,
		bChaos_PBDCollisionSolver_Velocity_SolveEnabled	,
		TEXT("")
	)

◆ CVarChaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness

FAutoConsoleVariableRef Chaos::CVars::CVarChaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness(TEXT("p.Chaos.PBDCollisionSolver.Velocity.StaticFriction.Stiffness"), Chaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.Velocity.StaticFriction.Stiffness")	,
		Chaos_PBDCollisionSolver_Velocity_StaticFrictionStiffness	,
		TEXT("")
	)

◆ CVarChaosCollisionCCDAllowClipping

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionCCDAllowClipping(TEXT("p.Chaos.Collision.CCD.AllowClipping"), bChaosCollisionCCDAllowClipping, TEXT("This will clip the CCD object at colliding positions when computation budgets run out. Default is true. Turning this option off might cause tunneling."))	(	TEXT("p.Chaos.Collision.CCD.AllowClipping")	,
		bChaosCollisionCCDAllowClipping	,
		TEXT("This will clip the CCD object at colliding positions when computation budgets run out. Default is true. Turning this option off might cause tunneling.")
	)

◆ CVarChaosCollisionCCDConstraintMaxProcessCount

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionCCDConstraintMaxProcessCount(TEXT("p.Chaos.Collision.CCD.ConstraintMaxProcessCount"), ChaosCollisionCCDConstraintMaxProcessCount, TEXT("The max number of times each constraint can be resolved when applying CCD constraints. Default is 2. The larger this number is, the more fully CCD constraints are resolved."))	(	TEXT("p.Chaos.Collision.CCD.ConstraintMaxProcessCount")	,
		ChaosCollisionCCDConstraintMaxProcessCount	,
		TEXT("The max number of times each constraint can be resolved when applying CCD constraints. Default is 2. The larger this number is, the more fully CCD constraints are resolved.")
	)

◆ CVarChaosCollisionCCDCorrectionIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionCCDCorrectionIterations(TEXT("p.Chaos.Collision.CCD.CorrectionIterations"), ChaosCollisionCCDCorrectionIterations, TEXT("The number of post-solve CCD correction ietaryions to run."))	(	TEXT("p.Chaos.Collision.CCD.CorrectionIterations")	,
		ChaosCollisionCCDCorrectionIterations	,
		TEXT("The number of post-solve CCD correction ietaryions to run.")
	)

◆ CVarChaosCollisionCCDCorrectionPhiToleranceScale

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionCCDCorrectionPhiToleranceScale(TEXT("p.Chaos.Collision.CCD.CorrectionPhiToleranceScale"), ChaosCollisionCCDCorrectionPhiToleranceScale, TEXT("How much penetration we allow during the correction phase (multiplier on shape size)"))	(	TEXT("p.Chaos.Collision.CCD.CorrectionPhiToleranceScale")	,
		ChaosCollisionCCDCorrectionPhiToleranceScale	,
		TEXT("How much penetration we allow during the correction phase (multiplier on shape size)")
	)

◆ CVarChaosCollisionCCDEnableResweep

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionCCDEnableResweep(TEXT("p.Chaos.Collision.CCD.EnableResweep"), bChaosCollisionCCDEnableResweep, TEXT("Enable resweep for CCD. Resweeping allows CCD to catch more secondary collisions but also is more costly. Default is true."))	(	TEXT("p.Chaos.Collision.CCD.EnableResweep")	,
		bChaosCollisionCCDEnableResweep	,
		TEXT("Enable resweep for CCD. Resweeping allows CCD to catch more secondary collisions but also is more costly. Default is true.")
	)

◆ CVarChaosCollisionCCDUseTightBoundingBox

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionCCDUseTightBoundingBox(TEXT("p.Chaos.Collision.CCD.UseTightBoundingBox"), bChaosCollisionCCDUseTightBoundingBox, TEXT(""))	(	TEXT("p.Chaos.Collision.CCD.UseTightBoundingBox")	,
		bChaosCollisionCCDUseTightBoundingBox	,
		TEXT("")
	)

◆ CVarChaosCollisionEnableInitialDepentration

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionEnableInitialDepentration(TEXT("p.Chaos.PBDCollisionSolver.EnableInitialDepenetration"), bChaos_Collision_EnableInitialDepenetration, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.EnableInitialDepenetration")	,
		bChaos_Collision_EnableInitialDepenetration	,
		TEXT("")
	)

◆ CVarChaosCollisionEnableSoftCollisions

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionEnableSoftCollisions(TEXT("p.Chaos.PBDCollisionSolver.EnableSoftCollisions"), bChaos_Collision_EnableSoftCollisions, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.EnableSoftCollisions")	,
		bChaos_Collision_EnableSoftCollisions	,
		TEXT("")
	)

◆ CVarChaosCollisionMaxSolverManifoldPoints

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionMaxSolverManifoldPoints(TEXT("p.Chaos.PBDCollisionSolver.MaxManifoldPoints"), Chaos_Collision_MaxSolverManifoldPoints, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.MaxManifoldPoints")	,
		Chaos_Collision_MaxSolverManifoldPoints	,
		TEXT("")
	)

◆ CVarChaosCollisionModiferBeforeCCD

FAutoConsoleVariableRef Chaos::CVars::CVarChaosCollisionModiferBeforeCCD(TEXT("p.Chaos.Solver.CollisionModifiersBeforeCCD"), bChaosCollisionModiferBeforeCCD, TEXT("True: run the collision modifiers before CCD rewind is applied; False(default): run modifiers after CCD rewind. See comments in code."))	(	TEXT("p.Chaos.Solver.CollisionModifiersBeforeCCD")	,
		bChaosCollisionModiferBeforeCCD	,
		TEXT("True: run the collision modifiers before CCD rewind is applied; False(default): run modifiers after CCD rewind. See comments in code.")
	)

◆ CVarChaosConstraintGraphValidate

FAutoConsoleVariableRef Chaos::CVars::CVarChaosConstraintGraphValidate(TEXT("p.Chaos.ConstraintGraph.Validate"), bChaosConstraintGraphValidate, TEXT("Enable per-tick ConstraintGraph validation checks/assertions"))	(	TEXT("p.Chaos.ConstraintGraph.Validate")	,
		bChaosConstraintGraphValidate	,
		TEXT("Enable per-tick ConstraintGraph validation checks/assertions")
	)

◆ CVarChaosConvexDynamicMode

FAutoConsoleVariableRef Chaos::CVars::CVarChaosConvexDynamicMode(TEXT("p.Chaos.Convex.DynamicMode"), ChaosConvexDynamicMode, TEXT("Simplification mode for the dynamic shapes (0: Single Convex, 1: One convex per children, 2: Merge connected children using the splitting threshold)"))	(	TEXT("p.Chaos.Convex.DynamicMode")	,
		ChaosConvexDynamicMode	,
		TEXT("Simplification mode for the dynamic shapes (0: Single Convex, 1: One convex per children, 2: Merge connected children using the splitting threshold)")
	)

◆ CVarChaosConvexEnableMerging

FAutoConsoleVariableRef Chaos::CVars::CVarChaosConvexEnableMerging(TEXT("p.Chaos.Convex.EnableMerging"), ChaosConvexEnableMerging, TEXT("Boolean to check if we are merging (bottom-up) or splitting (top-bottom) the convexes"))	(	TEXT("p.Chaos.Convex.EnableMerging")	,
		ChaosConvexEnableMerging	,
		TEXT("Boolean to check if we are merging (bottom-up) or splitting (top-bottom) the convexes")
	)

◆ CVarChaosConvexKinematicMode

FAutoConsoleVariableRef Chaos::CVars::CVarChaosConvexKinematicMode(TEXT("p.Chaos.Convex.KinematicMode"), ChaosConvexKinematicMode, TEXT("Simplification mode for the kinematic shapes (0: Single Convex, 1: One convex per children, 2: Merge connected children using the splitting threshold"))	(	TEXT("p.Chaos.Convex.KinematicMode")	,
		ChaosConvexKinematicMode
	)

◆ CVarChaosConvexMinVolume

FAutoConsoleVariableRef Chaos::CVars::CVarChaosConvexMinVolume(TEXT("p.Chaos.Convex.MinVolume"), ChaosConvexMinVolume, TEXT("Min volume of the simplified convexes"))	(	TEXT("p.Chaos.Convex.MinVolume")	,
		ChaosConvexMinVolume	,
		TEXT("Min volume of the simplified convexes")
	)

◆ CVarChaosConvexSplittingThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaosConvexSplittingThreshold(TEXT("p.Chaos.Convex.SplittingThreshold"), ChaosConvexSplittingThreshold, TEXT("Tribox volume / convex hull threshold to trigger a volume splitting during tree construction"))	(	TEXT("p.Chaos.Convex.SplittingThreshold")	,
		ChaosConvexSplittingThreshold	,
		TEXT("Tribox volume / convex hull threshold to trigger a volume splitting during tree construction")
	)

◆ CVarChaosConvexUseDirectOverlap

FAutoConsoleVariableRef Chaos::CVars::CVarChaosConvexUseDirectOverlap(TEXT("p.Chaos.Convex.UseDirectOverlap"), ChaosConvexUseDirectOverlap, TEXT("Boolean to check if we can use direct overlap test against the bounds"))	(	TEXT("p.Chaos.Convex.UseDirectOverlap")	,
		ChaosConvexUseDirectOverlap	,
		TEXT("Boolean to check if we can use direct overlap test against the bounds")
	)

◆ CVarChaosEnableOverrideSingleParticleTypeToCluster

FAutoConsoleVariableRef Chaos::CVars::CVarChaosEnableOverrideSingleParticleTypeToCluster(TEXT("p.Chaos.EnableOverrideSingleParticleTypeToCluster"), bChaosEnableOverrideSingleParticleTypeToCluster, TEXT("When enabled particles are promoted to cluster type so they may be used with cluster unions"))	(	TEXT("p.Chaos.EnableOverrideSingleParticleTypeToCluster")	,
		bChaosEnableOverrideSingleParticleTypeToCluster	,
		TEXT("When enabled particles are promoted to cluster type so they may be used with cluster unions")
	)

◆ CVarChaosIgnoreOneWayPairCollisions

FAutoConsoleVariableRef Chaos::CVars::CVarChaosIgnoreOneWayPairCollisions(TEXT("p.Chaos.Solver.OneWayPairCollisionMode"), ChaosOneWayInteractionPairCollisionMode, TEXT("How to treat collisions between two one-way interaction particles. See EOneWayInteractionPairCollisionMode (0: Ignore collisions; 1: Collide as normal; 2: Collide as spheres)"))	(	TEXT("p.Chaos.Solver.OneWayPairCollisionMode")	,
		ChaosOneWayInteractionPairCollisionMode	,
		TEXT("How to treat collisions between two one-way interaction particles. See EOneWayInteractionPairCollisionMode (0: Ignore collisions; 1: Collide as normal; 2: Collide as spheres)")
	)

◆ CVarChaosImmPhysUseSimdForLinearSolver

FAutoConsoleVariableRef Chaos::CVars::CVarChaosImmPhysUseSimdForLinearSolver(TEXT("p.Chaos.Solver.Joint.UseSimd"), bChaosRigids_UseSimdForJointsSolver, TEXT("Enable/Disable SIMD on the linear joint solver"))	(	TEXT("p.Chaos.Solver.Joint.UseSimd")	,
		bChaosRigids_UseSimdForJointsSolver	,
		TEXT("Enable/Disable SIMD on the linear joint solver")
	)

◆ CVarChaosImplicitBVHOptimizedCountLeafObjects

FAutoConsoleVariableRef Chaos::CVars::CVarChaosImplicitBVHOptimizedCountLeafObjects(TEXT("p.Chaos.Collision.UnionBVH.UseOptimizedCountLeafObjects"), bChaosImplicitBVHOptimizedCountLeafObjects, TEXT(""))	(	TEXT("p.Chaos.Collision.UnionBVH.UseOptimizedCountLeafObjects")	,
		bChaosImplicitBVHOptimizedCountLeafObjects	,
		TEXT("")
	)

◆ CVarChaosMeshContactGeneratorFixContactNormalFixEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaosMeshContactGeneratorFixContactNormalFixEnabled(TEXT("p.Chaos.MeshContactGenerator.FixContactNormal.FixEnabled"), bMeshContactGeneratorFixContactNormalFixEnabled, TEXT("Until new code path is well tested"))	(	TEXT("p.Chaos.MeshContactGenerator.FixContactNormal.FixEnabled")	,
		bMeshContactGeneratorFixContactNormalFixEnabled	,
		TEXT("Until new code path is well tested")
	)

◆ CVarChaosMidPhaseActivateWakingConstraints

FAutoConsoleVariableRef Chaos::CVars::CVarChaosMidPhaseActivateWakingConstraints(TEXT("p.Chaos.Bugs.ActivateWakingConstraints"), bChaosMidPhaseActivateWakingConstraints, TEXT(""))	(	TEXT("p.Chaos.Bugs.ActivateWakingConstraints")	,
		bChaosMidPhaseActivateWakingConstraints	,
		TEXT("")
	)

◆ CVarChaosMidPhaseModifierConvexOptimizerFix

FAutoConsoleVariableRef Chaos::CVars::CVarChaosMidPhaseModifierConvexOptimizerFix(TEXT("p.Chaos.Bugs.MidPhaseModifierConvexOptimizerFix"), bChaosMidPhaseModifierConvexOptimizerFix, TEXT(""))	(	TEXT("p.Chaos.Bugs.MidPhaseModifierConvexOptimizerFix")	,
		bChaosMidPhaseModifierConvexOptimizerFix	,
		TEXT("")
	)

◆ CVarChaosOneWayPairSphereRadiusAlpha

FAutoConsoleVariableRef Chaos::CVars::CVarChaosOneWayPairSphereRadiusAlpha(TEXT("p.Chaos.Solver.OneWayPairSphereRadiusAlpha"), ChaosOneWayPairSphereRadiusAlpha, TEXT("If one-way interactions are treated as spheres, the diameter is lerp(Size.Min, Size.Max, RadiusAlpha)"))	(	TEXT("p.Chaos.Solver.OneWayPairSphereRadiusAlpha")	,
		ChaosOneWayPairSphereRadiusAlpha	,
		TEXT("If one-way interactions are treated as spheres, the diameter is lerp(Size.Min, Size.Max, RadiusAlpha)")
	)

◆ CVarChaosPBDCollisionSolverAutoStiffnessMassRatio1

FAutoConsoleVariableRef Chaos::CVars::CVarChaosPBDCollisionSolverAutoStiffnessMassRatio1(TEXT("p.Chaos.PBDCollisionSolver.AutoStiffness.MassRatio1"), Chaos_PBDCollisionSolver_AutoStiffness_MassRatio1, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.AutoStiffness.MassRatio1")	,
		Chaos_PBDCollisionSolver_AutoStiffness_MassRatio1	,
		TEXT("")
	)

◆ CVarChaosPBDCollisionSolverAutoStiffnessMassRatio2

FAutoConsoleVariableRef Chaos::CVars::CVarChaosPBDCollisionSolverAutoStiffnessMassRatio2(TEXT("p.Chaos.PBDCollisionSolver.AutoStiffness.MassRatio2"), Chaos_PBDCollisionSolver_AutoStiffness_MassRatio2, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.AutoStiffness.MassRatio2")	,
		Chaos_PBDCollisionSolver_AutoStiffness_MassRatio2	,
		TEXT("")
	)

◆ CVarChaosPBDCollisionSolverJacobiPositionTolerance

FAutoConsoleVariableRef Chaos::CVars::CVarChaosPBDCollisionSolverJacobiPositionTolerance(TEXT("p.Chaos.PBDCollisionSolver.JacobiPositionTolerance"), Chaos_PBDCollisionSolver_JacobiPositionTolerance, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.JacobiPositionTolerance")	,
		Chaos_PBDCollisionSolver_JacobiPositionTolerance	,
		TEXT("")
	)

◆ CVarChaosPBDCollisionSolverJacobiRotationTolerance

FAutoConsoleVariableRef Chaos::CVars::CVarChaosPBDCollisionSolverJacobiRotationTolerance(TEXT("p.Chaos.PBDCollisionSolver.JacobiRotationTolerance"), Chaos_PBDCollisionSolver_JacobiRotationTolerance, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.JacobiRotationTolerance")	,
		Chaos_PBDCollisionSolver_JacobiRotationTolerance	,
		TEXT("")
	)

◆ CVarChaosPBDCollisionSolverJacobiStiffness

FAutoConsoleVariableRef Chaos::CVars::CVarChaosPBDCollisionSolverJacobiStiffness(TEXT("p.Chaos.PBDCollisionSolver.JacobiStiffness"), Chaos_PBDCollisionSolver_JacobiStiffness, TEXT(""))	(	TEXT("p.Chaos.PBDCollisionSolver.JacobiStiffness")	,
		Chaos_PBDCollisionSolver_JacobiStiffness	,
		TEXT("")
	)

◆ CVarChaosRandomizeConstraintOrder

FAutoConsoleVariableRef Chaos::CVars::CVarChaosRandomizeConstraintOrder(TEXT("p.Chaos.Solver.RandomizeConstraintOrder"), bChaosRandomizeConstraintOrder, TEXT("Randomize constraint order for testing"))	(	TEXT("p.Chaos.Solver.RandomizeConstraintOrder")	,
		bChaosRandomizeConstraintOrder	,
		TEXT("Randomize constraint order for testing")
	)

◆ CVarChaosRemoveParticleFromMovingKinematicsOnDisable

FAutoConsoleVariableRef Chaos::CVars::CVarChaosRemoveParticleFromMovingKinematicsOnDisable(TEXT("p.Chaos.RemoveParticleFromMovingKinematicsOnDisable"), bRemoveParticleFromMovingKinematicsOnDisable, TEXT(""))	(	TEXT("p.Chaos.RemoveParticleFromMovingKinematicsOnDisable")	,
		bRemoveParticleFromMovingKinematicsOnDisable	,
		TEXT("")
	)

◆ CVarChaosSimplifyUnion

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSimplifyUnion(TEXT("p.Chaos.Convex.SimplifyUnion"), bChaosConvexSimplifyUnion, TEXT("If true replace all the convexes within an implcit hierarchy with a simplified one (kdop18 tribox for now) for collision"))	(	TEXT("p.Chaos.Convex.SimplifyUnion")	,
		bChaosConvexSimplifyUnion	,
		TEXT("If true replace all the convexes within an implcit hierarchy with a simplified one (kdop18 tribox for now) for collision")
	)

◆ CVarChaosSingleThreadPushData

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSingleThreadPushData(TEXT("p.Chaos.SingleThreadPushData"), bSingleThreadPushData, TEXT("Run push Data in Single Thread."))	(	TEXT("p.Chaos.SingleThreadPushData")	,
		bSingleThreadPushData	,
		TEXT("Run push Data in Single Thread.")
	)

◆ CVarChaosSolverAngularWakeThresholdMultiplier

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverAngularWakeThresholdMultiplier(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.AngularWakeThresholdMultiplier"), AngularPartialWakeThresholdMultiplier, TEXT("[EXPERIMENTAL] A multiplier applied to AngularSleepThreshold for particle waking.[def:10]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.AngularWakeThresholdMultiplier")	,
		AngularPartialWakeThresholdMultiplier	,
		TEXT("[EXPERIMENTAL] A multiplier applied to AngularSleepThreshold for particle waking.[def:10]")
	)

◆ CVarChaosSolverArrayCollectionMaxSlackFraction

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverArrayCollectionMaxSlackFraction(TEXT("p.Chaos.ArrayCollection.MaxSlackFraction"), ChaosArrayCollectionMaxSlackFraction, TEXT("Shrink particle arrays if the number of slack elements exceeds the number of elements by this fraction"))	(	TEXT("p.Chaos.ArrayCollection.MaxSlackFraction")	,
		ChaosArrayCollectionMaxSlackFraction	,
		TEXT("Shrink particle arrays if the number of slack elements exceeds the number of elements by this fraction")
	)

◆ CVarChaosSolverArrayCollectionMinSlack

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverArrayCollectionMinSlack(TEXT("p.Chaos.ArrayCollection.MinSlack"), ChaosArrayCollectionMinSlack, TEXT("Do not reduce the size of particle arrays if it would leave less slack than this"))	(	TEXT("p.Chaos.ArrayCollection.MinSlack")	,
		ChaosArrayCollectionMinSlack	,
		TEXT("Do not reduce the size of particle arrays if it would leave less slack than this")
	)

◆ CVarChaosSolverChaosCharacterGroundConstraintPriority

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverChaosCharacterGroundConstraintPriority(TEXT("p.Chaos.Solver.CharacterGroundConstraint.Priority"), ChaosSolverCharacterGroundConstraintPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))	(	TEXT("p.Chaos.Solver.CharacterGroundConstraint.Priority")	,
		ChaosSolverCharacterGroundConstraintPriority	,
		TEXT("Set constraint priority. Larger values are evaluated later [def:0]")
	)

◆ CVarChaosSolverCheckParticleViews

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCheckParticleViews(TEXT("p.Chaos.Solver.CheckParticleViews"), bChaosSolverCheckParticleViews, TEXT(""))	(	TEXT("p.Chaos.Solver.CheckParticleViews")	,
		bChaosSolverCheckParticleViews	,
		TEXT("")
	)

◆ CVarChaosSolverCleanupCommandsOnDestruction

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCleanupCommandsOnDestruction(TEXT("p.Chaos.Solver.CleanupCommandsOnDestruction"), ChaosSolverCleanupCommandsOnDestruction, TEXT("Whether or not to run internal command queue cleanup on solver destruction (0 = no cleanup, >0 = cleanup all commands)"))	(	TEXT("p.Chaos.Solver.CleanupCommandsOnDestruction")	,
		ChaosSolverCleanupCommandsOnDestruction	,
		TEXT("Whether or not to run internal command queue cleanup on solver destruction (0 = no cleanup, >0 = cleanup all commands)")
	)

◆ CVarChaosSolverCollisionAllowManifoldUpdate

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionAllowManifoldUpdate(TEXT("p.Chaos.Solver.Collision.AllowManifoldUpdate"), ChaosSolverCollisionAllowManifoldUpdate, TEXT("Enable/Disable reuse of manifolds between ticks (for small movement)."))	(	TEXT("p.Chaos.Solver.Collision.AllowManifoldUpdate")	,
		ChaosSolverCollisionAllowManifoldUpdate	,
		TEXT("Enable/Disable reuse of manifolds between ticks (for small movement).")
	)

◆ CVarChaosSolverCollisionAngularSleepThresholdSize

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionAngularSleepThresholdSize(TEXT("p.Chaos.Solver.Sleep.AngularSleepThresholdSize"), ChaosSolverCollisionAngularSleepThresholdSize, TEXT("Scales the angular threshold based on size (0 to disable size based scaling)"))	(	TEXT("p.Chaos.Solver.Sleep.AngularSleepThresholdSize")	,
		ChaosSolverCollisionAngularSleepThresholdSize	,
		TEXT("Scales the angular threshold based on size (0 to disable size based scaling)")
	)

◆ CVarChaosSolverCollisionDefaultAngularSleepThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionDefaultAngularSleepThreshold(TEXT("p.Chaos.Solver.Sleep.Defaults.AngularSleepThreshold"), ChaosSolverCollisionDefaultAngularSleepThreshold, TEXT("Default angular threshold for sleeping.[def:0.0087]"))	(	TEXT("p.Chaos.Solver.Sleep.Defaults.AngularSleepThreshold")	,
		ChaosSolverCollisionDefaultAngularSleepThreshold	,
		TEXT("Default angular threshold for sleeping.[def:0.0087]")
	)

◆ CVarChaosSolverCollisionDefaultLinearSleepThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionDefaultLinearSleepThreshold(TEXT("p.Chaos.Solver.Sleep.Defaults.LinearSleepThreshold"), ChaosSolverCollisionDefaultLinearSleepThreshold, TEXT("Default linear threshold for sleeping.[def:0.001]"))	(	TEXT("p.Chaos.Solver.Sleep.Defaults.LinearSleepThreshold")	,
		ChaosSolverCollisionDefaultLinearSleepThreshold	,
		TEXT("Default linear threshold for sleeping.[def:0.001]")
	)

◆ CVarChaosSolverCollisionDefaultSleepCounterThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionDefaultSleepCounterThreshold(TEXT("p.Chaos.Solver.Sleep.Defaults.SleepCounterThreshold"), ChaosSolverCollisionDefaultSleepCounterThreshold, TEXT("Default counter threshold for sleeping.[def:20]"))	(	TEXT("p.Chaos.Solver.Sleep.Defaults.SleepCounterThreshold")	,
		ChaosSolverCollisionDefaultSleepCounterThreshold	,
		TEXT("Default counter threshold for sleeping.[def:20]")
	)

◆ CVarChaosSolverCollisionDeferNarrowPhase

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionDeferNarrowPhase(TEXT("p.Chaos.Solver.Collision.DeferNarrowPhase"), ChaosSolverCollisionDeferNarrowPhase, TEXT("Create contacts for all broadphase pairs, perform NarrowPhase later."))	(	TEXT("p.Chaos.Solver.Collision.DeferNarrowPhase")	,
		ChaosSolverCollisionDeferNarrowPhase	,
		TEXT("Create contacts for all broadphase pairs, perform NarrowPhase later.")
	)

◆ CVarChaosSolverCollisionDisable

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionDisable(TEXT("p.Chaos.Solver.Collision.Enabled"), bChaosSolverCollisionEnabled, TEXT("Enable/Disable collisions in the main scene."))	(	TEXT("p.Chaos.Solver.Collision.Enabled")	,
		bChaosSolverCollisionEnabled	,
		TEXT("Enable/Disable collisions in the main scene.")
	)

◆ CVarChaosSolverCollisionPositionFrictionIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionPositionFrictionIterations(TEXT("p.Chaos.Solver.Collision.PositionFrictionIterations"), ChaosSolverCollisionPositionFrictionIterations, TEXT("Override number of position iterations where friction is applied (if >= 0)"))	(	TEXT("p.Chaos.Solver.Collision.PositionFrictionIterations")	,
		ChaosSolverCollisionPositionFrictionIterations	,
		TEXT("Override number of position iterations where friction is applied (if >= 0)")
	)

◆ CVarChaosSolverCollisionPositionShockPropagationIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionPositionShockPropagationIterations(TEXT("p.Chaos.Solver.Collision.PositionShockPropagationIterations"), ChaosSolverCollisionPositionShockPropagationIterations, TEXT("Override number of position iterations where shock propagation is applied (if >= 0)"))	(	TEXT("p.Chaos.Solver.Collision.PositionShockPropagationIterations")	,
		ChaosSolverCollisionPositionShockPropagationIterations	,
		TEXT("Override number of position iterations where shock propagation is applied (if >= 0)")
	)

◆ CVarChaosSolverCollisionPriority

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionPriority(TEXT("p.Chaos.Solver.Collision.Priority"), ChaosSolverCollisionPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))	(	TEXT("p.Chaos.Solver.Collision.Priority")	,
		ChaosSolverCollisionPriority	,
		TEXT("Set constraint priority. Larger values are evaluated later [def:0]")
	)

◆ CVarChaosSolverCollisionSolverType

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionSolverType(TEXT("p.Chaos.Solver.Collision.SolverType"), ChaosSolverCollisionSolverType, TEXT("-1: Use default (Gauss Seidel); 0: Gauss Seidel; 1: Gauss Seidel SOA 2: Partial Jacobi"))	(	TEXT("p.Chaos.Solver.Collision.SolverType")	,
		ChaosSolverCollisionSolverType	,
		TEXT("-1: Use default (Gauss Seidel); 0: Gauss Seidel; 1: Gauss Seidel SOA 2: Partial Jacobi")
	)

◆ CVarChaosSolverCollisionUseManifolds

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionUseManifolds(TEXT("p.Chaos.Solver.Collision.UseManifolds"), ChaosSolverCollisionUseManifolds, TEXT("Enable/Disable use of manifolds in collision."))	(	TEXT("p.Chaos.Solver.Collision.UseManifolds")	,
		ChaosSolverCollisionUseManifolds	,
		TEXT("Enable/Disable use of manifolds in collision.")
	)

◆ CVarChaosSolverCollisionVelocityFrictionIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionVelocityFrictionIterations(TEXT("p.Chaos.Solver.Collision.VelocityFrictionIterations"), ChaosSolverCollisionVelocityFrictionIterations, TEXT("Override number of velocity iterations where friction is applied (if >= 0)"))	(	TEXT("p.Chaos.Solver.Collision.VelocityFrictionIterations")	,
		ChaosSolverCollisionVelocityFrictionIterations	,
		TEXT("Override number of velocity iterations where friction is applied (if >= 0)")
	)

◆ CVarChaosSolverCollisionVelocityShockPropagationIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCollisionVelocityShockPropagationIterations(TEXT("p.Chaos.Solver.Collision.VelocityShockPropagationIterations"), ChaosSolverCollisionVelocityShockPropagationIterations, TEXT("Override number of velocity iterations where shock propagation is applied (if >= 0)"))	(	TEXT("p.Chaos.Solver.Collision.VelocityShockPropagationIterations")	,
		ChaosSolverCollisionVelocityShockPropagationIterations	,
		TEXT("Override number of velocity iterations where shock propagation is applied (if >= 0)")
	)

◆ CVarChaosSolverComputeIterationSettingsEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverComputeIterationSettingsEnabled(TEXT("p.Chaos.Solver.ComputeIterationSettings.Enabled"), bChaosSolverComputeIterationSettings, TEXT("Recompute iteration settings every time an island is changed"))	(	TEXT("p.Chaos.Solver.ComputeIterationSettings.Enabled")	,
		bChaosSolverComputeIterationSettings	,
		TEXT("Recompute iteration settings every time an island is changed")
	)

◆ CVarChaosSolverCullDistance

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverCullDistance(TEXT("p.Chaos.Solver.Collision.CullDistance"), ChaosSolverCullDistance, TEXT("Override cull distance (if >= 0)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.Collision.CullDistance")	,
		ChaosSolverCullDistance	,
		TEXT("Override cull distance (if >= 0)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosSolverDeterministic

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverDeterministic(TEXT("p.Chaos.Solver.Deterministic"), ChaosSolverDeterministic, TEXT("Override determinism. 0: disabled; 1: enabled; -1: use config"))	(	TEXT("p.Chaos.Solver.Deterministic")	,
		ChaosSolverDeterministic	,
		TEXT("Override determinism. 0: disabled; 1: enabled; -1: use config")
	)

◆ CVarChaosSolverForcePartialIslandWake

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverForcePartialIslandWake(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.ForcePartialIslandWake"), bChaosSolverForcePartialIslandWake, TEXT("[EXPERIMENTAL] Safeguard only: We force partial wake events even if all particles in the island are already awake to guarantee resetting the particle sleep counter.[def:false]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.ForcePartialIslandWake")	,
		bChaosSolverForcePartialIslandWake	,
		TEXT("[EXPERIMENTAL] Safeguard only: We force partial wake events even if all particles in the island are already awake to guarantee resetting the particle sleep counter.[def:false]")
	)

◆ CVarChaosSolverInertiaConditioningDistance

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverInertiaConditioningDistance(TEXT("p.Chaos.Solver.InertiaConditioning.Distance"), ChaosSolverInertiaConditioningDistance, TEXT("An input to inertia conditioning system. The joint distance error which needs to be stable (generate a low rotation)."), OnInertiaConditioningCVarChangedDelegate)	(	TEXT("p.Chaos.Solver.InertiaConditioning.Distance")	,
		ChaosSolverInertiaConditioningDistance	,
		TEXT("An input to inertia conditioning system. The joint distance error which needs to be stable (generate a low rotation).")	,
		OnInertiaConditioningCVarChangedDelegate
	)

◆ CVarChaosSolverInertiaConditioningEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverInertiaConditioningEnabled(TEXT("p.Chaos.Solver.InertiaConditioning.Enabled"), bChaosSolverInertiaConditioningEnabled, TEXT("Enable/Disable constraint stabilization through inertia conditioning"), OnInertiaConditioningCVarChangedDelegate)	(	TEXT("p.Chaos.Solver.InertiaConditioning.Enabled")	,
		bChaosSolverInertiaConditioningEnabled	,
		TEXT("Enable/Disable constraint stabilization through inertia conditioning")	,
		OnInertiaConditioningCVarChangedDelegate
	)

◆ CVarChaosSolverInertiaConditioningMaxInvInertiaComponentRatio

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverInertiaConditioningMaxInvInertiaComponentRatio(TEXT("p.Chaos.Solver.InertiaConditioning.MaxInvInertiaComponentRatio"), ChaosSolverMaxInvInertiaComponentRatio, TEXT("An input to inertia conditioning system. The largest inertia component must be at least least multiple of the smallest component"), OnInertiaConditioningCVarChangedDelegate)	(	TEXT("p.Chaos.Solver.InertiaConditioning.MaxInvInertiaComponentRatio")	,
		ChaosSolverMaxInvInertiaComponentRatio	,
		TEXT("An input to inertia conditioning system. The largest inertia component must be at least least multiple of the smallest component")	,
		OnInertiaConditioningCVarChangedDelegate
	)

◆ CVarChaosSolverInertiaConditioningRotationRatio

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverInertiaConditioningRotationRatio(TEXT("p.Chaos.Solver.InertiaConditioning.RotationRatio"), ChaosSolverInertiaConditioningRotationRatio, TEXT("An input to inertia conditioning system. The maximum ratio of joint correction from rotation versus translation"), OnInertiaConditioningCVarChangedDelegate)	(	TEXT("p.Chaos.Solver.InertiaConditioning.RotationRatio")	,
		ChaosSolverInertiaConditioningRotationRatio	,
		TEXT("An input to inertia conditioning system. The maximum ratio of joint correction from rotation versus translation")	,
		OnInertiaConditioningCVarChangedDelegate
	)

◆ CVarChaosSolverInitialOverlapDepentrationVelocity

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverInitialOverlapDepentrationVelocity(TEXT("p.Chaos.Solver.Collision.DepenetrationVelocity"), ChaosSolverDepenetrationVelocity, TEXT("Override initial overlap depenetration velocity (if >= 0)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.Collision.DepenetrationVelocity")	,
		ChaosSolverDepenetrationVelocity	,
		TEXT("Override initial overlap depenetration velocity (if >= 0)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosSolverIsolatedParticleSleepAngularThresholdMultiplier

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverIsolatedParticleSleepAngularThresholdMultiplier(TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.AngularMultiplier"), IsolatedParticleSleepAngularThresholdMultiplier, TEXT("A multiplier applied to SleepAngularThreshold for floating particles"))	(	TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.AngularMultiplier")	,
		IsolatedParticleSleepAngularThresholdMultiplier	,
		TEXT("A multiplier applied to SleepAngularThreshold for floating particles")
	)

◆ CVarChaosSolverIsolatedParticleSleepCounterThresholdMultiplier

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverIsolatedParticleSleepCounterThresholdMultiplier(TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.CounterMultiplier"), IsolatedParticleSleepCounterThresholdMultiplier, TEXT("A multiplier applied to SleepCounterThreshold for floating particles"))	(	TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.CounterMultiplier")	,
		IsolatedParticleSleepCounterThresholdMultiplier	,
		TEXT("A multiplier applied to SleepCounterThreshold for floating particles")
	)

◆ CVarChaosSolverIsolatedParticleSleepLinearThresholdMultiplier

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverIsolatedParticleSleepLinearThresholdMultiplier(TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.LinearMultiplier"), IsolatedParticleSleepLinearThresholdMultiplier, TEXT("A multiplier applied to SleepLinearThreshold for floating particles"))	(	TEXT("p.Chaos.Solver.Sleep.IsolatedParticle.LinearMultiplier")	,
		IsolatedParticleSleepLinearThresholdMultiplier	,
		TEXT("A multiplier applied to SleepLinearThreshold for floating particles")
	)

◆ CVarChaosSolverIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverIterations(TEXT("p.Chaos.Solver.Iterations.Position"), ChaosSolverPositionIterations, TEXT("Override number of solver position iterations (-1 to use config)"))	(	TEXT("p.Chaos.Solver.Iterations.Position")	,
		ChaosSolverPositionIterations	,
		TEXT("Override number of solver position iterations (-1 to use config)")
	)

◆ CVarChaosSolverJointAngleTolerance

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointAngleTolerance(TEXT("p.Chaos.Solver.Joint.AngleTolerance"), ChaosSolverJointAngleTolerance, TEXT("AngleTolerance."))	(	TEXT("p.Chaos.Solver.Joint.AngleTolerance")	,
		ChaosSolverJointAngleTolerance	,
		TEXT("AngleTolerance.")
	)

◆ CVarChaosSolverJointMaxInertiaRatio

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointMaxInertiaRatio(TEXT("p.Chaos.Solver.Joint.MaxInertiaRatio"), ChaosSolverJointMaxInertiaRatio, TEXT("6Dof joint MaxInertiaRatio (if > 0)"))	(	TEXT("p.Chaos.Solver.Joint.MaxInertiaRatio")	,
		ChaosSolverJointMaxInertiaRatio	,
		TEXT("6Dof joint MaxInertiaRatio (if > 0)")
	)

◆ CVarChaosSolverJointMaxSolverStiffness

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointMaxSolverStiffness(TEXT("p.Chaos.Solver.Joint.MaxSolverStiffness"), ChaosSolverJointMaxSolverStiffness, TEXT("Solver stiffness on last iteration, increases each iteration from MinSolverStiffness."))	(	TEXT("p.Chaos.Solver.Joint.MaxSolverStiffness")	,
		ChaosSolverJointMaxSolverStiffness	,
		TEXT("Solver stiffness on last iteration, increases each iteration from MinSolverStiffness.")
	)

◆ CVarChaosSolverJointMinParentMassRatio

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointMinParentMassRatio(TEXT("p.Chaos.Solver.Joint.MinParentMassRatio"), ChaosSolverJointMinParentMassRatio, TEXT("6Dof joint MinParentMassRatio (if > 0)"))	(	TEXT("p.Chaos.Solver.Joint.MinParentMassRatio")	,
		ChaosSolverJointMinParentMassRatio	,
		TEXT("6Dof joint MinParentMassRatio (if > 0)")
	)

◆ CVarChaosSolverJointMinSolverStiffness

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointMinSolverStiffness(TEXT("p.Chaos.Solver.Joint.MinSolverStiffness"), ChaosSolverJointMinSolverStiffness, TEXT("Solver stiffness on first iteration, increases each iteration toward MaxSolverStiffness."))	(	TEXT("p.Chaos.Solver.Joint.MinSolverStiffness")	,
		ChaosSolverJointMinSolverStiffness	,
		TEXT("Solver stiffness on first iteration, increases each iteration toward MaxSolverStiffness.")
	)

◆ CVarChaosSolverJointNumIterationsAtMaxSolverStiffness

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointNumIterationsAtMaxSolverStiffness(TEXT("p.Chaos.Solver.Joint.NumIterationsAtMaxSolverStiffness"), ChaosSolverJointNumIterationsAtMaxSolverStiffness, TEXT("How many iterations we want at MaxSolverStiffness."))	(	TEXT("p.Chaos.Solver.Joint.NumIterationsAtMaxSolverStiffness")	,
		ChaosSolverJointNumIterationsAtMaxSolverStiffness	,
		TEXT("How many iterations we want at MaxSolverStiffness.")
	)

◆ CVarChaosSolverJointNumShockPropagationIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointNumShockPropagationIterations(TEXT("p.Chaos.Solver.Joint.NumShockPropagationIterations"), ChaosSolverJointNumShockProagationIterations, TEXT("How many iterations to enable SHockProagation for."))	(	TEXT("p.Chaos.Solver.Joint.NumShockPropagationIterations")	,
		ChaosSolverJointNumShockProagationIterations	,
		TEXT("How many iterations to enable SHockProagation for.")
	)

◆ CVarChaosSolverJointPositionTolerance

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointPositionTolerance(TEXT("p.Chaos.Solver.Joint.PositionTolerance"), ChaosSolverJointPositionTolerance, TEXT("PositionTolerance."))	(	TEXT("p.Chaos.Solver.Joint.PositionTolerance")	,
		ChaosSolverJointPositionTolerance	,
		TEXT("PositionTolerance.")
	)

◆ CVarChaosSolverJointPriority

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointPriority(TEXT("p.Chaos.Solver.Joint.Priority"), ChaosSolverJointPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))	(	TEXT("p.Chaos.Solver.Joint.Priority")	,
		ChaosSolverJointPriority	,
		TEXT("Set constraint priority. Larger values are evaluated later [def:0]")
	)

◆ CVarChaosSolverJointShockPropagation

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointShockPropagation(TEXT("p.Chaos.Solver.Joint.ShockPropagation"), ChaosSolverJointShockPropagation, TEXT("6Dof joint shock propagation override (if >= 0)."))	(	TEXT("p.Chaos.Solver.Joint.ShockPropagation")	,
		ChaosSolverJointShockPropagation	,
		TEXT("6Dof joint shock propagation override (if >= 0).")
	)

◆ CVarChaosSolverJointSolvePositionFirst

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointSolvePositionFirst(TEXT("p.Chaos.Solver.Joint.SolvePositionLast"), bChaosSolverJointSolvePositionLast, TEXT("Should we solve joints in position-then-rotation order (false) or rotation-then-position order (true, default)"))	(	TEXT("p.Chaos.Solver.Joint.SolvePositionLast")	,
		bChaosSolverJointSolvePositionLast	,
		TEXT("Should we solve joints in position-then-rotation order (false) or rotation-then-position order (true, default)")
	)

◆ CVarChaosSolverJointUsePBDVelocityDrives

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverJointUsePBDVelocityDrives(TEXT("p.Chaos.Solver.Joint.UsePBDDrives"), bChaosSolverJointUsePositionBasedDrives, TEXT("Whether to solve drives in the position or velocity phase of the solver (default true"))	(	TEXT("p.Chaos.Solver.Joint.UsePBDDrives")	,
		bChaosSolverJointUsePositionBasedDrives
	)

◆ CVarChaosSolverLinearWakeThresholdMultiplier

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverLinearWakeThresholdMultiplier(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.LinearWakeThresholdMultiplier"), LinearPartialWakeThresholdMultiplier, TEXT("[EXPERIMENTAL] A multiplier applied to LinearSleepThreshold for particle waking.[def:10]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.LinearWakeThresholdMultiplier")	,
		LinearPartialWakeThresholdMultiplier	,
		TEXT("[EXPERIMENTAL] A multiplier applied to LinearSleepThreshold for particle waking.[def:10]")
	)

◆ CVarChaosSolverMaxPushOutVelocity

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverMaxPushOutVelocity(TEXT("p.Chaos.Solver.Collision.MaxPushOutVelocity"), ChaosSolverMaxPushOutVelocity, TEXT("Override max pushout velocity (if >= 0)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.Collision.MaxPushOutVelocity")	,
		ChaosSolverMaxPushOutVelocity	,
		TEXT("Override max pushout velocity (if >= 0)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosSolverMaxVelocityBoundsExpansion

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverMaxVelocityBoundsExpansion(TEXT("p.Chaos.Solver.Collision.MaxVelocityBoundsExpansion"), ChaosSolverMaxVelocityBoundsExpansion, TEXT("Override max velocity bounds expansion (if >= 0)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.Collision.MaxVelocityBoundsExpansion")	,
		ChaosSolverMaxVelocityBoundsExpansion	,
		TEXT("Override max velocity bounds expansion (if >= 0)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosSolverMaxVelocityBoundsExpansionMACD

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverMaxVelocityBoundsExpansionMACD(TEXT("p.Chaos.Solver.Collision.MaxVelocityBoundsExpansionMACD"), ChaosSolverMaxVelocityBoundsExpansionMACD, TEXT("Override max velocity bounds expansion for MACD (if >= 0)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.Collision.MaxVelocityBoundsExpansionMACD")	,
		ChaosSolverMaxVelocityBoundsExpansionMACD	,
		TEXT("Override max velocity bounds expansion for MACD (if >= 0)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosSolverMidPhaseRedistributionEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverMidPhaseRedistributionEnabled(TEXT("p.Chaos.BroadPhase.MidPhaseRedistributionEnabled"), bChaosMidPhaseRedistributionEnabled, TEXT(""))	(	TEXT("p.Chaos.BroadPhase.MidPhaseRedistributionEnabled")	,
		bChaosMidPhaseRedistributionEnabled	,
		TEXT("")
	)

◆ CVarChaosSolverMinMotionlessRatio

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverMinMotionlessRatio(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.MinimumMotionlessRatio"), ChaosSolverMinMotionlessRatio, TEXT("[EXPERIMENTAL] Ratio of the particles which need to be motionless in an island for partial island sleep to become active (0 to always activate partial island sleep).[def:0.1]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.MinimumMotionlessRatio")	,
		ChaosSolverMinMotionlessRatio	,
		TEXT("[EXPERIMENTAL] Ratio of the particles which need to be motionless in an island for partial island sleep to become active (0 to always activate partial island sleep).[def:0.1]")
	)

◆ CVarChaosSolverMomentumPropagation

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverMomentumPropagation(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.MomentumPropagation"), ChaosSolverMomentumPropagation, TEXT("[EXPERIMENTAL] Ratio of the impact momentum transferred from one sleeping particle to another through a constraint during partial wake event (0 to disable, 1 to propagate without dissipation).[def:0.3]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.MomentumPropagation")	,
		ChaosSolverMomentumPropagation	,
		TEXT("[EXPERIMENTAL] Ratio of the impact momentum transferred from one sleeping particle to another through a constraint during partial wake event (0 to disable, 1 to propagate without dissipation).[def:0.3]")
	)

◆ CVarChaosSolverPartialIslandSleep

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverPartialIslandSleep(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep"), bChaosSolverPartialIslandSleep, TEXT("[EXPERIMENTAL] Single non-moving particles in islands will be deactivated even if they are connected to moving particles."))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep")	,
		bChaosSolverPartialIslandSleep	,
		TEXT("[EXPERIMENTAL] Single non-moving particles in islands will be deactivated even if they are connected to moving particles.")
	)

◆ CVarChaosSolverPartialIslandWake

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverPartialIslandWake(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PartialIslandWake"), bChaosSolverPartialIslandWake, TEXT("[EXPERIMENTAL] Safeguard only: New constraints and particle state changes will trigger partial wake events instead of waking up the entire island.[def:true]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PartialIslandWake")	,
		bChaosSolverPartialIslandWake	,
		TEXT("[EXPERIMENTAL] Safeguard only: New constraints and particle state changes will trigger partial wake events instead of waking up the entire island.[def:true]")
	)

◆ CVarChaosSolverPartialSleepCollisionConstraintsOnly

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverPartialSleepCollisionConstraintsOnly(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.CollisionConstraintsOnly"), bChaosSolverPartialSleepCollisionConstraintsOnly, TEXT("[EXPERIMENTAL] Safeguard only: Only collision constraints permit partial sleep, i.e. the sleep state of particles connect by other constraint types must match.[def:true]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.CollisionConstraintsOnly")	,
		bChaosSolverPartialSleepCollisionConstraintsOnly	,
		TEXT("[EXPERIMENTAL] Safeguard only: Only collision constraints permit partial sleep, i.e. the sleep state of particles connect by other constraint types must match.[def:true]")
	)

◆ CVarChaosSolverPartialWakePreIntegration

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverPartialWakePreIntegration(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PartialWakePreIntegration"), bChaosSolverPartialWakePreIntegration, TEXT("[EXPERIMENTAL] Safeguard only: Partial wake events also happen pre-integration when the user explicilty sets a particle transform or applies external impulses or forces.[def:true]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PartialWakePreIntegration")	,
		bChaosSolverPartialWakePreIntegration	,
		TEXT("[EXPERIMENTAL] Safeguard only: Partial wake events also happen pre-integration when the user explicilty sets a particle transform or applies external impulses or forces.[def:true]")
	)

◆ CVarChaosSolverParticlePoolNumFrameUntilShrink

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverParticlePoolNumFrameUntilShrink(TEXT("p.Chaos.Solver.ParticlePoolNumFrameUntilShrink"), ChaosSolverParticlePoolNumFrameUntilShrink, TEXT("Num Frame until we can potentially shrink the pool"))	(	TEXT("p.Chaos.Solver.ParticlePoolNumFrameUntilShrink")	,
		ChaosSolverParticlePoolNumFrameUntilShrink	,
		TEXT("Num Frame until we can potentially shrink the pool")
	)

◆ CVarChaosSolverPersistentGraph

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverPersistentGraph(TEXT("p.Chaos.Solver.PersistentGraph"), bChaosSolverPersistentGraph, TEXT(""))	(	TEXT("p.Chaos.Solver.PersistentGraph")	,
		bChaosSolverPersistentGraph	,
		TEXT("")
	)

◆ CVarChaosSolverPostStepWakeThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverPostStepWakeThreshold(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PostStepWakeThreshold"), ChaosSolverPostStepWakeThreshold, TEXT("[EXPERIMENTAL] Post-solver waking of sleeping particles: Minimum squared change of velocity induced by the velocity-based collision solver (VBD, 0 to disable).[def:20]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.PostStepWakeThreshold")	,
		ChaosSolverPostStepWakeThreshold	,
		TEXT("[EXPERIMENTAL] Post-solver waking of sleeping particles: Minimum squared change of velocity induced by the velocity-based collision solver (VBD, 0 to disable).[def:20]")
	)

◆ CVarChaosSolverProjectionIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverProjectionIterations(TEXT("p.Chaos.Solver.Iterations.Projection"), ChaosSolverProjectionIterations, TEXT("Override number of solver projection iterations (-1 to use config)"))	(	TEXT("p.Chaos.Solver.Iterations.Projection")	,
		ChaosSolverProjectionIterations	,
		TEXT("Override number of solver projection iterations (-1 to use config)")
	)

◆ CVarChaosSolverPushOutIterations

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverPushOutIterations(TEXT("p.Chaos.Solver.Iterations.Velocity"), ChaosSolverVelocityIterations, TEXT("Override number of solver velocity iterations (-1 to use config)"))	(	TEXT("p.Chaos.Solver.Iterations.Velocity")	,
		ChaosSolverVelocityIterations	,
		TEXT("Override number of solver velocity iterations (-1 to use config)")
	)

◆ CVarChaosSolverShrinkArrays

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverShrinkArrays(TEXT("p.Chaos.Solver.ShrinkArrays"), bChaosSolverShrinkArrays, TEXT("Enable/Disable particle array shrinking in the main scene"))	(	TEXT("p.Chaos.Solver.ShrinkArrays")	,
		bChaosSolverShrinkArrays	,
		TEXT("Enable/Disable particle array shrinking in the main scene")
	)

◆ CVarChaosSolverSleepEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverSleepEnabled(TEXT("p.Chaos.Solver.Sleep.Enabled"), bChaosSolverSleepEnabled, TEXT("Islands of non - moving particles will be deactivated."))	(	TEXT("p.Chaos.Solver.Sleep.Enabled")	,
		bChaosSolverSleepEnabled	,
		TEXT("Islands of non - moving particles will be deactivated.")
	)

◆ CVarChaosSolverSleepModeSwitchThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverSleepModeSwitchThreshold(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.SleepModeSwitchCounterThreshold"), ChaosSolverSleepModeSwitchThreshold, TEXT("[EXPERIMENTAL] Safeguard only: Number of steps MinimumMotionlessRatio needs to be satisfied before switching the between full and partial island sleep.[def:10]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.SleepModeSwitchCounterThreshold")	,
		ChaosSolverSleepModeSwitchThreshold	,
		TEXT("[EXPERIMENTAL] Safeguard only: Number of steps MinimumMotionlessRatio needs to be satisfied before switching the between full and partial island sleep.[def:10]")
	)

◆ CVarChaosSolverSuspensionPriority

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverSuspensionPriority(TEXT("p.Chaos.Solver.Suspension.Priority"), ChaosSolverSuspensionPriority, TEXT("Set constraint priority. Larger values are evaluated later [def:0]"))	(	TEXT("p.Chaos.Solver.Suspension.Priority")	,
		ChaosSolverSuspensionPriority	,
		TEXT("Set constraint priority. Larger values are evaluated later [def:0]")
	)

◆ CVarChaosSolverTestModeEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverTestModeEnabled(TEXT("p.Chaos.Solver.TestMode.Enabled"), bChaos_Solver_TestMode_Enabled, TEXT(""))	(	TEXT("p.Chaos.Solver.TestMode.Enabled")	,
		bChaos_Solver_TestMode_Enabled	,
		TEXT("")
	)

◆ CVarChaosSolverTestModeShowInitialTransforms

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverTestModeShowInitialTransforms(TEXT("p.Chaos.Solver.TestMode.ShowInitialTransforms"), bChaos_Solver_TestMode_ShowInitialTransforms, TEXT(""))	(	TEXT("p.Chaos.Solver.TestMode.ShowInitialTransforms")	,
		bChaos_Solver_TestMode_ShowInitialTransforms	,
		TEXT("")
	)

◆ CVarChaosSolverTestModeStep

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverTestModeStep(TEXT("p.Chaos.Solver.TestMode.Step"), Chaos_Solver_TestMode_Step, TEXT(""))	(	TEXT("p.Chaos.Solver.TestMode.Step")	,
		Chaos_Solver_TestMode_Step	,
		TEXT("")
	)

◆ CVarChaosSolverUseParticlePool

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverUseParticlePool(TEXT("p.Chaos.Solver.UseParticlePool"), ChaosSolverUseParticlePool, TEXT("Whether or not to use dirty particle pool (Optim)"))	(	TEXT("p.Chaos.Solver.UseParticlePool")	,
		ChaosSolverUseParticlePool	,
		TEXT("Whether or not to use dirty particle pool (Optim)")
	)

◆ CVarChaosSolverVelocityBoundsMultiplier

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverVelocityBoundsMultiplier(TEXT("p.Chaos.Solver.Collision.VelocityBoundsMultiplier"), ChaosSolverVelocityBoundsMultiplier, TEXT("Override velocity bounds multiplier (if >= 0)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.Collision.VelocityBoundsMultiplier")	,
		ChaosSolverVelocityBoundsMultiplier	,
		TEXT("Override velocity bounds multiplier (if >= 0)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosSolverVelocityBoundsMultiplierMACD

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverVelocityBoundsMultiplierMACD(TEXT("p.Chaos.Solver.Collision.VelocityBoundsMultiplierMACD"), ChaosSolverVelocityBoundsMultiplierMACD, TEXT("Override velocity bounds multiplier for MACD (if >= 0)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.Collision.VelocityBoundsMultiplierMACD")	,
		ChaosSolverVelocityBoundsMultiplierMACD	,
		TEXT("Override velocity bounds multiplier for MACD (if >= 0)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosSolverWakeOnMovingOnly

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverWakeOnMovingOnly(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.WakeOnMovingOnly"), bChaosSolverWakeOnMovingOnly, TEXT("[EXPERIMENTAL] Safeguard only: Only newly detected constraints connected to a moving particle will trigger wake-up event.[def:true]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.WakeOnMovingOnly")	,
		bChaosSolverWakeOnMovingOnly	,
		TEXT("[EXPERIMENTAL] Safeguard only: Only newly detected constraints connected to a moving particle will trigger wake-up event.[def:true]")
	)

◆ CVarChaosSolverWakeOnParticleStateChanged

FAutoConsoleVariableRef Chaos::CVars::CVarChaosSolverWakeOnParticleStateChanged(TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.WakeOnParticleStateChanged"), bChaosSolverWakeOnParticleStateChanged, TEXT("[EXPERIMENTAL] Safeguard only: State changes of a particle will trigger the island to wake up entirely.[def:false]"))	(	TEXT("p.Chaos.Solver.Sleep.PartialIslandSleep.WakeOnParticleStateChanged")	,
		bChaosSolverWakeOnParticleStateChanged	,
		TEXT("[EXPERIMENTAL] Safeguard only: State changes of a particle will trigger the island to wake up entirely.[def:false]")
	)

◆ CVarChaosUnionBVHEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarChaosUnionBVHEnabled(TEXT("p.Chaos.Collision.UnionBVH.Enabled"), bChaosUnionBVHEnabled, TEXT("Set to false to disable use of BVH during collision detection (without affecting creations and serialization)"))	(	TEXT("p.Chaos.Collision.UnionBVH.Enabled")	,
		bChaosUnionBVHEnabled	,
		TEXT("Set to false to disable use of BVH during collision detection (without affecting creations and serialization)")
	)

◆ CVarChaosUnionBVHMaxDepth

FAutoConsoleVariableRef Chaos::CVars::CVarChaosUnionBVHMaxDepth(TEXT("p.Chaos.Collision.UnionBVH.MaxDepth"), ChaosUnionBVHMaxDepth, TEXT("The allowed depth of the BVH when used to wrap a shape hiererchy"))	(	TEXT("p.Chaos.Collision.UnionBVH.MaxDepth")	,
		ChaosUnionBVHMaxDepth	,
		TEXT("The allowed depth of the BVH when used to wrap a shape hiererchy")
	)

◆ CVarChaosUnionBVHMinShapes

FAutoConsoleVariableRef Chaos::CVars::CVarChaosUnionBVHMinShapes(TEXT("p.Chaos.Collision.UnionBVH.NumShapes"), ChaosUnionBVHMinShapes, TEXT("If a geometry hierarchy has this many shapes, wrap it in a BVH for collision detection (negative to disable BVH)"))	(	TEXT("p.Chaos.Collision.UnionBVH.NumShapes")	,
		ChaosUnionBVHMinShapes	,
		TEXT("If a geometry hierarchy has this many shapes, wrap it in a BVH for collision detection (negative to disable BVH)")
	)

◆ CVarChaosUnionBVHSplitBias

FAutoConsoleVariableRef Chaos::CVars::CVarChaosUnionBVHSplitBias(TEXT("p.Chaos.Collision.UnionBVH.SplitBias"), ChaosUnionBVHSplitBias, TEXT(""))	(	TEXT("p.Chaos.Collision.UnionBVH.SplitBias")	,
		ChaosUnionBVHSplitBias	,
		TEXT("")
	)

◆ CVarChaosUseCCD

FAutoConsoleVariableRef Chaos::CVars::CVarChaosUseCCD(TEXT("p.Chaos.Solver.UseCCD"), bChaosUseCCD, TEXT("Global flag to turn CCD on or off. Default is true (on)"), OnCollisionConfigCVarChanged)	(	TEXT("p.Chaos.Solver.UseCCD")	,
		bChaosUseCCD	,
		TEXT("Global flag to turn CCD on or off. Default is true (on)")	,
		OnCollisionConfigCVarChanged
	)

◆ CVarChaosVisualDebuggerEnable

FAutoConsoleVariableRef Chaos::CVars::CVarChaosVisualDebuggerEnable(TEXT("p.Chaos.VisualDebuggerEnable"), ChaosVisualDebuggerEnable, TEXT("Enable/Disable pushing/saving data to the visual debugger"))	(	TEXT("p.Chaos.VisualDebuggerEnable")	,
		ChaosVisualDebuggerEnable	,
		TEXT("Enable/Disable pushing/saving data to the visual debugger")
	)

◆ CVarClearNullCCDConstraintsOnApply

FAutoConsoleVariableRef Chaos::CVars::CVarClearNullCCDConstraintsOnApply(TEXT("p.Chaos.Collision.CCD.ClearNullConstraints"), bClearNullCCDConstraintsOnApply, TEXT("Remove null constraints encountered during correction application for CCD."))	(	TEXT("p.Chaos.Collision.CCD.ClearNullConstraints")	,
		bClearNullCCDConstraintsOnApply	,
		TEXT("Remove null constraints encountered during correction application for CCD.")
	)

◆ CVarCollisionStoreEnabled

FAutoConsoleVariableRef Chaos::CVars::CVarCollisionStoreEnabled(TEXT("p.Chaos.CollisionStore.Enabled"), bChaos_CollisionStore_Enabled, TEXT(""))	(	TEXT("p.Chaos.CollisionStore.Enabled")	,
		bChaos_CollisionStore_Enabled	,
		TEXT("")
	)

◆ CVarDisableCulledContacts

FAutoConsoleVariableRef Chaos::CVars::CVarDisableCulledContacts(TEXT("p.CollisionDisableCulledContacts"), CollisionDisableCulledContacts, TEXT("Allow the PBDRigidsEvolutionGBF collision constraints to throw out contacts mid solve if they are culled."))	(	TEXT("p.CollisionDisableCulledContacts")	,
		CollisionDisableCulledContacts	,
		TEXT("Allow the PBDRigidsEvolutionGBF collision constraints to throw out contacts mid solve if they are culled.")
	)

◆ CVarDisableParticleUpdateVelocityParallelFor

FAutoConsoleVariableRef Chaos::CVars::CVarDisableParticleUpdateVelocityParallelFor(TEXT("p.DisableParticleUpdateVelocityParallelFor"), DisableParticleUpdateVelocityParallelFor, TEXT("Disable Particle Update Velocity ParallelFor and run the update on a single thread"))	(	TEXT("p.DisableParticleUpdateVelocityParallelFor")	,
		DisableParticleUpdateVelocityParallelFor	,
		TEXT("Disable Particle Update Velocity ParallelFor and run the update on a single thread")
	)

◆ CVarDisableThreshold

FAutoConsoleVariableRef Chaos::CVars::CVarDisableThreshold(TEXT("p.DisableThreshold2"), DisableThreshold, TEXT("Disable threshold frames to transition to sleeping"))	(	TEXT("p.DisableThreshold2")	,
		DisableThreshold	,
		TEXT("Disable threshold frames to transition to sleeping")
	)

◆ CVarDoFinalProbeNarrowPhase

FAutoConsoleVariableRef Chaos::CVars::CVarDoFinalProbeNarrowPhase(TEXT("p.Chaos.Solver.DoFinalProbeNarrowPhase"), DoFinalProbeNarrowPhase, TEXT(""))	(	TEXT("p.Chaos.Solver.DoFinalProbeNarrowPhase")	,
		DoFinalProbeNarrowPhase	,
		TEXT("")
	)

◆ CVarDoTransferJointConstraintCollisions

FAutoConsoleVariableRef Chaos::CVars::CVarDoTransferJointConstraintCollisions(TEXT("p.Chaos.Solver.Joint.TransferCollisions"), DoTransferJointConstraintCollisions, TEXT("Allows joints to apply collisions to the parent from the child when the Joints TransferCollisionScale is not 0 [def:true]"))	(	TEXT("p.Chaos.Solver.Joint.TransferCollisions")	,
		DoTransferJointConstraintCollisions	,
		TEXT("Allows joints to apply collisions to the parent from the child when the Joints TransferCollisionScale is not 0 [def:true]")
	)

◆ CVarEnableAsyncInitBody

FAutoConsoleVariableRef Chaos::CVars::CVarEnableAsyncInitBody(TEXT("p.Chaos.EnableAsyncInitBody"), bEnableAsyncInitBody, TEXT("[Experimental] Allow body instances to be initialized outside of game thread (default is false)."), ECVF_ReadOnly)	(	TEXT("p.Chaos.EnableAsyncInitBody")	,
		bEnableAsyncInitBody	,
		TEXT("[Experimental] Allow body instances to be initialized outside of game thread (default is false).")	,
		ECVF_ReadOnly
	)

◆ CVarForceDeepCopyOnModifyGeometry

FAutoConsoleVariableRef Chaos::CVars::CVarForceDeepCopyOnModifyGeometry(TEXT("p.Chaos.Geometry.ForceDeepCopyAccess"), GForceDeepCopyOnModifyGeometry, TEXT("Whether we always use a deep copy when modifying particle geometry"))	(	TEXT("p.Chaos.Geometry.ForceDeepCopyAccess")	,
		GForceDeepCopyOnModifyGeometry	,
		TEXT("Whether we always use a deep copy when modifying particle geometry")
	)

◆ CVarHackMaxAngularVelocity

FAutoConsoleVariableRef Chaos::CVars::CVarHackMaxAngularVelocity(TEXT("p.HackMaxAngularVelocity"), HackMaxAngularVelocity, TEXT("Max cap on angular velocity: rad/s. This is only a temp solution and should not be relied on as a feature. -1.f to disable"))	(	TEXT("p.HackMaxAngularVelocity")	,
		HackMaxAngularVelocity	,
		TEXT("Max cap on angular velocity: rad/s. This is only a temp solution and should not be relied on as a feature. -1.f to disable")
	)

◆ CVarHackMaxVelocity

FAutoConsoleVariableRef Chaos::CVars::CVarHackMaxVelocity(TEXT("p.HackMaxVelocity2"), HackMaxVelocity, TEXT("Max cap on velocity: cm/s. This is only a temp solution and should not be relied on as a feature. -1.f to disable"))	(	TEXT("p.HackMaxVelocity2")	,
		HackMaxVelocity	,
		TEXT("Max cap on velocity: cm/s. This is only a temp solution and should not be relied on as a feature. -1.f to disable")
	)

◆ CVarNumWorkerCollisionFactor

FAutoConsoleVariableRef Chaos::CVars::CVarNumWorkerCollisionFactor(TEXT("p.Chaos.NumWorkerCollisionFactor"), NumWorkerCollisionFactor, TEXT("Set the number of tasks created for collision detection per worker."))	(	TEXT("p.Chaos.NumWorkerCollisionFactor")	,
		NumWorkerCollisionFactor	,
		TEXT("Set the number of tasks created for collision detection per worker.")
	)

◆ CVarSerializeEvolution

FAutoConsoleVariableRef Chaos::CVars::CVarSerializeEvolution(TEXT("p.SerializeEvolution"), SerializeEvolution, TEXT(""))	(	TEXT("p.SerializeEvolution")	,
		SerializeEvolution	,
		TEXT("")
	)

◆ CVarSmoothedPositionLerpRate

FAutoConsoleVariableRef Chaos::CVars::CVarSmoothedPositionLerpRate(TEXT("p.Chaos.SmoothedPositionLerpRate"), SmoothedPositionLerpRate, TEXT("The interpolation rate for the smoothed position calculation. Used for sleeping."))	(	TEXT("p.Chaos.SmoothedPositionLerpRate")	,
		SmoothedPositionLerpRate	,
		TEXT("The interpolation rate for the smoothed position calculation. Used for sleeping.")
	)

◆ CVarTransferCollisionsDebugTestAgainstMaxClamp

FAutoConsoleVariableRef Chaos::CVars::CVarTransferCollisionsDebugTestAgainstMaxClamp(TEXT("p.Chaos.Solver.Joint.TransferCollisionsDebugTestAgainstMaxClamp"), TransferCollisionsDebugTestAgainstMaxClamp, TEXT("Force all joint collision constraint settings to max clamp value to validate stability [def:false]"))	(	TEXT("p.Chaos.Solver.Joint.TransferCollisionsDebugTestAgainstMaxClamp")	,
		TransferCollisionsDebugTestAgainstMaxClamp	,
		TEXT("Force all joint collision constraint settings to max clamp value to validate stability [def:false]")
	)

◆ CVarTransferCollisionsKinematicScale

FAutoConsoleVariableRef Chaos::CVars::CVarTransferCollisionsKinematicScale(TEXT("p.Chaos.Solver.Joint.TransferCollisionsKinematicScale"), TransferCollisionsKinematicScale, TEXT("Scale to apply to collision transfers between kinematic bodies [def:1.0]"))	(	TEXT("p.Chaos.Solver.Joint.TransferCollisionsKinematicScale")	,
		TransferCollisionsKinematicScale	,
		TEXT("Scale to apply to collision transfers between kinematic bodies [def:1.0]")
	)

◆ CVarTransferCollisionsMultiply

FAutoConsoleVariableRef Chaos::CVars::CVarTransferCollisionsMultiply(TEXT("p.Chaos.Solver.Joint.TransferCollisionsLimit"), TransferCollisionsLimit, TEXT("Maximum number of constraints that are allowed to transfer to the parent. Lowering this will improve performance but reduce accuracy. [def:INT_MAX]"))	(	TEXT("p.Chaos.Solver.Joint.TransferCollisionsLimit")	,
		TransferCollisionsLimit	,
		TEXT("Maximum number of constraints that are allowed to transfer to the parent. Lowering this will improve performance but reduce accuracy. [def:INT_MAX]")
	)

◆ CVarTransferCollisionsStiffnessClamp

FAutoConsoleVariableRef Chaos::CVars::CVarTransferCollisionsStiffnessClamp(TEXT("p.Chaos.Solver.Joint.TransferCollisionsStiffnessClamp"), TransferCollisionsStiffnessClamp, TEXT("Clamp of maximum value of the stiffness clamp[def:1.0]"))	(	TEXT("p.Chaos.Solver.Joint.TransferCollisionsStiffnessClamp")	,
		TransferCollisionsStiffnessClamp	,
		TEXT("Clamp of maximum value of the stiffness clamp[def:1.0]")
	)

◆ DisableParticleUpdateVelocityParallelFor

int Chaos::CVars::DisableParticleUpdateVelocityParallelFor = 0

◆ DisableThreshold

int Chaos::CVars::DisableThreshold = 5

◆ DoFinalProbeNarrowPhase

bool Chaos::CVars::DoFinalProbeNarrowPhase = true

◆ DoTransferJointConstraintCollisions

bool Chaos::CVars::DoTransferJointConstraintCollisions = true

◆ GCVarIslandGroupsMaxWorkers

FAutoConsoleVariableRef Chaos::CVars::GCVarIslandGroupsMaxWorkers(TEXT("p.Chaos.Solver.IslandGroups.MaxWorkers"), GIslandGroupsMaxWorkers, TEXT("The maximum number of worker threads to use (0 means unlimited)"))	(	TEXT("p.Chaos.Solver.IslandGroups.MaxWorkers")	,
		GIslandGroupsMaxWorkers	,
		TEXT("The maximum number of worker threads to use (0 means unlimited)")
	)

◆ GCVarIslandGroupsMinBodiesPerWorker

FAutoConsoleVariableRef Chaos::CVars::GCVarIslandGroupsMinBodiesPerWorker(TEXT("p.Chaos.Solver.IslandGroups.MinBodiesPerWorker"), GIslandGroupsMinBodiesPerWorker, TEXT("The minimum number of bodies we want per worker thread"))	(	TEXT("p.Chaos.Solver.IslandGroups.MinBodiesPerWorker")	,
		GIslandGroupsMinBodiesPerWorker	,
		TEXT("The minimum number of bodies we want per worker thread")
	)

◆ GCVarIslandGroupsMinConstraintsPerWorker

FAutoConsoleVariableRef Chaos::CVars::GCVarIslandGroupsMinConstraintsPerWorker(TEXT("p.Chaos.Solver.IslandGroups.MinConstraintsPerWorker"), GIslandGroupsMinConstraintsPerWorker, TEXT("The minimum number of constraints we want per worker thread"))	(	TEXT("p.Chaos.Solver.IslandGroups.MinConstraintsPerWorker")	,
		GIslandGroupsMinConstraintsPerWorker	,
		TEXT("The minimum number of constraints we want per worker thread")
	)

◆ GCVarIslandGroupsParallelMode

FAutoConsoleVariableRef Chaos::CVars::GCVarIslandGroupsParallelMode(TEXT("p.Chaos.Solver.IslandGroups.ParallelMode"), GIslandGroupsParallelMode, TEXT("0: Single-Threaded; 1: Parallel-For; 2: Tasks"))	(	TEXT("p.Chaos.Solver.IslandGroups.ParallelMode")	,
		GIslandGroupsParallelMode	,
		TEXT("0: Single-Threaded; 1: Parallel-For; 2: Tasks")
	)

◆ GCVarIslandGroupsWorkerThreadMultiplier

FAutoConsoleVariableRef Chaos::CVars::GCVarIslandGroupsWorkerThreadMultiplier(TEXT("p.Chaos.Solver.IslandGroups.WorkerMultiplier"), GIslandGroupsWorkerMultiplier, TEXT("Total number of island groups in the solver will be NumWorkerThreads * WorkerThreadMultiplier. [def:1]"))	(	TEXT("p.Chaos.Solver.IslandGroups.WorkerMultiplier")	,
		GIslandGroupsWorkerMultiplier	,
		TEXT("Total number of island groups in the solver will be NumWorkerThreads * WorkerThreadMultiplier. [def:1]")
	)

◆ GIslandGroupsMaxWorkers

int32 Chaos::CVars::GIslandGroupsMaxWorkers = 0

◆ GIslandGroupsMinBodiesPerWorker

int32 Chaos::CVars::GIslandGroupsMinBodiesPerWorker = 50

◆ GIslandGroupsMinConstraintsPerWorker

int32 Chaos::CVars::GIslandGroupsMinConstraintsPerWorker = 50

◆ GIslandGroupsParallelMode

int32 Chaos::CVars::GIslandGroupsParallelMode = 2

◆ GIslandGroupsWorkerMultiplier

FRealSingle Chaos::CVars::GIslandGroupsWorkerMultiplier = 1

◆ HackMaxAngularVelocity

CHAOS_API FRealSingle Chaos::CVars::HackMaxAngularVelocity = 1000.f

◆ HackMaxVelocity

CHAOS_API FRealSingle Chaos::CVars::HackMaxVelocity = -1.f

◆ IsolatedParticleSleepAngularThresholdMultiplier

FRealSingle Chaos::CVars::IsolatedParticleSleepAngularThresholdMultiplier = 1.0f

◆ IsolatedParticleSleepCounterThresholdMultiplier

int32 Chaos::CVars::IsolatedParticleSleepCounterThresholdMultiplier = 1

◆ IsolatedParticleSleepLinearThresholdMultiplier

FRealSingle Chaos::CVars::IsolatedParticleSleepLinearThresholdMultiplier = 1.0f

◆ LinearPartialWakeThresholdMultiplier

FRealSingle Chaos::CVars::LinearPartialWakeThresholdMultiplier = 10.0f

Cvar to adjust the linear wake threshold for partial waking

◆ NumWorkerCollisionFactor

int32 Chaos::CVars::NumWorkerCollisionFactor = 2

◆ OnCollisionConfigCVarChanged

FConsoleVariableDelegate Chaos::CVars::OnCollisionConfigCVarChanged = FConsoleVariableDelegate::CreateLambda([](IConsoleVariable* CVar) -> void { bChaosCollisionConfigChanged = true; })

◆ OnInertiaConditioningCVarChangedDelegate

FConsoleVariableDelegate Chaos::CVars::OnInertiaConditioningCVarChangedDelegate = FConsoleVariableDelegate::CreateLambda([](IConsoleVariable*) { ++ChaosSolverInertiaConditioningEpoch; })

◆ SerializeEvolution

int32 Chaos::CVars::SerializeEvolution = 0

◆ SmoothedPositionLerpRate

CHAOS_API FRealSingle Chaos::CVars::SmoothedPositionLerpRate = 0.3f

◆ TransferCollisionsDebugTestAgainstMaxClamp

bool Chaos::CVars::TransferCollisionsDebugTestAgainstMaxClamp = false

◆ TransferCollisionsKinematicScale

FRealSingle Chaos::CVars::TransferCollisionsKinematicScale = 1.0f

◆ TransferCollisionsLimit

int32 Chaos::CVars::TransferCollisionsLimit = INT_MAX

◆ TransferCollisionsStiffnessClamp

FRealSingle Chaos::CVars::TransferCollisionsStiffnessClamp = 1.0f

Functions

Variables

Function Documentation

◆ CVarChaosInertiaConditioningExtentTolerance()

◆ CVarChaosInertiaConditioningInvInertiaTolerance()

◆ CVarChaosInertiaConditioningInvMassTolerance()

◆ DECLARE_CYCLE_STAT() [1/28]

◆ DECLARE_CYCLE_STAT() [2/28]

◆ DECLARE_CYCLE_STAT() [3/28]

◆ DECLARE_CYCLE_STAT() [4/28]

◆ DECLARE_CYCLE_STAT() [5/28]

◆ DECLARE_CYCLE_STAT() [6/28]

◆ DECLARE_CYCLE_STAT() [7/28]

◆ DECLARE_CYCLE_STAT() [8/28]

◆ DECLARE_CYCLE_STAT() [9/28]

◆ DECLARE_CYCLE_STAT() [10/28]

◆ DECLARE_CYCLE_STAT() [11/28]

◆ DECLARE_CYCLE_STAT() [12/28]

◆ DECLARE_CYCLE_STAT() [13/28]

◆ DECLARE_CYCLE_STAT() [14/28]

◆ DECLARE_CYCLE_STAT() [15/28]

◆ DECLARE_CYCLE_STAT() [16/28]

◆ DECLARE_CYCLE_STAT() [17/28]

◆ DECLARE_CYCLE_STAT() [18/28]

◆ DECLARE_CYCLE_STAT() [19/28]

◆ DECLARE_CYCLE_STAT() [20/28]

◆ DECLARE_CYCLE_STAT() [21/28]

◆ DECLARE_CYCLE_STAT() [22/28]

◆ DECLARE_CYCLE_STAT() [23/28]

◆ DECLARE_CYCLE_STAT() [24/28]

◆ DECLARE_CYCLE_STAT() [25/28]

◆ DECLARE_CYCLE_STAT() [26/28]

◆ DECLARE_CYCLE_STAT() [27/28]

◆ DECLARE_CYCLE_STAT() [28/28]

◆ ForceDeepCopyOnModifyGeometry()

Variable Documentation

◆ AngularPartialWakeThresholdMultiplier

◆ bCCDAxisThresholdUsesProbeShapes

◆ bCCDNewTargetDepthMode

◆ bCCDSweepsUseProbeShapes

◆ bChaos_Collision_EnableInitialDepenetration

◆ bChaos_Collision_EnableSoftCollisions

◆ bChaos_Collision_MidPhase_EnableShapePairs

◆ bChaos_CollisionStore_Enabled

◆ bChaos_PBDCollisionSolver_Position_SolveEnabled

◆ bChaos_PBDCollisionSolver_UseJacobiPairSolver2

◆ bChaos_PBDCollisionSolver_Velocity_AveragePointEnabled

◆ bChaos_PBDCollisionSolver_Velocity_FrictionEnabled

◆ bChaos_PBDCollisionSolver_Velocity_SolveEnabled

◆ bChaos_Solver_TestMode_Enabled

◆ bChaos_Solver_TestMode_ShowInitialTransforms

◆ bChaosCollisionCCDAllowClipping

◆ bChaosCollisionCCDEnableResweep

◆ bChaosCollisionCCDUseTightBoundingBox

◆ bChaosCollisionConfigChanged

◆ bChaosCollisionModiferBeforeCCD

◆ bChaosConstraintGraphValidate

◆ bChaosConvexSimplifyUnion

◆ bChaosEnableOverrideSingleParticleTypeToCluster

◆ bChaosForceMACD

◆ bChaosImplicitBVHOptimizedCountLeafObjects

◆ bChaosMidPhaseActivateWakingConstraints

◆ bChaosMidPhaseModifierConvexOptimizerFix

◆ bChaosMidPhaseRedistributionEnabled

◆ bChaosRandomizeConstraintOrder

◆ bChaosRigids_UseSimdForJointsSolver

◆ bChaosSolverCheckParticleViews

◆ bChaosSolverCollisionEnabled

◆ bChaosSolverComputeIterationSettings

◆ bChaosSolverForcePartialIslandWake

◆ bChaosSolverInertiaConditioningEnabled

◆ bChaosSolverJointSolvePositionLast

◆ bChaosSolverJointUsePositionBasedDrives

◆ bChaosSolverPartialIslandSleep

◆ bChaosSolverPartialIslandWake

◆ bChaosSolverPartialSleepCollisionConstraintsOnly

◆ bChaosSolverPartialWakePreIntegration

◆ bChaosSolverPersistentGraph

◆ bChaosSolverShrinkArrays

◆ bChaosSolverSleepEnabled