code: static [FGeometryParticleHandle](API\Runtime\Chaos\Chaos\FGeometryParticleHandle) * GetParticleHandleFromProxy ( [IPhysicsProxyBase](API\Runtime\Chaos\Chaos\Framework\IPhysicsProxyBase) * ProxyBase )


description: Lifespan Management

module: Chaos

code: void InitializeOnPhysicsThread ( [FPBDRigidsSolver](API\Runtime\Chaos\FPBDRigidsSolver) * InSolver, [FDirtyPropertiesManager](API\Runtime\Chaos\Chaos\FDirtyPropertiesManager) & Manager, int32 DataIdx, [FDirtyChaosProperties](API\Runtime\Chaos\Chaos\FDirtyChaosProperties) & RemoteData )


description: Merge to perform a remote sync.

code: void PushStateOnGameThread ( [FDirtyPropertiesManager](API\Runtime\Chaos\Chaos\FDirtyPropertiesManager) & Manager, int32 DataIdx, [FDirtyChaosProperties](API\Runtime\Chaos\Chaos\FDirtyChaosProperties) & RemoteData )


code: void PushStateOnPhysicsThread ( [FPBDRigidsSolver](API\Runtime\Chaos\FPBDRigidsSolver) * InSolver, const [FDirtyPropertiesManager](API\Runtime\Chaos\Chaos\FDirtyPropertiesManager) & Manager, int32 DataIdx, const [FDirtyChaosProperties](API\Runtime\Chaos\Chaos\FDirtyChaosProperties) & RemoteData )


code: void SetHandle ( [FPBDSuspensionConstraintHandle](API\Runtime\Chaos\Chaos\FPBDSuspensionConstraintHandle) * InHandle )


code: void UpdateTargetOnPhysicsThread ( [FPBDRigidsSolver](API\Runtime\Chaos\FPBDRigidsSolver) * InSolver, const FVector & TargetPos, const FVector & Normal, bool Enabled )


code: FSuspensionConstraintPhysicsProxy()


code: FSuspensionConstraintPhysicsProxy ( [FSuspensionConstraint](API\Runtime\Chaos\Chaos\FSuspensionConstraint) * InConstraint, [FPBDSuspensionConstraintHandle](API\Runtime\Chaos\Chaos\FPBDSuspensionConstraintHandle) * InHandle, [UObject](API\Runtime\CoreUObject\UObject\UObject) * InOwner )


className: FSuspensionConstraintPhysicsProxy

code: class FSuspensionConstraintPhysicsProxy : public [IPhysicsProxyBase](API\Runtime\Chaos\Chaos\Framework\IPhysicsProxyBase)


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetAngularBreakTorque() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetAngularDriveDamping() const


code: const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & GetAngularDriveForceMode() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetAngularDriveMaxTorque() const


code: const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & GetAngularDrivePositionTarget() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetAngularDriveStiffness() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetAngularDriveVelocityTarget() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetAngularLimits() const


code: const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & GetAngularMotionTypesX() const


code: const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & GetAngularMotionTypesY() const


code: const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & GetAngularMotionTypesZ() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetAngularPlasticityLimit() const


code: const bool & GetAngularSLerpPositionDriveEnabled() const


code: const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & GetAngularSoftForceMode() const


code: const bool & GetAngularSLerpVelocityDriveEnabled() const


code: const bool & GetAngularSwingPositionDriveEnabled() const


code: const bool & GetAngularSwingVelocityDriveEnabled() const


code: const bool & GetAngularTwistPositionDriveEnabled() const


code: const bool & GetAngularTwistVelocityDriveEnabled() const


code: const bool & GetCollisionEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetContactTransferScale() const


description: CHAOS_INNER_JOINT_PROPERTY(OuterProp, FuncName, InnerName, InnerType)

code: const [FTransformPair](API\Runtime\Chaos\Chaos\FTransformPair) & GetJointTransforms() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetLinearBreakForce() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetLinearContactDistance() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetLinearDriveDamping() const


code: const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & GetLinearDriveForceMode() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetLinearDriveMaxForce() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetLinearDrivePositionTarget() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetLinearDriveStiffness() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & GetLinearDriveVelocityTarget() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetLinearLimit() const


code: const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & GetLinearMotionTypesX() const


code: const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & GetLinearMotionTypesY() const


code: const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & GetLinearMotionTypesZ() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetLinearPlasticityLimit() const


code: const [EPlasticityType](API\Runtime\Chaos\Chaos\Chaos__EPlasticityType) & GetLinearPlasticityType() const


code: const bool & GetLinearPositionDriveXEnabled() const


code: const bool & GetLinearPositionDriveYEnabled() const


code: const bool & GetLinearPositionDriveZEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetLinearRestitution() const


code: const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & GetLinearSoftForceMode() const


code: const bool & GetLinearVelocityDriveZEnabled() const


code: const bool & GetLinearVelocityDriveXEnabled() const


code: const bool & GetLinearVelocityDriveYEnabled() const


code: const bool & GetMassConditioningEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetParentInvMassScale() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetProjectionAngularTolerance() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetProjectionAngularAlpha() const


code: const bool & GetProjectionEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetProjectionLinearAlpha() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetProjectionLinearTolerance() const


code: const bool & GetShockPropagationEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetShockPropagationAlpha() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSoftLinearDamping() const


code: const bool & GetSoftLinearLimitsEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSoftLinearStiffness() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSoftSwingDamping() const


code: const bool & GetSoftSwingLimitsEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSoftSwingStiffness() const


code: const bool & GetSoftTwistLimitsEnabled() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSoftTwistDamping() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSoftTwistStiffness() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetStiffness() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSwingContactDistance() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetSwingRestitution() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetTwistContactDistance() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & GetTwistRestitution() const


code: void SetAngularBreakTorque ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetAngularDriveDamping ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetAngularDriveMaxTorque ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetAngularDrivePositionTarget ( const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & Val )


code: void SetAngularDriveForceMode ( const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & Val )


code: void SetAngularDriveStiffness ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetAngularDriveVelocityTarget ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetAngularLimits ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetAngularMotionTypesX ( const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & Val )


code: void SetAngularMotionTypesY ( const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & Val )


code: void SetAngularMotionTypesZ ( const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & Val )


code: void SetAngularSLerpPositionDriveEnabled ( const bool & Val )


code: void SetAngularSLerpVelocityDriveEnabled ( const bool & Val )


code: void SetAngularSoftForceMode ( const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & Val )


code: void SetAngularSwingPositionDriveEnabled ( const bool & Val )


code: void SetAngularSwingVelocityDriveEnabled ( const bool & Val )


code: void SetAngularTwistPositionDriveEnabled ( const bool & Val )


code: void SetAngularTwistVelocityDriveEnabled ( const bool & Val )


code: void SetCollisionEnabled ( const bool & Val )


code: void SetAngularPlasticityLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetContactTransferScale ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetJointTransforms ( const [FTransformPair](API\Runtime\Chaos\Chaos\FTransformPair) & Val )


code: void SetLinearBreakForce ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetLinearContactDistance ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetLinearDriveDamping ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetLinearDriveForceMode ( const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & Val )


code: void SetLinearDriveMaxForce ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetLinearDrivePositionTarget ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetLinearDriveStiffness ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetLinearDriveVelocityTarget ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Val )


code: void SetLinearLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetLinearMotionTypesX ( const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & Val )


code: void SetLinearMotionTypesY ( const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & Val )


code: void SetLinearMotionTypesZ ( const [EJointMotionType](API\Runtime\Chaos\Chaos\Chaos__EJointMotionType) & Val )


code: void SetLinearPlasticityLimit ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetLinearPlasticityType ( const [EPlasticityType](API\Runtime\Chaos\Chaos\Chaos__EPlasticityType) & Val )


code: void SetLinearPositionDriveXEnabled ( const bool & Val )


code: void SetLinearPositionDriveYEnabled ( const bool & Val )


code: void SetLinearPositionDriveZEnabled ( const bool & Val )


code: void SetLinearRestitution ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetLinearSoftForceMode ( const [EJointForceMode](API\Runtime\Chaos\Chaos\Chaos__EJointForceMode) & Val )


code: void SetLinearVelocityDriveXEnabled ( const bool & Val )


code: void SetLinearVelocityDriveYEnabled ( const bool & Val )


code: void SetLinearVelocityDriveZEnabled ( const bool & Val )


code: void SetMassConditioningEnabled ( const bool & Val )


code: void SetParentInvMassScale ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetProjectionAngularTolerance ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetProjectionAngularAlpha ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetProjectionLinearAlpha ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetProjectionEnabled ( const bool & Val )


code: void SetProjectionLinearTolerance ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetShockPropagationEnabled ( const bool & Val )


code: void SetShockPropagationAlpha ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSoftLinearDamping ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSoftLinearLimitsEnabled ( const bool & Val )


code: void SetSoftLinearStiffness ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSoftSwingDamping ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSoftSwingLimitsEnabled ( const bool & Val )


code: void SetSoftSwingStiffness ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSoftTwistDamping ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSoftTwistLimitsEnabled ( const bool & Val )


code: void SetSoftTwistStiffness ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetStiffness ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSwingContactDistance ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetSwingRestitution ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetTwistContactDistance ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetTwistRestitution ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) & Val )


code: void SetUserData ( const void *& Val )


description: Wrapper class that routes all reads and writes to the appropriate joint data. This is helpful for cases where we want to both write to a joint and a network buffer for example

code: template<bool bExternal> class TThreadedJointConstraintPhysicsProxyBase : protected [Chaos::FJointConstraintPhysicsProxy](API\Runtime\Chaos\PhysicsProxy\FJointConstraintPhysicsProxy)


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) Acceleration() const


code: void AddForce ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InForce, bool bInvalidate )


code: void AddTorque ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InTorque, bool bInvalidate )


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) AngularAcceleration() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) AngularEtherDrag() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) AngularImpulse() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) AngularImpulseVelocity() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) CenterOfMass() const


code: [TSerializablePtr](API\Runtime\Chaos\Chaos\TSerializablePtr)< [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject) > Geometry() const


code: const [Chaos::TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) > I() const


code: bool InertiaConditioningEnabled() const


code: const [Chaos::TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) > InvI() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) InvM() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) LinearEtherDrag() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) LinearImpulse() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) LinearImpulseVelocity() const


code: const [FReal](API\Runtime\ChaosCore\Chaos\FReal) M() const


code: const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & R() const


code: const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) RotationOfMass() const


code: void SetAcceleration ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & Acceleration, bool bInvalidate )


code: void SetAngularAcceleration ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & AngularAcceleration, bool bInvalidate )


code: void SetAngularEtherDrag ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) InAngularEtherDrag )


code: void SetAngularImpulse ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InAngularImpulse, bool bIsVelocity, bool bInvalidate )


code: void SetCCDEnabled ( const bool InCCDEnabled )


code: void SetCenterOfMass ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InCenterOfMass, bool bInvalidate )


code: void SetGravityEnabled ( const bool InGravityEnabled )


code: void SetI ( const [Chaos::TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) > & InI )


code: void SetInertiaConditioningEnabled ( const bool bInEnabled )


code: void SetInvI ( const [Chaos::TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) > & InInvI )


code: void SetInvM ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) InInvM )


