description: Generate a CoM-relative extent that encompasses all constraints (collision and joints for now) on the particle. For collisions, we approximate the max extend using the CoM-space bounds. For joints we use the actual joint attachment positions.

code: namespace Chaos { [FVec3f](API\Runtime\ChaosCore\Chaos\FVec3f) Chaos::CalculateParticleConstraintExtents ( const [FPBDRigidParticleHandle](API\Runtime\Chaos\Chaos\FPBDRigidParticleHandle) * Rigid ) }


description: Calculate the margins used for queries based on shape radius, shape margins and shape types.

module: Chaos

code: namespace Chaos { template<typename TGeometryA, typename TGeometryB, typename T> void Chaos::CalculateQueryMargins ( const TGeometryA & A, const TGeometryB & B, T & outMarginA, T & outMarginB ) }


code: namespace Chaos { constexpr [EChaosPropertyFlags](API\Runtime\Chaos\Chaos\Chaos__EChaosPropertyFlags) Chaos::ChaosPropertyToFlag ( [EChaosProperty](API\Runtime\Chaos\Chaos\Chaos__EChaosProperty) Prop ) }


code: namespace Chaos { [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > Chaos::CleanCollisionParticles ( const [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Vertices, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) SnapDistance ) }


description: Check the GJK iteration count against a limit to prevent infinite loops. We should never really hit the limit but we are seeing it happen in some cases and more often on some platforms than others so for now we have a warning when it hits.

code: namespace Chaos { template<typename ConvexTypeA, typename ConvexTypeB> bool Chaos::CheckGJKIterationLimit ( const int32 NumIterations, const ConvexTypeA & A, const ConvexTypeB & B ) }


code: namespace Chaos { [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > Chaos::CleanCollisionParticles ( const [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Vertices, [FAABB3](API\Runtime\Chaos\Chaos\FAABB3) BBox, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) SnapDistance ) }


code: namespace Chaos { [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > Chaos::CleanCollisionParticles ( [FTriangleMesh](API\Runtime\Chaos\Chaos\FTriangleMesh) & TriMesh, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Vertices, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Fraction ) }


code: namespace Chaos { void Chaos::CleanCollisionParticles ( [FTriangleMesh](API\Runtime\Chaos\Chaos\FTriangleMesh) & TriMesh, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Vertices, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Fraction, [TSet](API\Runtime\Core\Containers\TSet)< int32 > & ResultingIndices ) }


code: namespace Chaos { namespace Collisions { template<typename TRealType> [TMatrix33](API\Runtime\ChaosCore\Chaos\TMatrix33)< TRealType > Chaos::Collisions::ComputeFactorMatrix3 ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< TRealType > & V, const [TMatrix33](API\Runtime\ChaosCore\Chaos\TMatrix33)< TRealType > & M, const TRealType Im ) } }


description: Compute the diagonal part of the rigid objects rotational contribution

code: namespace Chaos { namespace Collisions { template<typename TRealType> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< TRealType > Chaos::Collisions::ComputeFactorDiagonal3 ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< TRealType > & V, const [TMatrix33](API\Runtime\ChaosCore\Chaos\TMatrix33)< TRealType > & M, const TRealType Im ) } }


description: DEPRECATED STUFF

code: namespace Chaos { namespace Collisions { void Chaos::Collisions::ConstructConstraints ( [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 3 > * Particle0, [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 3 > * Particle1, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Implicit0, const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * Shape0, const [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) * Simplicial0, const int32 ImplicitID0, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Implicit1, const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * Shape1, const [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) * Simplicial1, const int32 ImplicitID1, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & ParticleWorldTransform0, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Transform0, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & ParticleWorldTransform1, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Transform1, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) CullDistance, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, const bool bEnableSweep, const [FCollisionContext](API\Runtime\Chaos\Chaos\Collision\FCollisionContext) & Context ) } }


code: namespace Chaos { template<class OBJECT_ARRAY, class T, int d> void Chaos::ComputeAllWorldSpaceBoundingBoxes ( const OBJECT_ARRAY & Objects, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & AllObjects, const bool bUseVelocity, const T Dt, [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<class T, int d> void Chaos::ComputeAllWorldSpaceBoundingBoxes ( const [TGeometryParticles](API\Runtime\Chaos\Chaos\TGeometryParticles)< T, d > & Objects, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & AllObjects, const bool bUseVelocity, const T Dt, [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<class T, int d> void Chaos::ComputeAllWorldSpaceBoundingBoxes ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Objects, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & AllObjects, const bool bUseVelocity, const T Dt, [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


description: Todo: how do we protect ourselves and make it const?

code: namespace Chaos { template<typename ParticleView, typename T, int d> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< TModels_V< [CParticleView](API\Runtime\Chaos\Chaos\CParticleView_1), ParticleView > >::Type Chaos::ComputeAllWorldSpaceBoundingBoxes ( const ParticleView & Particles, const [TArray](API\Runtime\Core\Containers\TArray)< bool > & RequiresBounds, const bool bUseVelocity, const T Dt, [TArray](API\Runtime\Core\Containers\TArray)< [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<typename ParticleView, typename T, int d> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)<!TModels_V< [CParticleView](API\Runtime\Chaos\Chaos\CParticleView_1), ParticleView > >::Type Chaos::ComputeAllWorldSpaceBoundingBoxes ( const ParticleView & Particles, const [TArray](API\Runtime\Core\Containers\TArray)< bool > & RequiresBounds, const bool bUseVelocity, const T Dt, [TArray](API\Runtime\Core\Containers\TArray)< [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<class T, int d> void Chaos::ComputeAllWorldSpaceBoundingBoxes ( const [TArray](API\Runtime\Core\Containers\TArray)< [Private::FImplicitBVHObject](API\Runtime\Chaos\Chaos\FImplicitBVHObject) > & Objects, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & AllObjects, const bool bUseVelocity, const T Dt, [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<typename T, int d> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 2 > Chaos::ComputeBarycentricInPlane ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P0, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P1, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P2, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P ) }


code: namespace Chaos { template<class T, int d> void Chaos::ComputeAllWorldSpaceBoundingBoxes ( const [TParticles](API\Runtime\Chaos\Chaos\TParticles)< T, d > & Objects, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & AllObjects, const bool bUseVelocity, const T Dt, [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<typename THandle> [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) Chaos::ComputeBoundsThickness ( const [THandle](API\Runtime\Chaos\Chaos\Framework\THandle) & ParticleHandle, [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, [FReal](API\Runtime\ChaosCore\Chaos\FReal) MinBoundsThickness, [FReal](API\Runtime\ChaosCore\Chaos\FReal) BoundsVelocityInflation ) }


code: namespace Chaos { [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) Chaos::ComputeBoundsThickness ( [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) Vel, [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, [FReal](API\Runtime\ChaosCore\Chaos\FReal) MinBoundsThickness, [FReal](API\Runtime\ChaosCore\Chaos\FReal) MaxBoundsThickness, [FReal](API\Runtime\ChaosCore\Chaos\FReal) BoundsVelocityInflation ) }


code: namespace Chaos { [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) Chaos::ComputeBoundsThickness ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 3 > & InParticles, [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, int32 BodyIndex, [FReal](API\Runtime\ChaosCore\Chaos\FReal) MinBoundsThickness, [FReal](API\Runtime\ChaosCore\Chaos\FReal) BoundsVelocityInflation ) }


code: namespace Chaos { template<typename T> void Chaos::ComputeEPAResults ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * VertsA, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * VertsB, const [TEPAEntry](API\Runtime\Chaos\Chaos\TEPAEntry)< T > & Entry, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutDir, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutB ) }


code: namespace Chaos { template<typename OBJECT_ARRAY, typename T, int d> const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeGlobalBoxAndSplitAxis ( const OBJECT_ARRAY & Objects, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & AllObjects, const [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes, bool bAllowMultipleSplitting, int32 & OutAxis ) }


code: namespace Chaos { template<typename T, int d> const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeGlobalBoxAndSplitAxis ( const [TParticles](API\Runtime\Chaos\Chaos\TParticles)< T, d > & Objects, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & AllObjects, const [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes, bool bAllowMultipleSplitting, int32 & OutAxis ) }


code: namespace Chaos { template<typename T> void Chaos::ComputeGridBasedGraphSubColoringPointer ( const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ElementsPerColor, const [TMPMGrid](API\Runtime\Chaos\Chaos\TMPMGrid)< T > & Grid, const int32 GridSize, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> *& PreviousColoring, const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ConstraintsNodesSet, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >>> & ElementsPerSubColors ) }


code: namespace Chaos { void Chaos::ComputeHashTable ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector > & ParticleArray, const FBox & BoundingBox, [TMultiMap](API\Runtime\Core\Containers\TMultiMap)< int32, int32 > & HashTableMap, const float SpatialHashRadius ) }


code: namespace Chaos { template<typename T> [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 > > Chaos::ComputeNodalColoring ( const [TArray](API\Runtime\Core\Containers\TArray)< [TVec4](API\Runtime\ChaosCore\Chaos\TVec4)< int32 >> & Graph, const [Chaos::TDynamicParticles](API\Runtime\Chaos\Chaos\TDynamicParticles)< T, 3 > & InParticles, const int32 GraphParticlesStart, const int32 GraphParticlesEnd, const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & IncidentElements, const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & IncidentElementsLocalIndex ) }


code: namespace Chaos { template<typename T> void Chaos::ComputeWeakConstraintsColoring ( const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & Indices, const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & SecondIndices, const [Chaos::TDynamicParticles](API\Runtime\Chaos\Chaos\TDynamicParticles)< T, 3 > & InParticles, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ConstraintsPerColor ) }


code: namespace Chaos { template<typename T, int d, bool bPersistent> [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeWorldSpaceBoundingBox ( const [TPBDRigidParticleHandleImp](API\Runtime\Chaos\Chaos\TPBDRigidParticleHandleImp)< T, d, bPersistent > & Handle, bool bUseVelocity, T Dt ) }


code: namespace Chaos { template<typename T, int d, bool bPersistent> [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeWorldSpaceBoundingBox ( const [TGeometryParticleHandleImp](API\Runtime\Chaos\Chaos\TGeometryParticleHandleImp)< T, d, bPersistent > & Handle, bool bUseVelocity, T Dt ) }


code: namespace Chaos { template<typename T, typename GenericEntry> [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, 3 > Chaos::ComputeWorldSpaceBoundingBox ( const GenericEntry & InEntry, bool bUseVelocity, T Dt ) }


code: namespace Chaos { template<class T, int d> [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeWorldSpaceBoundingBox ( const [TParticles](API\Runtime\Chaos\Chaos\TParticles)< T, d > & Objects, const int32 i, bool bUseVelocity, T Dt ) }


code: namespace Chaos { template<class T, int d> [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeWorldSpaceBoundingBox ( const [TGeometryParticles](API\Runtime\Chaos\Chaos\TGeometryParticles)< T, d > & Objects, const int32 i, bool bUseVelocity, T Dt ) }


code: namespace Chaos { template<class T, int d> [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeWorldSpaceBoundingBox ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Objects, const int32 i, bool bUseVelocity, T Dt ) }


code: namespace Chaos { template<typename THandle, typename T, int d, bool bPersistent> [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::ComputeWorldSpaceBoundingBoxForHandle ( const [THandle](API\Runtime\Chaos\Chaos\Framework\THandle) & Handle ) }


code: namespace Chaos { template<typename T> T Chaos::CopyFromHelper ( const T & Src ) }


code: namespace Chaos { template<typename TPayloadType, typename T, int d> [TSpatialAccelerationBucketEntry](API\Runtime\Chaos\Chaos\TSpatialAccelerationBucketEntry)< TPayloadType, T, d > Chaos::CopyFromHelper ( const [TSpatialAccelerationBucketEntry](API\Runtime\Chaos\Chaos\TSpatialAccelerationBucketEntry)< TPayloadType, T, d > & Src ) }


code: namespace Chaos { static constexpr [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) Chaos::DefaultHorizonEpsilon() }


description: Prerequisites: The array must be sorted from StartIndex to EndIndex. The extra element won't be deallocated returns true if the element has been found and successfully deleted

code: namespace Chaos { bool Chaos::DeleteValueFromSortedSubArray ( [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Array, int32 Value, int32 StartIndex, int32 Count ) }


code: namespace Chaos { template<typename T, typename FunctionType> bool Chaos::DoForOverlappedCells ( const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, 3 > & AABB, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSize, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv, FunctionType Function ) }


description: Only execute function for new Cells not covered in old (Set difference: {Cells spanned by AABB} - { Cells spanned by AABBExclude})

code: namespace Chaos { template<typename T, typename FunctionType> bool Chaos::DoForOverlappedCellsExclude ( const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, 3 > & AABB, const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, 3 > & AABBExclude, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSize, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv, FunctionType Function ) }


code: namespace Chaos { template<typename FunctionType> void Chaos::DoForRaycastIntersectCells ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & StartPoint, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, [FReal](API\Runtime\ChaosCore\Chaos\FReal) Length, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSize, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv, FunctionType InFunction ) }


code: namespace Chaos { template<typename FunctionType> void Chaos::DoForSweepIntersectCells ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) QueryHalfExtents, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & StartPoint, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, [FReal](API\Runtime\ChaosCore\Chaos\FReal) Length, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSize, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv, FunctionType InFunction ) }


description: This function should be called with a dominant x direction only! Todo: Refactor: Use TVectors consistently

code: namespace Chaos { template<typename FunctionType> void Chaos::DoForSweepIntersectCellsImp ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) QueryHalfExtentsX, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) QueryHalfExtentsY, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) StartPointX, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) StartPointY, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) RayX, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) RayY, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSize, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv, FunctionType InFunction ) }


description: Typical gear ratios: Reverse −4.181, 1st 3.818, 2nd 2.294, 3rd 1.500, 4th 1.133, 5th 0.911 Source: Georg Rill. Road Vehicle Dynamics: Fundamentals and Modeling (Ground Vehicle Engineering Series) (p. 121). CRC Press.

code: namespace Chaos { enum EAABBQueryType { Raycast, Sweep, Overlap, } }


code: namespace Chaos { enum EChaosCollisionTraceFlag { Chaos_CTF_UseDefault, Chaos_CTF_UseSimpleAndComplex, Chaos_CTF_UseSimpleAsComplex, Chaos_CTF_UseComplexAsSimple, Chaos_CTF_MAX, } }


code: namespace Chaos { enum EChaosProperty { CHAOS_PROPERTY_CHECKED, XR, Velocities, Dynamics, DynamicMisc, NonFrequentData, MassProps, KinematicTarget, JointSettings, JointParticleProxies, JointPhysicsObjects, SuspensionSettings, SuspensionParticleProxy, SuspensionLocation, CharacterGroundConstraintSettings, CharacterGroundConstraintDynamicData, CharacterParticleProxy, GroundParticleProxy, ClusterXR, ClusterVelocities, NumProperties, } }


code: namespace Chaos { enum EClusterUnionConnectivityOperation { Add, Remove, } }


code: namespace Chaos { enum EClusterUnionOperation { Add, AddReleased, Remove, UpdateChildToParent, } }


description: Return value of the collision modification callback

code: namespace Chaos { enum ECollisionModifierResult { Unchanged, Modified, Disabled, } }


code: namespace Chaos { enum EClusterUnionOperationTiming { Never, Defer, Immediate, } }


description: Specifies the type of work we should do

code: namespace Chaos { enum ECollisionUpdateType { Any, Deepest, } }


code: namespace Chaos { enum EConstraintType { NoneType = 0, JointConstraintType = 1, SpringConstraintType = 2, SuspensionConstraintType = 3, CharacterGroundConstraintType = 4, } }


code: namespace Chaos { enum EChaosPropertyFlags { CHAOS_PROPERTY_CHECKED, XR = (uint32)1 << (uint32)EChaosProperty:: XR, Velocities = (uint32)1 << (uint32)EChaosProperty:: Velocities, Dynamics = (uint32)1 << (uint32)EChaosProperty:: Dynamics, DynamicMisc = (uint32)1 << (uint32)EChaosProperty:: DynamicMisc, NonFrequentData = (uint32)1 << (uint32)EChaosProperty:: NonFrequentData, MassProps = (uint32)1 << (uint32)EChaosProperty:: MassProps, KinematicTarget = (uint32)1 << (uint32)EChaosProperty:: KinematicTarget, JointSettings = (uint32)1 << (uint32)EChaosProperty:: JointSettings, JointParticleProxies = (uint32)1 << (uint32)EChaosProperty:: JointParticleProxies, JointPhysicsObjects = (uint32)1 << (uint32)EChaosProperty:: JointPhysicsObjects, SuspensionSettings = (uint32)1 << (uint32)EChaosProperty:: SuspensionSettings, SuspensionParticleProxy = (uint32)1 << (uint32)EChaosProperty:: SuspensionParticleProxy, SuspensionLocation = (uint32)1 << (uint32)EChaosProperty:: SuspensionLocation, CharacterGroundConstraintSettings = (uint32)1 << (uint32)EChaosProperty:: CharacterGroundConstraintSettings, CharacterGroundConstraintDynamicData = (uint32)1 << (uint32)EChaosProperty:: CharacterGroundConstraintDynamicData, CharacterParticleProxy = (uint32)1 << (uint32)EChaosProperty:: CharacterParticleProxy, GroundParticleProxy = (uint32)1 << (uint32)EChaosProperty:: GroundParticleProxy, ClusterXR = (uint32)1 << (uint32)EChaosProperty:: ClusterXR, ClusterVelocities = (uint32)1 << (uint32)EChaosProperty:: ClusterVelocities, DummyFlag, } }


description: The shape types involved in a contact constraint. Used to look up the collision detection function

code: namespace Chaos { enum EContactShapesType { Unknown, SphereSphere, SphereCapsule, SphereBox, SphereConvex, SphereTriMesh, SphereHeightField, SpherePlane, CapsuleCapsule, CapsuleBox, CapsuleConvex, CapsuleTriMesh, CapsuleHeightField, BoxBox, BoxConvex, BoxTriMesh, BoxHeightField, BoxPlane, ConvexConvex, ConvexTriMesh, ConvexHeightField, GenericConvexConvex, LevelSetLevelSet, NumShapesTypes, } }


code: namespace Chaos { enum EDamageEvaluationModel { StrainFromDamageThreshold, StrainFromMaterialStrengthAndConnectivity, } }


code: namespace Chaos { enum EEPAResult { Ok, MaxIterations, Degenerate, BadInitialSimplex, NoValidContact, } }


code: namespace Chaos { enum EFilterFlags { SimpleCollision = 0b00000001, ComplexCollision = 0b00000010, CCD = 0b00000100, ContactNotify = 0b00001000, StaticShape = 0b00010000, ModifyContacts = 0b00100000, KinematicKinematicPairs = 0b01000000, } }


code: namespace Chaos { enum EGeometryParticlesSimType { RigidBodySim, Other, } }


description: Status of a call to GJKDistance.

code: namespace Chaos { enum EGJKDistanceResult { Separated, Contact, DeepContact, } }


code: namespace Chaos { namespace EImplicitObject { enum Flags { IsConvex = 1, HasBoundingBox = 1 << 1, DisableCollisions = 1 << 2, } } }


description: Used for down casting when iterating over multiple SOAs.

code: namespace Chaos { enum EInternalClusterType { None, KinematicOrStatic, Dynamic, } }


description: The order of the angular constraints (for settings held in vectors etc)

code: namespace Chaos { enum EJointAngularConstraintIndex { Twist, Swing2, Swing1, } }


code: namespace Chaos { enum EJointConstraintFlags { JointTransforms = static_cast<uint64_t>(1) << 0, CollisionEnabled = static_cast<uint64_t>(1) << 1, Projection = static_cast<uint64_t>(1) << 2, ParentInvMassScale = static_cast<uint64_t>(1) << 3, LinearBreakForce = static_cast<uint64_t>(1) << 4, AngularBreakTorque = static_cast<uint64_t>(1) << 5, UserData = static_cast<uint64_t>(1) << 6, LinearDrive = static_cast<uint64_t>(1) << 7, AngularDrive = static_cast<uint64_t>(1) << 8, Stiffness = static_cast<uint64_t>(1) << 9, Limits = static_cast<uint64_t>(1) << 10, DummyFlag, } }


code: namespace Chaos { enum EJointCylindricalPositionConstraintType { Axial, Radial, } }


code: namespace Chaos { enum EJointForceMode { Acceleration, Force, } }


code: namespace Chaos { enum EJointMotionType { Free, Limited, Locked, } }


description: Controls how a kinematic body is integrated each Evolution Advance

code: namespace Chaos { enum EKinematicTargetMode { None, Reset, Position, Velocity, } }


code: namespace Chaos { enum EMassOffsetType { EPosition = 1 << 0, ERotation = 1 << 1, } }


code: namespace Chaos { void Chaos::EnsureSleepingObjectState ( [EObjectStateType](API\Runtime\Chaos\Chaos\Chaos__EObjectStateType) ObjectState ) }


code: namespace Chaos { enum EObjectStateType { Uninitialized = 0, Sleeping = 1, Kinematic = 2, Static = 3, Dynamic = 4, Count, } }


description: Expanding Polytope Algorithm for finding the contact point for overlapping convex polyhedra. See e.g., "Collision Detection in Interactive 3D Environments" (Gino van den Bergen, 2004) or "Real-time Collision Detection with Implicit Objects" (Leif Olvang, 2010)

code: namespace Chaos { template<typename T, typename TSupportA, typename TSupportB> [EEPAResult](API\Runtime\Chaos\Chaos\Chaos__EEPAResult) Chaos::EPA ( [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsABuffer, [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsBBuffer, const TSupportA & SupportA, const TSupportB & SupportB, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutDir, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & WitnessA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & WitnessB, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Eps ) }


code: namespace Chaos { template<typename T> [EEPAResult](API\Runtime\Chaos\Chaos\Chaos__EEPAResult) Chaos::EPA ( [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsABuffer, [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsBBuffer, const [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 >(const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > &V)> & SupportA, const [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 >(const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > &V)> & SupportB, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutDir, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & WitnessA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & WitnessB, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) EpsRel ) }


code: namespace Chaos { template<typename T> void Chaos::EPAComputeVisibilityBorder ( [TEPAWorkingArray](API\Runtime\Chaos\Chaos\TEPAWorkingArray)< [TEPAEntry](API\Runtime\Chaos\Chaos\TEPAEntry)< T >> & Entries, int32 EntryIdx, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & W, [TEPAWorkingArray](API\Runtime\Chaos\Chaos\TEPAWorkingArray)< [FEPAFloodEntry](API\Runtime\Chaos\Chaos\FEPAFloodEntry) > & OutBorderEdges, [TEPAWorkingArray](API\Runtime\Chaos\Chaos\TEPAWorkingArray)< [FEPAFloodEntry](API\Runtime\Chaos\Chaos\FEPAFloodEntry) > & ToVisitStack ) }


code: namespace Chaos { enum EParticleType { Static, Kinematic, Rigid, Clustered, StaticMesh, SkeletalMesh, GeometryCollection, Unknown, } }


code: namespace Chaos { enum EPendingSpatialDataOperation { Delete, Add, Add, Add, Update { virtual void Reset() override, } }


code: namespace Chaos { enum EPlasticityType { Free, Shrink, Grow, } }


code: namespace Chaos { enum ERemoveParticleBehavior { RemoveAtSwap, Remove, } }


code: namespace Chaos { enum EResimType { FullResim = 0, ResimAsFollower = 1, } }


description: The feature type returned by SATPenetration.

code: namespace Chaos { enum ESATFeatureType { None, Plane, Edge, Vertex, } }


code: namespace Chaos { enum EShapeFlags { CollisionData = (uint32)1 << (uint32)EShapeProperty:: CollisionData, Materials = (uint32)1 << (uint32)EShapeProperty:: Materials, DummyFlag, } }


code: namespace Chaos { enum EShapeProperty { CollisionData, Materials, NumShapeProperties, } }


code: namespace Chaos { enum ESimCallbackOptions { Presimulate = 1 << 0, MidPhaseModification = 1 << 1, CCDModification = 1 << 2, ContactModification = 1 << 3, StrainModification = 1 << 5, ParticleRegister = 1 << 6, ParticleUnregister = 1 << 7, RunOnFrozenGameThread = 1 << 8, Rewind = 1 << 9, } }


code: namespace Chaos { enum ESleepType { MaterialSleep, NeverSleep, } }


code: namespace Chaos { enum ESpatialAcceleration { BoundingVolume, AABBTree, AABBTreeBV, Collection, Unknown, } }


description: Bucket inner indices define for specific use cases.

code: namespace Chaos { enum ESpatialAccelerationCollectionBucketInnerIdx { Default = 0, Dynamic = 1, Dynamic, Dynamic = 4, DefaultQueryOnly = 2, DynamicQueryOnly = 3, } }


code: namespace Chaos { enum EStrainTypes { InternalStrain = 1 << 0, ExternalStrain = 1 << 1, CollisionStrain = 1 << 2, } }


code: namespace Chaos { enum ESuspensionConstraintFlags { Location = 0, Enabled = static_cast<uint64_t>(1) << 1, Target = static_cast<uint64_t>(1) << 2, HardstopStiffness = static_cast<uint64_t>(1) << 3, HardstopVelocityCompensation = static_cast<uint64_t>(1) << 4, SpringPreload = static_cast<uint64_t>(1) << 5, SpringStiffness = static_cast<uint64_t>(1) << 6, SpringDamping = static_cast<uint64_t>(1) << 7, MinLength = static_cast<uint64_t>(1) << 8, MaxLength = static_cast<uint64_t>(1) << 9, Axis = static_cast<uint64_t>(1) << 10, Normal = static_cast<uint64_t>(1) << 11, DummyFlag, } }


code: namespace Chaos { enum ESyncState { InSync, HardDesync, } }


description: Event Emitter flag.

code: namespace Chaos { enum EventEmitterFlag { EmptyDispatcher = 0, OwnDispatcher = 1, GlobalDispatcher = 2, BothDispatcher = 3, } }


code: namespace Chaos { enum EUpdateClusterUnionPropertiesFlags { None = 0, RecomputeMassOrientation = 1 << 0, ForceGenerateConnectionGraph = 1 << 1, IncrementalGenerateConnectionGraph = 1 << 2, UpdateKinematicProperties = 1 << 3, All = RecomputeMassOrientation | ForceGenerateConnectionGraph | UpdateKinematicProperties, } }


code: namespace Chaos { enum EWakeEventEntry { None, Awake, Sleep, } }


code: namespace Chaos { template<typename T, int d> const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > Chaos::FindClosestPointAndAlphaOnLineSegment ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P0, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P1, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P, T & OutAlpha ) }


code: namespace Chaos { template<typename T, int d> const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > Chaos::FindClosestPointOnLineSegment ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P0, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P1, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P ) }


description: This method follows FindClosestPointOnTriangle but does less duplicate work and can handle degenerate triangles. It also returns the barycentric coordinates for the returned point.

code: namespace Chaos { template<typename T, int d> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > Chaos::FindClosestPointAndBaryOnTriangle ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P0, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P1, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P2, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & Bary ) }


code: namespace Chaos { template<typename T, int d> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > Chaos::FindClosestPointOnTriangle ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & ClosestPointOnPlane, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P0, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P1, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P2, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P ) }


code: namespace Chaos { template<typename T, int d> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > Chaos::FindClosestPointOnTriangle ( const [TPlane](API\Runtime\Chaos\Chaos\TPlane)< T, d > & TrianglePlane, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P0, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P1, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P2, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P ) }


code: namespace Chaos { virtual [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::FindGeometryOpposingNormal ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & DenormDir, int32 FaceIndex, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OriginalNormal ) const }


code: namespace Chaos { int32 Chaos::FindInsertIndexIntoSortedArray ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Array, int32 FindValue, int32 StartIndex, int32 EndIndex ) }


code: namespace Chaos { int32 Chaos::FindInSortedArray ( const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Array, int32 FindValue, int32 StartIndex, int32 EndIndex ) }


code: namespace Chaos { template<typename T> void Chaos::FreeObjHelper ( T *& RawPtr ) }


code: namespace Chaos { template<typename TPayloadType, typename T, int d> void Chaos::FreeObjHelper ( [TSpatialAccelerationBucketEntry](API\Runtime\Chaos\Chaos\TSpatialAccelerationBucketEntry)< TPayloadType, T, d > & BucketEntry ) }


description: ToBarycentric()

code: namespace Chaos { template<typename RealType> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< RealType > Chaos::FromBarycentric ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< RealType > & Barycentric, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< RealType > & V0, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< RealType > & V1, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< RealType > & V2 ) }


code: namespace Chaos { template<typename T> T Chaos::GCm3ToKgCm3 ( T Density ) }


description: Concrete can either be the game thread or physics representation, but API stays the same. Useful for keeping initialization and other logic the same

code: namespace Chaos { template<typename T, int d, typename FConcrete> void Chaos::GeometryParticleDefaultConstruct ( FConcrete & Concrete, const [FGeometryParticleParameters](API\Runtime\Chaos\Chaos\FGeometryParticleParameters) & Params ) }


code: namespace Chaos { template<typename FConcrete> bool Chaos::GeometryParticleSleeping ( const FConcrete & Concrete ) }


description: Gets a bucket of acceleration structure pointers.

code: namespace Chaos { template<int Idx, typename First, typename... Rest> auto & Chaos::GetAccelerationsPerType ( [TSpatialTypeTuple](API\Runtime\Chaos\Chaos\TSpatialTypeTuple)< First, Rest... > & Types ) }


code: namespace Chaos { template<int Idx, typename First, typename... Rest> const auto & Chaos::GetAccelerationsPerType ( const [TSpatialTypeTuple](API\Runtime\Chaos\Chaos\TSpatialTypeTuple)< First, Rest... > & Types ) }


code: namespace Chaos { uint32 Chaos::GetChaosCollisionChannelAndExtraFilter ( uint32 Word3, uint8 & OutMaskFilter ) }


code: namespace Chaos { int64 Chaos::GetDirtyCellIndexFromWorldCoordinate ( [FReal](API\Runtime\ChaosCore\Chaos\FReal) Coordinate, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv ) }


code: namespace Chaos { template<typename T, int d> [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< T, d > * Chaos::GetHandleHelper ( [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< T, d > * Handle ) }


code: namespace Chaos { template<typename T, int d> const [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< T, d > * Chaos::GetHandleHelper ( const [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< T, d > * Handle ) }


code: namespace Chaos { template<typename T, int d> [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< T, d > * Chaos::GetHandleHelper ( [TTransientGeometryParticleHandle](API\Runtime\Chaos\Chaos\TTransientGeometryParticleHandle)< T, d > * Handle ) }


code: namespace Chaos { template<typename T, int d> const [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< T, d > * Chaos::GetHandleHelper ( const [TTransientGeometryParticleHandle](API\Runtime\Chaos\Chaos\TTransientGeometryParticleHandle)< T, d > * Handle ) }


code: namespace Chaos { [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Chaos::GetInnerType ( [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Type ) }


code: namespace Chaos { [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::GetNormal() const }


code: namespace Chaos { template<class OBJECT_ARRAY> int32 Chaos::GetObjectCount ( const OBJECT_ARRAY & Objects ) }


code: namespace Chaos { template<class T, int d> int32 Chaos::GetObjectCount ( const [TParticles](API\Runtime\Chaos\Chaos\TParticles)< T, d > & Objects ) }


code: namespace Chaos { template<class T, int d> int32 Chaos::GetObjectCount ( const [TGeometryParticles](API\Runtime\Chaos\Chaos\TGeometryParticles)< T, d > & Objects ) }


code: namespace Chaos { template<class T, int d> int32 Chaos::GetObjectCount ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Objects ) }


code: namespace Chaos { [TPlane](API\Runtime\Chaos\Chaos\TPlane)< T, 3 > Chaos::GetPlane() const }


code: namespace Chaos { virtual uint32 Chaos::GetTypeHash() const }


code: namespace Chaos { uint32 Chaos::GetTypeHash ( const [FParticleID](API\Runtime\Chaos\Chaos\FParticleID) & Unique ) }


code: namespace Chaos { uint32 Chaos::GetTypeHash ( const [FSpatialAccelerationIdx](API\Runtime\Chaos\Chaos\FSpatialAccelerationIdx) & Idx ) }


code: namespace Chaos { uint32 Chaos::GetTypeHash ( const [FUniqueIdx](API\Runtime\Chaos\Chaos\FUniqueIdx) & Unique ) }


code: namespace Chaos { uint32 Chaos::GetTypeHash ( const [Chaos::FHierarchicalSpatialHashCellIdx](API\Runtime\Chaos\Chaos\FHierarchicalSpatialHashCellIdx) & Idx ) }


code: namespace Chaos { template<typename T, int d> static uint32 Chaos::GetTypeHash ( const [TParticles](API\Runtime\Chaos\Chaos\TParticles)< T, d > & InParticles ) }


code: namespace Chaos { template<typename T> uint32 Chaos::GetTypeHash ( const [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > & Ptr ) }


code: namespace Chaos { virtual [FName](API\Runtime\Core\UObject\FName) Chaos::GetTypeName() const }


code: namespace Chaos { template<typename [TPayload](API\Runtime\Core\Delegates\TPayload)> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)<![TIsPointer](API\Runtime\Core\Templates\TIsPointer)< [TPayload](API\Runtime\Core\Delegates\TPayload) >::Value, [FUniqueIdx](API\Runtime\Chaos\Chaos\FUniqueIdx) >::Type Chaos::GetUniqueIdx ( const [TPayload](API\Runtime\Core\Delegates\TPayload) & Payload ) }


code: namespace Chaos { template<typename [TPayload](API\Runtime\Core\Delegates\TPayload)> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [TIsPointer](API\Runtime\Core\Templates\TIsPointer)< [TPayload](API\Runtime\Core\Delegates\TPayload) >::Value, [FUniqueIdx](API\Runtime\Chaos\Chaos\FUniqueIdx) >::Type Chaos::GetUniqueIdx ( const [TPayload](API\Runtime\Core\Delegates\TPayload) & Payload ) }


code: namespace Chaos { [FUniqueIdx](API\Runtime\Chaos\Chaos\FUniqueIdx) Chaos::GetUniqueIdx ( const [FUniqueIdx](API\Runtime\Chaos\Chaos\FUniqueIdx) Payload ) }


code: namespace Chaos { [FUniqueIdx](API\Runtime\Chaos\Chaos\FUniqueIdx) Chaos::GetUniqueIdx ( const int32 Payload ) }


code: namespace Chaos { template<class OBJECT_ARRAY, class T, int d> const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::GetWorldSpaceBoundingBox ( const OBJECT_ARRAY & Objects, const int32 i, const [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<class T, int d> const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > & Chaos::GetWorldSpaceBoundingBox ( const [TParticles](API\Runtime\Chaos\Chaos\TParticles)< T, d > & Objects, const int32 i, const [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<class T, int d> const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::GetWorldSpaceBoundingBox ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Objects, const int32 i, const [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<class T, int d> const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > & Chaos::GetWorldSpaceBoundingBox ( const [TGeometryParticles](API\Runtime\Chaos\Chaos\TGeometryParticles)< T, d > & Objects, const int32 i, const [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


code: namespace Chaos { template<class T, int d> const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > Chaos::GetWorldSpaceBoundingBox ( const [TArray](API\Runtime\Core\Containers\TArray)< [Private::FImplicitBVHObject](API\Runtime\Chaos\Chaos\FImplicitBVHObject) > & Objects, const int32 ObjectIndex, const [TMap](API\Runtime\Core\Containers\TMap)< int32, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d >> & WorldSpaceBoxes ) }


description:
This algorithm aborts if objects are overlapping and it does not initialize the out parameters.
EGJKDistanceResult - see comments on the enum

code: namespace Chaos { template<typename T, typename GJKShapeTypeA, typename GJKShapeTypeB> [EGJKDistanceResult](API\Runtime\Chaos\Chaos\Chaos__EGJKDistanceResult) Chaos::GJKDistance ( const GJKShapeTypeA & A, const GJKShapeTypeB & B, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & InitialV, T & OutDistance, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNearestA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNearestB, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormalA, const T Epsilon, const int32 MaxIts ) }


description: If you do roll your own function, make sure that the vector returned is in or on the Minkowski sum (and don't just use a unit vector along some direction for example) or GJKDistance may early-exit with an inaccurate result.

code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > Chaos::GJKDistanceInitialV ( const TGeometryA & A, const TGeometryB & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & BToATM ) }


description:
Determines if two convex geometries overlap.
True if the geometries overlap, False otherwise

code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKIntersection ( const TGeometryA &__restrict A, const TGeometryB &__restrict B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & BToATM, const T InThicknessA, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & InitialDir ) }


code: namespace Chaos { template<typename T> bool Chaos::GJKIntersection ( const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) &__restrict A, const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) &__restrict B, [FReal](API\Runtime\ChaosCore\Chaos\FReal) EpsilonScale, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & BToATM, const T InThicknessA, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & InitialDir ) }


code: namespace Chaos { template<typename TGeometryA, typename TGeometryB> bool Chaos::GJKIntersectionSimd ( const TGeometryA &__restrict A, const TGeometryB &__restrict B, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & Translation, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & Rotation, [FReal](API\Runtime\ChaosCore\Chaos\FReal) InThicknessA, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & InitialDir ) }


description:
Determines if two convex geometries in the same space overlap IMPORTANT: the two convex geometries must be in the same space!
True if the geometries overlap, False otherwise

code: namespace Chaos { template<typename TGeometryA, typename TGeometryB> bool Chaos::GJKIntersectionSameSpaceSimd ( const TGeometryA & A, const TGeometryB & B, [FReal](API\Runtime\ChaosCore\Chaos\FReal) InThicknessA, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & InitialDir ) }


code: namespace Chaos { bool Chaos::GJKIntersectionSimd ( const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) &__restrict A, const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) &__restrict B, [FReal](API\Runtime\ChaosCore\Chaos\FReal) EpsilonScale, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & Translation, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & Rotation, [FReal](API\Runtime\ChaosCore\Chaos\FReal) InThicknessA, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & InitialDir ) }


description: NOTE: OutPenetration is the penetration including the Thickness (i.e., the actual penetration depth), but the closest points returned are on the core shapes (i.e., ignoring the Thickness). If you want the closest positions on the shape surface (including the Thickness) useGJKPenetration().

code: namespace Chaos { template<bool bNegativePenetrationAllowed, typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKPenetration ( const TGeometryA & A, const TGeometryB & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & BToATM, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestB, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormal, int32 & OutClosestVertexIndexA, int32 & OutClosestVertexIndexB, const T InThicknessA, const T InThicknessB, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & InitialDir, const T Epsilon ) }


code: namespace Chaos { template<bool bNegativePenetrationAllowed, typename T> bool Chaos::GJKPenetrationImpl ( const [FGeomGJKHelper](API\Runtime\Chaos\Chaos\FGeomGJKHelper) & A, const [FGeomGJKHelper](API\Runtime\Chaos\Chaos\FGeomGJKHelper) & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & BToATM, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestB, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormal, int32 & OutClosestVertexIndexA, int32 & OutClosestVertexIndexB, const T InThicknessA, const T InThicknessB, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & InitialDir, const T Epsilon ) }


description:
Calculate the penetration data for two shapes using GJK, assuming both shapes are already in the same space. This is intended for use with triangles which have been transformed into the space of the convex shape.
true always

code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKPenetrationSameSpace ( const TGeometryA & A, const TGeometryB & B, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestB, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormal, int32 & OutVertexA, int32 & OutVertexB, T & OutMaxSupportDelta, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & InitialDir, const T Epsilon, const T EPAEpsilon ) }


code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKPenetrationSameSpace2 ( const TGeometryA & A, const TGeometryB & B, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestB, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormal, int32 & OutVertexA, int32 & OutVertexB, T & OutMaxSupportDelta, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & InitialDir, const T Epsilon, const T EPAEpsilon ) }


description: EPA())

code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKPenetrationWarmStartable ( const TGeometryA & A, const TGeometryB & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & BToATM, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestB, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormalA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormalB, int32 & OutVertexA, int32 & OutVertexB, [TGJKSimplexData](API\Runtime\Chaos\Chaos\TGJKSimplexData)< T > & InOutSimplexData, T & OutMaxSupportDelta, const T Epsilon, const T EPAEpsilon ) }


description: Same as GJKPenetrationWarmStartable but with an index-less algorithm.

code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKPenetrationWarmStartable2 ( const TGeometryA & A, const TGeometryB & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & BToATM, T & OutPenetration, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutClosestB, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormalA, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormalB, int32 & OutVertexA, int32 & OutVertexB, [TGJKSimplexData](API\Runtime\Chaos\Chaos\TGJKSimplexData)< T > & InOutSimplexData, T & OutMaxSupportDelta, const T Epsilon, const T EPAEpsilon ) }


description:
If A overlaps B at the start of the ray ("initial overlap" condition) then this function returns true, and sets OutTime = 0, but does not set any other output variables.
True if the geometries overlap during the sweep, False otherwise

code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKRaycast ( const TGeometryA & A, const TGeometryB & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & StartTM, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & RayDir, const T RayLength, T & OutTime, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & OutPosition, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & OutNormal, const T ThicknessA, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & InitialDir, const T ThicknessB ) }


code: namespace Chaos { template<typename T, typename TGeometryA, typename TGeometryB> bool Chaos::GJKRaycast2 ( const TGeometryA & A, const TGeometryB & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & StartTM, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & RayDir, const T RayLength, T & OutTime, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & OutPosition, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & OutNormal, const T GivenThicknessA, bool bComputeMTD, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & InitialDir, const T GivenThicknessB ) }


code: namespace Chaos { template<typename T> bool Chaos::GJKRaycast2Impl ( const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) & A, const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) & B, const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, 3 > & StartTM, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & RayDir, const T RayLength, T & OutTime, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & OutPosition, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & OutNormal, const T GivenThicknessA, bool bComputeMTD, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & InitialDir, const T GivenThicknessB ) }


code: namespace Chaos { template<typename THandleView, typename ContextCreatorType, typename Lambda> void Chaos::HandleViewParallelForImp ( const [THandleView](API\Runtime\Chaos\Chaos\THandleView) & HandleView, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


code: namespace Chaos { template<typename T> bool Chaos::GJKRaycast2ImplSimd ( const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) & A, const [FGeomGJKHelperSIMD](API\Runtime\Chaos\Chaos\FGeomGJKHelperSIMD) & B, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & BToARotation, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & StartPoint, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & RayDir, T RayLength, T & OutTime, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutPosition, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutNormal, bool bComputeMTD, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & InitialDir ) }


code: namespace Chaos { template<typename Generic> bool Chaos::HasBoundingBox ( const [Generic](API\Runtime\Chaos\Chaos\Collision\Chaos__EParticlePairMidPhaseType) & Item ) }


code: namespace Chaos { template<typename T, int d, bool bPersistent> bool Chaos::HasBoundingBox ( const [TGeometryParticleHandleImp](API\Runtime\Chaos\Chaos\TGeometryParticleHandleImp)< T, d, bPersistent > & Handle ) }


code: namespace Chaos { template<typename T, int d, bool bPersistent> bool Chaos::HasBoundingBox ( const [TPBDRigidParticleHandleImp](API\Runtime\Chaos\Chaos\TPBDRigidParticleHandleImp)< T, d, bPersistent > & Handle ) }


code: namespace Chaos { template<class OBJECT_ARRAY> bool Chaos::HasBoundingBox ( const OBJECT_ARRAY & Objects, const int32 i ) }


code: namespace Chaos { template<class T, int d> bool Chaos::HasBoundingBox ( const [TParticles](API\Runtime\Chaos\Chaos\TParticles)< T, d > & Objects, const int32 i ) }


code: namespace Chaos { template<class T, int d> bool Chaos::HasBoundingBox ( const [TGeometryParticles](API\Runtime\Chaos\Chaos\TGeometryParticles)< T, d > & Objects, const int32 i ) }


code: namespace Chaos { template<class T, int d> bool Chaos::HasBoundingBox ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Objects, const int32 i ) }


description: DO NOT USE: This is only required for serializing the old BVH data.

code: namespace Chaos { template<> bool Chaos::HasBoundingBox ( const [TArray](API\Runtime\Core\Containers\TArray)< [Private::FImplicitBVHObject](API\Runtime\Chaos\Chaos\FImplicitBVHObject) > & Objects, const int32 ObjectIndex ) }


code: namespace Chaos { int32 Chaos::HashCell ( int64 XCell, int64 YCell ) }


code: namespace Chaos { int32 Chaos::HashCoordinates ( [FReal](API\Runtime\ChaosCore\Chaos\FReal) Xcoordinate, [FReal](API\Runtime\ChaosCore\Chaos\FReal) Ycoordinate, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv ) }


code: namespace Chaos { namespace ImplicitObjectType { enum { Sphere = 0, Box, Plane, Capsule, Transformed, Union, LevelSet, Unknown, Convex, TaperedCylinder, Cylinder, TriangleMesh, HeightField, DEPRECATED_Scaled, Triangle, UnionClustered, TaperedCapsule, WeightedLatticeBone, ConcreteObjectCount, IsWeightedLattice = 1 << 5, IsInstanced = 1 << 6, IsScaled = 1 << 7, } } }


code: namespace Chaos { template<typename T> bool Chaos::InitializeEPA ( [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsA, [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsB, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 >(const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > &V)> SupportA, [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 >(const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > &V)> SupportB, [TEPAWorkingArray](API\Runtime\Chaos\Chaos\TEPAWorkingArray)< [TEPAEntry](API\Runtime\Chaos\Chaos\TEPAEntry)< T >> & OutEntries, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutTouchNormal ) }


code: namespace Chaos { template<typename T, typename SupportALambda, typename SupportBLambda> bool Chaos::InitializeEPA ( [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsA, [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T >> & VertsB, const SupportALambda & SupportA, const SupportBLambda & SupportB, [TEPAWorkingArray](API\Runtime\Chaos\Chaos\TEPAWorkingArray)< [TEPAEntry](API\Runtime\Chaos\Chaos\TEPAEntry)< T >> & OutEntries, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutTouchNormal ) }


description: Prerequisites: The array must be sorted from StartIndex to StartIndex + Count -1, and must have one element past StartIndex + Count -1 allocated returns false if the value was already in the array and therefore not added again

code: namespace Chaos { bool Chaos::InsertValueIntoSortedSubArray ( [TArray](API\Runtime\Core\Containers\TArray)< int32 > & Array, int32 Value, int32 StartIndex, int32 Count ) }


code: namespace Chaos { uint32 Chaos::InterleaveWithZeros ( uint16 input ) }


code: namespace Chaos { template<typename T, int d> bool Chaos::IntersectPlanes2 ( [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & I, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & D, const [TPlane](API\Runtime\Chaos\Chaos\TPlane)< T, d > & P1, const [TPlane](API\Runtime\Chaos\Chaos\TPlane)< T, d > & P2 ) }


code: namespace Chaos { template<class OBJECT_ARRAY> bool Chaos::IsDisabled ( const OBJECT_ARRAY & Objects, const uint32 Index ) }


code: namespace Chaos { template<class T, int d> bool Chaos::IsDisabled ( const [TGeometryParticles](API\Runtime\Chaos\Chaos\TGeometryParticles)< T, d > & Objects, const uint32 Index ) }


code: namespace Chaos { template<class T, int d> bool Chaos::IsDisabled ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Objects, const uint32 Index ) }


description: Deprecated* Not used

code: namespace Chaos { const bool Chaos::IsEPASuccess ( [EEPAResult](API\Runtime\Chaos\Chaos\Chaos__EEPAResult) EPAResult ) }


code: namespace Chaos { bool Chaos::IsInstanced ( [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Type ) }


code: namespace Chaos { template<typename T> bool Chaos::IsInterclusterEdge ( const [TPBDRigidParticleHandle](API\Runtime\Chaos\Chaos\TPBDRigidParticleHandle)< T, 3 > & Particle, const [TConnectivityEdge](API\Runtime\Chaos\Chaos\TConnectivityEdge)< T > & Edge ) }


description: Check whether the two edges of two convex shapes contribute to the Minkowski sum. A and B are the face normals for the faces of the edge convex 1 C and D are the negated face normals for the faces of the edge convex 2

code: namespace Chaos { bool Chaos::IsMinkowskiSumFace ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & A, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & B, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & C, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & D ) }


code: namespace Chaos { template<int d> bool Chaos::IsPowerOfTwo ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< int32, d > & Counts ) }


code: namespace Chaos { template<typename T> constexpr [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< TModels_V< [CSerializablePtr](API\Runtime\Chaos\Chaos\CSerializablePtr), T >, bool >::Type Chaos::IsSerializablePtr() }


code: namespace Chaos { bool Chaos::IsScaled ( [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Type ) }


code: namespace Chaos { bool Chaos::IsWeightedLattice ( [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Type ) }


code: namespace Chaos { template<typename T> T Chaos::KgCm3ToKgM3 ( T Density ) }


code: namespace Chaos { template<typename T> T Chaos::KgM3ToKgCm3 ( T Density ) }


code: namespace Chaos { template<typename T, int d, typename FConcrete> void Chaos::KinematicGeometryParticleDefaultConstruct ( FConcrete & Concrete, const [FKinematicGeometryParticleParameters](API\Runtime\Chaos\Chaos\FKinematicGeometryParticleParame-) & Params ) }


code: namespace Chaos { template<typename T, int d> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > Chaos::LineSimplexFindOrigin ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > * Simplex, int32 * Idxs, int32 & NumVerts, T * OutBarycentric ) }


code: namespace Chaos { template<typename T> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::LineSimplexFindOrigin2 ( [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * Simplex, int32 & NumVerts, T * OutBarycentric, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * A, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * B ) }


description: Make a bitmask which covers the lowest NumBits bits with 1's.

code: namespace Chaos { constexpr int8 Chaos::LowBitsMask ( const int8 NumBits ) }


code: namespace Chaos { template<typename THandle> [TConstHandleIterator](API\Runtime\Chaos\Chaos\TConstHandleIterator)< typename THandle::TSOAType > Chaos::MakeConstHandleIterator ( const [TArray](API\Runtime\Core\Containers\TArray)< [THandle](API\Runtime\Chaos\Chaos\Framework\THandle) * > & Handles ) }


code: namespace Chaos { template<typename THandle> [TConstHandleView](API\Runtime\Chaos\Chaos\TConstHandleView)< typename THandle::TSOAType > Chaos::MakeConstHandleView ( const [TArray](API\Runtime\Core\Containers\TArray)< [THandle](API\Runtime\Chaos\Chaos\Framework\THandle) * > & Handles ) }


code: namespace Chaos { template<typename TSOA> [TConstParticleIterator](API\Runtime\Chaos\Chaos\TConstParticleIterator)< TSOA > Chaos::MakeConstParticleIterator ( const [TArray](API\Runtime\Core\Containers\TArray)< [TSOAView](API\Runtime\Chaos\Chaos\TSOAView)< TSOA >> & SOAs ) }


code: namespace Chaos { template<typename TSOA> [TConstParticleView](API\Runtime\Chaos\Chaos\TConstParticleView)< TSOA > Chaos::MakeConstParticleView ( [TSOAView](API\Runtime\Chaos\Chaos\TSOAView)< TSOA > && SOAView ) }


code: namespace Chaos { template<typename TSOA> [TConstParticleView](API\Runtime\Chaos\Chaos\TConstParticleView)< TSOA > Chaos::MakeConstParticleView ( [TArray](API\Runtime\Core\Containers\TArray)< [TSOAView](API\Runtime\Chaos\Chaos\TSOAView)< TSOA >> && SOAViews ) }


code: namespace Chaos { template<typename TSOA> [TConstParticleView](API\Runtime\Chaos\Chaos\TConstParticleView)< TSOA > Chaos::MakeConstParticleView ( TSOA * SOA ) }


description: Utility for creatingTGJKCoreShapeobjects using template parameter deduction.

code: namespace Chaos { template<typename T_SHAPE> [TGJKCoreShape](API\Runtime\Chaos\Chaos\TGJKCoreShape)< T_SHAPE > Chaos::MakeGJKCoreShape ( const T_SHAPE & InShape ) }


description: Utility for creatingTGJKShapeobjects using template parameter deduction.

code: namespace Chaos { template<typename T_SHAPE> [TGJKShape](API\Runtime\Chaos\Chaos\TGJKShape)< T_SHAPE > Chaos::MakeGJKShape ( const T_SHAPE & InShape ) }


code: namespace Chaos { template<typename THandle> [THandleIterator](API\Runtime\Chaos\Chaos\THandleIterator)< typename THandle::TSOAType > Chaos::MakeHandleIterator ( const [TArray](API\Runtime\Core\Containers\TArray)< [THandle](API\Runtime\Chaos\Chaos\Framework\THandle) * > & Handles ) }


code: namespace Chaos { template<typename THandle> [THandleView](API\Runtime\Chaos\Chaos\THandleView)< typename THandle::TSOAType > Chaos::MakeHandleView ( const [TArray](API\Runtime\Core\Containers\TArray)< [THandle](API\Runtime\Chaos\Chaos\Framework\THandle) * > & Handles ) }


code: namespace Chaos { template<typename TSOA> [TParticleIterator](API\Runtime\Chaos\Chaos\TParticleIterator)< TSOA > Chaos::MakeParticleIterator ( const [TArray](API\Runtime\Core\Containers\TArray)< [TSOAView](API\Runtime\Chaos\Chaos\TSOAView)< TSOA >> & SOAs ) }


code: namespace Chaos { template<typename TSOA> [TParticleView](API\Runtime\Chaos\Chaos\TParticleView)< TSOA > Chaos::MakeParticleView ( [TArray](API\Runtime\Core\Containers\TArray)< [TSOAView](API\Runtime\Chaos\Chaos\TSOAView)< TSOA >> && SOAViews ) }


code: namespace Chaos { template<typename TSOA> [TParticleView](API\Runtime\Chaos\Chaos\TParticleView)< TSOA > Chaos::MakeParticleView ( TSOA * SOA ) }


code: namespace Chaos { template<typename T> [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > Chaos::MakeSerializable ( const [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< T > & Unique ) }


code: namespace Chaos { template<typename Ret, typename T> [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< Ret > Chaos::MakeSerializable ( const [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< T > & Unique ) }


code: namespace Chaos { template<typename T> [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > Chaos::MakeSerializable ( const [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > & P ) }


code: namespace Chaos { template<typename T> [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > Chaos::MakeSerializable ( const [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< T > && Unique ) }


code: namespace Chaos { template<typename T, ESPMode TESPMode> [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > Chaos::MakeSerializable ( const [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< T, TESPMode > & Shared ) }


code: namespace Chaos { template<typename Ret, typename T> [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > Chaos::MakeSerializable ( const [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< T > && Unique ) }


description: Solver uses Kg for mass, Second for time and Cm for distance Since a Pascal is 1N/m2 => (Kg.m)/(m2.s2) we get 1MPa = 10000 Kg/(cm.s2)

code: namespace Chaos { constexpr float Chaos::MegaPascalToKgPerCmS2 ( float MegaPascals ) }


code: namespace Chaos { template<typename T> const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::MinkowskiVert ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * VertsABuffer, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * VertsBBuffer, const int32 Idx ) }


description: Counts the number of bits needed to represent an int with a max.

code: namespace Chaos { constexpr int8 Chaos::NumBitsNeeded ( const int8 MaxValue ) }


description: Count N, the number of bits needed to store an object state.

code: namespace Chaos { static Chaos::ObjectStateBitCount = NumBitsNeeded((int8)EObjectStateType::Count - (int8)1); }


code: namespace Chaos { template<class T, int d> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > & AABB ) }


code: namespace Chaos { template<typename TPayloadType, class T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TBoundingVolume](API\Runtime\Chaos\Chaos\TBoundingVolume)< TPayloadType, T, d > & BoundingVolume ) }


code: namespace Chaos { template<typename TPayloadType, class T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TBoundingVolume](API\Runtime\Chaos\Chaos\TBoundingVolume)< TPayloadType, T, d > & BoundingVolume ) }


code: namespace Chaos { template<typename T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TBVHNode](API\Runtime\Chaos\Chaos\TBVHNode)< T, d > & LeafNode ) }


code: namespace Chaos { template<class OBJECT_ARRAY, class LEAF_TYPE, class T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TBoundingVolumeHierarchy](API\Runtime\Chaos\Chaos\TBoundingVolumeHierarchy)< OBJECT_ARRAY, LEAF_TYPE, T, d > & BVH ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) & Value ) }


code: namespace Chaos { [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) & Value ) }


code: namespace Chaos { template<typename T> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T > & Serializable ) }


code: namespace Chaos { template<typename T, typename TAllocator> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T >, TAllocator > & Array ) }


code: namespace Chaos { template<typename T, typename TAllocator> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< T, TAllocator > & Array ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [Chaos::FReal](API\Runtime\ChaosCore\Chaos\FReal) & Real ) }


code: namespace Chaos { template<class T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, d > & AABB ) }


code: namespace Chaos { template<typename T> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [IsSerializablePtr](API\Runtime\Chaos\Chaos\Chaos__IsSerializablePtr)< T >), [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< T > & Obj ) }


code: namespace Chaos { template<typename T, ESPMode Mode> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [IsSerializablePtr](API\Runtime\Chaos\Chaos\Chaos__IsSerializablePtr)< T >), [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< T, Mode > & Obj ) }


code: namespace Chaos { template<typename T> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< T::AlwaysSerializable, [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, T *& Obj ) }


code: namespace Chaos { template<typename T, typename TAllocator> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [IsSerializablePtr](API\Runtime\Chaos\Chaos\Chaos__IsSerializablePtr)< T >), [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< T >, TAllocator > & Array ) }


code: namespace Chaos { template<typename T, typename TAllocator> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< T::AlwaysSerializable, [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< T *, TAllocator > & Array ) }


code: namespace Chaos { template<typename T, typename TAllocator, typename TAllocator2> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [IsSerializablePtr](API\Runtime\Chaos\Chaos\Chaos__IsSerializablePtr)< T >), [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< T >, TAllocator >, TAllocator2 > & Array ) }


code: namespace Chaos { template<typename T, typename TAllocator, ESPMode Mode> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [IsSerializablePtr](API\Runtime\Chaos\Chaos\Chaos__IsSerializablePtr)< T >), [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< T, Mode >, TAllocator > & Array ) }


code: namespace Chaos { template<typename T, typename TAllocator, typename TAllocator2, ESPMode Mode> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [IsSerializablePtr](API\Runtime\Chaos\Chaos\Chaos__IsSerializablePtr)< T >), [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< T, Mode >, TAllocator >, TAllocator2 > & Array ) }


code: namespace Chaos { template<typename T, typename TAllocator, typename TAllocator2> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [IsSerializablePtr](API\Runtime\Chaos\Chaos\Chaos__IsSerializablePtr)< T >), [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & >::Type Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< T >, TAllocator >, TAllocator2 > & Array ) }


code: namespace Chaos { template<typename T, int d, EGeometryParticlesSimType SimType> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TGeometryParticlesImp](API\Runtime\Chaos\Chaos\TGeometryParticlesImp)< T, d, SimType > & Particles ) }


code: namespace Chaos { template<typename TPayloadType, bool bComputeBounds, typename T> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TAABBTreeLeafArray](API\Runtime\Chaos\Chaos\TAABBTreeLeafArray)< TPayloadType, bComputeBounds, T > & LeafArray ) }


code: namespace Chaos { [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [FSpatialAccelerationIdx](API\Runtime\Chaos\Chaos\FSpatialAccelerationIdx) & Idx ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, FHeightField::FDataType::MinMaxHeights & Value ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & Value ) }


code: namespace Chaos { [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & Value ) }


code: namespace Chaos { template<typename TPayloadType, typename T> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TPayloadBoundsElement](API\Runtime\Chaos\Chaos\TPayloadBoundsElement)< TPayloadType, T > & PayloadElement ) }


code: namespace Chaos { template<typename TKey, typename TValue> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArrayAsMap](API\Runtime\Chaos\Chaos\TArrayAsMap)< TKey, TValue > & Map ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FParticlePositionRotation](API\Runtime\Chaos\Chaos\FParticlePositionRotation) & Data ) }


code: namespace Chaos { template<typename T, int d, EGeometryParticlesSimType SimType> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TKinematicGeometryParticlesImp](API\Runtime\Chaos\Chaos\TKinematicGeometryParticlesImp)< T, d, SimType > & Particles ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FParticleVelocities](API\Runtime\Chaos\Chaos\FParticleVelocities) & Data ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FParticleDynamics](API\Runtime\Chaos\Chaos\FParticleDynamics) & Data ) }


