description: Get the first physical material on the particle (a multi-shape particle may have many)

code: namespace Chaos { namespace Private { const [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) * Chaos::Private::GetFirstPhysicsMaterial ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle, const [TArrayCollectionArray](API\Runtime\Engine\Physics\Experimental\TArrayCollectionArray)< [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) >> * PhysicsMaterials, const [TArrayCollectionArray](API\Runtime\Engine\Physics\Experimental\TArrayCollectionArray)< [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) >> * PerParticlePhysicsMaterials, const [THandleArray](API\Runtime\Chaos\Chaos\Framework\THandleArray)< [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) > *const SimMaterials ) } }


description: Get the physical material for the specified Shape on the particle. NOTE: each shape may have its own material, but the particle may also have an override.

module: Chaos

code: namespace Chaos { namespace Private { const [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) * Chaos::Private::GetPhysicsMaterial ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle, const [FShapeInstance](API\Runtime\Chaos\Chaos\FShapeInstance) * Shape, const int32 FaceIndex, const [TArrayCollectionArray](API\Runtime\Engine\Physics\Experimental\TArrayCollectionArray)< [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) >> * PhysicsMaterials, const [TArrayCollectionArray](API\Runtime\Engine\Physics\Experimental\TArrayCollectionArray)< [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) >> * PerParticlePhysicsMaterials, const [THandleArray](API\Runtime\Chaos\Chaos\Framework\THandleArray)< [FChaosPhysicsMaterial](API\Runtime\Chaos\Chaos\FChaosPhysicsMaterial) > *const SimMaterials ) } }


code: namespace Chaos { virtual bool Chaos::Raycast ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & StartPoint, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & Dir, const T Length, const T Thickness, T & OutTime, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutPosition, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutNormal, int32 & OutFaceIndex ) const }


description: Ray / triangle intersection this provides a double sided test note : this method assumes that the triangle formed by A,B and C is well formed

code: namespace Chaos { template<typename T> bool Chaos::RayTriangleIntersection ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & RayStart, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & RayDir, T RayLength, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & A, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & B, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & C, T & OutT, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutN ) }


code: namespace Chaos { template<typename T, typename ToleranceProvider> bool Chaos::RayTriangleIntersectionAndBary ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & RayStart, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & RayDir, T RayLength, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & A, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & B, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & C, T & OutT, [TVec2](API\Runtime\ChaosCore\Chaos\TVec2)< T > & OutBary, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & OutN ) }


description: Find the nearest Edge-Edge pair that contributes to the minkowski surface.

code: namespace Chaos { template<typename ConvexImplicitType1, typename ConvexImplicitType2> [FSATResult](API\Runtime\Chaos\Chaos\FSATResult) Chaos::SATEdgeEdge ( const ConvexImplicitType1 & Convex1, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Convex1Transform, const ConvexImplicitType2 & Convex2, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Convex2Transform, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) CullDistance ) }


code: namespace Chaos { template<typename T> void Chaos::ReorderGJKArray ( T * Data, [FSimplex](API\Runtime\Chaos\Chaos\FSimplex) & Idxs ) }


description: Separating Axis Test Find the pair of features with the minimum separation distance or the minimum depenetration distance

code: namespace Chaos { template<typename ConvexImplicitType1, typename ConvexImplicitType2> [FSATResult](API\Runtime\Chaos\Chaos\FSATResult) Chaos::SATPenetration ( const ConvexImplicitType1 & Convex1, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Convex1Transform, const ConvexImplicitType2 & Convex2, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Convex2Transform, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) CullDistance, const [FSATSettings](API\Runtime\Chaos\Chaos\FSATSettings) & Settings ) }


description: Find the nearest Plane-Vertex pair by looking at the Vertices of Convex1 and the Planes of Convex2.

code: namespace Chaos { template<typename ConvexImplicitType1, typename ConvexImplicitType2> [FSATResult](API\Runtime\Chaos\Chaos\FSATResult) Chaos::SATPlaneVertex ( const ConvexImplicitType1 & Convex1, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Convex1Transform, const ConvexImplicitType2 & Convex2, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Convex2Transform, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) CullDistance ) }


description: Serializes and loads ObjectToSave to memory and to disk, returning loaded versions in array for testing. also loads and returns all binaries in test's subdirectory in SerializedBinaryDirectory. Used to test backwards compatibility for previous serialization formats.

code: namespace Chaos { template<class T, class U> bool Chaos::SaveLoadUtility ( U & ObjectToSave, TCHAR const * SerializedBinaryDirectory, TCHAR const * BinaryFolderName, bool bSave, [TArray](API\Runtime\Core\Containers\TArray)< U > & ObjectsToTest ) }


code: namespace Chaos { virtual void Chaos::Serialize ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar ) }


code: namespace Chaos { constexpr [EShapeFlags](API\Runtime\Chaos\Chaos\Chaos__EShapeFlags) Chaos::ShapePropToFlag ( [EShapeProperty](API\Runtime\Chaos\Chaos\Chaos__EShapeProperty) Prop ) }


code: namespace Chaos { void Chaos::SetObjectStateHelper ( [IPhysicsProxyBase](API\Runtime\Chaos\Chaos\Framework\IPhysicsProxyBase) & Proxy, [FPBDRigidParticle](API\Runtime\Chaos\Chaos\FPBDRigidParticle) & Rigid, [EObjectStateType](API\Runtime\Chaos\Chaos\Chaos__EObjectStateType) InState, bool bAllowEvents, bool bInvalidate ) }


code: namespace Chaos { template<typename T> bool Chaos::SignMatch ( T A, T B ) }


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


code: namespace Chaos { template<class T> bool Chaos::SmoothProject ( const TConstArrayView< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Points, const [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< int32 >> & Tris, const [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & PointNormals, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Pos, const int32 TriIdx, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Weights ) }


code: namespace Chaos { template<typename T> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::SimplexFindClosestToOrigin2 ( [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 ) }


code: namespace Chaos { template<class T> bool Chaos::SmoothProject ( const TConstArrayView< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Points, const [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< int32 >> & Tris, const [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & PointNormals, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Pos, const int32 TriIdx, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Weights, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) >> & TangentBases, T * B, T * C, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & C0, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & C1, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & C2, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & W0, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & W1, [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & W2 ) }


code: namespace Chaos { template<class T> [TArray](API\Runtime\Core\Containers\TArray)< bool > Chaos::SmoothProject ( const TConstArrayView< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Points, const [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< int32 >> & Tris, const [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & PointNormals, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Pos, const [TArray](API\Runtime\Core\Containers\TArray)< int32 > & TriIdx, [TArray](API\Runtime\Core\Containers\TArray)< [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) > & Weights, const bool UseFirstFound ) }


code: namespace Chaos { namespace Softs { static [FSolverReal](API\Runtime\Chaos\Chaos\FSolverReal) Chaos::Softs::CalcExponentialParameterFit ( const [FSolverReal](API\Runtime\Chaos\Chaos\FSolverReal) ParameterFitBase, const [FSolverReal](API\Runtime\Chaos\Chaos\FSolverReal) ParameterFitLogBase, const [FSolverReal](API\Runtime\Chaos\Chaos\FSolverReal) InValue ) } }


description: DECLARE_CYCLE_STAT(TEXT("Chaos XPBD Corotated Constraint"), STAT_ChaosXPBDCorotated, STATGROUP_Chaos); DECLARE_CYCLE_STAT(TEXT("Chaos XPBD Corotated Constraint Polar Compute"), STAT_ChaosXPBDCorotatedPolar, STATGROUP_Chaos); DECLARE_CYCLE_STAT(TEXT("Chaos XPBD Corotated Constraint Det Compute"), STAT_ChaosXPBDCorotatedDet, STATGROUP_Chaos);

code: namespace Chaos { namespace Softs { enum ECollectionPropertyUpdateFlags { None = 0, AppendNewProperties = 1 << 0, UpdateExistingProperties = 1 << 1, RemoveMissingProperties = 1 << 2, DisableMissingProperties = 1 << 3, } } }


code: namespace Chaos { namespace Softs { ECollectionPropertyFlag & Chaos::Softs::operator&= ( ECollectionPropertyFlag & Lhs, ECollectionPropertyFlag Rhs ) } }


description: Property flags, whether properties are enabled, animatable, ...etc.

code: namespace Chaos { namespace Softs { enum ECollectionPropertyFlags { None = 0, Enabled = 1 << 0, Animatable = 1 << 1, Legacy = 1 << 2, StringDirty = 1 << 6, Dirty = 1 << 7, } } }


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


code: namespace Chaos { namespace Softs { [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) & Chaos::Softs::operator&= ( [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) & Lhs, [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Rhs ) } }


code: namespace Chaos { namespace Softs { ECollectionPropertyFlag & Chaos::Softs::operator^= ( ECollectionPropertyFlag & Lhs, ECollectionPropertyFlag Rhs ) } }


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


code: namespace Chaos { namespace Softs { [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) & Chaos::Softs::operator^= ( [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) & Lhs, [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Rhs ) } }


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


code: namespace Chaos { namespace Softs { constexpr ECollectionPropertyFlag Chaos::Softs::operator& ( ECollectionPropertyFlag Lhs, ECollectionPropertyFlag Rhs ) } }


code: namespace Chaos { namespace Softs { constexpr [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Chaos::Softs::operator& ( [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Lhs, [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Rhs ) } }


code: namespace Chaos { namespace Softs { constexpr ECollectionPropertyFlag Chaos::Softs::operator^ ( ECollectionPropertyFlag Lhs, ECollectionPropertyFlag Rhs ) } }


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


code: namespace Chaos { namespace Softs { constexpr [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Chaos::Softs::operator^ ( [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Lhs, [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Rhs ) } }


code: namespace Chaos { namespace Softs { constexpr bool Chaos::Softs::operator! ( ECollectionPropertyFlag E ) } }


code: namespace Chaos { namespace Softs { constexpr bool Chaos::Softs::operator! ( [ECollectionPropertyFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-) E ) } }


code: namespace Chaos { namespace Softs { constexpr ECollectionPropertyFlag Chaos::Softs::operator~ ( ECollectionPropertyFlag E ) } }


code: namespace Chaos { namespace Softs { constexpr [ECollectionPropertyFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-) Chaos::Softs::operator~ ( [ECollectionPropertyFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-) E ) } }


code: namespace Chaos { namespace Softs { constexpr [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) Chaos::Softs::operator~ ( [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) E ) } }


code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDAxialSpringMaxStiffness = (FSolverReal)1e7; } }


description: Stiffness is in kg/s^2

code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDAxialSpringMinStiffness = (FSolverReal)1e-4; } }


code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDBendMaxStiffness = (FSolverReal)1e7; } }


description: Stiffness is in kg cm^2 / rad^2 s^2

code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDBendMinStiffness = (FSolverReal)1e-4; } }


code: namespace Chaos { namespace Softs { constexpr bool Chaos::Softs::operator! ( [ECollectionPropertyUpdateFlags](API\Runtime\Chaos\Chaos\Chaos__Softs__ECollectionPropert-_1) E ) } }


code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDLongRangeMaxStiffness = (FSolverReal)1e7; } }


code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDLongRangeMinStiffness = (FSolverReal)1e-1; } }


code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDSpringMaxStiffness = (FSolverReal)1e7; } }


description: Stiffness is in kg cm /s^2

code: namespace Chaos { namespace Softs { static Chaos::Softs::XPBDSpringMinStiffness = (FSolverReal)1e-4; } }


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


code: namespace Chaos { static constexpr [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Chaos::StaticType() }


code: namespace Chaos { virtual [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::Support ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & Direction, const T Thickness, int32 & VertexIndex ) const }


code: namespace Chaos { template<typename SweptGeometry> bool Chaos::SweepQuery ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & A, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & ATM, const SweptGeometry & B, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & BTM, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Length, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & OutTime, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutPosition, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutNormal, int32 & OutFaceIndex, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutFaceNormal, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Thickness, const bool bComputeMTD ) }


code: namespace Chaos { bool Chaos::SweepQuery ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & A, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & ATM, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & B, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & BTM, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Length, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & OutTime, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutPosition, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutNormal, int32 & OutFaceIndex, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutFaceNormal, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Thickness, const bool bComputeMTD ) }