code: void SetKinematicTarget ( const [FRigidTransform3](API\Runtime\ChaosCore\Chaos\FRigidTransform3) & InTargetTransform, bool bInvalidate )


code: void SetKinematicTarget ( const [FKinematicTarget](API\Runtime\Chaos\Chaos\FKinematicTarget) & InKinematicTarget, bool bInvalidate )


code: void SetLinearEtherDrag ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) InLinearEtherDrag )


code: void SetLinearImpulse ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InLinearImpulse, bool bIsVelocity, bool bInvalidate )


code: void SetM ( const [FReal](API\Runtime\ChaosCore\Chaos\FReal) InM )


code: void SetObjectStateBase ( const [EObjectStateType](API\Runtime\Chaos\Chaos\Chaos__EObjectStateType) InState, bool bAllowEvents, bool bInvalidate )


code: void SetOneWayInteraction ( const bool bInOneWayInteraction )


code: void SetRBase ( const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & InR, bool bInvalidate )


code: void SetResimType ( [EResimType](API\Runtime\Chaos\Chaos\Chaos__EResimType) ResimType )


code: void SetRotationOfMass ( const [FRotation3](API\Runtime\ChaosCore\Chaos\FRotation3) & InRotationOfMass, bool bInvalidate )


code: void SetSpatialIdx ( [FSpatialAccelerationIdx](API\Runtime\Chaos\Chaos\FSpatialAccelerationIdx) Idx )


code: void SetSleepType ( [ESleepType](API\Runtime\Chaos\Chaos\Chaos__ESleepType) InSleepType )


code: void SetUniqueIdx ( const [FUniqueIdx](API\Runtime\Chaos\Chaos\FUniqueIdx) UniqueIdx, bool bInvalidate )


code: void SetUpdateKinematicFromSimulation ( const bool InUpdateKinematicFromSimulation )


code: void SetVBase ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InV, bool bInvalidate )


code: void SetWBase ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InW, bool bInvalidate )


code: void SetXBase ( const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & InX, bool bInvalidate )


code: const [FShapesArray](API\Runtime\Chaos\Chaos\FShapesArray) & ShapesArray() const


code: const [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [FImplicitObject](API\Runtime\Chaos\Chaos\FImplicitObject), ESPMode::ThreadSafe > & SharedGeometryLowLevel() const


description: API for kinematic particle.

code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) V() const


code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) W() const


description: API for static particle.

code: const [FVec3](API\Runtime\ChaosCore\Chaos\FVec3) & X() const


className: TThreadedSingleParticlePhysicsProxyBase

description: No constructors are accessible with public or protected access.

code: template<bool bExternal> class TThreadedSingleParticlePhysicsProxyBase : protected [Chaos::FSingleParticlePhysicsProxy](API\Runtime\Chaos\PhysicsProxy\FSingleParticlePhysicsProxy)


description: Get the closest (min/max) valid datas from the Datas frame

code: int32 ClosestDatas ( const int32 DatasFrame, const bool bMinDatas )


description: Extract states at a given time

code: virtual bool ExtractDatas ( const int32 ExtractFrame, const bool bResetSolver, void * HistoryDatas, const bool bExactFrame )


description: Current datas that is being loaded/recorded

code: DatasType & GetCurrentDatas()


code: const DatasType & GetCurrentDatas() const


description: Check if the history buffer contains an entry for the given frame

code: virtual bool HasValidDatas ( const int32 ValidFrame ) const


description: Load the datas from the buffer at a specific frame

code: bool LoadDatas ( const int32 LoadFrame )


description: Get the number of valid datas in the buffer index range

code: uint32 NumValidDatas ( const uint32 StartFrame, const uint32 EndFrame ) const


description: Eval the datas from the buffer at a specific frame

code: bool EvalDatas ( const int32 EvalFrame )


description: Record the datas from the buffer at a specific frame

code: virtual bool RecordDatas ( const int32 RecordFrame, const void * HistoryDatas )


code: TDatasRewindHistory ( const int32 FrameCount, const bool bIsHistoryLocal )


className: TDatasRewindHistory

description: Templated datas history holding a datas buffer

code: template<typename DatasType> struct TDatasRewindHistory : public [Chaos::FBaseRewindHistory](API\Runtime\Chaos\FBaseRewindHistory)

bIsLocalHistory

type: bool

description: Check if the history is on the local/remote client

CurrentFrame

description: Current frame that is being loaded/recorded

CurrentIndex

description: Current index that is being loaded/recorded

DatasArray

type: TArray< DatasTy...

description: Datas buffer holding the history

NumFrames

description: Number of frames used in that history


code: TVal & Add ( const [TKey](API\Runtime\Chaos\TDirtyObjects\TKey) Key, TVal && Val )


code: const TVal * Find ( const [TKey](API\Runtime\Chaos\TDirtyObjects\TKey) Key ) const


code: TVal * Find ( const [TKey](API\Runtime\Chaos\TDirtyObjects\TKey) Key )


code: const TVal & FindChecked ( const [TKey](API\Runtime\Chaos\TDirtyObjects\TKey) Key ) const


code: TVal & FindChecked ( const [TKey](API\Runtime\Chaos\TDirtyObjects\TKey) Key )


code: TVal & GetDenseAt ( const int32 Idx )


code: const TVal & GetDenseAt ( const int32 Idx ) const


code: void Remove ( const [TKey](API\Runtime\Chaos\TDirtyObjects\TKey) Key )


className: TKey

code: typedef decltype([ConstifyHelper](API\Runtime\Chaos\Chaos__ConstifyHelper)(((TVal *) 0) ->GetObjectPtr())) TKey


className: TDirtyObjects

code: template<typename TVal> class TDirtyObjects


code: virtual void AddEvent ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(PayloadType &EventDataInOut)> InFunction )


code: virtual void DestroyStaleEvents ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(PayloadType &EventDataInOut)> InFunction )


description: Dispatch events to the registered handlers

code: virtual void DispatchConsumerData()


description: Flips the buffer if the buffer type is double or triple

code: virtual void FlipBufferIfRequired()


description: Inject data from the physics solver into the producer side of the buffer

code: virtual void InjectProducerData ( const [FPBDRigidsSolver](API\Runtime\Chaos\FPBDRigidsSolver) * Solver, bool bResetData )


description: Register the delegate function that will handle the events on the game thread

code: virtual void RegisterHandler ( const [FEventHandlerPtr](API\Runtime\Chaos\FEventHandlerPtr) & Handler )


description: Unregister the delegate function that handles the events on the game thread

code: virtual void UnregisterHandler ( const void * InHandler )


description: Copy constructor

code: TEventContainer ( [TEventContainer](API\Runtime\Chaos\TEventContainer)< PayloadType > & Other )


description: Regular constructor

code: TEventContainer ( const [Chaos::EMultiBufferMode](API\Runtime\Chaos\Chaos\Framework\Chaos__EMultiBufferMode) & BufferMode, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(const [FPBDRigidsSolver](API\Runtime\Chaos\FPBDRigidsSolver) *Solver, PayloadType &EventDataInOut, bool bResetData)> InFunction )


description: Destructor cleans up memory

code: ~TEventContainer()


className: TEventContainer

description: Class that owns the injected producer function and its associated data buffer

code: template<typename PayloadType> class TEventContainer : public [Chaos::FEventContainerBase](API\Runtime\Chaos\FEventContainerBase)


code: void ClearEntryAndFuture ( const [FFrameAndPhase](API\Runtime\Chaos\FFrameAndPhase) FrameAndPhase )


code: void ExtractBufferState ( int32 & ValidCount, int32 & NextIterator ) const


code: T & Insert ( const [FFrameAndPhase](API\Runtime\Chaos\FFrameAndPhase) FrameAndPhase, [FDirtyPropertiesPool](API\Runtime\Chaos\Chaos\FDirtyPropertiesPool) & Manager )


code: bool IsClean ( const [FFrameAndPhase](API\Runtime\Chaos\FFrameAndPhase) FrameAndPhase ) const


code: template<typename [THandle](API\Runtime\Chaos\Chaos\Framework\THandle)> bool IsInSync ( const [THandle](API\Runtime\Chaos\Chaos\Framework\THandle) & Handle, const [FFrameAndPhase](API\Runtime\Chaos\FFrameAndPhase) FrameAndPhase, const [FDirtyPropertiesPool](API\Runtime\Chaos\Chaos\FDirtyPropertiesPool) & Pool ) const


description: Searches in reverse order for interval that contains FrameAndPhase.

code: const T * Read ( const [FFrameAndPhase](API\Runtime\Chaos\FFrameAndPhase) FrameAndPhase, const [FDirtyPropertiesPool](API\Runtime\Chaos\Chaos\FDirtyPropertiesPool) & Manager ) const


description: Releases data back into the pool.

code: void Release ( [FDirtyPropertiesPool](API\Runtime\Chaos\Chaos\FDirtyPropertiesPool) & Manager )


code: void RestoreBufferState ( const int32 & ValidCount, const int32 & NextIterator )


description: Gets access into buffer in monotonically increasing FrameAndPhase order: x_{n+1} > x_n.

code: T & WriteAccessMonotonic ( const [FFrameAndPhase](API\Runtime\Chaos\FFrameAndPhase) FrameAndPhase, [FDirtyPropertiesPool](API\Runtime\Chaos\Chaos\FDirtyPropertiesPool) & Manager )


description: Gets access into buffer in non-decreasing FrameAndPhase order: x_{n+1} >= x_n If x_{n+1} == x_n we return null to inform the user (usefull when a single phase can have multiple writes)

code: T * WriteAccessNonDecreasing ( const [FFrameAndPhase](API\Runtime\Chaos\FFrameAndPhase) FrameAndPhase, [FDirtyPropertiesPool](API\Runtime\Chaos\Chaos\FDirtyPropertiesPool) & Manager )


code: TParticlePropertyBuffer ( [TParticlePropertyBuffer](API\Runtime\Chaos\TParticlePropertyBuffer)< T, PropName > && Other )


code: TParticlePropertyBuffer ( int32 InCapacity )


code: TParticlePropertyBuffer ( const [TParticlePropertyBuffer](API\Runtime\Chaos\TParticlePropertyBuffer)< T, PropName > & Other )


className: TParticlePropertyBuffer

code: template<typename T, [EChaosProperty](API\Runtime\Chaos\Chaos\Chaos__EChaosProperty) PropName, bool bNoEntryIsHead> class TParticlePropertyBuffer


description: Deprecated* To be removed