code: namespace Chaos { template<typename LeafType> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TLeafContainer](API\Runtime\Chaos\Chaos\TLeafContainer)< LeafType > & LeafArray ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FParticleMassProps](API\Runtime\Chaos\Chaos\FParticleMassProps) & Data ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FParticleDynamicMisc](API\Runtime\Chaos\Chaos\FParticleDynamicMisc) & Data ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FParticleNonFrequentData](API\Runtime\Chaos\Chaos\FParticleNonFrequentData) & Data ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FCollisionData](API\Runtime\Chaos\Chaos\FCollisionData) & Data ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FMaterialData](API\Runtime\Chaos\Chaos\FMaterialData) & Data ) }


code: namespace Chaos { template<typename T, int d> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TGeometryParticle](API\Runtime\Chaos\Chaos\TGeometryParticle)< T, d > & Particle ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FAccelerationStructureHandle](API\Runtime\Chaos\Chaos\FAccelerationStructureHandle) & AccelerationHandle ) }


code: namespace Chaos { template<typename T, int d> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Particles ) }


code: namespace Chaos { template<typename T> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TPlaneConcrete](API\Runtime\Chaos\Chaos\TPlaneConcrete)< T > & PlaneConcrete ) }


code: namespace Chaos { template<typename T, EChaosProperty PropName> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TChaosProperty](API\Runtime\Chaos\Chaos\TChaosProperty)< T, PropName > & Prop ) }