code: namespace Chaos { template<typename T> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::TetrahedronSimplexFindOrigin2 ( [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 ) }


code: namespace Chaos { template<typename T> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::TetrahedronSimplexFindOrigin ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * Simplex, [FSimplex](API\Runtime\Chaos\Chaos\FSimplex) & Idxs, T * OutBarycentric ) }


code: namespace Chaos { void Chaos::TImplicitObjectTransformAccumulateSerializableHelper ( [TArray](API\Runtime\Core\Containers\TArray)< [Pair](API\Runtime\ChaosCore\Chaos\Pair)< [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) >, [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) >> & Out, [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) > Obj, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & NewTM ) }


code: namespace Chaos { void Chaos::TImplicitObjectTransformAccumulateSerializableHelper ( [TArray](API\Runtime\Core\Containers\TArray)< [Pair](API\Runtime\ChaosCore\Chaos\Pair)< [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) >, [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) >> & Out, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Obj, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & NewTM ) }


code: namespace Chaos { void Chaos::TImplicitObjectTransformSerializeHelper ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) > & Obj ) }


code: namespace Chaos { void Chaos::TImplicitObjectTransformSerializeHelper ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Obj ) }


description: Deprecated* Deprecated. this class is to be deleted, use other triangle based ImplicitObjects

code: namespace Chaos { template<typename T> Chaos::TImplicitTriangle ( TImplicitTriangle && InToSteal ) }


code: namespace Chaos { Chaos::TImplicitTriangle ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & InA, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & InB, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & InC ) }


description: FromBarycentric()

code: namespace Chaos { template<typename RealType> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< RealType > Chaos::ToBarycentric ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< RealType > & Point, 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> bool Chaos::TooManyOverlapQueryCells ( const [TAABB](API\Runtime\Chaos\Chaos\TAABB)< T, 3 > & AABB, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv, int32 MaximumOverlap ) }


code: namespace Chaos { bool Chaos::TooManyRaycastQueryCells ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & StartPoint, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Length, [FReal](API\Runtime\ChaosCore\Chaos\FReal) DirtyElementGridCellSizeInv, int32 DirtyElementMaxGridCellQueryCount ) }


code: namespace Chaos { bool Chaos::TooManySweepQueryCells ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FReal](API\Runtime\ChaosCore\Chaos\FReal) > & 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) DirtyElementGridCellSizeInv, int32 DirtyElementMaxGridCellQueryCount ) }


code: namespace Chaos { virtual [FString](API\Runtime\Core\Containers\FString) Chaos::ToString() const }


code: namespace Chaos { template<typename IdxType, typename ParticlesType> void Chaos::TriangleMeshTransformVertsHelper ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & TriMeshScale, int32 TriIdx, const ParticlesType & Particles, const [TArray](API\Runtime\Core\Containers\TArray)< [TVector](API\Runtime\Chaos\Chaos\TVector)< IdxType, 3 >> & Elements, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutA, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutB, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutC ) }


code: namespace Chaos { template<typename IdxType, typename ParticlesType> void Chaos::TriangleMeshTransformVertsHelper ( const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & Transform, int32 TriIdx, const ParticlesType & Particles, const [TArray](API\Runtime\Core\Containers\TArray)< [TVector](API\Runtime\Chaos\Chaos\TVector)< IdxType, 3 >> & Elements, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutA, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutB, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutC, int32 & OutVertexIndexA, int32 & OutVertexIndexB, int32 & OutVertexIndexC ) }


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


description: Based on an algorithm in Real Time Collision Detection - Ericson (very close to that) Using the same variable name conventions for easy reference

code: namespace Chaos { template<bool CalculatExtraInformation> [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) Chaos::TriangleSimplexFindOriginFast ( [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict Simplex, [VectorRegister4Int](API\Runtime\Core\Math\VectorRegister4Int) &__restrict NumVerts, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) &__restrict OutBarycentric, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict As, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict Bs ) }


code: namespace Chaos { template<typename T> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::TriangleSimplexFindOrigin ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > * Simplex, [FSimplex](API\Runtime\Chaos\Chaos\FSimplex) & Idxs, T * OutBarycentric ) }


code: namespace Chaos { template<typename T, typename [TEnableIf](API\Runtime\Core\Templates\TEnableIf)<!TModels_V< CIsUpdatableElement, T >>::Type *> static void Chaos::UpdateElementHelper ( T & InElem, const T & InFrom ) }


description: When encountering a triangle or quad in hull generation (3-points or 4 coplanar points) we will instead generate a prism with a small thickness to emulate the desired result as a hull. Otherwise hull generation will fail on these cases. Verbose logging on LogChaos will point out when this path is taken for further scrutiny about the geometry

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


description: Approximate Asin using expansion to the specified Order (must be 1, 3, 5, or 7). Defaults to 5th order.

code: namespace Chaos { namespace Utilities { template<typename T, int Order> T Chaos::Utilities::AsinEst ( const T X ) } }


description: Approximate Asin(X) to 1st order ~= X + ... Returns an approximation for all valid input range [-1, 1] with an error that increases as the input magnitude approaches 1.

code: namespace Chaos { namespace Utilities { template<typename T> T Chaos::Utilities::AsinEst1 ( const T X ) } }


description: Approximate Asin(X) to 3rd order ~= X + (1/6)X^3 + ... Returns an approximation for all valid input range [-1, 1] with an error that increases as the input magnitude approaches 1.

code: namespace Chaos { namespace Utilities { template<typename T> T Chaos::Utilities::AsinEst3 ( const T X ) } }


description: Approximate Asin(X) to 5th order ~= X + (1/6)X^3 + (3/40)X^5 + ... Returns an approximation for all valid input range [-1, 1] with an error that increases as the input magnitude approaches 1.

code: namespace Chaos { namespace Utilities { template<typename T> T Chaos::Utilities::AsinEst5 ( const T X ) } }


description: Approximate Asin(X) to 7th order ~= X + (1/6)X^3 + (3/40)X^5 + (15/336)X^7 + ... Returns an approximation for all valid input range [-1, 1] with an error that increases as the input magnitude approaches 1.