code: [TArray](API\Runtime\Core\Containers\TArray)< [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > > & AllP()


description: Deprecated* To be removed

code: [TArray](API\Runtime\Core\Containers\TArray)< [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > > & AllPreV()


description: Deprecated* To be removed

code: [TArray](API\Runtime\Core\Containers\TArray)< [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > > & AllPreW()


description: Deprecated* To be removed

code: [TArray](API\Runtime\Core\Containers\TArray)< [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > > & AllQ()


code: const [THandleType](API\Runtime\Chaos\Chaos\TGeometryParticlesImp\THandleType) * Handle ( int32 Index ) const


description: Cannot be reference because double pointer would allow for badness, but still useful to have non const access to handle

code: [THandleType](API\Runtime\Chaos\Chaos\TGeometryParticlesImp\THandleType) * Handle ( int32 Index )


code: const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P ( const int32 index ) const


code: [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & P ( const int32 index )


code: const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > PCom ( const int32 index ) const


code: const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & PreV ( const int32 index ) const


code: [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & PreV ( const int32 index )


code: const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & PreW ( const int32 index ) const


code: [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & PreW ( const int32 index )


code: const [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > & Q ( const int32 index ) const


code: [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > & Q ( const int32 index )


code: const [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > QCom ( const int32 index ) const


description: World-space center of mass rotation.

code: const [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > RCom ( const int32 index ) const


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


code: void SetObjectState ( int32 Index, [EObjectStateType](API\Runtime\Chaos\Chaos\Chaos__EObjectStateType) InObjectState )


code: void SetSleeping ( int32 Index, bool bSleeping )


code: void SetSleepType ( int32 Index, [ESleepType](API\Runtime\Chaos\Chaos\Chaos__ESleepType) InSleepType )


code: void SetSolverBodyIndex ( const int32 index, const int32 InSolverBodyIndex )


code: void SetTransformPQCom ( const int32 index, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & InPCom, const [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > & InQCom )


description: FSolverBodyContainer

code: int32 SolverBodyIndex ( const int32 index ) const


className: THandleType

description: Must be reinterpret cast instead of static_cast as it's a forward declare.

code: typedef [TPBDRigidParticleHandle](API\Runtime\Chaos\Chaos\TPBDRigidParticleHandle)< T, d > THandleType


code: [FString](API\Runtime\Core\Containers\FString) ToString ( int32 index ) const


description: World-space center of mass location.

code: const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > XCom ( const int32 index ) const


code: TPBDRigidParticles ( const [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > & Other )


code: TPBDRigidParticles ( [TPBDRigidParticles](API\Runtime\Chaos\TPBDRigidParticles)< T, d > && Other )


className: TPBDRigidParticles

code: template<class T, int d> class TPBDRigidParticles : public [Chaos::TRigidParticles< T, d >](API\Runtime\Chaos\Chaos\TRigidParticles)


className: TPerShapeDataStateProperty

code: template<typename T, [EShapeProperty](API\Runtime\Chaos\Chaos\Chaos__EShapeProperty) PropName> class TPerShapeDataStateProperty


code: [FPerShapeDataState](API\Runtime\Chaos\FPerShapeDataState) operator[] ( const int32 ShapeIdx ) const


code: TShapesArrayState ( const TParticle & InParticle, const [FShapesArrayStateBase](API\Runtime\Chaos\FShapesArrayStateBase) * InState )


className: TShapesArrayState

code: template<typename TParticle> class TShapesArrayState


className: TSolverSimMaterialScope

code: template<[ELockType](API\Runtime\Chaos\Chaos__ELockType) LockType> struct TSolverSimMaterialScope


code: TSolverSimMaterialScope &40; FPhysicsSolverBase &42; InSolver &41;


code: namespace TSolverSimMaterialScope< ELockType { template<> struct TSolverSimMaterialScope< ELockType::Read > }


code: namespace TSolverSimMaterialScope< ELockType { template<> struct TSolverSimMaterialScope< ELockType::Write > }


module: ChaosCore

code: namespace Chaos { float Chaos::ConvertDoubleToFloat ( double DoubleValue ) }


code: namespace Chaos { [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< float > Chaos::ConvertDoubleToFloat ( [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< double > DoubleValue ) }


code: namespace Chaos { double Chaos::ConvertFloatToDouble ( float FloatValue ) }


description: 3X3 version of dRdF indexing of diff: dRdF[9*(i*3+j)+(m*3+n)] = dR.GetAt(m, n) /dF.GetAt (i, j):

code: namespace Chaos { template<class T> void Chaos::dRdFCorotated ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & F, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 81 > & dRdF ) }


description: Helper function of 3X3 SVD for flipping signs due to flipping signs of sigma.

code: namespace Chaos { template<class T> void Chaos::FlipSign ( int i, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & sigma ) }


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


code: namespace Chaos { template<class T> uint32 Chaos::GetTypeHash ( const [Chaos::TVector](API\Runtime\Chaos\Chaos\TVector)< T, 2 > & V ) }


code: namespace Chaos { template<class T> uint32 Chaos::GetTypeHash ( const [Chaos::TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & V ) }


code: namespace Chaos { [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< double > Chaos::ConvertFloatToDouble ( [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< float > FloatValue ) }


code: namespace Chaos { template<class T1, class T2> [Pair](API\Runtime\ChaosCore\Chaos\Pair)< T1, T2 > Chaos::MakePair ( const T1 & First, const T2 & Second ) }


description: Make a 3X3 matrix to lambda shape original form of H: x x x x x x x x x after : x 0 0 x x 0 x 0 x

code: namespace Chaos { template<class T> void Chaos::MakeLambdaShape ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & H, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & V ) }


description: Make a 3X3 matrix to upper bidiagonal form original form of H: x x x x x x x x x after zero chase: x x 0 0 x x 0 0 x

code: namespace Chaos { template<class T> void Chaos::MakeUpperBidiag ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & H, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & V ) }


code: namespace Chaos { template<typename Derived, typename T, int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar, [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< Derived, T, d > & ValueIn ) }


code: namespace Chaos { template<int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TVector](API\Runtime\Chaos\Chaos\TVector)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle), d > & ValueIn ) }


code: namespace Chaos { template<int d> [FArchive](API\Runtime\Core\Serialization\FArchive) & Chaos::operator<< ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TVector](API\Runtime\Chaos\Chaos\TVector)< [FRealDouble](API\Runtime\ChaosCore\Chaos\FRealDouble), d > & ValueIn ) }


description: General for for all other vectors

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


code: namespace Chaos { template<class T1, class T2> bool Chaos::operator== ( const [Pair](API\Runtime\ChaosCore\Chaos\Pair)< T1, T2 > & First, const [Pair](API\Runtime\ChaosCore\Chaos\Pair)< T1, T2 > & Second ) }


code: namespace Chaos { template<class T1, class T2> bool Chaos::operator< ( const [Pair](API\Runtime\ChaosCore\Chaos\Pair)< T1, T2 > & First, const [Pair](API\Runtime\ChaosCore\Chaos\Pair)< T1, T2 > & Second ) }


code: namespace Chaos { template<class T> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > Chaos::operator* ( const T S, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & V ) }


code: namespace Chaos { template<class T1, class T2> bool Chaos::operator> ( const [Pair](API\Runtime\ChaosCore\Chaos\Pair)< T1, T2 > & First, const [Pair](API\Runtime\ChaosCore\Chaos\Pair)< T1, T2 > & Second ) }


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


code: namespace Chaos { template<class T> [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > Chaos::operator/ ( const T S, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & V ) }


description: Whole matrix S is stored since its faster to calculate due to simd vectorization Polar guarantees negative sign is on the small magnitude singular value. S is guaranteed to be the closest one to identity. R is guaranteed to be the closest rotation to A.

code: namespace Chaos { template<class T> void Chaos::PolarDecomposition ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & A, [GivensRotation](API\Runtime\ChaosCore\Chaos\GivensRotation)< T > & R, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & S_Sym ) }


code: namespace Chaos { template<class T> void Chaos::PolarDecomposition ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & A, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & R, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & S_Sym ) }


description: Whole matrix S is stored Polar guarantees negative sign is on the small magnitude singular value. S is guaranteed to be the closest one to identity. R is guaranteed to be the closest rotation to A.

code: namespace Chaos { template<class T> void Chaos::PolarDecomposition ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & A, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & R, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & S_Sym ) }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdAdd ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdAdd ( const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & L, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & R ) } }


description: NOTE: Only TNumLanes == 4 is supported for now

code: namespace Chaos { namespace Private { static Chaos::Private::SimdAlignment = 16; } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdAnd ( const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InL, const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InR ) } }


code: namespace Chaos { namespace Private { [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) Chaos::Private::SimdAllTrue ( const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InL ) } }


description: 4-wide Logical operations

code: namespace Chaos { namespace Private { [bool](API\Runtime\Chaos\Chaos\Collision\Chaos__Private__bool\1) Chaos::Private::SimdAnyTrue ( const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InL ) } }


code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdCrossProduct ( const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & L, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & R ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdDivide ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdDotProduct ( const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & L, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & R ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdEqual ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


description: 4-wide Gather/Scatter operationsConvert 4 row-vectors into 3 column-vectors NOTE: The input vectors must be 16-byte aligned and padded to 16 bytes to avoid reading past valid memory

code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdGatherAligned ( const [FVec3f](API\Runtime\ChaosCore\Chaos\FVec3f) & InA, const [FVec3f](API\Runtime\ChaosCore\Chaos\FVec3f) & InB, const [FVec3f](API\Runtime\ChaosCore\Chaos\FVec3f) & InC, const [FVec3f](API\Runtime\ChaosCore\Chaos\FVec3f) & InD ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdGreater ( const [FSimd4Int32](API\Runtime\ChaosCore\Chaos\FSimd4Int32) & InL, const [FSimd4Int32](API\Runtime\ChaosCore\Chaos\FSimd4Int32) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdGreater ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdGreaterEqual ( const [FSimd4Int32](API\Runtime\ChaosCore\Chaos\FSimd4Int32) & InL, const [FSimd4Int32](API\Runtime\ChaosCore\Chaos\FSimd4Int32) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdGreaterEqual ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdInvSqrt ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InV ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdLess ( const [FSimd4Int32](API\Runtime\ChaosCore\Chaos\FSimd4Int32) & InL, const [FSimd4Int32](API\Runtime\ChaosCore\Chaos\FSimd4Int32) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdMax ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdMin ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdMultiply ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdMultiply ( const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & L, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdMultiply ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & L, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & R ) } }


code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdMultiply ( const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & L, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & R ) } }


code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdMultiplyAdd ( const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & L, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & R, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & Acc ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdLess ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


description: 4-wide Math operations

code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdNegate ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdNot ( const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InL ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdOr ( const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InL, const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdSelect ( const [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) & InSelector, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdSqrt ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InV ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdSquare ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InV ) } }


code: namespace Chaos { namespace Private { [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) Chaos::Private::SimdSubtract ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


code: namespace Chaos { namespace Private { [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) Chaos::Private::SimdSubtract ( const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & L, const [FSimd4Vec3f](API\Runtime\ChaosCore\Chaos\FSimd4Vec3f) & R ) } }


code: namespace Chaos { namespace Private { [FSimd4Selector](API\Runtime\ChaosCore\Chaos\FSimd4Selector) Chaos::Private::SimdNotEqual ( const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InL, const [FSimd4Realf](API\Runtime\ChaosCore\Chaos\FSimd4Realf) & InR ) } }


description: Helper function of 3X3 SVD for Processing 2X2 SVD.

code: namespace Chaos { template<int t, class T> void Chaos::Process ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & B, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & sigma, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & V ) }


description: This is used as

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


description: 2x2 SVD (singular value decomposition) A=USV'

code: namespace Chaos { template<class T> void Chaos::SingularValueDecomposition ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & A, [GivensRotation](API\Runtime\ChaosCore\Chaos\GivensRotation)< T > & U, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 2 > & Sigma, [GivensRotation](API\Runtime\ChaosCore\Chaos\GivensRotation)< T > & V, const T tol ) }


code: namespace Chaos { template<class T> void Chaos::SingularValueDecomposition ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & A, const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & U, const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 2 > & Sigma, const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & V, const T tol ) }


description: 3X3 SVD (singular value decomposition) A=USV'

code: namespace Chaos { template<class T> int Chaos::SingularValueDecomposition ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & A, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & sigma, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & V, T tol ) }


description: Helper function of 3X3 SVD for sorting singular values.

code: namespace Chaos { template<class T> void Chaos::Sort0 ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & sigma, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & V ) }


description: Helper function of 3X3 SVD for Sorting singular values.

code: namespace Chaos { template<class T> void Chaos::Sort1 ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [TVector](API\Runtime\Chaos\Chaos\TVector)< T, 3 > & sigma, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & V ) }


description: IMPORTANT: test this function before testing polar:

code: namespace Chaos { template<class T> void Chaos::SwapCols ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & A, const int i1, const int i2 ) }


code: namespace Chaos { template<typename T> void Chaos::TryBulkSerializeArrayNDBase ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< T > & Array ) }


code: namespace Chaos { void Chaos::TryBulkSerializeArrayNDBase ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< float > & Array ) }


code: namespace Chaos { void Chaos::TryBulkSerializeArrayNDBase ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle) >> & Array ) }