code: namespace Chaos { template<typename T> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TAABBTreeNode](API\Runtime\Chaos\Chaos\TAABBTreeNode)< T > & Node ) }


code: namespace Chaos { template<typename T, EShapeProperty PropName> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TShapeProperty](API\Runtime\Chaos\Chaos\TShapeProperty)< T, PropName > & Prop ) }


code: namespace Chaos { template<typename T, int d> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TRigidParticles](API\Runtime\Chaos\Chaos\TRigidParticles)< T, d > & Particles ) }


description: Misc stuff

code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) & Shape ) }


code: namespace Chaos { template<typename TPayloadType, typename T, int d> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TSpatialAccelerationBucketEntry](API\Runtime\Chaos\Chaos\TSpatialAccelerationBucketEntry)< TPayloadType, T, d > & BucketEntry ) }


code: namespace Chaos { template<typename TObj> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TSpatialCollectionBucket](API\Runtime\Chaos\Chaos\TSpatialCollectionBucket)< TObj > & Bucket ) }


code: namespace Chaos { template<typename T> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TTetrahedron](API\Runtime\Chaos\Chaos\TTetrahedron)< T > & Value ) }


code: namespace Chaos { template<typename T> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TTriangle](API\Runtime\Chaos\Chaos\TTriangle)< T > & Value ) }