code: namespace Chaos { namespace Utilities { template<typename T> T Chaos::Utilities::AsinEst7 ( const T X ) } }


description: Approximate Asin(X). Like AsinApprox but with a crossover toFMath::Asinfor larger input magnitudes.

code: namespace Chaos { namespace Utilities { template<typename T, int Order> T Chaos::Utilities::AsinEstCrossover ( const T X, const T Crossover ) } }


description: Compute the box size that would generate the given (diagonal) inertia.

code: namespace Chaos { namespace Utilities { bool Chaos::Utilities::BoxFromInertia ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InInertia, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Mass, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutCenter, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutSize ) } }


description: Call the lambda with concrete shape type. Unwraps shapes contained in Instanced (e.g., Instanced-Sphere will be called with Sphere. Note that this will effectively discard any instance properties like the margin)

code: namespace Chaos { namespace Utilities { template<typename Lambda> decltype(auto) Chaos::Utilities::CastHelper ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & Geom, const Lambda & Func ) } }


code: namespace Chaos { namespace Utilities { template<typename Lambda> decltype(auto) Chaos::Utilities::CastHelper ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & Geom, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & TM, const Lambda & Func ) } }


description: Call the lambda with concrete shape type. This version does NOT unwrap shapes contained in Instanced or Scaled.

code: namespace Chaos { namespace Utilities { template<typename Lambda> decltype(auto) Chaos::Utilities::CastHelperNoUnwrap ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & Geom, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & TM, const Lambda & Func ) } }


code: namespace Chaos { namespace Utilities { template<typename Lambda> decltype(auto) Chaos::Utilities::CastHelperNoUnwrap ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & Geom, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & TM0, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & TM1, const Lambda & Func ) } }


description: Given an ImplicitObject known to be of type T or a wrapper around T, call the Lambda with the concrete type which will be const T*, const TImplicitObjectInstanced*, or const TImplicitObjectScaled*.

code: namespace Chaos { namespace Utilities { template<typename T, typename Lambda> decltype(auto) Chaos::Utilities::CastWrapped ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) & A, const Lambda & Func ) } }


description:
Clip a line segment to inside a plane (plane normal pointing outwards).
false if the line is completely outside the plane, true otherwise.

code: namespace Chaos { namespace Utilities { bool Chaos::Utilities::ClipLineSegmentToPlane ( [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V0, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V1, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & PlaneNormal, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & PlanePos ) } }


description: Clip a line segment to the inside of an axis aligned plane (normal pointing outwards).

code: namespace Chaos { namespace Utilities { bool Chaos::Utilities::ClipLineSegmentToAxisAlignedPlane ( [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V0, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V1, const int32 AxisIndex, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) PlaneDir, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) PlanePos ) } }


code: namespace Chaos { namespace Utilities { template<typename T> T Chaos::Utilities::ClosestTimeOnLineSegment ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & Point, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & StartPoint, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & EndPoint ) } }


description: Calculate the matrix diagonal that maps a constraint position error to constraint position and rotation corrections.

code: namespace Chaos { namespace Utilities { template<class T> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::Utilities::ComputeDiagonalJointFactorMatrix ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & V, const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & M, const T & Im ) } }


description: Calculate the matrix that maps a constraint position error to constraint position and rotation corrections.

code: namespace Chaos { namespace Utilities { template<class T> [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > Chaos::Utilities::ComputeJointFactorMatrix ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & V, const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & M, const T & Im ) } }