description: LWC_TODO : Perf pessimization : this is sub-optimal but will do until we sort the serialization out.

code: namespace Chaos { void Chaos::TryBulkSerializeArrayNDBase ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< [TVec3](API\Runtime\ChaosCore\Chaos\TVec3)< [FRealDouble](API\Runtime\ChaosCore\Chaos\FRealDouble) >> & Array ) }


code: namespace Chaos { void Chaos::TryBulkSerializeArrayNDBase ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< double > & Array ) }


code: namespace Chaos { template<typename DOUBLE_T, typename FLOAT_T> void Chaos::TryBulkSerializeArrayNDBaseForDoubles ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar, [TArray](API\Runtime\Core\Containers\TArray)< DOUBLE_T > & DoubleTypedArray ) }


description: Compute WilkinsonShift of the block a1 b1 b1 a2 based on the WilkinsonShift formula mu = c + d - sign (d) \ sqrt (d*d + b*b), where d = (a-c)/2.

code: namespace Chaos { template<class T> T Chaos::WilkinsonShift ( const T a1, const T b1, const T a2 ) }


description: Zero chasing the 3X3 matrix to bidiagonal form original form of H: x x 0 x x x 0 0 x after zero chase: x x 0 0 x x 0 0 x

code: namespace Chaos { template<class T> void Chaos::ZeroChase ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & H, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & U, [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & V ) }


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


code: typedef [TAABB](API\Runtime\Chaos\Chaos\TAABB)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle), 3 > FAABB3f


code: typedef [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 4, 4 > FMatrix44


className: FReal

description: Common data types for the Chaos physics engine. Unless a specific precision of type is required most code should use these existing types (e.g. FVec3) to adapt to global changes in precision.


className: FRealDouble

description: Specific precision types, this should be used in very targeted places where the use of a specific type is necessary over using FReal

code: typedef double FRealDouble


className: FRealSingle

code: typedef float FRealSingle


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


code: typedef [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle), 3 > FRigidTransform3f


code: typedef [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle), 3 > FRigidTransformRealSingle3


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


code: typedef [TRotation](API\Runtime\Chaos\Chaos\TRotation)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle), 3 > FRotation3f


code: typedef [TSimdInt32](API\Runtime\ChaosCore\Chaos\TSimdInt32)< 4 > FSimd4Int32


description: 4-wide float typedefs

code: typedef [TSimdRealf](API\Runtime\ChaosCore\Chaos\TSimdRealf)< 4 > FSimd4Realf


code: typedef [TSimdSelector](API\Runtime\ChaosCore\Chaos\TSimdSelector)< 4 > FSimd4Selector


code: typedef [TVector](API\Runtime\Chaos\Chaos\TVector)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 2 > FVec2


code: typedef [TVector](API\Runtime\Chaos\Chaos\TVector)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle), 2 > FVec2f


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


code: typedef [TVector](API\Runtime\Chaos\Chaos\TVector)< [FRealSingle](API\Runtime\ChaosCore\Chaos\FRealSingle), 3 > FVec3f


code: typedef [TSimdVec3f](API\Runtime\ChaosCore\Chaos\TSimdVec3f)< 4 > FSimd4Vec3f


code: typedef [TVector](API\Runtime\Chaos\Chaos\TVector)< [FReal](API\Runtime\ChaosCore\Chaos\FReal), 4 > FVec4


description: This function does something like c s 0 A ( -s c 0 ) -> A 0 0 1 It only affects column i and column k of A.

code: void ColumnRotation ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & A ) const


description: Template="">

code: void ColumnRotation ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & A ) const


description: Compute c and s from a and b so that ( c -s ) ( a ) = ( * ) s c b ( 0 )

code: void Compute ( const T a, const T b )


description: This function Computes c and s so that ( c -s ) ( a ) = ( 0 ) s c b ( * )

code: void ComputeUnconventional ( const T a, const T b )


description: Fill the R with the entries of this rotation

code: void Fill ( const [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & R ) const


description: Multiply givens must be for same row and column

code: [GivensRotation](API\Runtime\ChaosCore\Chaos\GivensRotation)< T > operator* ( const [GivensRotation](API\Runtime\ChaosCore\Chaos\GivensRotation)< T > & A ) const


description: This function does something like c -s 0 ( s c 0 ) A -> A 0 0 1 It only affects row i and row k of A.

code: void RowRotation ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 2, 2 > & A ) const


description: Template="">