code: namespace Chaos { [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [FAABBVectorized](API\Runtime\Chaos\Chaos\FAABBVectorized) & Bounds ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FTrimeshBVH::FChildData](API\Runtime\Chaos\Chaos\FTrimeshBVH\FChildData) & ChildData ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FTrimeshBVH::FNode](API\Runtime\Chaos\Chaos\FTrimeshBVH\FNode) & Node ) }


code: namespace Chaos { [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [FAABBTreePayloadInfo](API\Runtime\Chaos\Chaos\FAABBTreePayloadInfo) & PayloadInfo ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FTrimeshBVH::FAABBType](API\Runtime\Chaos\Chaos\FTrimeshBVH\FAABBType) & Bounds ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FAABBVectorized](API\Runtime\Chaos\Chaos\FAABBVectorized) & Bounds ) }


code: namespace Chaos { [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [FTrimeshBVH](API\Runtime\Chaos\Chaos\FTrimeshBVH) & TrimeshBVH ) }


code: namespace Chaos { [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [FTrimeshIndexBuffer](API\Runtime\Chaos\Chaos\FTrimeshIndexBuffer) & Buffer ) }


code: namespace Chaos { template<typename T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TUniformGridBase](API\Runtime\Chaos\Chaos\TUniformGridBase)< T, d > & Value ) }