code: namespace Chaos { namespace Utilities { template<int d> [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int > > Chaos::Utilities::ComputeIncidentElements ( const [TArray](API\Runtime\Core\Containers\TArray)< [TVector](API\Runtime\Chaos\Chaos\TVector)< int32, d >> & Mesh, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> * LocalIndex ) } }


description: Calculate the world-space inertia (or inverse inertia) for a body with center-of-mass rotation "CoMRotation" and local-space inertia/inverse-inertia "I".

code: namespace Chaos { namespace Utilities { static [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::ComputeWorldSpaceInertia ( const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & CoMRotation, const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & I ) } }


code: namespace Chaos { namespace Utilities { static [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::ComputeWorldSpaceInertia ( const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & CoMRotation, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & I ) } }


code: namespace Chaos { namespace Utilities { void Chaos::Utilities::ConnectedComponentsDFSIterative ( const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & L, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & C ) } }


code: namespace Chaos { namespace Utilities { static [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::CrossProductMatrix ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V ) } }


code: namespace Chaos { namespace Utilities { void Chaos::Utilities::DFS_iterative ( const [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & L, int32 v, [TArray](API\Runtime\Core\Containers\TArray)< bool > & visited, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & component ) } }


code: namespace Chaos { namespace Utilities { template<class T> T Chaos::Utilities::DotProduct ( const [TArray](API\Runtime\Core\Containers\TArray)< T > & X, const [TArray](API\Runtime\Core\Containers\TArray)< T > & Y ) } }


code: namespace Chaos { namespace Utilities { [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) > Chaos::Utilities::DuplicateImplicitWithTransform ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) *const InObject, FTransform NewTransform ) } }


description: Take the factorial of `Num_, which should be of integral type.

code: namespace Chaos { namespace Utilities { template<class TINT> TINT Chaos::Utilities::Factorial ( TINT Num ) } }


code: namespace Chaos { namespace Utilities { void Chaos::Utilities::FindConnectedRegions ( const [TArray](API\Runtime\Core\Containers\TArray)< FIntVector4 > & Elements, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ConnectedComponents ) } }


code: namespace Chaos { namespace Utilities { void Chaos::Utilities::FindConnectedRegions ( const [TArray](API\Runtime\Core\Containers\TArray)< FIntVector3 > & Elements, [TArray](API\Runtime\Core\Containers\TArray)< [TArray](API\Runtime\Core\Containers\TArray)< int32 >> & ConnectedComponents ) } }


description: Compute the average value.

code: namespace Chaos { namespace Utilities { template<class T, class TARRAY> T Chaos::Utilities::GetAverage ( const TARRAY & Values ) } }


description: Compute the minimum, average, and maximum values of `Values_.

code: namespace Chaos { namespace Utilities { template<class T, class TARRAY> void Chaos::Utilities::GetMinAvgMax ( const TARRAY & Values, T & MinV, double & AvgV, T & MaxV ) } }


description: Compute the standard deviation from `Variance_.

code: namespace Chaos { namespace Utilities { template<class T> T Chaos::Utilities::GetStandardDeviation ( const T Variance ) } }


description: Compute the standard deviation of `Values_ (computes their average on the fly).

code: namespace Chaos { namespace Utilities { template<class T, class TARRAY> T Chaos::Utilities::GetStandardDeviation ( const TARRAY & Values ) } }


description: Compute the standard deviation ofValues_, given the average value ofAvg_.

code: namespace Chaos { namespace Utilities { template<class T, class TARRAY> T Chaos::Utilities::GetStandardDeviation ( const TARRAY & Values, const T Avg ) } }


description: Compute the variance ofValues_, given the average value ofAvg_.

code: namespace Chaos { namespace Utilities { template<class T, class TARRAY> T Chaos::Utilities::GetVariance ( const TARRAY & Values, const T Avg ) } }


code: namespace Chaos { namespace Utilities { const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Chaos::Utilities::ImplicitChildHelper ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * ImplicitObject ) } }


description: Compute the variance of `Values_ (computes their average on the fly).

code: namespace Chaos { namespace Utilities { template<class T, class TARRAY> T Chaos::Utilities::GetVariance ( const TARRAY & Values ) } }


description: Detects intersections between 2D line segments, returns intersection results as times along each line segment - these times can be used to calculate exact intersection locations

code: namespace Chaos { namespace Utilities { template<typename T> bool Chaos::Utilities::IntersectLineSegments2D ( const [TVec2](API\Runtime\ChaosCore\Chaos\TVec2)< T > & InStartA, const [TVec2](API\Runtime\ChaosCore\Chaos\TVec2)< T > & InEndA, const [TVec2](API\Runtime\ChaosCore\Chaos\TVec2)< T > & InStartB, const [TVec2](API\Runtime\ChaosCore\Chaos\TVec2)< T > & InEndB, T & OutTA, T & OutTB ) } }


description: This is the mathematically expected operator. FMatrix operator* calculates C = R.Transpose(L), so this is not equivalent to that.

code: namespace Chaos { namespace Utilities { [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::Multiply ( const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & L, const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & R ) } }


code: namespace Chaos { namespace Utilities { [FMatrix44](API\Runtime\ChaosCore\Chaos\FMatrix44) Chaos::Utilities::Multiply ( const [FMatrix44](API\Runtime\ChaosCore\Chaos\FMatrix44) & L, const [FMatrix44](API\Runtime\ChaosCore\Chaos\FMatrix44) & R ) } }


description: Multiple a vector by a matrix: C = L.R If L is a rotation matrix, then this will return R rotated by that rotation.

code: namespace Chaos { namespace Utilities { [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) Chaos::Utilities::Multiply ( const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & L, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & R ) } }


code: namespace Chaos { namespace Utilities { [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) > Chaos::Utilities::Multiply ( const [TMatrix33](API\Runtime\ChaosCore\Chaos\TMatrix33)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) > & L, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) > & R ) } }


code: namespace Chaos { namespace Utilities { [FVec4](API\Runtime\ChaosCore\Chaos\FVec4) Chaos::Utilities::Multiply ( const [FMatrix44](API\Runtime\ChaosCore\Chaos\FMatrix44) & L, const [FVec4](API\Runtime\ChaosCore\Chaos\FVec4) & R ) } }


description: Concatenate two transforms. This returns a transform that logically applies R then L.

code: namespace Chaos { namespace Utilities { [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) Chaos::Utilities::Multiply ( const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) L, const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & R ) } }


code: namespace Chaos { namespace Utilities { [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::MultiplyAB ( const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & LIn, const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & RIn ) } }


code: namespace Chaos { namespace Utilities { [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::MultiplyABt ( const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & L, const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & R ) } }


description: Number of ways to choose ofR_ elements from a set of sizeN_, with no repetitions.

code: namespace Chaos { namespace Utilities { template<class TINT> TINT Chaos::Utilities::NChooseR ( const TINT N, const TINT R ) } }


code: namespace Chaos { namespace Utilities { [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::MultiplyAtB ( const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & L, const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & R ) } }


description: For implementation notes, see "Realtime Collision Detection", Christer Ericson, 2005.

code: namespace Chaos { namespace Utilities { void Chaos::Utilities::NearestPointsOnLineSegments ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & P1, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Q1, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & P2, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Q2, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & S, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & T, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & C1, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & C2, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Epsilon ) } }


code: namespace Chaos { namespace Utilities { bool Chaos::Utilities::NormalizeSafe ( [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V, [FReal](API\Runtime\ChaosCore\Chaos\FReal) EpsilonSq ) } }


description: Number of ways to choose ofR_ elements from a set of sizeN_, with repetitions.

code: namespace Chaos { namespace Utilities { template<class TINT> TINT Chaos::Utilities::NPermuteR ( const TINT N, const TINT R ) } }


description: Project a point V along direction Dir onto an axis aligned plane. /note Does not check for division by zero (Dir parallel to plane).

code: namespace Chaos { namespace Utilities { void Chaos::Utilities::ProjectPointOntoAxisAlignedPlane ( [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, int32 AxisIndex, [FReal](API\Runtime\ChaosCore\Chaos\FReal) PlaneDir, [FReal](API\Runtime\ChaosCore\Chaos\FReal) PlanePos ) } }


description: Project a point V along direction Dir onto an axis aligned plane. /return true if the point was successfully projected onto the plane; false if the direction is parallel to the plane.

code: namespace Chaos { namespace Utilities { bool Chaos::Utilities::ProjectPointOntoAxisAlignedPlaneSafe ( [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & V, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, int32 AxisIndex, [FReal](API\Runtime\ChaosCore\Chaos\FReal) PlaneDir, [FReal](API\Runtime\ChaosCore\Chaos\FReal) PlanePos, [FReal](API\Runtime\ChaosCore\Chaos\FReal) Epsilon ) } }


description: Given the local-space diagonal inertia for an unscaled object, return an inertia as if generated from a non-uniformly scaled shape with the specified scale. If bScaleMass is true, it also takes into account the fact that the mass would have changed by the increase in volume.

code: namespace Chaos { namespace Utilities { template<typename T> [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > Chaos::Utilities::ScaleInertia ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & Inertia, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & Scale, const bool bScaleMass ) } }


description: The distance from Start to the sphere along the vector Dir. Returns numeric max if no intersection.

code: namespace Chaos { namespace Utilities { template<typename T> T Chaos::Utilities::RaySphereIntersectionDistance ( const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & RayStart, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & RayDir, const [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< T > & SpherePos, const T SphereRadius ) } }


description: Given the local-space inertia for an unscaled object, return an inertia as if generated from a non-uniformly scaled shape with the specified scale. If bScaleMass is true, it also takes into account the fact that the mass would have changed by the increase in volume.

code: namespace Chaos { namespace Utilities { [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) Chaos::Utilities::ScaleInertia ( const [FMatrix33](API\Runtime\ChaosCore\Chaos\FMatrix33) & Inertia, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Scale, const bool bScaleMass ) } }


description: Generate a tetrahedral mesh from a Freudenthal lattice defined on a 3 dimensional grid.

code: namespace Chaos { namespace Utilities { template<class T, class TV, class TV_INT4> void Chaos::Utilities::TetMeshFromGrid ( const [TUniformGrid](API\Runtime\Chaos\Chaos\TUniformGrid)< T, 3 > & Grid, [TArray](API\Runtime\Core\Containers\TArray)< TV_INT4 > & Mesh, [TArray](API\Runtime\Core\Containers\TArray)< TV > & X ) } }


description: Replacement forFMath::Wrapthat works for integers and returns a value in [Begin, End). Note: this implementation uses a loop to bring the value into range - it should not be used if the value is much larger than the range.

code: namespace Chaos { namespace Utilities { int32 Chaos::Utilities::WrapIndex ( int32 V, int32 Begin, int32 End ) } }


code: namespace Chaos { void Chaos::VectorComputeEPAResults ( const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) * VertsA, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) * VertsB, const [VectorTEPAEntry](API\Runtime\Chaos\Chaos\VectorTEPAEntry) & Entry, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutPenetration, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutDir, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutA, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutB, [EEPAResult](API\Runtime\Chaos\Chaos\Chaos__EEPAResult) & ResultStatus ) }


code: namespace Chaos { template<typename TSupportA, typename TSupportB> [EEPAResult](API\Runtime\Chaos\Chaos\Chaos__EEPAResult) Chaos::VectorEPA ( [TArray](API\Runtime\Core\Containers\TArray)< [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) > & VertsABuffer, [TArray](API\Runtime\Core\Containers\TArray)< [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) > & VertsBBuffer, const TSupportA & SupportA, const TSupportB & SupportB, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutPenetration, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutDir, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & WitnessA, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & WitnessB ) }


code: namespace Chaos { void Chaos::VectorEPAComputeVisibilityBorder ( [TEPAWorkingArray](API\Runtime\Chaos\Chaos\TEPAWorkingArray)< [VectorTEPAEntry](API\Runtime\Chaos\Chaos\VectorTEPAEntry) > & Entries, int32 EntryIdx, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & 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 { template<typename SupportALambda, typename SupportBLambda> bool Chaos::VectorInitializeEPA ( [TArray](API\Runtime\Core\Containers\TArray)< [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) > & VertsA, [TArray](API\Runtime\Core\Containers\TArray)< [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) > & VertsB, const SupportALambda & SupportA, const SupportBLambda & SupportB, [TEPAWorkingArray](API\Runtime\Chaos\Chaos\TEPAWorkingArray)< [VectorTEPAEntry](API\Runtime\Chaos\Chaos\VectorTEPAEntry) > & OutEntries, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) & OutTouchNormal ) }


code: namespace Chaos { const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) Chaos::VectorMinkowskiVert ( const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) * VertsABuffer, const [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) * VertsBBuffer, const int32 Idx ) }


code: namespace Chaos { template<bool CalculatExtraInformation> [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) Chaos::VectorLineSimplexFindOrigin ( [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict Simplex, [VectorRegister4Int](API\Runtime\Core\Math\VectorRegister4Int) &__restrict NumVerts, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) &__restrict OutBarycentric, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict A, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict B ) }


code: namespace Chaos { bool Chaos::VectorSignMatch ( [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) A, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) B ) }


description: CalculatExtraHitInformation : Should we calculate the BaryCentric coordinates, As and Bs?

code: namespace Chaos { template<bool CalculatExtraInformation> [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) Chaos::VectorSimplexFindClosestToOrigin ( [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict Simplex, [VectorRegister4Int](API\Runtime\Core\Math\VectorRegister4Int) &__restrict NumVerts, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) &__restrict OutBarycentric, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict A, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict B ) }


code: namespace Chaos { template<bool CalculatExtraInformation> [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) Chaos::VectorTetrahedronSimplexFindOrigin ( [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict Simplex, [VectorRegister4Int](API\Runtime\Core\Math\VectorRegister4Int) &__restrict NumVerts, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) &__restrict OutBarycentric, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict A, [VectorRegister4Float](API\Runtime\Core\Math\VectorRegister4Float) *__restrict B ) }


description: Get the force applied by the solver due to this constraint. Units are ML/T^2.

code: FVector GetSolverAppliedForce() const


description: Get the torque applied by the solver due to this constraint. Units are ML^2/T^2.

code: FVector GetSolverAppliedTorque() const


description: Deprecated* Split into swing/twist torque limits. Use GetTwistTorqueLimit instead for torque limit about vertical axis.


description: The constraint requires a character body, which is fixed, but the ground body is optional and can be changed dynamically using SetGroundParticleProxy

code: void Init ( [FSingleParticlePhysicsProxy](API\Runtime\Chaos\PhysicsProxy\FSingleParticlePhysicsProxy) * InCharacterProxy )


description: This is the height below which the character is assumed to be on the ground and can apply force to move. This is useful if the character is slightly off the ground but should still be considered in a locomotion rather than falling state. If this number is set to zero then the constraint can only apply force to move to the motion target if the solver determines that there is a ground reaction force Input should be positive

code: void SetAssumedOnGroundHeight ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


code: void SetCosMaxWalkableSlopeAngle ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: The damping factor is used to add softness to the vertical constraint between the character and the ground. This can add springiness to landings and slow the rate of step ups. Input should be positive. A value of 0 gives rigid behavior. A value of 1/Dt or above will give maximum softness Units are /T

code: void SetDampingFactor ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: The maximum force that the character can apply in the plane defined by the ground normal to hold the character in place while standing on an unwalkable incline (defined by max walkable slope angle)

code: void SetFrictionForceLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: Vertical distance from the character body to the ground This should be set every frame as the character moves over the ground and is typically measured by performing one or more physics traces Input should be positive

code: void SetGroundDistance ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: Unit normal to the ground plane Input vector is normalized if it is not already a unit vector

code: void SetGroundNormal ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Normal )


code: void SetGroundParticleProxy ( [FSingleParticlePhysicsProxy](API\Runtime\Chaos\PhysicsProxy\FSingleParticlePhysicsProxy) * InGroundProxy )


description: The maximum angle of slope that is considered walkable. The slope angle is defined as the angle between the ground normal and vertical axis. If the slope angle is greater than the maximum walkable slope angle the motion target vector is adjusted to stop movement up the slope

code: void SetMaxWalkableSlopeAngle ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: Set both the target delta position and facing angle. This is more efficient than setting them both individually

code: void SetMotionTarget ( const FVector & TargetDeltaPosition, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & TargetDeltaFacing )


description: The maximum force that the character can apply in the plane defined by the ground normal to move the character to its target position (or hold the character in place if no target delta position is set).

code: void SetRadialForceLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: The maximum torque that the character can apply about the non vertical axes to keep the character upright

code: void SetSwingTorqueLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: Set the target orientation change about the vertical axis. This is used to turn the character when it is on the ground. The solver will do this by applying a torque if the character is considered to be on the ground and the torque required is less than or equal to the torque limit. For orientation change off the ground, e.g. in air steering, set an angular velocity or impulse on the character body directly. This should be set every frame for a locomoting character, and the value is typically controlled either from a character movement model or from root motion extracted from an animation sequence.

code: void SetTargetDeltaFacing ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: Set the target change in position for the character. This is used to move the character along the ground, and this target will be clamped to the ground plane. The solver will apply a force to move the character to the desired position as long as the character is considered to be on the ground and the force required is less than or equal to the radial force limit. For motion off of the ground, e.g. jumping, set a velocity or impulse on the character body directly. This should be set every frame for a locomoting character, and the value is typically controlled either from a character movement model or from root motion extracted from an animation sequence.

code: void SetTargetDeltaPosition ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Value )


description: Target vertical distance from the character body to the ground If the ground distance is smaller than this number the constraint will try to fix up the error to keep the character at the target height Input should be positive

code: void SetTargetHeight ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: The maximum torque that the character can apply about the vertical axis to rotate the character to its target facing direction (or hold the character in place if no target delta facing is set).

code: void SetTorqueLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


code: void SetTwistTorqueLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Value )


description: Unit vector defining the character up direction Input vector is normalized if it is not already a unit vector

code: void SetVerticalAxis ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Axis )


code: virtual ~FCharacterGroundConstraint()


className: FCharacterGroundConstraint

description: Game thread side representation of a character ground constraint Modified data from this class will be pushed automatically to the physics thread and available through theFCharacterGroundConstraintHandleclass. TheFCharacterGroundConstraintProxyclass, accessible viaGetProxy(), knows about both representations and marshalls the data between them

code: class FCharacterGroundConstraint : public [Chaos::FConstraintBase](API\Runtime\Chaos\Chaos\FConstraintBase)


code: [FCharacterGroundConstraintHandle](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintHandle) * AddConstraint ( const [FCharacterGroundConstraintSettings](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintSettin-) & InConstraintSettings, const [FCharacterGroundConstraintDynamicData](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintDynami-) & InConstraintData, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * CharacterParticle, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * GroundParticle )


description: Add all the constraints in the container to the graph

code: virtual void AddConstraintsToGraph ( [Private::FPBDIslandManager](API\Runtime\Chaos\Chaos\Island\FPBDIslandManager) & IslandManager )


description: Create a constraint solver for an Evolution with Graph support (World evolution). The system will create several of these: usually one per worker thread (Island Group) but possibly more in complex scenes where constraint coloring is being used. It will be used to solve constraints in groups, with the constraints in each group determined by the graph/islands/islandgroups.

code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FConstraintContainerSolver](API\Runtime\Chaos\Chaos\Evolution\FConstraintContainerSolver) > CreateGroupSolver ( const int32 Priority )


description: FConstraintContainer Implementation.

code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [FConstraintContainerSolver](API\Runtime\Chaos\Chaos\Evolution\FConstraintContainerSolver) > CreateSceneSolver ( const int32 Priority )


code: virtual void DisconnectConstraints ( const [TSet](API\Runtime\Core\Containers\TSet)< [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 3 > * > & )


className: FConstConstraints

code: typedef [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FCharacterGroundConstraintHandle](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintHandle) *const > FConstConstraints


className: FConstraints

code: typedef [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FCharacterGroundConstraintHandle](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintHandle) *const > FConstraints


code: [FCharacterGroundConstraintHandle](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintHandle) * GetConstraint ( int32 ConstraintIndex )


code: const [FCharacterGroundConstraintHandle](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintHandle) * GetConstraint ( int32 ConstraintIndex ) const


description: Get the number of constraints in this container (includes inactive and disabled)

code: virtual int32 GetNumConstraints() const


code: bool IsConstraintEnabled ( int32 ConstraintIndex ) const


description: Called oncer per tick to initialize buffers required for the rest of the tick

code: virtual void PrepareTick()


description: Empty the constraints (must be removed from the graph first, if required)

code: virtual void ResetConstraints()


code: void RemoveConstraint ( [FCharacterGroundConstraintHandle](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintHandle) * Constraint )


description: Required API from FConstraintContainer.

code: void SetConstraintEnabled ( int32 ConstraintIndex, bool bEnabled )


description: Should undo any allocations in PrepareTick

code: virtual void UnprepareTick()


code: FCharacterGroundConstraintContainer()


className: FCharacterGroundConstraintContainer

description: Container class for all character ground constraints on the physics thread.

code: class FCharacterGroundConstraintContainer : public [Chaos::FPBDConstraintContainer](API\Runtime\Chaos\Chaos\FPBDConstraintContainer)


code: bool operator== ( const [FCharacterGroundConstraintDynamicData](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintDynami-) & Other ) const


className: FCharacterGroundConstraintDynamicData

CosMaxWalkableSlopeAngle

type: FReal

description: Distance from the character body to the ground.

GroundDistance

description: Target rotation in radians about the vertical axis.

TargetDeltaFacing

description: Target linear movement vector. Will be projected onto ground plane.

TargetDeltaPosition

description: World space ground normal.


description: Declared final so that TPBDConstraintGraphRuleImpl::AddToGraph() does not need to hit vtable.

code: virtual [FParticlePair](API\Runtime\Chaos\Chaos\FParticlePair) GetConstrainedParticles() const


code: const [FCharacterGroundConstraintDynamicData](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintDynami-) & GetData() const


code: [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FConstraintHandle\FGeometryParticleHandle) * GetGroundParticle() const


description: Settings is only modifiable on the game thread viaFCharacterGroundConstraintbut Data can be modified on the physics thread and is synced with the game thread

code: const [FCharacterGroundConstraintSettings](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintSettin-) & GetSettings() const


description: Get the force applied by the solver due to this constraint. Units are ML/T^2.


description: Get the torque applied by the solver due to this constraint. Units are ML^2/T^2.


code: void SetData ( const [FCharacterGroundConstraintDynamicData](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintDynami-) & InData )


code: virtual void SetEnabled ( bool InEnabled )


code: void SetGroundParticle ( [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FConstraintHandle\FGeometryParticleHandle) * InGroundParticle )


code: void SetEnabledDuringResim ( bool bEnabled )


code: void SetSyncState ( [ESyncState](API\Runtime\Chaos\Chaos\Chaos__ESyncState) InSyncState )


code: bool operator== ( const [FCharacterGroundConstraintSettings](API\Runtime\Chaos\Chaos\Character\FCharacterGroundConstraintSettin-) & Other ) const


className: FCharacterGroundConstraintSettings

AssumedOnGroundHeight

description: Applies a damping to the vertical ground constraint making it softer. Units: /T.

CosMaxWalkableSlopeAngle

description: How much torque the character can apply about the other axes to remain upright.

DampingFactor

description: Cosine of the maximum angle in degrees that the character is allowed to walk on.

FrictionForceLimit

description: How much force the character can apply parallel to the ground plane to reach the target position.

RadialForceLimit

description: Desired distance from the character body to the ground.

SwingTorqueLimit

description: How much torque the character can apply about the vertical axis to reach the target facing direction.

TargetHeight

description: World space up direction (default z axis)

TwistTorqueLimit

description: How much force the character can apply parallel to the ground plane to reach the target position when standing on an unwalkable incline.

UserData

type: void *

description: Below this height the character is assumed to be on the ground and can apply force/torque to reach the target position and facing.


code: static const [FConstraintHandleTypeID](API\Runtime\Chaos\Chaos\FConstraintHandleTypeID) & StaticType()


code: template<typename ElementT> auto Requires ( ElementT & InElem, const ElementT & InOtherElem )


className: CIsUpdatableElement

description: DECLARE_CYCLE_STAT(TEXT("AABBTreeGrowPhase"), STAT_AABBTreeGrowPhase, STATGROUP_Chaos); DECLARE_CYCLE_STAT(TEXT("AABBTreeChildrenPhase"), STAT_AABBTreeChildrenPhase, STATGROUP_Chaos);

code: struct CIsUpdatableElement


className: FCharacterGroundConstraintHandle

description: Physics thread side representation of a character ground constraint Data accessed through this class is synced from the game thread representationFCharacterGroundConstraint

code: class FCharacterGroundConstraintHandle : public [Chaos::TIntrusiveConstraintHandle< FCharacterGroundConstraintHandle >](API\Runtime\Chaos\Chaos\TIntrusiveConstraintHandle)


code: ClusterId ( [FPBDRigidParticleHandle](API\Runtime\Chaos\Chaos\FPBDRigidParticleHandle) * NewId, int NumChildrenIn )


className: ClusterId

description: TODO: Chaos - Add dimension template param? Add floating point param?

code: struct ClusterId

Id

type: FPBDRigidPartic...


className: Chaos::

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 { NumExtraFilterBits = 6, } }


code: namespace Chaos { enum { NumCollisionChannelBits = 5, } }


code: namespace Chaos { namespace CollisionStats { static Chaos::CollisionStats::BucketSizes2 = { 0,1,4,8,16,32,64,128,512, ((int32) 0x7fffffff) }; } }


description: Sim Collision filter (i.e., not Query collision filter)

code: namespace Chaos { bool Chaos::DoCollide ( [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Implicit0Type, const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * Shape0, [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Implicit1Type, const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * Shape1 ) }


description: Whether we should run CCD (swept collision) or not.

code: namespace Chaos { enum ECollisionCCDType { Disabled, Enabled, } }


description: The resting directionality of a contact constraint for use in constraint solver ordering.

code: namespace Chaos { enum ECollisionConstraintDirection { Particle0ToParticle1, Particle1ToParticle0, NoRestingDependency, } }


description: Flags for user-control over per-particle collision behaviour.

code: namespace Chaos { enum ECollisionConstraintFlags { CCF_None = 0x0, CCF_BroadPhaseIgnoreCollisions = 0x1, CCF_SmoothEdgeCollisions = 0x2, CCF_DummyFlag, } }


description: The order here is the order of preference in the solver. I.e., we like to solve Plane contacts before edge contacts before vertex contacts. This is most impotant for collisions against triangle meshes (or any concave shape) where the second shape is always the triangle, and so a PlaneVertex collision counts as a vertex collision.

code: namespace Chaos { enum EContactPointType { Unknown, VertexPlane, EdgeEdge, PlaneVertex, VertexVertex, } }


description: Return value in collision visitors to indicate whether we should continue visiting for stop.

code: namespace Chaos { enum ECollisionVisitorResult { Stop, Continue, } }


description: Does the shape collide with anything at all in the Sim? (else it is query-only)

code: namespace Chaos { bool Chaos::FilterHasSimEnabled ( const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * Shape ) }


description: The type of the particle pair midphase.

code: namespace Chaos { enum EParticlePairMidPhaseType { Generic, ShapePair, } }


description: Return true if the particles are in the preferred order (the first one has the lower ID)

code: namespace Chaos { bool Chaos::AreParticlesInPreferredOrder ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle0, const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1 ) }


description: The value used for Phi (contact separation) to indicate that it is unset/invalid.

code: namespace Chaos { template<typename T> constexpr T Chaos::InvalidPhi() }


description: A filter set to all zeroes means we do not filter

code: namespace Chaos { bool Chaos::IsFilterValid ( const [FCollisionFilterData](API\Runtime\Chaos\Chaos\FCollisionFilterData) & Filter ) }


description:
Check whether the two particles need to be considered in the broadphase.
true if the particle pair should be considered by the broadphase

code: namespace Chaos { bool Chaos::ParticlePairBroadPhaseFilter ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1, const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle2, const [FIgnoreCollisionManager](API\Runtime\Chaos\Chaos\Collision\FIgnoreCollisionManager) * IgnoreCollisionManager ) }


description: Combine two hashes in an order-independent way so that Hash(A, B) == Hash(B, A)

code: namespace Chaos { uint32 Chaos::OrderIndependentHashCombine ( const uint32 A, const uint32 B ) }


code: namespace Chaos { namespace Private { *TParam [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) a shape that returns true to check a particle for overlaps Signature Chaos::Private::bool ( const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) *, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * ) const } }


description: FSimSweepParticleFilterBroadPhasewhich provides the standard broadphase filter used in collision detection.

code: namespace Chaos { namespace Private { *tparam [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) A custom filter functor with the signature Chaos::Private::bool ( const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * SweptShape, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * SweptImplicit, const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * OtherShape, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * OtherImplicit ) const } }


code: namespace Chaos { namespace Private { [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) Chaos::Private::CalculateBodyShockPropagation ( const [FSolverBody](API\Runtime\Chaos\Chaos\Evolution\FSolverBody) & Body0, const [FSolverBody](API\Runtime\Chaos\Chaos\Evolution\FSolverBody) & Body1, const [FSolverReal](API\Runtime\Chaos\Chaos\Evolution\FSolverReal) ShockPropagation, [FSolverReal](API\Runtime\Chaos\Chaos\Evolution\FSolverReal) & OutShockPropagation0, [FSolverReal](API\Runtime\Chaos\Chaos\Evolution\FSolverReal) & OutShockPropagation1 ) } }


code: namespace Chaos { namespace Private { void Chaos::Private::GatherBodyPositionCorrections ( const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body0, const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body1, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DP0, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DQ0, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DP1, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DQ1 ) } }


code: namespace Chaos { namespace Private { void Chaos::Private::GatherBodyVelocities ( const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body0, const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body1, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & V0, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & W0, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & V1, [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & W1 ) } }


description: Check whether the two particles are allowed to collide, and also whether we should flip their order.

code: namespace Chaos { namespace Private { [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) Chaos::Private::ParticlePairCollisionAllowed ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1, const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle2, const [FIgnoreCollisionManager](API\Runtime\Chaos\Chaos\Collision\FIgnoreCollisionManager) & IgnoreCollisionManager, const [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) bIsResimming, [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) & bOutSwapOrder ) } }


code: namespace Chaos { namespace Private { void Chaos::Private::ScatterBodyPositionCorrections ( const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DP0, const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DQ0, const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DP1, const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & DQ1, const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body0, const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body1 ) } }


code: namespace Chaos { namespace Private { void Chaos::Private::ScatterBodyVelocities ( const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & V0, const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & W0, const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & V1, const [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > & W1, const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body0, const [TSolverBodyPtrSimd](API\Runtime\Chaos\Chaos\Collision\TSolverBodyPtrSimd)< 4 > & Body1 ) } }


code: namespace Chaos { namespace Private { *TParam [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) a shape that returns true to check a particle for overlaps Signature TOverlapCollector void Chaos::Private::SimOverlapBounds ( [ISpatialAcceleration](API\Runtime\Engine\Physics\Experimental\ISpatialAcceleration)< [FAccelerationStructureHandle](API\Runtime\Chaos\Chaos\FAccelerationStructureHandle), [FReal](API\Runtime\ChaosCore\Chaos\FReal), 3 > * SpatialAcceleration, const [FAABB3](API\Runtime\Chaos\Chaos\FAABB3) & QueryBounds, TParticleFilter & ParticleFilter, [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) & ShapeFilter, TOverlapCollector & OverlapCollector ) } }


description: FSimSweepCollectorFirstHitwhich keeps the hit with the lowest time of impact and the most opposing normalifthere is a tie.

code: namespace Chaos { namespace Private { template<typename TShapeFilter, typename THitCollector> void Chaos::Private::SimSweepParticlePair ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * SweptParticle, const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * OtherParticle, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & StartPos, const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & Rot, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Length, [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) & ShapeFilter, THitCollector & HitCollector ) } }


code: namespace Chaos { namespace Private { template<typename TParticleFilter, typename TShapeFilter, typename THitCollector> *tparam [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) A custom filter functor with the signature const [FReal](API\Runtime\ChaosCore\Chaos\FReal) const [FSimSweepParticleHit](API\Runtime\Chaos\Chaos\Collision\FSimSweepParticleHit) &InHit *It should return true to continue checking further or false to stop any further sweeping *see [FSimSweepCollectorFirstHit](API\Runtime\Chaos\Chaos\Collision\FSimSweepCollectorFirstHit) which keeps the hit with the lowest time of impact and the most opposing normal [if](API\Plugins\NetcodeUnitTest\if) there is a tie **param SweptParticle The particle to be swept *param StartPos The start position of the particle to be swept *param Rot The rotation to usefor the [sweep](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__sweep) *param Dir The direction of the they are not sorted by TOI *void Chaos::Private::SimSweepParticle ( [ISpatialAcceleration](API\Runtime\Engine\Physics\Experimental\ISpatialAcceleration)< [FAccelerationStructureHandle](API\Runtime\Chaos\Chaos\FAccelerationStructureHandle), [FReal](API\Runtime\ChaosCore\Chaos\FReal), 3 > * SpatialAcceleration, const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * SweptParticle, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & StartPos, const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & Rot, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Dir, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Length, TParticleFilter & ParticleFilter, [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) & ShapeFilter, THitCollector & HitCollector ) } }


code: namespace Chaos { namespace Private { *tparam [TShapeFilter](API\Runtime\Chaos\Chaos\Collision\TShapeFilter) A custom filter functor with the signature const [FReal](API\Runtime\ChaosCore\Chaos\FReal) const [FSimSweepParticleHit](API\Runtime\Chaos\Chaos\Collision\FSimSweepParticleHit) &InHit *It should return true to continue checking further or false to stop any further sweeping *see [FSimSweepCollectorFirstHit](API\Runtime\Chaos\Chaos\Collision\FSimSweepCollectorFirstHit) which keeps the hit with the lowest time of impact and the most opposing normal [if](API\Plugins\NetcodeUnitTest\if) there is a tie **param SweptParticle The particle to be swept *param StartPos The start position of the particle to be swept *param Rot The rotation to usefor the sweep *param Dir The direction of the Chaos::Private::sweep ( must be normalized ) } }


description: Project a triangle onto an axis and return the projected range as well as the vertex indices that bound the range.

code: namespace Chaos { void Chaos::ProjectOntoAxis ( const [FTriangle](API\Runtime\Chaos\Chaos\FTriangle) & Triangle, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & AxisN, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & AxisX, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & PMin, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & PMax, int32 & MinVertexIndex, int32 & MaxVertexIndex ) }


description: Project a capsule segment onto an axis and return the projected range as well as the vertex indices that bound the range.

code: namespace Chaos { void Chaos::ProjectOntoAxis ( const FCapsule & Capsule, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & AxisN, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & AxisX, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & PMin, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & PMax, int32 & MinVertexIndex, int32 & MaxVertexIndex ) }


description: Project a convex onto an axis and return the projected range as well as the vertex indices that bound the range.

code: namespace Chaos { template<typename ConvexType> void Chaos::ProjectOntoAxis ( const ConvexType & Convex, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & AxisN, const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & AxisX, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & PMin, [FReal](API\Runtime\ChaosCore\Chaos\FReal) & PMax, int32 & MinVertexIndex, int32 & MaxVertexIndex, [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FReal](API\Runtime\ChaosCore\Chaos\FReal) > * VertexDs ) }


description:
Check whether the two particles need to be considered in the broadphase NOTE: Implicit0Type and Implicit1Type must be the inner type of the implicit, with any decorators removed (scaled, instanced, transformed).
true if the shape pair should be considered by the narrowphase

code: namespace Chaos { bool Chaos::ShapePairNarrowPhaseFilter ( [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Implicit0Type, const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * Shape0, [EImplicitObjectType](API\Runtime\Chaos\Chaos\EImplicitObjectType) Implicit1Type, const [FPerShapeData](API\Runtime\Chaos\Chaos\FPerShapeData) * Shape1 ) }


description: Used to order particles in a consistent way in Broadphase and Resim. Returns whether the partcile order should be reversed. We want the particle with the lower ID first, unless only one is dynamic in which case that one is first.

code: namespace Chaos { bool Chaos::ShouldSwapParticleOrder ( const bool bIsDynamicOrSleeping0, const bool bIsDynamicOrSleeping1, const bool bIsParticle0Preferred ) }


code: namespace Chaos { bool Chaos::ShouldSwapParticleOrder ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle0, const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1 ) }


className: FParticleHandle

code: typedef [TGeometryParticleHandle](API\Runtime\Chaos\Chaos\TGeometryParticleHandle)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 3 > FParticleHandle


code: void ProduceOverlaps ( [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, [Private::FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) * Allocator, const [FCollisionDetectorSettings](API\Runtime\Chaos\Chaos\Collision\FCollisionDetectorSettings) & Settings )


code: void ProduceOverlaps &40; FReal Dt, const FCollisionContext & Context, FParticleHandle &42; ParticleA, FParticleHandle &42; ParticleB, FParticleHandle &42; SearchParticle &41;


code: FBasicBroadPhase ( const [TArray](API\Runtime\Core\Containers\TArray)< [FParticlePair](API\Runtime\Chaos\Chaos\FParticlePair) > * InParticlePairs, const [TArray](API\Runtime\Core\Containers\TArray)< [FParticleHandle](API\Runtime\Chaos\Chaos\Collision\FBasicBroadPhase\FParticleHandle) * > * InParticlesA, const [TArray](API\Runtime\Core\Containers\TArray)< [FParticleHandle](API\Runtime\Chaos\Chaos\Collision\FBasicBroadPhase\FParticleHandle) * > * InParticlesB )


className: FBasicBroadPhase

description: No spatial acceleration, and the order is assumed to be already optimized for cache efficiency.

code: class FBasicBroadPhase


code: virtual void DetectCollisions ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, [FEvolutionResimCache](API\Runtime\Chaos\Chaos\FEvolutionResimCache) * Unused )


code: FBasicCollisionDetector ( [FBasicBroadPhase](API\Runtime\Chaos\Chaos\Collision\FBasicBroadPhase) & InBroadPhase, [FPBDCollisionConstraints](API\Runtime\Chaos\Chaos\FPBDCollisionConstraints) & InCollisionContainer )


className: FBasicCollisionDetector

code: class FBasicCollisionDetector : public [Chaos::FCollisionDetector](API\Runtime\Chaos\Chaos\Collision\FCollisionDetector)


className: FBroadPhaseContext

description: Per-thread context for the broadphase.

code: class FBroadPhaseContext

CollisionContext

type: FCollisionConte...

MidPhases

type: TArray<FPartic...

Overlaps

type: TArray<FBroadP...


code: void ApplyFilter ( const [FIgnoreCollisionManager](API\Runtime\Chaos\Chaos\Collision\FIgnoreCollisionManager) & IgnoreCollisionManager, const [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) bIsResimming )


code: FBroadPhaseOverlap ( [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle0, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1, const int32 InSearchParticleIndex )


className: FBroadPhaseOverlap

description: Output element from the broadphase

code: class FBroadPhaseOverlap

bCollisionsEnabled

type: bool

Particles

type: FGeometryPartic...


description: Add a set of pre-built constraints and build required internal mapping data This is used by the resim cache when restoring constraints after a desync.

code: void AddResimConstraints ( const [TArray](API\Runtime\Core\Containers\TArray)< [FPBDCollisionConstraint](API\Runtime\Chaos\Chaos\Collision\FPBDCollisionConstraint) > & InConstraints, const [FCollisionContext](API\Runtime\Chaos\Chaos\Collision\FCollisionContext) Context )


description: Called at the start of the tick to prepare for collision detection. Resets the list of active contacts.

code: void BeginDetectCollisions()


description: Called at the start of the frame to clear the frame's active collision list.

code: void BeginFrame()


description: This is not thread-safe and should not be used during the collision detection phase (i.e., when the list is being built)

code: [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FPBDCollisionConstraint](API\Runtime\Chaos\Chaos\Collision\FPBDCollisionConstraint) *const > GetCCDConstraints() const


description: Called after collision detection to clean up Prunes unused contacts.

code: void EndDetectCollisions()


code: [TArrayView](API\Runtime\Core\Containers\TArrayView)< const [FPBDCollisionConstraint](API\Runtime\Chaos\Chaos\Collision\FPBDCollisionConstraint) *const > GetConstConstraints() const


code: [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FPBDCollisionConstraint](API\Runtime\Chaos\Chaos\Collision\FPBDCollisionConstraint) *const > GetConstraints() const


code: [FCollisionContextAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionContextAllocator) * GetContextAllocator ( const int32 Index )


description: Sleeping constrainst will report they are expired, but they should not be deleted until awoken. We deliberately don't check the sleeping flag here because it adds a cache miss. This function should be called only when you already know the sleep state (or you must also check IsSleeping())

code: [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) IsConstraintExpired ( const [FPBDCollisionConstraint](API\Runtime\Chaos\Chaos\Collision\FPBDCollisionConstraint) & Constraint )


code: [FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) & operator= ( const [FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) & )


code: [FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) & operator= ( [FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) && )


description: If we add new constraints after collision detection, do what needs to be done to add them to the system.

code: void ProcessInjectedConstraints()


description: Collect all the midphases created on the context allocators (probably on multiple threads) and register them

code: void ProcessNewMidPhases()


description: Called each tick after the graph is updated to remove unused collisions.

code: void PruneExpiredItems()


description: Destroy all collision and caches involving the particle Called when a particle is destroyed or disabled (not sleeping).

code: void RemoveParticle ( [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle )


description: Destroy all constraints.

code: void Reset()


code: void SetCollisionContainer ( [FPBDCollisionConstraints](API\Runtime\Chaos\Chaos\FPBDCollisionConstraints) * InCollisionContainer )


code: void SetMaxContexts ( const int32 MaxContexts )


description: Sort all the constraints for better solver stability.

code: void SortConstraintsHandles()


description: Iterate over all collisions (write-enabled), including sleeping ones Visitor signature: ECollisionVisitorResult(FPBDCollisionConstraint&)

code: template<typename TLambda> void VisitCollisions ( const TLambda & Visitor ) const


description: Iterate over all collisions (read-only), including sleeping ones Visitor signature: ECollisionVisitorResult(const FPBDCollisionConstraint&)

code: template<typename TLambda> void VisitConstCollisions ( const TLambda & Visitor ) const


description: Iterate over all midphases Visitor signature: ECollisionVisitorResult(FParticlePairMidPhase&)

code: template<typename TLambda> void VisitMidPhases ( const TLambda & Visitor )


code: FCollisionConstraintAllocator ( [FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) && )


code: FCollisionConstraintAllocator ( const [FCollisionConstraintAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionConstraintAllocator) & )


code: FCollisionConstraintAllocator ( const int32 InNumCollisionsPerBlock )


className: FCollisionConstraintAllocator

description: NOTE: To reduce RBAN memory use, we do not create any collision blocks until the first call to CreateCollisionConstraint (see ConstraintPool initialization)

code: class FCollisionConstraintAllocator


code: const [FCollisionDetectorSettings](API\Runtime\Chaos\Chaos\Collision\FCollisionDetectorSettings) & GetSettings() const


code: void SetAllocator ( [Private::FCollisionContextAllocator](API\Runtime\Chaos\Chaos\Collision\FCollisionContextAllocator) * InAllocator )


code: void SetSettings ( const [FCollisionDetectorSettings](API\Runtime\Chaos\Chaos\Collision\FCollisionDetectorSettings) & InSettings )


className: FCollisionContext

description: Data passed down into the collision detection functions.

code: class FCollisionContext

MidPhase

type: FParticlePairMi...

description: This is used in the older collision detection path which is still used for particles that do not flatten their implicit hierrarchies into the Particle's ShapesArray.

Settings

type: constFCollisio...


description: Set the constraint as Active - it will be added to the graph and solved this tick. NOTE: This actually just enqueues the constraint - actual activation happens after the parallel phase is done.

code: [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) ActivateConstraint ( [FPBDCollisionConstraint](API\Runtime\Chaos\Chaos\Collision\FPBDCollisionConstraint) * Constraint )


description: Create an uninitialized collision constraint (public only for use by Resim which overwrites it with a saved constraint)


description: Create a constraint (called by the MidPhase)

code: [FPBDCollisionConstraintPtr](API\Runtime\Chaos\Chaos\FPBDCollisionConstraintPtr) CreateConstraint ( [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle0, 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 [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & ShapeRelativeTransform0, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1, 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 [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & ShapeRelativeTransform1, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) CullDistance, const [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) bUseManifold, const [EContactShapesType](API\Runtime\Chaos\Chaos\Chaos__EContactShapesType) ShapePairType )


description: Return a midphase for a particle pair if it already exists, otherwise return null

code: [FParticlePairMidPhase](API\Runtime\Chaos\Chaos\Collision\FParticlePairMidPhase) * FindMidPhase ( [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle0, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * SearchParticlePerformanceHint )


description: The current epoch used to determine if a collision is up to date

code: int32 GetCurrentEpoch() const


description: Nothing outside of thie allocator should hold a pointer to the midphase, or any constraints it creates for more than the duration of the tick. Except the IslandManager :|

code: [FParticlePairMidPhase](API\Runtime\Chaos\Chaos\Collision\FParticlePairMidPhase) * GetMidPhase ( [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle0, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1, [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * SearchParticlePerformanceHint, const [FCollisionContext](API\Runtime\Chaos\Chaos\Collision\FCollisionContext) & Context )


code: FCollisionContextAllocator ( [FPBDCollisionConstraints](API\Runtime\Chaos\Chaos\FPBDCollisionConstraints) * InCollisionContainer, const int32 InNumCollisionsPerBlock, const int32 InCurrentEpoch )


className: FCollisionContextAllocator

description: Container the storage for theFCollisionConstraintAllocator, as well as the API to create new midphases and collision constraints. We have one of these objects per thread on which collisions detection is performed to get lock-free allocations and lists.

code: class FCollisionContextAllocator


code: void DetectCollisions ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) Dt, [FEvolutionResimCache](API\Runtime\Chaos\Chaos\FEvolutionResimCache) * ResimCache )


description: Deprecated* Moved toFPBDCollisionConstraints


description: Deprecated* Moved toFPBDCollisionConstraintsand renamed to SetCullDistance

code: void SetBoundsExpansion ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) InBoundsExpansion )


description: Deprecated* No longer supported

code: void SetBoundsVelocityInflation ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) InBoundsVelocityInflation )


code: FCollisionDetector ( [FPBDCollisionConstraints](API\Runtime\Chaos\Chaos\FPBDCollisionConstraints) & InCollisionContainer )


className: FCollisionDetector

code: class FCollisionDetector

CollisionContainer

type: FPBDCollisionCo...


className: FCollisionDetectorSettings

code: class FCollisionDetectorSettings

bAllowCCD

description: Whether CCD is allowed (disabled for RBAN)

bAllowManifoldReuse

description: Whether we can reuse manifolds between frames if contacts have not moved far.

bAllowManifolds

description: Whether to use one-shot manifolds where supported.

bDeferNarrowPhase

description: Whether to defer the narrow phase to the constraint-solve phase.

bFilteringEnabled

description: Whether to check the shape query flags in the narrow phase (e.g., Rigid Body nodes have already performed filtering prior to collision detection)

BoundsExpansion

description: Shape bounds are expanded by this in all 3 directions. This is also used as the CullDistance for collision response.

BoundsVelocityInflation

description: Shape bounds in the broadphase are expanded by this multiple of velocity.

MaxVelocityBoundsExpansion

description: We only allow the bounds to grow from velocity by this much.


code: FCollisionParticlePairConstraintKey()


description: Deprecated* Replaced with version that takes Shape and ImplicitID

code: FCollisionParticlePairConstraintKey ( const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Implicit0, const [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) * Simplicial0, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Implicit1, const [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) * Simplicial1 )


code: FCollisionParticlePairConstraintKey ( const [FShapeInstance](API\Runtime\Chaos\Chaos\FShapeInstance) * Shape0, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Implicit0, const int32 ImplicitId0, const [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) * Simplicial0, const [FShapeInstance](API\Runtime\Chaos\Chaos\FShapeInstance) * Shape1, const [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) * Implicit1, const int32 ImplicitId1, const [FBVHParticles](API\Runtime\Chaos\Chaos\FBVHParticles) * Simplicial1 )


className: FCollisionParticlePairConstraintKey

description: This key only needs to be uinque within the context of a particle pair. There is no guarantee of global uniqueness. This key is only used by the FMultiShapePairCollisionDetector class which is used for colliding shape pairs where each shape is actually a hierarchy of shapes.


code: FCollisionParticlePairKey ( const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle0, const [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * Particle1 )


className: FCollisionParticlePairKey

description: This uses ParticleID and truncates it from 32 to 31 bits

code: class FCollisionParticlePairKey


code: FContactEdgeID ( const [FContactVertexID](API\Runtime\Chaos\Chaos\Collision\FContactVertexID) VertexIndexA, const [FContactVertexID](API\Runtime\Chaos\Chaos\Collision\FContactVertexID) VertexIndexB )


className: FContactEdgeID

code: struct FContactEdgeID

type: union Chaos::FC...

VertexIDs

type: FContactVertexI...


description: Get the centroid of the triangle.


description: Given a contact point on a triangle, check if it is an edge contact or vertex contact and return vertex indices if so

code: bool GetEdgeVerticesAtPosition ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & ContactPosition, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutEdgeVertexA, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutEdgeVertexB, int32 & OutVertexIndexA, int32 & OutVertexIndexB, const [FReal](API\Runtime\ChaosCore\Chaos\FReal) BaryCentricTolerance ) const


description: Get the positions of the other two vertices in the triangle. (VertexIndex is an index into the owning mesh's vertices)

code: bool GetOtherVertexPositions ( const int32 VertexIndex, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutVertex0, [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & OutVertex1 ) const


description: Does this triangle contains the specified vertex? (VertexIndex is an index into the owning mesh's vertices)

code: bool HasVertexIndex ( const int32 VertexIndex ) const


className: FContactTriangle

description: Data held alongside contact points when generating contacts against a (likely non-convex) mesh of triangles.

code: class FContactTriangle

VertexIndices

description: Indices into the mesh (trimesh or heightfield) that generated the triangle.

Vertices

description: Triangle data.