code: void RowRotation ( [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > & A ) const


code: GivensRotation ( int rowi_in, int rowk_in )


code: GivensRotation ( T a, T b, int rowi_in, int rowk_in )


code: void operator*= ( const [GivensRotation](API\Runtime\ChaosCore\Chaos\GivensRotation)< T > & A )


className: GivensRotation

description: Assume rowi

code: template<class T> class GivensRotation

c

type: T

rowi

type: int


code: Pair ( const T1 & First, const T2 & Second )


className: Pair

code: template<class T1, class T2> struct Pair


className: PMatrix< FRealDouble, 3, 2 >::operator*

code: TVector< FRealDouble, 3 > operator&42; &40; const TVector< FRealDouble, 2 > & Other &41;


className: PMatrix< FRealDouble, 3, 2 >::PMatrix

code: PMatrix &40; const TVector< FRealDouble, 3 > & C1, const TVector< FRealDouble, 3 > & C2 &41;


code: PMatrix &40; const FRealDouble x00, const FRealDouble x10, const FRealDouble x20, const FRealDouble x01, const FRealDouble x11, const FRealDouble x21 &41;


className: PMatrix< FRealDouble, 3, 2 >

code: template<> class PMatrix< FRealDouble, 3, 2 >


className: PMatrix< FRealDouble, 3, 3 >::Determinant

code: FRealDouble Determinant&40;&41; const


className: PMatrix< FRealDouble, 3, 3 >::Equals

code: bool Equals &40; const PMatrix< FRealDouble, 3, 3 > & Other, FRealDouble Tolerance &41; const


className: PMatrix< FRealDouble, 3, 3 >::FromDiagonal

description: Return a diagonal matrix with the specified elements

code: static PMatrix< FRealDouble, 3, 3 > FromDiagonal &40; const TVector< FRealDouble, 3 > & D &41;


className: PMatrix< FRealDouble, 3, 3 >::GetAt

code: FRealDouble GetAt &40; int32 RowIndex, int32 ColIndex &41; const


className: PMatrix< FRealDouble, 3, 3 >::GetAxis

description: we are treating matrices as column major, so axis elements are sequential in memory

code: TVector< FRealDouble, 3 > GetAxis &40; int32 AxisIndex &41; const


className: PMatrix< FRealDouble, 3, 3 >::GetColumn

description: we are treating matrices as column major, so columns are sequential in memory  GetAxis, GetRow

code: TVector< FRealDouble, 3 > GetColumn &40; int32 ColumnIndex &41; const


className: PMatrix< FRealDouble, 3, 3 >::GetDiagonal

description: Get the diagonal elements as a vector.

code: TVector< FRealDouble, 3 > GetDiagonal&40;&41; const


className: PMatrix< FRealDouble, 3, 3 >::GetRow

description: we are treating matrices as column major, so rows are not sequential in memory  GetAxis, GetColumn

code: TVector< FRealDouble, 3 > GetRow &40; int32 RowIndex &41; const


className: PMatrix< FRealDouble, 3, 3 >::GetTransposed

code: PMatrix< FRealDouble, 3, 3 > GetTransposed&40;&41; const


className: Identity

code: static Identity = PMatrix<FRealDouble, 3, 3>(1, 1, 1);


className: PMatrix< FRealDouble, 3, 3 >::LargestColumnNormalized

code: TVector< FRealDouble, 3 > LargestColumnNormalized&40;&41; const


className: PMatrix< FRealDouble, 3, 3 >::operator+

code: PMatrix< FRealDouble, 3, 3 > operator&43; &40; const PMatrix< FRealDouble, 3, 3 > & Other &41; const


className: PMatrix< FRealDouble, 3, 3 >::operator+=

code: PMatrix< FRealDouble, 3, 3 > & operator&43;&61; &40; const PMatrix< FRealDouble, 3, 3 > & Other &41;


className: PMatrix< FRealDouble, 3, 3 >::operator*

description: TDOD(mlentine): This should really be a vector multiply and sum for each entry using sse.

code: TVector< FRealDouble, 3 > operator&42; &40; const TVector< FRealDouble, 3 > & Other &41; const


code: PMatrix< FRealDouble, 3, 3 > operator&42; &40; const PMatrix< FRealDouble, 3, 3 > & Other &41; const


code: PMatrix< FRealDouble, 3, 2 > operator&42; &40; const PMatrix< FRealDouble, 3, 2 > & Other &41; const


description: Needs to be overridden because base version multiplies M[3][3].

code: PMatrix< FRealDouble, 3, 3 > operator&42; &40; const FRealDouble Other &41; const


className: PMatrix< FRealDouble, 3, 3 >::operator*=

code: PMatrix< FRealDouble, 3, 3 > operator&42;&61; &40; const FRealDouble Other &41;


className: PMatrix< FRealDouble, 3, 3 >::operator-

code: PMatrix< FRealDouble, 3, 3 > operator&45; &40; const PMatrix< FRealDouble, 3, 3 > & Other &41; const


className: PMatrix< FRealDouble, 3, 3 >::PMatrix


code: PMatrix &40; const FRealDouble x00, const FRealDouble x10, const FRealDouble x20, const FRealDouble x01, const FRealDouble x11, const FRealDouble x21, const FRealDouble x02, const FRealDouble x12, const FRealDouble x22 &41;


code: PMatrix &40; UE::Math::TMatrix< FRealDouble > && Other &41;


code: PMatrix &40; const UE::Math::TMatrix< FRealSingle > & Other &41;


code: PMatrix &40; const UE::Math::TMatrix< FRealDouble > & Other &41;


code: PMatrix &40; const TVector< FRealDouble, 3 > & Vector &41;


code: PMatrix &40; const FRealDouble x &41;


code: PMatrix &40; const FRealDouble x00, const FRealDouble x11, const FRealDouble x22 &41;


code: PMatrix &40; const TVector< FRealDouble, 3 > & C1, const TVector< FRealDouble, 3 > & C2, const TVector< FRealDouble, 3 > & C3 &41;


code: PMatrix &40; const FRealDouble x00, const FRealDouble x10, const FRealDouble x20, const FRealDouble x11, const FRealDouble x21, const FRealDouble x22 &41;


className: PMatrix< FRealDouble, 3, 3 >::SetAt

code: void SetAt &40; int32 RowIndex, int32 ColIndex, FRealDouble V &41;


className: PMatrix< FRealDouble, 3, 3 >::SetColumn

description: we are treating matrices as column major, so axis elements are sequential in memory  SetAxis, SetRow

code: void SetColumn &40; int32 ColumnIndex, const TVector< FRealDouble, 3 > & V &41;


className: PMatrix< FRealDouble, 3, 3 >::SetRow

description: we are treating matrices as column major, so axis elements are sequential in memory  SetAxis, SetColumn

code: void SetRow &40; int32 RowIndex, const TVector< FRealDouble, 3 > & V &41;


className: PMatrix< FRealDouble, 3, 3 >::SubtractDiagonal

code: PMatrix< FRealDouble, 3, 3 > SubtractDiagonal &40; const FRealDouble Scalar &41; const


className: PMatrix< FRealDouble, 3, 3 >::SymmetricCofactorMatrix

code: PMatrix< FRealDouble, 3, 3 > SymmetricCofactorMatrix&40;&41; const


className: Zero

code: static Zero = PMatrix<FRealDouble, 3, 3>(0, 0, 0);


className: PMatrix< FRealDouble, 3, 3 >

description: TODO(mlentine): Do not use 4x4 matrix for 3x3 implementation.

code: template<> class PMatrix< FRealDouble, 3, 3 > : public [UE::Math::TMatrix< FRealDouble >](API\Runtime\Core\Math\TMatrix)


className: PMatrix< FRealDouble, 3, 3 >::SetAxis

code: void SetAxis &40; int32 AxisIndex, const TVector< FRealDouble, 3 > & Axis &41;


className: PMatrix< FRealDouble, 4, 4 >::operator*

code: PMatrix< FRealDouble, 4, 4 > operator&42; &40; const PMatrix< FRealDouble, 4, 4 > & Other &41; const


className: PMatrix< FRealDouble, 4, 4 >::PMatrix


code: PMatrix &40; const UE::Math::TMatrix< FRealDouble > & Matrix &41;


code: PMatrix &40; const FRealDouble x00, const FRealDouble x10, const FRealDouble x20, const FRealDouble x30, const FRealDouble x01, const FRealDouble x11, const FRealDouble x21, const FRealDouble x31, const FRealDouble x02, const FRealDouble x12, const FRealDouble x22, const FRealDouble x32, const FRealDouble x03, const FRealDouble x13, const FRealDouble x23, const FRealDouble x33 &41;


className: PMatrix< FRealDouble, 4, 4 >

code: template<> class PMatrix< FRealDouble, 4, 4 > : public [UE::Math::TMatrix< FRealDouble >](API\Runtime\Core\Math\TMatrix)


className: PMatrix< FRealSingle, 2, 2 >::Inverse

code: PMatrix< FRealSingle, 2, 2 > Inverse&40;&41; const


className: PMatrix< FRealSingle, 2, 2 >::PMatrix

code: PMatrix &40; const FRealSingle x00, const FRealSingle x10, const FRealSingle x11 &41;


code: PMatrix &40; const FRealSingle x00, const FRealSingle x10, const FRealSingle x01, const FRealSingle x11 &41;


className: PMatrix< FRealSingle, 2, 2 >::SubtractDiagonal

code: PMatrix< FRealSingle, 2, 2 > SubtractDiagonal &40; const FRealSingle Scalar &41; const


className: PMatrix< FRealSingle, 2, 2 >::TransformPosition

code: TVector< FRealSingle, 2 > TransformPosition &40; const TVector< FRealSingle, 2 > & Other &41; const


className: PMatrix< FRealSingle, 2, 2 >

code: template<> class PMatrix< FRealSingle, 2, 2 >


className: PMatrix< FRealSingle, 3, 2 >::operator*

code: TVector< FRealSingle, 3 > operator&42; &40; const TVector< FRealSingle, 2 > & Other &41;


className: PMatrix< FRealSingle, 3, 2 >::PMatrix

code: PMatrix &40; const TVector< FRealSingle, 3 > & C1, const TVector< FRealSingle, 3 > & C2 &41;


code: PMatrix &40; const FRealSingle x00, const FRealSingle x10, const FRealSingle x20, const FRealSingle x01, const FRealSingle x11, const FRealSingle x21 &41;


className: PMatrix< FRealSingle, 3, 2 >

code: template<> class PMatrix< FRealSingle, 3, 2 >


className: PMatrix< FRealSingle, 3, 3 >::Determinant

code: FRealSingle Determinant&40;&41; const


className: PMatrix< FRealSingle, 3, 3 >::Equals

code: bool Equals &40; const PMatrix< FRealSingle, 3, 3 > & Other, FRealSingle Tolerance &41; const


className: PMatrix< FRealSingle, 3, 3 >::FromDiagonal

code: static PMatrix< FRealSingle, 3, 3 > FromDiagonal &40; const TVector< FRealSingle, 3 > & D &41;


className: PMatrix< FRealSingle, 3, 3 >::GetAt

code: FRealSingle GetAt &40; int32 RowIndex, int32 ColIndex &41; const


className: PMatrix< FRealSingle, 3, 3 >::GetAxis

code: TVector< FRealSingle, 3 > GetAxis &40; int32 AxisIndex &41; const


className: PMatrix< FRealSingle, 3, 3 >::GetColumn

code: TVector< FRealSingle, 3 > GetColumn &40; int32 ColumnIndex &41; const


className: PMatrix< FRealSingle, 3, 3 >::GetDiagonal

description: Get the diagonal elements as a vector.

code: TVector< FRealSingle, 3 > GetDiagonal&40;&41; const


className: PMatrix< FRealSingle, 3, 3 >::GetRow

code: TVector< FRealSingle, 3 > GetRow &40; int32 RowIndex &41; const


className: PMatrix< FRealSingle, 3, 3 >::GetTransposed

code: PMatrix< FRealSingle, 3, 3 > GetTransposed&40;&41; const


className: Identity

code: static Identity = PMatrix<FRealSingle, 3, 3>(1, 1, 1);


className: PMatrix< FRealSingle, 3, 3 >::LargestColumnNormalized

code: TVector< FRealSingle, 3 > LargestColumnNormalized&40;&41; const


className: PMatrix< FRealSingle, 3, 3 >::operator+

code: PMatrix< FRealSingle, 3, 3 > operator&43; &40; const PMatrix< FRealSingle, 3, 3 > & Other &41; const


className: PMatrix< FRealSingle, 3, 3 >::operator+=

code: PMatrix< FRealSingle, 3, 3 > & operator&43;&61; &40; const PMatrix< FRealSingle, 3, 3 > & Other &41;


className: PMatrix< FRealSingle, 3, 3 >::operator*

code: TVector< FRealSingle, 3 > operator&42; &40; const TVector< FRealSingle, 3 > & Other &41; const


code: PMatrix< FRealSingle, 3, 3 > operator&42; &40; const PMatrix< FRealSingle, 3, 3 > & Other &41; const


code: PMatrix< FRealSingle, 3, 3 > operator&42; &40; const FRealSingle Other &41; const


code: PMatrix< FRealSingle, 3, 2 > operator&42; &40; const PMatrix< FRealSingle, 3, 2 > & Other &41; const


className: PMatrix< FRealSingle, 3, 3 >::operator*=

code: PMatrix< FRealSingle, 3, 3 > operator&42;&61; &40; const FRealSingle Other &41;


className: PMatrix< FRealSingle, 3, 3 >::operator-

code: PMatrix< FRealSingle, 3, 3 > operator&45; &40; const PMatrix< FRealSingle, 3, 3 > & Other &41; const


className: PMatrix< FRealSingle, 3, 3 >::PMatrix


code: PMatrix &40; const FRealSingle x00, const FRealSingle x10, const FRealSingle x20, const FRealSingle x01, const FRealSingle x11, const FRealSingle x21, const FRealSingle x02, const FRealSingle x12, const FRealSingle x22 &41;


code: PMatrix &40; UE::Math::TMatrix< FRealSingle > && Other &41;


code: PMatrix &40; const UE::Math::TMatrix< FRealSingle > & Other &41;


code: PMatrix &40; const UE::Math::TMatrix< FRealDouble > & Other &41;


code: PMatrix &40; const TVector< FRealSingle, 3 > & Vector &41;


code: PMatrix &40; const FRealSingle x &41;


code: PMatrix &40; const FRealSingle x00, const FRealSingle x11, const FRealSingle x22 &41;


code: PMatrix &40; const TVector< FRealSingle, 3 > & C1, const TVector< FRealSingle, 3 > & C2, const TVector< FRealSingle, 3 > & C3 &41;


code: PMatrix &40; const FRealSingle x00, const FRealSingle x10, const FRealSingle x20, const FRealSingle x11, const FRealSingle x21, const FRealSingle x22 &41;


className: PMatrix< FRealSingle, 3, 3 >::SetAt

code: void SetAt &40; int32 RowIndex, int32 ColIndex, FRealSingle V &41;


className: PMatrix< FRealSingle, 3, 3 >::SetAxis

code: void SetAxis &40; int32 AxisIndex, const TVector< FRealSingle, 3 > & Axis &41;


className: PMatrix< FRealSingle, 3, 3 >::SetColumn

code: void SetColumn &40; int32 ColumnIndex, const TVector< FRealSingle, 3 > & V &41;


className: PMatrix< FRealSingle, 3, 3 >::SubtractDiagonal

code: PMatrix< FRealSingle, 3, 3 > SubtractDiagonal &40; const FRealSingle Scalar &41; const


className: PMatrix< FRealSingle, 3, 3 >::SetRow

code: void SetRow &40; int32 RowIndex, const TVector< FRealSingle, 3 > & V &41;


className: PMatrix< FRealSingle, 3, 3 >::SymmetricCofactorMatrix

code: PMatrix< FRealSingle, 3, 3 > SymmetricCofactorMatrix&40;&41; const


className: Zero

code: static Zero = PMatrix<FRealSingle, 3, 3>(0, 0, 0);


className: PMatrix< FRealSingle, 3, 3 >

code: template<> class PMatrix< FRealSingle, 3, 3 > : public [UE::Math::TMatrix< FRealSingle >](API\Runtime\Core\Math\TMatrix)


className: PMatrix< FRealSingle, 4, 4 >::operator*

code: PMatrix< FRealSingle, 4, 4 > operator&42; &40; const PMatrix< FRealSingle, 4, 4 > & Other &41; const


className: PMatrix< FRealSingle, 4, 4 >::PMatrix


code: PMatrix &40; const UE::Math::TMatrix< FRealSingle > & Matrix &41;


code: PMatrix &40; const FRealSingle x00, const FRealSingle x10, const FRealSingle x20, const FRealSingle x30, const FRealSingle x01, const FRealSingle x11, const FRealSingle x21, const FRealSingle x31, const FRealSingle x02, const FRealSingle x12, const FRealSingle x22, const FRealSingle x32, const FRealSingle x03, const FRealSingle x13, const FRealSingle x23, const FRealSingle x33 &41;


className: PMatrix< FRealSingle, 4, 4 >

code: template<> class PMatrix< FRealSingle, 4, 4 > : public [UE::Math::TMatrix< FRealSingle >](API\Runtime\Core\Math\TMatrix)


className: PMatrix< FReal, 2, 2 >::Inverse

code: PMatrix< FReal, 2, 2 > Inverse&40;&41; const


className: PMatrix< FReal, 2, 2 >::PMatrix

code: PMatrix &40; const FReal x00, const FReal x10, const FReal x11 &41;


code: PMatrix &40; const FReal x00, const FReal x10, const FReal x01, const FReal x11 &41;


className: PMatrix< FReal, 2, 2 >::SubtractDiagonal

code: PMatrix< FReal, 2, 2 > SubtractDiagonal &40; const FReal Scalar &41; const


className: PMatrix< FReal, 2, 2 >::TransformPosition

code: TVector< FReal, 2 > TransformPosition &40; const TVector< FReal, 2 > & Other &41; const


className: PMatrix< FReal, 2, 2 >

code: template<> class PMatrix< FReal, 2, 2 >


code: int32 AddArray ( [TArrayCollectionArrayBase](API\Runtime\ChaosCore\Chaos\TArrayCollectionArrayBase) * Array )


code: uint64 ComputeColumnSize() const


code: void AddElementsHelper ( const int32 Num )


code: void MoveToOtherArrayCollection ( const int32 Index, [TArrayCollection](API\Runtime\ChaosCore\Chaos\TArrayCollection) & Other )


code: void RemoveArray ( [TArrayCollectionArrayBase](API\Runtime\ChaosCore\Chaos\TArrayCollectionArrayBase) * Array )


code: void RemoveAt ( int32 Index, int32 Count )


code: void RemoveAtHelper ( const int32 Index, const int32 Count )


code: void RemoveAtSwapHelper ( const int32 Index )


code: void ResizeHelper ( const int32 Num )


code: void ShrinkArrays ( const float MaxSlackFraction, const int32 MinSlack )


code: TArrayCollection ( const [TArrayCollection](API\Runtime\ChaosCore\Chaos\TArrayCollection) & Other )


code: TArrayCollection ( [TArrayCollection](API\Runtime\ChaosCore\Chaos\TArrayCollection) && Other )


className: TArrayCollection

code: class TArrayCollection


code: void ApplyShrinkPolicy ( const float MaxSlackFraction, const int32 MinSlack )


code: void MoveToOtherArray ( const int Idx, [TArrayCollectionArrayBase](API\Runtime\ChaosCore\Chaos\TArrayCollectionArrayBase) & Other )


code: void RemoveAt ( const int Idx, const int Count )


code: void RemoveAtSwap ( const int Idx )


className: TArrayCollectionArrayBase

code: class TArrayCollectionArrayBase


className: TArrayFaceND< T, 3 >::Copy

code: TArrayFaceND< T, 3 > Copy&40;&41;


className: TArrayFaceND< T, 3 >::Fill

code: void Fill &40; const T & Scalar &41;


className: TArrayFaceND< T, 3 >::GetComponent

code: const TArrayND< T, 3 > & GetComponent &40; const int32 Axis &41; const


code: TArrayND< T, 3 > & GetComponent &40; const int32 Axis &41;


className: TArrayFaceND< T, 3 >::operator()

code: T & operator&40;&41; &40; const Pair< int32, TVec3< int32 >> & Index &41;


code: const T & operator&40;&41; &40; const Pair< int32, TVec3< int32 >> & Index &41; const


code: T & operator&40;&41; &40; const int32 Axis, const int32 & x, const int32 & y, const int32 & z &41;


code: const T & operator&40;&41; &40; const int32 Axis, const int32 & x, const int32 & y, const int32 & z &41; const


className: TArrayFaceND< T, 3 >::TArrayFaceND

code: TArrayFaceND &40; const TUniformGrid< FReal, 3 > & Grid &41;


code: TArrayFaceND &40; const TVec3< int32 > & Counts &41;


code: TArrayFaceND &40; const TArrayFaceND< T, 3 > & Other &41;


code: TArrayFaceND &40; TArrayFaceND< T, 3 > && Other &41;


code: TArrayFaceND &40; const TArray< TArrayND< T, 3 >, TFixedAllocator< 3 >> & Array &41;


className: TArrayFaceND< T, 3 >

code: template<class T> class TArrayFaceND< T, 3 >


code: void Copy ( const [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< T_DERIVED, T, d > & Source )


code: [TVector](API\Runtime\Chaos\Chaos\TVector)< int32, d > Counts() const


code: [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< T_DERIVED, T, d > & operator= ( const [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< T_DERIVED, T, d > & Other )


code: const T & operator[] ( const int32 i ) const


code: [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< T_DERIVED, T, d > & operator= ( [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< T_DERIVED, T, d > && Other )


code: T & operator[] ( const int32 i )


code: void Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar )


code: void Serialize ( [FChaosArchive](API\Runtime\Chaos\Chaos\FChaosArchive) & Ar )


code: TArrayNDBase ( const [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< T_DERIVED, T, d > & Other )


code: TArrayNDBase ( [TArrayNDBase](API\Runtime\ChaosCore\Chaos\TArrayNDBase)< T_DERIVED, T, d > && Other )


code: TArrayNDBase ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< int32, d > & Counts, const [TArray](API\Runtime\Core\Containers\TArray)< T > & Array )


className: TArrayNDBase

code: template<class T_DERIVED, class T, int d> class TArrayNDBase

MArray

type: TArray< T >

MCounts

type: TVector< int32,...


className: Base

code: typedef TArrayNDBase< TArrayND< T, 3 >, T, 3 > Base


className: TArrayND< T, 3 >::operator()

code: T & operator&40;&41; &40; const TVec3< int32 > & Index &41;


code: const T & operator&40;&41; &40; const TVec3< int32 > & Index &41; const


code: T & operator&40;&41; &40; const int32 & x, const int32 & y, const int32 & z &41;


code: const T & operator&40;&41; &40; const int32 & x, const int32 & y, const int32 & z &41; const


className: TArrayND< T, 3 >::operator=

code: TArrayND< T, 3 > & operator&61; &40; const TArrayND< T, 3 > & Other &41;


code: TArrayND< T, 3 > & operator&61; &40; TArrayND< T, 3 > && Other &41;


className: TArrayND< T, 3 >::SetCounts

code: void SetCounts &40; const TVector< int32, 3 > & Counts &41;


code: template<typename U> void SetCounts &40; const TUniformGrid< U, 3 > & Grid, bool NodeValues &41;


className: TArrayND< T, 3 >::TArrayND

code: TArrayND &40; const TVec3< int32 > & Counts &41;


code: TArrayND &40; const TArrayND< T, 3 > & Other &41;


code: TArrayND &40; TArrayND< T, 3 > && Other &41;


code: template<typename U> TArrayND &40; const TUniformGrid< U, 3 > & Grid, bool NodeValues &41;


code: TArrayND &40; const TVec3< int32 > & Counts, const TArray< T > & Array &41;


className: TArrayND< T, 3 >

code: template<class T> class TArrayND< T, 3 > : public [Chaos::TArrayNDBase< TArrayND< T, 3 >, T, 3 >](API\Runtime\ChaosCore\Chaos\TArrayNDBase)


code: typedef [PMatrix](API\Runtime\Chaos\Chaos\PMatrix)< T, 3, 3 > TMatrix33


description:
Allocate an object from the pool Returns an instance of the object type specified for this pool, either from the next available on the final block, the free list or by allocating a new block to continue providing objects. As this method may defer to the runtime allocator it may sometimes run significantly slower when the pool is exhausted Requires that the object is default constructible
The newly allocated object

code: template<typename... TArgs> [FPtr](API\Runtime\ChaosCore\Chaos\TObjectPool\FPtr) Alloc ( TArgs &&... Args )


className: FObject

code: typedef ObjectType FObject


className: FItem

description: Helper alias for the item in this pool.

code: typedef TItem< ObjectType > FItem


description: Free a single object provided by this pool Takes an object previously allocated in this pool and frees it, accessing the pointer beyond a call to free is an undefined operation and could return garbage or an entirely different object. Avoiding this case is the responsibility of the caller Behavior is also undefined if an object not owned by this pool is passed to Free. Outside of debug this will not be asserted

code: void Free ( [FPtr](API\Runtime\ChaosCore\Chaos\TObjectPool\FPtr) Object )


description: Get the allocated (total) size of all blocks in the pool

code: int32 GetAllocatedSize() const


description:
Gets the total number of items the pool can currently stor
The pool capacity

code: int32 GetCapacity() const


description: Get the number of blocks currently allocated in the pool

code: int32 GetNumAllocatedBlocks() const


description: Get the number of allocated items.

code: int32 GetNumAllocated() const


description: Get the max number of items per block

code: int32 GetNumPerBlock() const


description:
Gets the number of free items the pool has remaining
Number of free items

code: int32 GetNumFree() const


description:
Calculates the storage/overhead ratio of the pool. Larger items that have a size close to the alignment boundary will be more efficient on space
Ratio of storage to overhead

code: float GetRatio() const


className: ItemAlign

description: Alignment of the stored type.

code: static constexpr int32 ItemAlign = alignof(ObjectType);


code: [TObjectPool](API\Runtime\ChaosCore\Chaos\TObjectPool) & operator= ( const [TObjectPool](API\Runtime\ChaosCore\Chaos\TObjectPool) & )


code: [TObjectPool](API\Runtime\ChaosCore\Chaos\TObjectPool) & operator= ( [TObjectPool](API\Runtime\ChaosCore\Chaos\TObjectPool) && )


className: PaddedItemSize

description: Size of the item, plus padding up to the correct alignment so we can allocate the whole block with the correct size.

code: static constexpr int32 PaddedItemSize = Align(int32(sizeof(FItem)), ItemAlign);


description: Makes sure the pool has at least NumBlocks blocks allocated Note: This will never reduce the number of blocks, it will only make sure the pool has at least NumBlocks block allocated, empty or not.

code: void ReserveBlocks ( int32 NumBlocks )


description: ShrinkToNumItems - Number of items to reserve

code: void ReserveItems ( int32 NumItems )


description: Reset the whole pool This will invalidate every currently live object from the pool. If a pointer from this pool is dereferenced beyond a call to Reset then it may return garbage, or point to an entirely different object. Avoiding this case is the responsibility of the caller.

code: void Reset()


description: Shrinks the number of blocks All blocks that are not empty are kept, plus a number of empty blocks specified by the caller Passing zero will remove all empty blocks, leaving any non-empty blocks behind

code: void ShrinkTo ( int32 NumDesiredEmptyBlocks )


description: No copy, no move, no default #TODO possibly add move and copy if the internal type is copy constructible but likely better to discourage copying. Moving to another pool should be fine.

code: TObjectPool()


code: TObjectPool ( const [TObjectPool](API\Runtime\ChaosCore\Chaos\TObjectPool) & )


code: TObjectPool ( [TObjectPool](API\Runtime\ChaosCore\Chaos\TObjectPool) && )


code: TObjectPool ( int32 InNumPerBlock, int32 InitialBlocks )


code: typedef typename FObjectPool::FObject FObject


className: TObjectPool

code: template<typename ObjectType> class TObjectPool


className: FObjectPool

code: typedef ObjectPoolType FObjectPool


code: void operator() ( [FObject](API\Runtime\ChaosCore\Chaos\TObjectPoolDeleter\FObject) * Object )


code: TObjectPoolDeleter ( [FObjectPool](API\Runtime\ChaosCore\Chaos\TObjectPoolDeleter\FObjectPool) & InPool )


className: TObjectPoolDeleter

description: A deleter for use withTUniquePtrand aTObjectPoolitem

code: template<typename ObjectPoolType> class TObjectPoolDeleter


className: TRequiresDestructor

description: The type needs to have a destructor run when the pool pointer is freed.

code: typedef std::enable_if_t<![TIsTriviallyDestructible](API\Runtime\Core\Templates\TIsTriviallyDestructible)< T >::Value > TRequiresDestructor


className: TRigidTransform< FRealDouble, 3 >::GetRelativeTransformNoScale

description: Get the transform which maps from Other to This, ignoring the scale on both.

code: TRigidTransform< FRealDouble, 3 > GetRelativeTransformNoScale &40; const TRigidTransform< FRealDouble, 3 > & Other &41; const


className: BaseTransform

code: typedef UE::Math::TTransform< FRealDouble > BaseTransform


className: TRigidTransform< FRealDouble, 3 >::Inverse

code: TRigidTransform< FRealDouble, 3 > Inverse&40;&41; const


className: TRigidTransform< FRealDouble, 3 >::MultiplyNoScale

description: Equivalent to (A * B) but assuming both have unit scale.

code: static TRigidTransform< FRealDouble, 3 > MultiplyNoScale &40; const TRigidTransform< FRealDouble, 3 > & A, const TRigidTransform< FRealDouble, 3 > & B &41;


className: TRigidTransform< FRealDouble, 3 >::operator*

code: PMatrix< FRealDouble, 4, 4 > operator&42; &40; const Chaos::PMatrix< FRealDouble, 4, 4 > & Matrix &41; const


code: TRigidTransform< FRealDouble, 3 > operator&42; &40; const TRigidTransform< FRealDouble, 3 > & Other &41; const


className: TRigidTransform< FRealDouble, 3 >::ToMatrixNoScale

code: PMatrix< FRealDouble, 4, 4 > ToMatrixNoScale&40;&41; const


className: TRigidTransform< FRealDouble, 3 >::ToMatrixWithScale

code: PMatrix< FRealDouble, 4, 4 > ToMatrixWithScale&40;&41; const


className: TRigidTransform< FRealDouble, 3 >::TransformNormal

description: Transform the normal when scale may be non-unitary.

code: TVector< FRealDouble, 3 > TransformNormal &40; const TVector< FRealDouble, 3 > & Normal &41; const


className: TRigidTransform< FRealDouble, 3 >::TransformNormalNoScale

code: TVector< FRealDouble, 3 > TransformNormalNoScale &40; const TVector< FRealDouble, 3 > & Normal &41; const


className: TRigidTransform< FRealDouble, 3 >::TransformNormalUnsafe

description: Transform the normal when scale may be non-unitary. Assumes no scale components are zero.

code: TVector< FRealDouble, 3 > TransformNormalUnsafe &40; const TVector< FRealDouble, 3 > & Normal &41; const


className: TRigidTransform< FRealDouble, 3 >::TRigidTransform


code: TRigidTransform &40; const FMatrix44f & Matrix &41;


code: TRigidTransform &40; const FMatrix44d & Matrix &41;


code: TRigidTransform &40; const BaseTransform & Transform &41;


code: template<typename OtherType> TRigidTransform &40; const OtherType & Other &41;


code: TRigidTransform &40; const TVector< FRealDouble, 3 > & Translation, const TRotation< FRealDouble, 3 > & Rotation, const TVector< FRealDouble, 3 > & Scale &41;


code: TRigidTransform &40; const TVector< FRealDouble, 3 > & Translation, const TRotation< FRealDouble, 3 > & Rotation &41;


className: TRigidTransform< FRealDouble, 3 >

code: template<> class TRigidTransform< FRealDouble, 3 > : public [UE::Math::TTransform< FRealDouble >](API\Runtime\Core\Math\TTransform)


code: typedef UE::Math::TTransform< FRealSingle > BaseTransform


className: TRigidTransform< FRealSingle, 3 >::GetRelativeTransformNoScale

code: TRigidTransform< FRealSingle, 3 > GetRelativeTransformNoScale &40; const TRigidTransform< FRealSingle, 3 > & Other &41; const


className: TRigidTransform< FRealSingle, 3 >::Inverse

code: TRigidTransform< FRealSingle, 3 > Inverse&40;&41; const


className: TRigidTransform< FRealSingle, 3 >::MultiplyNoScale

code: static TRigidTransform< FRealSingle, 3 > MultiplyNoScale &40; const TRigidTransform< FRealSingle, 3 > & A, const TRigidTransform< FRealSingle, 3 > & B &41;


className: TRigidTransform< FRealSingle, 3 >::operator*

code: PMatrix< FRealSingle, 4, 4 > operator&42; &40; const PMatrix< FRealSingle, 4, 4 > & Matrix &41; const


code: TRigidTransform< FRealSingle, 3 > operator&42; &40; const TRigidTransform< FRealSingle, 3 > & Other &41; const


className: TRigidTransform< FRealSingle, 3 >::ToMatrixWithScale

code: PMatrix< FRealSingle, 4, 4 > ToMatrixWithScale&40;&41; const


className: TRigidTransform< FRealSingle, 3 >::TransformNormal

code: TVector< FRealSingle, 3 > TransformNormal &40; const TVector< FRealSingle, 3 > & Normal &41; const


className: TRigidTransform< FRealSingle, 3 >::TransformNormalNoScale

code: TVector< FRealSingle, 3 > TransformNormalNoScale &40; const TVector< FRealSingle, 3 > & Normal &41; const


className: TRigidTransform< FRealSingle, 3 >::TransformNormalUnsafe

code: TVector< FRealSingle, 3 > TransformNormalUnsafe &40; const TVector< FRealSingle, 3 > & Normal &41; const


className: TRigidTransform< FRealSingle, 3 >::TRigidTransform


code: TRigidTransform &40; const FMatrix44f & Matrix &41;


className: TRigidTransform< FRealSingle, 3 >::ToMatrixNoScale

code: PMatrix< FRealSingle, 4, 4 > ToMatrixNoScale&40;&41; const


code: TRigidTransform &40; const BaseTransform & Transform &41;


code: TRigidTransform &40; const FMatrix44d & Matrix &41;


code: template<typename OtherType> TRigidTransform &40; const OtherType & Other &41;


code: TRigidTransform &40; const TVector< FRealSingle, 3 > & Translation, const TRotation< FRealSingle, 3 > & Rotation &41;


code: TRigidTransform &40; const TVector< FRealSingle, 3 > & Translation, const TRotation< FRealSingle, 3 > & Rotation, const TVector< FRealSingle, 3 > & Scale &41;


className: TRigidTransform< FRealSingle, 3 >

code: template<> class TRigidTransform< FRealSingle, 3 > : public [UE::Math::TTransform< FRealSingle >](API\Runtime\Core\Math\TTransform)


className: BaseTransform

code: typedef UE::Math::TTransform< FReal > BaseTransform


className: TRigidTransform< FReal, 2 >::Inverse

code: TRigidTransform< FReal, 2 > Inverse&40;&41; const


className: TRigidTransform< FReal, 2 >::operator*

code: TRigidTransform< FReal, 2 > operator&42; &40; const TRigidTransform< FReal, 2 > & Other &41; const


className: TRigidTransform< FReal, 2 >::TRigidTransform


code: TRigidTransform &40; const TVector< FReal, 3 > & Translation, const TRotation< FReal, 3 > & Rotation &41;


className: TRigidTransform< FReal, 2 >

code: template<> class TRigidTransform< FReal, 2 > : public [UE::Math::TTransform< FReal >](API\Runtime\Core\Math\TTransform)


code: typedef [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, 3 > TRotation3


className: BaseQuat

code: typedef UE::Math::TQuat< FRealDouble > BaseQuat


className: TRotation< FRealDouble, 3 >::CalculateAngularDelta

description: This should match the algorithm used in PerParticleUpdateFromDeltaPosition rule.

code: static TVector< FRealDouble, 3 > CalculateAngularDelta &40; const TRotation< FRealDouble, 3 > & InR0, const TRotation< FRealDouble, 3 > & InR1 &41;


className: TRotation< FRealDouble, 3 >::CalculateAngularVelocity

code: static TVector< FRealDouble, 3 > CalculateAngularVelocity &40; const TRotation< FRealDouble, 3 > & InR0, const TRotation< FRealDouble, 3 > & InR1, const FRealDouble InDt &41;


className: TRotation< FRealDouble, 3 >::CalculateAngularVelocity1

description: Uses the relation: DQ/DT = (W * Q)/2

code: static TVector< FRealDouble, 3 > CalculateAngularVelocity1 &40; const TRotation< FRealDouble, 3 > & R0, const TRotation< FRealDouble, 3 > & InR1, const FRealDouble InDt &41;


className: TRotation< FRealDouble, 3 >::CalculateAngularVelocity2

description: Uses the Quaternion to Axis/Angle method.

code: static TVector< FRealDouble, 3 > CalculateAngularVelocity2 &40; const TRotation< FRealDouble, 3 > & R0, const TRotation< FRealDouble, 3 > & InR1, const FRealDouble InDt &41;


className: TRotation< FRealDouble, 3 >::Conjugate

description: Return the complex conjugate of the rotation

code: static TRotation< FRealDouble, 3 > Conjugate &40; const ::Chaos::TRotation< FRealDouble, 3 > & InR &41;


className: TRotation< FRealDouble, 3 >::DotProduct

description: Return the dot product of two quaternions.

code: static FRealDouble DotProduct &40; const TRotation< FRealDouble, 3 > & L, const TRotation< FRealDouble, 3 > & R &41;


className: TRotation< FRealDouble, 3 >::FromAxisAngle

description: Create a rotation about an axis by an angle specified in radians

code: static TRotation< FRealDouble, 3 > FromAxisAngle &40; const ::Chaos::TVector< FRealDouble, 3 > & Axis, const FRealDouble AngleRad &41;


className: TRotation< FRealDouble, 3 >::FromElements

description: Create a rotation by explicitly specifying all elements

code: static TRotation< FRealDouble, 3 > FromElements &40; const ::Chaos::TVector< FRealDouble, 3 > & V, const FRealDouble W &41;


code: static TRotation< FRealDouble, 3 > FromElements &40; const FRealDouble X, const FRealDouble Y, const FRealDouble Z, const FRealDouble W &41;


className: TRotation< FRealDouble, 3 >::FromIdentity

description: Create an identity rotation

code: static TRotation< FRealDouble, 3 > FromIdentity&40;&41;


className: TRotation< FRealDouble, 3 >::FromRotatedVector

description: Generate a Rotation that would rotate vector InitialVector to FinalVector

code: static TRotation< FRealDouble, 3 > FromRotatedVector &40; const ::Chaos::TVector< FRealDouble, 3 > & InitialVector, const ::Chaos::TVector< FRealDouble, 3 > & FinalVector &41;


className: TRotation< FRealDouble, 3 >::FromVector

description: Create a rotation about an axis V/|V| by angle |V| in radians

code: static TRotation< FRealDouble, 3 > FromVector &40; const ::Chaos::TVector< FRealDouble, 3 > & V &41;


className: TRotation< FRealDouble, 3 >::GetAbsMax

description: Return the large absolute element value.

code: FRealDouble GetAbsMax&40;&41; const


className: TRotation< FRealDouble, 3 >::GetRotationAxisSafe

description:
EpsilonSq is approximately the square of the angle below which we cannot calculate the axis. It needs to be "much greater" than square of the error in the quaternion values which is usually ~1e-4, so values around 1e-3^2 = 1e-6 or greater are about right.
Whether the axis was successfully calculated (true except for very small angles around or less than Epsilon).

code: bool GetRotationAxisSafe &40; TVector< FRealDouble, 3 > & OutAxis, const TVector< FRealDouble, 3 > & DefaultAxis, FRealDouble EpsilionSq &41; const


className: TRotation< FRealDouble, 3 >::IntegrateRotationWithAngularVelocity

description: Uses the relation: DQ/DT = (W * Q)/2

code: static TRotation< FRealDouble, 3 > IntegrateRotationWithAngularVelocity &40; const TRotation< FRealDouble, 3 > & InR0, const TVector< FRealDouble, 3 > & InW, const FRealDouble InDt &41;


className: TRotation< FRealDouble, 3 >::IsNearlyEqual

description: Check that two rotations are approximately equal. Assumes the quaternions are normalized and in the same hemisphere. For small values of Epsilon, this is approximately equivalent to checking that the rotations are within 2*Epsilon radians of each other.

code: static bool IsNearlyEqual &40; const TRotation< FRealDouble, 3 > & A, const TRotation< FRealDouble, 3 > & B, const FRealDouble Epsilon &41;


className: TRotation< FRealDouble, 3 >::Negate

description: Negate all values of the quaternion (note: not the inverse rotation. See Conjugate)

code: static TRotation< FRealDouble, 3 > Negate &40; const ::Chaos::TRotation< FRealDouble, 3 > & InR &41;


className: TRotation< FRealDouble, 3 >::ToAxisAndAngleSafe

code: bool ToAxisAndAngleSafe &40; TVector< FRealDouble, 3 > & OutAxis, FRealDouble & OutAngle, const TVector< FRealDouble, 3 > & DefaultAxis, FRealDouble EpsilionSq &41; const


className: TRotation< FRealDouble, 3 >::ToMatrixAxes

description: Convert to a matrix and return as the 3 matrix axes.

code: void ToMatrixAxes &40; TVector< FRealDouble, 3 > & OutX, TVector< FRealDouble, 3 > & OutY, TVector< FRealDouble, 3 > & OutZ &41;


className: TRotation< FRealDouble, 3 >::ToMatrix

code: PMatrix< FRealDouble, 3, 3 > ToMatrix&40;&41; const


className: TRotation< FRealDouble, 3 >::ToSwingTwistX

description: Extract the Swing and Twist rotations, assuming that the Twist Axis is (1,0,0). /see ToSwingTwist

code: void ToSwingTwistX &40; BaseQuat & OutSwing, BaseQuat & OutTwist &41; const


className: TRotation< FRealDouble, 3 >::TRotation


code: TRotation &40; const BaseQuat & Quat &41;


code: TRotation &40; const FMatrix44d & Matrix &41;


code: TRotation &40; const FMatrix44f & Matrix &41;


code: template<typename OtherType> TRotation &40; const UE::Math::TQuat< OtherType > & Other &41;


className: TRotation< FRealDouble, 3 >

code: template<> class TRotation< FRealDouble, 3 > : public [UE::Math::TQuat< FRealDouble >](API\Runtime\Core\Math\TQuat)


className: BaseQuat

code: typedef UE::Math::TQuat< FRealSingle > BaseQuat


className: TRotation< FRealSingle, 3 >::CalculateAngularDelta

code: static TVector< FRealSingle, 3 > CalculateAngularDelta &40; const TRotation< FRealSingle, 3 > & InR0, const TRotation< FRealSingle, 3 > & InR1 &41;


className: TRotation< FRealSingle, 3 >::CalculateAngularVelocity

code: static TVector< FRealSingle, 3 > CalculateAngularVelocity &40; const TRotation< FRealSingle, 3 > & InR0, const TRotation< FRealSingle, 3 > & InR1, const FRealSingle InDt &41;


className: TRotation< FRealSingle, 3 >::CalculateAngularVelocity1

description: Uses the relation: DQ/DT = (W * Q)/2

code: static TVector< FRealSingle, 3 > CalculateAngularVelocity1 &40; const TRotation< FRealSingle, 3 > & R0, const TRotation< FRealSingle, 3 > & InR1, const FRealSingle InDt &41;


className: TRotation< FRealSingle, 3 >::CalculateAngularVelocity2

code: static TVector< FRealSingle, 3 > CalculateAngularVelocity2 &40; const TRotation< FRealSingle, 3 > & R0, const TRotation< FRealSingle, 3 > & InR1, const FRealSingle InDt &41;


className: TRotation< FRealSingle, 3 >::Conjugate

code: static TRotation< FRealSingle, 3 > Conjugate &40; const ::Chaos::TRotation< FRealSingle, 3 > & InR &41;


className: TRotation< FRealSingle, 3 >::DotProduct

code: static FRealSingle DotProduct &40; const TRotation< FRealSingle, 3 > & L, const TRotation< FRealSingle, 3 > & R &41;


className: TRotation< FRealSingle, 3 >::FromAxisAngle

code: static TRotation< FRealSingle, 3 > FromAxisAngle &40; const ::Chaos::TVector< FRealSingle, 3 > & Axis, const FRealSingle AngleRad &41;


className: TRotation< FRealSingle, 3 >::FromElements

code: static TRotation< FRealSingle, 3 > FromElements &40; const ::Chaos::TVector< FRealSingle, 3 > & V, const FRealSingle W &41;


code: static TRotation< FRealSingle, 3 > FromElements &40; const FRealSingle X, const FRealSingle Y, const FRealSingle Z, const FRealSingle W &41;


className: TRotation< FRealSingle, 3 >::FromIdentity

description: Create an identity rotation

code: static TRotation< FRealSingle, 3 > FromIdentity&40;&41;


className: TRotation< FRealSingle, 3 >::FromRotatedVector

code: static TRotation< FRealSingle, 3 > FromRotatedVector &40; const ::Chaos::TVector< FRealSingle, 3 > & InitialVector, const ::Chaos::TVector< FRealSingle, 3 > & FinalVector &41;


className: TRotation< FRealSingle, 3 >::FromVector

code: static TRotation< FRealSingle, 3 > FromVector &40; const ::Chaos::TVector< FRealSingle, 3 > & V &41;


className: TRotation< FRealSingle, 3 >::GetAbsMax

code: FRealSingle GetAbsMax&40;&41; const


className: TRotation< FRealSingle, 3 >::GetRotationAxisSafe

code: bool GetRotationAxisSafe &40; TVector< FRealSingle, 3 > & OutAxis, const TVector< FRealSingle, 3 > & DefaultAxis, FRealSingle EpsilionSq &41; const


className: TRotation< FRealSingle, 3 >::IntegrateRotationWithAngularVelocity

description: Uses the relation: DQ/DT = (W * Q)/2

code: static TRotation< FRealSingle, 3 > IntegrateRotationWithAngularVelocity &40; const TRotation< FRealSingle, 3 > & InR0, const TVector< FRealSingle, 3 > & InW, const FRealSingle InDt &41;


className: TRotation< FRealSingle, 3 >::ToAxisAndAngleSafe

code: bool ToAxisAndAngleSafe &40; TVector< FRealSingle, 3 > & OutAxis, FRealSingle & OutAngle, const TVector< FRealSingle, 3 > & DefaultAxis, FRealSingle EpsilionSq &41; const


className: TRotation< FRealSingle, 3 >::Negate

code: static TRotation< FRealSingle, 3 > Negate &40; const ::Chaos::TRotation< FRealSingle, 3 > & InR &41;


className: TRotation< FRealSingle, 3 >::IsNearlyEqual

code: static bool IsNearlyEqual &40; const TRotation< FRealSingle, 3 > & A, const TRotation< FRealSingle, 3 > & B, const FRealSingle Epsilon &41;


className: TRotation< FRealSingle, 3 >::ToMatrix

code: PMatrix< FRealSingle, 3, 3 > ToMatrix&40;&41; const


className: TRotation< FRealSingle, 3 >::ToMatrixAxes

code: void ToMatrixAxes &40; TVector< FRealSingle, 3 > & OutX, TVector< FRealSingle, 3 > & OutY, TVector< FRealSingle, 3 > & OutZ &41;


className: TRotation< FRealSingle, 3 >::ToSwingTwistX

code: void ToSwingTwistX &40; BaseQuat & OutSwing, BaseQuat & OutTwist &41; const


className: TRotation< FRealSingle, 3 >::TRotation


code: TRotation &40; const BaseQuat & Quat &41;


code: TRotation &40; const FMatrix44f & Matrix &41;


code: TRotation &40; const FMatrix44d & Matrix &41;


code: template<typename OtherType> TRotation &40; const UE::Math::TQuat< OtherType > & Other &41;


className: TRotation< FRealSingle, 3 >

code: template<> class TRotation< FRealSingle, 3 > : public [UE::Math::TQuat< FRealSingle >](API\Runtime\Core\Math\TQuat)


code: int32 GetValue ( const int32 LaneIndex ) const


code: template<> [TSimdInt32](API\Runtime\ChaosCore\Chaos\TSimdInt32)< 4 > Make ( const int32 I )


code: static [TSimdInt32](API\Runtime\ChaosCore\Chaos\TSimdInt32)< TNumLanes > Make ( const int32 I )


code: void SetValue ( const int32 LaneIndex, const int32 I )


code: template<> [TSimdInt32](API\Runtime\ChaosCore\Chaos\TSimdInt32)< 4 > Zero()


code: void SetValues ( const int32 I )


code: static [TSimdInt32](API\Runtime\ChaosCore\Chaos\TSimdInt32)< TNumLanes > Zero()


code: float GetValue ( const int32 LaneIndex ) const


description: A TNumLanes-wide set of integers.

code: template<int TNumLanes> struct TSimdInt32


code: template<> [TSimdRealf](API\Runtime\ChaosCore\Chaos\TSimdRealf)< 4 > Make ( const float F )


code: static [TSimdRealf](API\Runtime\ChaosCore\Chaos\TSimdRealf) Make ( const float F )


code: template<> [TSimdRealf](API\Runtime\ChaosCore\Chaos\TSimdRealf)< 4 > One()


code: void SetValue ( const int32 LaneIndex, const float F )


code: void SetValues ( const float F )


code: template<> [TSimdRealf](API\Runtime\ChaosCore\Chaos\TSimdRealf)< 4 > Zero()


className: TSimdRealf

description: A TNumLanes-wide set of single-precision floats.

code: template<int TNumLanes> struct TSimdRealf

V

type: float[TNumLanes...


code: template<> [TSimdSelector](API\Runtime\ChaosCore\Chaos\TSimdSelector)< 4 > False()


code: static [TSimdSelector](API\Runtime\ChaosCore\Chaos\TSimdSelector)< TNumLanes > False()