code: namespace Chaos { [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [FWeightedLatticeInfluenceData](API\Runtime\Chaos\Chaos\FWeightedLatticeInfluenceData) & Value ) }


code: namespace Chaos { template<typename TPayloadType, class T, int d> [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TBVCellElement](API\Runtime\Chaos\Chaos\TBVCellElement)< TPayloadType, T, d > & Elem ) }


code: namespace Chaos { template<typename TPayloadType, typename TLeafType, bool bMutable, typename T> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TAABBTree](API\Runtime\Chaos\Chaos\TAABBTree)< TPayloadType, TLeafType, bMutable, T > & AABBTree ) }


code: namespace Chaos { template<typename T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TBVPayloadInfo](API\Runtime\Chaos\Chaos\TBVPayloadInfo)< T, d > & Info ) }


code: namespace Chaos { bool Chaos::operator== ( [ESpatialAcceleration](API\Runtime\Chaos\Chaos\Chaos__ESpatialAcceleration) A, [SpatialAccelerationType](API\Runtime\Chaos\Chaos\SpatialAccelerationType) B ) }


code: namespace Chaos { bool Chaos::operator== ( [SpatialAccelerationType](API\Runtime\Chaos\Chaos\SpatialAccelerationType) A, [ESpatialAcceleration](API\Runtime\Chaos\Chaos\Chaos__ESpatialAcceleration) B ) }


code: namespace Chaos { bool Chaos::operator!= ( [ESpatialAcceleration](API\Runtime\Chaos\Chaos\Chaos__ESpatialAcceleration) A, [SpatialAccelerationType](API\Runtime\Chaos\Chaos\SpatialAccelerationType) B ) }


code: namespace Chaos { bool Chaos::operator!= ( [SpatialAccelerationType](API\Runtime\Chaos\Chaos\SpatialAccelerationType) A, [ESpatialAcceleration](API\Runtime\Chaos\Chaos\Chaos__ESpatialAcceleration) B ) }


code: namespace Chaos { [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & Chaos::operator[] ( uint32 InIndex ) }


code: namespace Chaos { [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) & Chaos::operator&= ( [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) & Lhs, [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Rhs ) }


code: namespace Chaos { [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) & Chaos::operator&= ( [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) & Lhs, [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Rhs ) }


code: namespace Chaos { [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) & Chaos::operator&= ( [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) & Lhs, [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Rhs ) }


code: namespace Chaos { [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) & Chaos::operator^= ( [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) & Lhs, [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Rhs ) }


code: namespace Chaos { [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) & Chaos::operator^= ( [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) & Lhs, [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Rhs ) }


code: namespace Chaos { [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) & Chaos::operator^= ( [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) & Lhs, [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Rhs ) }


code: namespace Chaos { constexpr [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Chaos::operator& ( [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Lhs, [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Rhs ) }


code: namespace Chaos { constexpr [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Chaos::operator& ( [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Lhs, [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Rhs ) }


code: namespace Chaos { constexpr [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Chaos::operator& ( [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Lhs, [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Rhs ) }


code: namespace Chaos { constexpr [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Chaos::operator^ ( [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Lhs, [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Rhs ) }


code: namespace Chaos { constexpr [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Chaos::operator^ ( [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Lhs, [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Rhs ) }


code: namespace Chaos { constexpr [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Chaos::operator^ ( [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Lhs, [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Rhs ) }


code: namespace Chaos { constexpr bool Chaos::operator! ( [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) E ) }


code: namespace Chaos { constexpr bool Chaos::operator! ( [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) E ) }


code: namespace Chaos { constexpr [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) Chaos::operator~ ( [EUpdateClusterUnionPropertiesFlags](API\Runtime\Chaos\Chaos\Chaos__EUpdateClusterUnionProper-) E ) }


code: namespace Chaos { constexpr [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) Chaos::operator~ ( [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) E ) }


code: namespace Chaos { constexpr bool Chaos::operator! ( [EMassOffsetType](API\Runtime\Chaos\Chaos\Chaos__EMassOffsetType) E ) }


code: namespace Chaos { constexpr [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) Chaos::operator~ ( [ESimCallbackOptions](API\Runtime\Chaos\Chaos\Chaos__ESimCallbackOptions) E ) }


code: namespace Chaos { [FComplex](API\Runtime\Chaos\Chaos\FComplex) Chaos::operator* ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Other, const [FComplex](API\Runtime\Chaos\Chaos\FComplex) Complex ) }


code: namespace Chaos { virtual bool Chaos::Overlap ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & Point, const T Thickness ) const }


code: namespace Chaos { template<typename QueryGeometry> bool Chaos::OverlapQuery ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & A, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & ATM, const QueryGeometry & B, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & BTM, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Thickness, [FMTDInfo](API\Runtime\Chaos\Chaos\FMTDInfo) * OutMTD ) }


code: namespace Chaos { template<typename TView, typename ContextCreatorType, typename Lambda> void Chaos::ParticlesParallelFor ( const TView & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func, bool bForceSingleThreaded ) }


code: namespace Chaos { template<typename TSOA, typename ContextCreatorType, typename Lambda> void Chaos::ParticlesParallelForImp ( const [TConstHandleView](API\Runtime\Chaos\Chaos\TConstHandleView)< TSOA > & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


code: namespace Chaos { template<typename TSOA, typename ContextCreatorType, typename Lambda> void Chaos::ParticlesParallelForImp ( const [THandleView](API\Runtime\Chaos\Chaos\THandleView)< TSOA > & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


code: namespace Chaos { template<typename TSOA, typename ContextCreatorType, typename Lambda> void Chaos::ParticlesParallelForImp ( const [TConstParticleView](API\Runtime\Chaos\Chaos\TConstParticleView)< TSOA > & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


code: namespace Chaos { template<typename TSOA, typename ContextCreatorType, typename Lambda> void Chaos::ParticlesParallelForImp ( const [TParticleView](API\Runtime\Chaos\Chaos\TParticleView)< TSOA > & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


code: namespace Chaos { template<typename TParticle, typename ContextCreatorType, typename Lambda> void Chaos::ParticlesParallelForImp ( const [TArray](API\Runtime\Core\Containers\TArray)< TParticle > & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


description: The non-parallel implementation of iteration should not deviate in behavior from this parallel implementation. They must be kept in sync.

code: namespace Chaos { template<typename TParticleView, typename ContextCreatorType, typename Lambda> void Chaos::ParticleViewParallelForImp ( const [TParticleView](API\Runtime\Chaos\Chaos\TParticleView) & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


code: namespace Chaos { template<typename TView, typename ContextCreatorType, typename Lambda> void Chaos::ParticlesSequentialFor ( const TView & Particles, const ContextCreatorType & ContextCreator, const Lambda & Func ) }


code: namespace Chaos { template<typename SpatialAccelerationCollection> std::enable_if_t< std::is_same_v< typename SpatialAccelerationCollection::TPayloadType, [FAccelerationStructureHandle](API\Runtime\Chaos\Chaos\FAccelerationStructureHandle) >, void > Chaos::PBDComputeConstraintsLowLevel_Helper ( [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, const SpatialAccelerationCollection & Accel, [FSpatialAccelerationBroadPhase](API\Runtime\Chaos\Chaos\Collision\FSpatialAccelerationBroadPhase) & BroadPhase, [Private::FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) * Allocator, const [FCollisionDetectorSettings](API\Runtime\Chaos\Chaos\Collision\FCollisionDetectorSettings) & Settings, [IResimCacheBase](API\Runtime\Chaos\Chaos\IResimCacheBase) * ResimCache ) }


code: namespace Chaos { template<typename SpatialAccelerationCollection> std::enable_if_t<!std::is_same_v< typename SpatialAccelerationCollection::TPayloadType, [FAccelerationStructureHandle](API\Runtime\Chaos\Chaos\FAccelerationStructureHandle) >, void > Chaos::PBDComputeConstraintsLowLevel_Helper ( [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, const SpatialAccelerationCollection & Accel, [FSpatialAccelerationBroadPhase](API\Runtime\Chaos\Chaos\Collision\FSpatialAccelerationBroadPhase) & BroadPhase, [Private::FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) * Allocator, const [FCollisionDetectorSettings](API\Runtime\Chaos\Chaos\Collision\FCollisionDetectorSettings) & Settings, [IResimCacheBase](API\Runtime\Chaos\Chaos\IResimCacheBase) * ResimCache ) }


code: namespace Chaos { template<typename T, int d, typename FConcrete> void Chaos::PBDRigidClusteredParticleDefaultConstruct ( FConcrete & Concrete, const [FPBDRigidParticleParameters](API\Runtime\Chaos\Chaos\FPBDRigidParticleParameters) & Params ) }


code: namespace Chaos { template<typename T, int d, typename FConcrete> void Chaos::PBDRigidParticleDefaultConstruct ( FConcrete & Concrete, const [FPBDRigidParticleParameters](API\Runtime\Chaos\Chaos\FPBDRigidParticleParameters) & Params ) }


code: namespace Chaos { virtual T Chaos::PhiWithNormal ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & InSamplePoint, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormal ) const }


code: namespace Chaos { template<typename [TPayload](API\Runtime\Core\Delegates\TPayload), typename TVisitor> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)<![TIsPointer](API\Runtime\Core\Templates\TIsPointer)< [TPayload](API\Runtime\Core\Delegates\TPayload) >::Value, bool >::Type Chaos::PrePreFilterHelper ( const [TPayload](API\Runtime\Core\Delegates\TPayload) & Payload, const TVisitor & Visitor ) }


code: namespace Chaos { template<typename [TPayload](API\Runtime\Core\Delegates\TPayload), typename TVisitor> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [TIsPointer](API\Runtime\Core\Templates\TIsPointer)< [TPayload](API\Runtime\Core\Delegates\TPayload) >::Value, bool >::Type Chaos::PrePreFilterHelper ( const [TPayload](API\Runtime\Core\Delegates\TPayload) & Payload, const TVisitor & Visitor ) }


code: namespace Chaos { template<typename TVisitor> bool Chaos::PrePreFilterHelper ( const int32 Payload, const TVisitor & Visitor ) }


description: Used to filter out at the acceleration structure layer using Query data Returns true when there is no way a later PreFilter will succeed. Avoid virtuals etc..

code: namespace Chaos { bool Chaos::PrePreQueryFilterImp ( const [FCollisionFilterData](API\Runtime\Chaos\Chaos\FCollisionFilterData) & QueryFilterData, const [FCollisionFilterData](API\Runtime\Chaos\Chaos\FCollisionFilterData) & UnionFilterData ) }


description: Used to filter out at the acceleration structure layer using Simdata Returns true when there is no way a later PreFilter will succeed. Avoid virtuals etc..

code: namespace Chaos { bool Chaos::PrePreSimFilterImp ( const [FCollisionFilterData](API\Runtime\Chaos\Chaos\FCollisionFilterData) & SimFilterData, const [FCollisionFilterData](API\Runtime\Chaos\Chaos\FCollisionFilterData) & OtherSimFilterData ) }


description: The type of solver to use for collisions.

code: namespace Chaos { namespace Private { enum ECollisionSolverType { GaussSeidel, GaussSeidelSimd, PartialJacobi, } } }